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

אחד הפינוקים שמציעה שפת הפייתון הוא 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'.

זה עובד גם אם ספרות. לדוגמה, נדפיס את כל הספרות בטווח:

numbers = [n for n in range(1,7)]
print(numbers)

התוצאה:

[1, 2, 3, 4, 5, 6]

יותר מזה. אפשר להפעיל סינון כדי לקבל את הפריטים הרצויים, ועל מה שנותר אחרי הסינון להפעיל פונקציה:

even_and_squared = [n**2 for n in range(1, 7) if n % 2 == 0]
print(even_and_squared)

• אם המספר בטווח 1 עד 7, לא כולל 7, מתחלק ב-2 ללא שארית אז תעלה אותו בריבוע ואת התוצאות תאסוף לתוך רשימה חדשה.

התוצאה:

[4, 16, 36]

אפשר לייצר רשימות מסדר גבוה. לדוגמה, רשימה של 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 Comprehensions

List Comprehensions מאוד שימושיים כשרוצים לכתוב לולאות מקוננות (=לולאה בתוך לולאה) בתחביר קומפקטי. לדוגמה:

nums = [[1, 2], [3, 4]]

אפשר להגיע לכל אחד מהפריטים באמצעות 2 לולאות שרצות אחת בתוך השנייה בתחביר פשוט:

nums = [[1, 2], [3, 4]]
arr = []
for l in nums:
    for num in l:
        arr.append(num)

הקוד משתמש בשתי לולאות. החיצונית בשביל להגיע למערכים הפנימיים והפנימית כדי להגיע לערכים בתוך המערכים. הקוד מרכז את הערכים בתוך המערך arr. כאשר נדפיס את המערך נקבל:

[1, 2, 3, 4]

נשתמש ב-List Comprehension כדי לכתוב את זה יותר בקצרה:

arr = [num for l in nums for num in l]

נראה מבלבל. אבל בוא ננסה לכתוב את זה בדרך שתקל על ההבנה:

arr = [num 
      for l in nums 
      for num in l]

כדי ליישם את הדרך הזו דרושים 2 צעדים פשוטים:

1. נתחיל מהאלמנט שאותו רוצים להשיג:

   arr = [num]

2. מתחת לאלמנט נוסיף את קוד הלולאות בדיוק כפי שכתבנו בתחביר הרגיל:

   arr = [num
         for l in nums 
         for num in l]

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 כוכבים