הבנת רשימות תיאור ב-Python 3

הקדמה

רשימות הבנה מציעות דרך קצרה ליצירת רשימות בהתבסס על רשימות קיימות. בעת השימוש ברשימות הבנה, ניתן לבנות רשימות על ידי השימוש בכל אוסף ניתן להשגה, כולל מחרוזות ו־זוגות.

מבחינה תחבירית, רשימות הבנה מורכבות מאוסף המכיל ביטוי שעוקב אחרי סעיף for. זה יכול להיות יותר מאוסף for או if, כך שידיעת לולאות for ו־הצהרות תנאי תעזור לך להבין את רשימות הבנה בצורה טובה יותר.

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

דרישות מוקדמות

עליך להיות מותקנת Python 3 ולהגדיר סביבת תכנות במחשב או בשרת שלך. אם אין לך סביבת תכנות מוגדרת, תוכל להתייעץ עם מדריכי ההתקנה וההגדרה עבור סביבת תכנות מקומית או עבור סביבת תכנות בשרת מתאימה למערכת ההפעלה שלך (Ubuntu, CentOS, Debian וכו')

טווחי הרשימה

ב-Python, טווחי הרשימה מורכבים כך:

list_variable = [x for x in iterable]

A list, or other iterable, is assigned to a variable. Additional variables that stand for items within the iterable are constructed around a for clause. The in keyword is used as it is in for loops, to iterate over the iterable.

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

shark_letters = [letter for letter in 'shark']
print(shark_letters)

כאן, הרשימה החדשה מוקצת למשתנה shark_letters, ו-letter משמש כדי לייצג את הפריטים המוכלים במחרוזת הניתנת לעיבוד 'shark'.

כדי לוודא איך נראית הרשימה החדשה shark_letters, אנו קוראים לה להדפיס ומקבלים את הפלט הבא:

Output
['s', 'h', 'a', 'r', 'k']

הרשימה שיצרנו באמצעות התיקול של רשימה מורכבת מהפריטים במחרוזת 'shark', כלומר, מחרוזת אחת עבור כל אות.

התיקולים של רשימות יכולים להיות מומרים ללולאות for, אך לא כל לולאת for יכולה להיות מומרת לתיקול של רשימה.

על ידי השימוש בתיקול של הרשימה שיצרה את הרשימת shark_letters למעלה, בואו נכתוב אותה מחדש כלולאת for. זה עשוי לעזור לנו להבין טוב יותר איך עובד התיקול של הרשימה.

shark_letters = []

for letter in 'shark':
    shark_letters.append(letter)

print(shark_letters)

כאשר יוצרים רשימה עם לולאת for, המשתנה שמוקצה לרשימה צריך להיות מאותחל עם רשימה ריקה, כפי שמופיע בשורה הראשונה של בלוק הקוד שלנו. הלולאה for מעברת על הפריט, בשימוש במשתנה letter במחרוזת הניתנת להמצאות 'shark'. בתוך הלולאה for, כל פריט במחרוזת מוסיף את עצמו לרשימה באמצעות השיטה list.append(x).

כתיבת הספירה של הרשימה כלולה כלולה בלולאת for מספקת לנו את אותו פלט:

Output
['s', 'h', 'a', 'r', 'k']

ספירות רשימה יכולות להיות כתובות מחדש כלולאות for, וכמה לולאות for יכולות להיות כתובות מחדש כספירות רשימה כדי להפוך את הקוד לקצר יותר.

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

בואו נסתכל על דוגמה של הצהרת if בשימוש בספירת רשימה:

fish_tuple = ('blowfish', 'clownfish', 'catfish', 'octopus')

fish_list = [fish for fish in fish_tuple if fish != 'octopus']
print(fish_list)

הרשימה המורכבת מהביטוי של fish_tuple משמשת כבסיס לרשימה החדשה הנקראת fish_list. המילות המפתח for ו־in משמשות, כמו שהיו בקטע למעלה, ועכשיו נוסף if. ההצהרה if אומרת להוסיף רק פריטים שאינם שווים למחרוזת 'octopus', כך שהרשימה החדשה מקבלת רק פריטים מהטיופל שאינם תואמים את 'octopus'.

כאשר נריץ את זה, נשים לב ש־fish_list מכילה את אותם פריטי מחרוזות כמו fish_tuple רק במעט, שהמחרוזת 'octopus' הוסרה:

Output
['blowfish', 'clownfish', 'catfish']

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

ניצור דוגמה נוספת שמשתמשת באופרטורים חשבוניים, במספרים שלמים, וב־סוג הרצף range().

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

הרשימה שמיוצרת, number_list, תתמלא בערכי הריבוע של כל פריט בטווח מ־0 עד 9 אם ערך הפריט חלקי ב־2. הפלט הוא כדלקמן:

Output
[0, 4, 16, 36, 64]

לפרק את מה שהמבנה המתמצת של הרשימה עושה קצת יותר, נחשוב על מה יודפס אם היינו קוראים רק x for x in range(10). התוכנית הקטנה שלנו והפלט שלה יראו כך:

number_list = [x for x in range(10)]
print(number_list)

Output
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

עכשיו, נוסיף את ההצהרה התנאית:

number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)

Output
[0, 2, 4, 6, 8]

ההצהרה if הגבילה את הפריטים ברשימה הסופית כך שרק יכלול את הפריטים שחלקי 2, שווים את כל המספרים האי-זוגיים.

לבסוף, אנו יכולים להוסיף את האופרטור כדי להכפיל את כל x בריבוע:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

לכן כל אחד מהמספרים ברשימה הקודמת של [0, 2, 4, 6, 8] כעת מורוד:

Output
[0, 4, 16, 36, 64]

ניתן גם לשכפל הצהרות תנאי if מקוננות עם הרשימה המתמצת:

number_list = [x for x in range(100) if x % 3 == 0 if x % 5 == 0]
print(number_list)

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

Output
[0, 15, 30, 45, 60, 75, 90]

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

לולאות מקוננות ברשימה מתמצת

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

הפעם, נבחן בנייה מקוננת קיימת של לולאת for ונעבור דרך התמשך אל פורמט של רשימה מתמצתת.

הקוד שלנו ייצור רשימה חדשה שמבצעת פעולות מתמטיות על פי שתי רשימות. הנה קטע הקוד של הלולאה המקוננת שלנו:

my_list = []

for x in [20, 40, 60]:
	for y in [2, 4, 6]:
		my_list.append(x * y)

print(my_list)

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

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

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

כדי להמיר זאת לתיאום רשימה, נדחוף כל אחת מהשורות של הקוד לשורה אחת, התחלת פעולת x * y. זה יהיה מעורב בלולאת for החיצונית, ואז בלולאת for הפנימית. נוסיף הדפסה (print()) מתחת לתיאום הרשימה שלנו כדי לוודא שהרשימה החדשה תואמת לרשימה שיצרנו עם קטע הקוד של הלולאה המקוננת שלנו למעלה:

my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]
print(my_list)

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

תיאום הרשימה שלנו מקנה לנו אפשרות לצרף את הלולאות המקוננות לשורה אחת של קוד, בעוד שעדיין יוצרת את אותה הרשימה המדויקת להקצאה למשתנה my_list.

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

מסקנה

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

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

אף על פי שפעולות הקיבוץ יכולות להפוך את הקוד שלנו לקצר יותר, חשוב לוודא שהקוד הסופי שלנו הוא כמה שיותר קריא ומובן, כך ששורות קוד ארוכות מאוד יש להימנע מהן כדי לוודא שהקוד שלנו נוח לשימוש.