מדריך פייתון : list comprehensions

מחבר:
בתאריך:

אחד הפינוקים שמציעה שפת הפייתון הוא list comprehension שפועל כמו לולאות על רשימות בתחביר קומפקטי וקריא יותר.

מדריך list comprehension פייתון

הדרך הבסיסית לעבוד עם רשימות היא באמצעות לולאות. לדוגמה, ייצור הרשימה my_list מרשימה ששמה letters באמצעות לולאת for:

letters = ['p','y','t','h','o','n']

# make a list by using a for loop
my_list = []
for l in letters:
  my_list.append(l)

print(my_list)

התוצאה:

['p', 'y', 't', 'h', 'o', 'n']

שימוש ב-list comprehension נותן את אותה התוצאה באמצעות קוד תמציתי יותר:

# list comprehension
my_list = [l for l in letters]

print(my_list)

והתוצאה זהה:

['p', 'y', 't', 'h', 'o', 'n']

מה שיותר מועיל הוא שניתן להפעיל פונקציה על כל אחד מהפריטים במערך. בדוגמה הבאה, נפעיל את הפונקציה upper() על כל אחד מהפריטים במערך כדי להפוך את כל האותיות לגדולות:

# to upper foreach l in letters
l2u = [l.upper() for l in letters]

print(l2u)
['P', 'Y', 'T', 'H', 'O', 'N']

כפי שניתן להפעיל פונקציה על כל פריט במערך, ניתן להפעיל לוגיקות שונות על כל אחד מהפריטים. לדוגמה, לסנן את רשימת אימות הקריאה ('a', 'e', 'i', 'o', 'u') החוצה מהמערך:

# l if l is not 'A, E, I, O, U'
vowels = ['a', 'e', 'i', 'o', 'u']
no_vowels = [l for l in letters if l not in vowels]

print(no_vowels)
['p', 'y', 't', 'h', 'n']

והמערך לא כולל את האות 'o'.

אפשר לייצר רשימות מסדר גבוה. לדוגמה, רשימה של tuples שבה כל tuple מורכב מאות וספרה.

בדוגמה הבאה, ה-list comprehension לוקח את האותיות מרשימת ה-letters ואת הספרות מרשימת ה-numbers.

# Create a list of tuples
numbers = list(range(1,7))
letters = 'python'

pairs = [(n,l) for n in numbers for l in letters]

print(pairs)
[(1, 'p'),
 (1, 'y'),
 (1, 't'),
 (1, 'h'),
 (1, 'o'),
 (1, 'n'),
 (2, 'p'),
 (2, 'y'),
 (2, 't'),
 (2, 'h'),
 (2, 'o'),
 (2, 'n'),
 (3, 'p'),
 (3, 'y'),
 (3, 't'),
 (3, 'h'),
 (3, 'o'),
 (3, 'n'),
 (4, 'p'),
 (4, 'y'),
 (4, 't'),
 (4, 'h'),
 (4, 'o'),
 (4, 'n'),
 (5, 'p'),
 (5, 'y'),
 (5, 't'),
 (5, 'h'),
 (5, 'o'),
 (5, 'n'),
 (6, 'p'),
 (6, 'y'),
 (6, 't'),
 (6, 'h'),
 (6, 'o'),
 (6, 'n')]

הקוד לעיל, חיבר בין כל פריט ברשימה הראשונה לכל פריט ברשימה השנייה ולפיכך משתי רשימות המכילות 6 פריטים כל אחת קיבלנו רשימה הכוללת 36 פריטים (6*6 קומבינציות).

כיצד נשדך בין הפריטים לפי הסדר כדי לקבל רשימה הכוללת שישה tuples בלבד?

 

List Comprehension לא רק רשימות

עד עכשיו ראינו שימוש בList Comprehension עבור רשימות, אבל אותו טריק יכול לשמש גם עבור מילונים.

הפונקציה zip() עוברת על הרשימות שנספק לה ומחברת מהרשימות מערך של tuples. השם של הפונקציה בא מ-zipper (רוכסן) מכיוון שהפונקציה מחברת כל חוליה מהרשימה הראשונה עם המקבילה שלה מהרשימה השנייה.

הקוד להלן, משדך בין רשימה של שפות מחשב ורשימה של שימושים בשפות:

languages = ['JavaScript','PHP','Bash','Python']
use_cases = ['web','server','unix commands','machine learning']

# print zip(languages, use_cases)
# creates a list of tuples that match the items
# from the 2 lists - 1 for 1
zipper = zip(languages, use_cases)

list(zipper)
[('JavaScript', 'web'),
 ('PHP', 'server'),
 ('Bash', 'unix commands'),
 ('Python', 'machine learning')]

נשתמש בפונקציה הפייתונית zip() וב- list comprehension כדי ליצור מילון של שפות מחשב ושימושים:

# Create a dictionary {language:use_case}
my_dict = {language:use_case for (language, use_case) in list(zip(languages, use_cases))}

print(my_dict)
{'JavaScript': 'web', 'PHP': 'server', 'Bash': 'unix commands', 'Python': 'machine learning'}

ואפשר להוסיף לוגיקה, שתסנן מהרשימה את Bash.

my_languages = {l:u for (l,u) in list(zip(languages,use_cases)) if l != 'Bash'}

print(my_languages)
{'JavaScript': 'web', 'PHP': 'server', 'Python': 'machine learning'}

 

לכל המדריכים בסדרה ללימוד פייתון

 

אהבתם? לא אהבתם? דרגו!

0 הצבעות, ממוצע 0 מתוך 5 כוכבים

 

 

הוסף תגובה חדשה

 

= 6 + 3