Generic selectors
Exact matches only
Search in title
Search in content
Post Type Selectors
Search in posts
Search in pages

072-3944399

Jade Template Engine

List Comprehension vs For Loop in Python

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

דוגמה 1: איטרציה דרך מחרוזת באמצעות for Loop

h_letters = []

for letter in 'human':

    h_letters.append(letter)

print(h_letters)

כאשר נריץ את הקוד נקבל : 

['h', 'u', 'm', 'a', 'n']

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

בואו נראה כיצד ניתן לכתוב את התוכנית לעיל באמצעות List Comprehension::

h_letters = [ letter for letter in 'human' ]

print( h_letters)

התוצאה תהיה : 

['h', 'u', 'm', 'a', 'n']

בדוגמה שלמעלה, רשימה חדשה מוקצית למשתנה h_letters, והרשימה מכילה את הפריטים של המחרוזת הניתנת לחזרה humen. אנו קוראים לפונקציה print() כדי לקבל את הפלט.

כעת אנו יכולים לזהות היכן נעשה שימוש בהבנת הרשימות.

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

אתה יכול לעשות זאת באמצעות לולאות. עם זאת, לא כל לולאה יכולה להיכתב מחדש כ List Comprehension. אבל ככל שתלמדו ותרגישו נוח עם List Comprehension, תמצאו את עצמכם מחליפים עוד ועוד לולאות בתחביר האלגנטי הזה.

List Comprehensions vs Lambda functions

List Comprehension:: היא לא הדרך היחידה לעבוד על רשימות. פונקציות מובנות שונות ופונקציות למבדה יכולות ליצור ולשנות רשימות בפחות שורות קוד.

דוגמה 3: שימוש בפונקציות Lambda בתוך List

letters = list(map(lambda x: x, 'human'))

print(letters)

כאשר נריץ את התוכנית, הפלט יהיה:

['h','u','m','a','n']

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

Conditionals in List Comprehension

List Comprehension: יכולה להשתמש בהצהרה מותנית כדי לשנות רשימה קיימת (או טופלים אחרים). ניצור רשימה שמשתמשת באופרטורים מתמטיים, מספרים שלמים וטווח().

דוגמה 4: שימוש ב-if עם List Comprehension.

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

print(number_list)

כאשר אנו מפעילים את התוכנית לעיל, הפלט יהיה:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

הרשימה ,number_list, תאוכלס בפריטים בטווח שבין 0-19 אם ערך הפריט מתחלק ב-2.

דוגמה 5: IF מקונן עם הבנת רשימה

num_list = [y for y in range(100) if y % 2 == 0 if y % 5 == 0]

print(num_list)

כאשר אנו מפעילים את התוכנית לעיל, הפלט יהיה:

[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

האם y מתחלק ב-5 או לא?

אם y עומד בשני התנאים, y מצורף ל-num_list.

דוגמה 6: if…else עם List Comprehensions

obj = ["Even" if i%2==0 else "Odd" for i in range(10)]

print(obj)

כאשר אנו מפעילים את התוכנית לעיל, הפלט יהיה:

['Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd']

כאן, הבנת הרשימה תבדוק את 10 המספרים מ-0 עד 9. אם i מתחלק ב-2, אז אפילו מצורף לרשימת האובייקטים. אם לא, אי זוגי מצורף.

Nested Loops in List Comprehension

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

דוגמה 7: טרנספוזיציה של מטריקס באמצעות לולאות מקוננות ( על דוגמאות נוספות נעבור ב קורס Python

transposed = []

matrix = [[1, 2, 3, 4], [4, 5, 6, 8]]

for i in range(len(matrix[0])):

    transposed_row = []

    for row in matrix:

        transposed_row.append(row[i])

    transposed.append(transposed_row)

print(transposed)

הפלט : 

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

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

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

דוגמה 8: טרנספוזיציה של מטריצה באמצעות List Comprehensions

matrix = [[1, 2], [3,4], [5,6], [7,8]]

transpose = [[row[i] for row in matrix] for i in range(2)]

print (transpose)

כאשר נריץ את הקוד נקבל : 

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

בתוכנית לעיל, יש לנו מטריצה משתנה שיש לה 4 שורות ו-2 עמודות. אנחנו צריכים למצוא טרנספוזיציה של המטריצה. לשם כך השתמשנו List Comprehensions.

**הערה: הלולאות המקוננות בהבנת רשימה אינן פועלות כמו לולאות מקוננות רגילות. בתוכנית לעיל, עבור i in range(2) מבוצע לפני שורה [i] עבור שורה במטריצה. מכאן שבהתחלה, ערך מוקצה ל-i ואז פריט המכוון על ידי שורה [i] מצורף במשתנה.

נקודות מפתח לזכור 

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

( על  עוד נקודות  נעבור ב קורס Python

העתיד שלך בהייטק מתחיל כאן
צור איתי קשר עוד היום

תודה!

דילוג לתוכן