הקדמה
א רשימה נחשב לאחד ממבני הנתונים הגמישים ביותר בשפת התכנות Python. מצד שני, רשימה דו-ממדית, או רשימה דו-ממדית, המכונה בדרך כלל רשימת רשימות, היא אובייקט של רשימה שבה כל אלמנט הוא רשימה עצמה. לדוגמה: [[19, 18, 17], [16, 15, 14], [13, 12, 11]].
שיטוח רשימת רשימות הוא תהליך של הפיכת רשימה דו-ממדית לרשימה חד-ממדית על ידי ביטול קינון של כל רכיב רשימה שנשמר ברשימת הרשימות, כלומר, הפיכת [[9, 8, 7], [6] , 5, 4], [3, 2, 1]] עד [9, 8, 7, 6, 5, 4, 3, 2, 1].
נוכל לבצע את תהליך ההשטחה בעזרת המקוננת ל לולאות, רקורסיה, הבנת רשימה, פונקציות ליבה או ייבוא הספריות או החבילות ב-Python על העומק והסדירות של הרשימות המקוננות.
במדריך זה, נעבוד על שיטות שונות על מנת לשטח את הרשימות המקוננות באמצעות שפת התכנות Python. אבל לפני שנתחיל, הבה נבין את סוגי הרשימות המקוננות.
מהם סוגי הרשימות המקוננות?
כידוע, פִּיתוֹן היא שפת תכנות עם הקלדה חלשה. לכן, אנו יכולים להיתקל בשני סוגים של רשימת רשימות. רשימת הרשימות או הרשימות המקוננות הן כדלקמן:
- רשימה רגילה של רשימות
- רשימה לא סדירה של רשימות
רשימה רגילה של רשימות
כל פריט ברשימה הרגילה של הרשימות מכונה תת-רשימה, ובכך שומר על אחידות סוג האלמנט. לדוגמה: [[9, 8, 7], [6, 5, 4], [3, 2, 1]] היא רשימה רגילה של רשימות כמו [9, 8, 7], [6, 5, 4] , [3, 2, 1] הוא מסוג רשימה.
רשימה לא סדירה של רשימות
שאלות ראיון בשפת ג'אווה
כל פריט ברשימה הבלתי סדירה של רשימות מכונה תת-רשימה או אלמנט שאינו רשימת (לדוגמה, מחרוזת או מספר שלם). לפיכך, קיימת אי סדירות מבחינת סוג האלמנט. לדוגמה: [[9, 8, 7], [6, 5], 4, 3] היא רשימה לא סדירה של רשימות שכן [9, 8, 7] ו-[6, 5] הן מסוגי הרשימות, בעוד ש-4 ו-3 הם מסוג int.
שיטוח רשימת הרשימות באמצעות Nested for Loops
שיטוח רשימת הרשימות עם המקוננים ל העזרה של לולאות נחשבת לגישה של כוח גס להשגת רשימה שטוחה. אנו יכולים לבצע שיטה זו על ידי בחירת כל פריט מתוך הרשימה הדו-ממדית וסידורו ברשימה חד-ממדית.
הבה נבחן את הדוגמה הבאה שעובדת גם עבור רשימות רגילות וגם לא סדירות של רשימות.
דוגמא:
# defining the function def flattenlist(_2dlist): # defining an empty list flatlist = [] # Iterating through the outer list for item in _2dlist: if type(item) is list: # If the item is of the list type, iterating through the sub-list for element in item: flatlist.append(element) else: flatlist.append(item) return flatlist # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] print('Genuine List:', nestedlist) print('Converted Flat List:', flattenlist(nestedlist))
תְפוּקָה:
Genuine List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] Converted Flat List: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
הֶסבֵּר:
בדוגמה לעיל, הגדרנו פונקציה כ רשימת שטחים שמקבל פרמטר כ _2dlist . השתמשנו אז ל לולאה כדי לחזור על הרכיבים של הרשימה המקוננת ולצרף אותם כדי ליצור רשימה שטוחה. לאחר מכן הגדרנו את הרשימה המקוננת ויישמנו את ה רשימת שטחים פוּנקצִיָה. כתוצאה מכך, הרשימה המקוננת הפכה בהצלחה לרשימה השטוחה.
שיטוח הרשימה המקוננת באמצעות הבנת רשימה
רידוד רשימת הרשימות בעזרת הבנת רשימה נחשבת לגישה אלגנטית לקבלת רשימה שטוחה בהתאם לרשימה דו-ממדית קיימת. עם זאת, גישה זו מציעה פתרון פחות אינטואיטיבי.
הבה נבחן את הדוגמה הבאה.
דוגמא:
# defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # list comprehension flatlist = [element for sub_list in nestedlist for element in sub_list] print('Genuine list:', nestedlist) print('Converted list:', flatlist)
תְפוּקָה:
Genuine list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
הֶסבֵּר:
בדוגמה לעיל, הגדרנו רשימה מקוננת והבנת רשימה. לאחר מכן הדפסנו אותם עבור המשתמשים. כתוצאה מכך, הרשימה המקוננת עברה טרנספורמציה לרשימה השטוחה בהצלחה.
שיטוח רשימת הרשימות בשיטה רקורסיבית
אנו יכולים גם להשתמש בשיטה הרקורסיבית כדי לשטח את הרשימה הדו-ממדית. הבה נבחן את הדוגמה הבאה המיישמת את השיטה הרקורסיבית על מנת לשטח את רשימת הרשימות. יישום זה עובד היטב עבור רשימה רגילה כמו גם רשימה לא סדירה של רשימות.
דוגמא:
# defining a function def flattenlist(nestedlist): if len(nestedlist) == 0: return nestedlist if isinstance(nestedlist[0], list): return flattenlist(nestedlist[0]) + flattenlist(nestedlist[1:]) return nestedlist[:1] + flattenlist(nestedlist[1:]) print(flattenlist([[10, 20, 30, 40], [50, 60, 70], [80, 90], 100]))
תְפוּקָה:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
הֶסבֵּר:
בדוגמה לעיל, הגדרנו פונקציה והשתמשנו ב-an אם הַצהָרָה אם אורך הרשימה המקוננת שווה לאפס, החזר את הרשימה המקוננת.
string.format java
אם אלמנט הנתונים באינדקס האפס הוא מופע של רשימה, אז אינדקס הרשימה נכנס שוב לפונקציה ומוסיף לאינדקס הבא של הרשימה וכן הלאה. אחרת הפונקציה תחזיר את האלמנטים וכן הלאה. לבסוף, הגדרנו את הרשימה המקוננת והפעלנו את הפונקציה. כתוצאה מכך, רשימת הרשימות השתטחה באופן רקורסיבי.
שימוש בספריות של Python
אנו יכולים גם להשתמש בחלק מספריות שפת התכנות של Python כדי לשטח את רשימת הרשימות. היישום של ספריות אלה מתואר להלן:
שיטוח רשימת הרשימות באמצעות כלי הפונקציות וספריות המפעיל
ה מַפעִיל הספרייה מספקת את iconcat() פונקציה לביצוע הפעולה הבסיסית כמו שרשור. אנו יכולים להחיל פונקציה זו במצטבר על רכיבי הנתונים של רשימה מקוננת, משמאל לימין, וכתוצאה מכך הקטנה של הרשימה המקוננת לרשימה שטוחה.
הבה נבחן את הדוגמה הבאה כדי להבין את יישומו.
דוגמא:
# importing the required libraries import operator import functools regularlist = [] # Converting the list of lists into a flattened one. def convo(nestedlist): for element in nestedlist: if type(element) is list: regularlist.append(element) else: regularlist.append([element]) return regularlist twoDlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110] regular2Dlist = convo(twoDlist) print('Given List:', twoDlist) print('Converted list:', functools.reduce(operator.iconcat, regular2Dlist, []))
תְפוּקָה:
Given List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110]
הֶסבֵּר:
בדוגמה לעיל, ייבאנו את functools הספרייה יחד עם מַפעִיל סִפְרִיָה. לאחר מכן הגדרנו רשימה ריקה בתור רשימה קבועה . לאחר מכן הגדרנו פונקציה כ שיחה כדי להפוך את רשימת הרשימות לרשימה שטוחה. בפונקציה זו, השתמשנו ב- ל לולאה שבה האלמנטים מהרשימה המקוננת מצורפים לרשימה הריקה שהגדרנו קודם לכן. מאוחר יותר הגדרנו את הרשימה המקוננת ומבצעת את הפונקציה. כתוצאה מכך, רשימת הרשימות מומרת לרשימה שטוחה בהצלחה.
שיטוח רשימת הרשימות באמצעות ספריית itertools
ה itertools הספרייה מספקת את שַׁרשֶׁרֶת() פונקציה המאפשרת לנו להפוך רשימה מקוננת לרשימה שטוחה יחידה באופן אידיאלי. פונקציה זו מתייחסת לסדרות עוקבות כסדרה בודדת על ידי איטרציה שלהן דרך ה-Iterable המועבר כפרמטר בצורה סדרתית.
הבה נבחן את הדוגמה הבאה:
דוגמא:
# importing the itertools library import itertools # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] flattenlist = list(itertools.chain(*nestedlist)) print('The nested list:', nestedlist) print('The flattened list:', flattenlist
תְפוּקָה:
The nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] The flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
הֶסבֵּר:
בדוגמה לעיל, ייבאנו את itertools הספרייה ויצרה רשימה מקוננת. לאחר מכן השתמשנו ב- שַׁרשֶׁרֶת() פונקציה כדי להמיר את הרשימה המקוננת הנתונה לרשימה השטוחה. סוף סוף, החזרנו את התוצאה למשתמשים. כתוצאה מכך, רשימת הרשימות משוטחת בהצלחה.
שינוי שם תיקיית לינוקס
שיטוח רשימת הרשימות באמצעות ספריית NumPy
ה NumPy הספרייה מספקת פעולות יומיומיות שונות, כולל שרשור של מערכים רגילים דו-ממדיים לפי עמודה או שורה. נשתמש בתכונה המכונה שָׁטוּחַ על מנת לקבל איטרטור חד מימדי מעל המערך כדי לכבוש את המטרה. הבה נבחן את הדוגמה הבאה כדי להבין את השימוש בפונקציית השרשור ובתכונת השטוח.
דוגמא:
# importing the library import numpy # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # using the concatenate function along with the flat attribute flattenlist = list(numpy.concatenate(nestedlist).flat) print('The Nested list:', nestedlist) print('The Flattened list:', flattenlist)
תְפוּקָה:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
הֶסבֵּר:
בדוגמה לעיל, ייבאנו את רדום הספרייה והגדיר רשימה מקוננת. לאחר מכן השתמשנו ב- לשרשור פונקציה של רדום הספרייה יחד איתה שָׁטוּחַ attribute כדי לשטח את הרכיבים של הרשימה המקוננת ולשרור אותם לרשימה שטוחה חדשה. סוף סוף, הדפסנו את התוצאה עבור המשתמשים. לפיכך, רשימת הרשימות שוטחת בהצלחה.
שימוש בפונקציות ליבה
אנחנו יכולים גם לבצע את משימת ההשטחה על ידי שימוש בכמה פונקציות ליבה ששפת התכנות Python מספקת.
שיטוח רשימת הרשימות באמצעות פונקציית הסכום
אנו יכולים לשקול סיכום על פני רשימות פנימיות כפתרון נוסף לבעיה. אנו מעבירים שני טיעונים ל- סְכוּם פונקציה: הפרמטר הראשון הוא ניתנת לחזרה , שהיא רשימה מקוננת, והפרמטר השני הוא הַתחָלָה שהיא רשימה ריקנית למקרה הבא המשמשת כרשימה השטוחה הראשונית שבה יתווספו רכיבי הנתונים של רשימות המשנה הפנימיות.
אנו יכולים לומר שגישה זו נוחה למדי מכיוון שאיננו צריכים לייבא דבר. עם זאת, זה איטי יותר מאשר itertools() ו שַׁרשֶׁרֶת() מתפקד כאשר יש מספר רב של רשימות משנה ברשימה המקוננת.
הבה נבחן את הדוגמה הבאה:
דוגמא:
# defining a nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # using the sum function flattenlist = sum(nestedlist, []) print('The Nested list:', nestedlist) print('The Flattened list:', flattenlist)
תְפוּקָה:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
הֶסבֵּר:
בדוגמה לעיל, הגדרנו את הרשימה המקוננת. לאחר מכן השתמשנו ב- סְכוּם() פונקציה ושטחה את הרשימה המקוננת לרשימה חד-ממדית, והדפיסה את הרשימה המתקבלת עבור המשתמשים. כתוצאה מכך, הפכנו את רשימת הרשימות לרשימה שטוחה בהצלחה.
שיטוח רשימת הרשימות באמצעות מילת מפתח למבדה
אנו יכולים להגדיר פונקציה אנונימית באמצעות מילת המפתח למבדה . אנו יכולים להעביר את הרשימה הרגילה/לא סדירה כפרמטר לפונקציה האנונימית הזו. הערכת הביטוי נעשית על מנת לקבל רשימה חד-ממדית שטוחה.
הבה נבחן את הדוגמה הבאה:
sonu nigam
דוגמא:
# Defining the nested list nestedlist = [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70] # Using lambda parameters: expression flattenlist = lambda nestedlist:[item for element in nestedlist for item in flattenlist(element)] if type(nestedlist) is list else [nestedlist] print('The Nested list:', nestedlist) print('The Flattened List:', flattenlist(nestedlist))
תְפוּקָה:
The Nested list: [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70] The Flattened List: [10, 20, 30, 30, 50, 60, 40, 60, 70, 70]
הֶסבֵּר:
בדוגמה לעיל, הגדרנו רשימה מקוננת. לאחר מכן השתמשנו ב- למבדה מילת מפתח יחד עם ארגומנט המגדיר ביטוי להבנת רשימה. לאחר מכן הדפסנו אותם עבור המשתמשים. כתוצאה מכך, המרנו בהצלחה את הרשימה הדו-ממדית הלא סדירה לרשימה השטוחה.