עבור לולאה בפייתון

ללולאת For ב- Python יש כמה תכונות שונות משפות תכנות אחרות. אני משאיר לך את מה שאני לומד כדי להפיק את המרב מאחת הלולאות הנפוצות ביותר.

ב-Python הוא נועד לחזור על אובייקט שניתן לחזור עליו, בין אם זה רשימה, אובייקט או אלמנט אחר.

המבנה הבא הוא

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in h2:
   instructions

כאן h2 הוא אלמנט שניתן לחזור עליו, למשל רשימה h2=[ 'Valencia', 'Castellón', 'Alicante']. ללולאה יהיו 3 איטרציות, בראשונה j=Valencia בשניה המשתנה j=Castellón.

ועם זה אנחנו יכולים להגדיר את ההוראות שאנחנו רוצים, תמיד לזכור את ההזחה, משהו חיוני ב-Python ושאנשים רבים מתעלמים ממנו, מקבלים שגיאות בקוד.

חזור על לולאה מספר מדויק של פעמים.

אם נרצה שזה יחזור על מספר מסוים של פעמים כפי שאנו יכולים לעשות ב-C++ נצטרך להשתמש ב-range(). כדי לחזור על 10 פעמים היינו משתמשים ב-a

for element in Range(9):
    instructions

שמנו 9 ולא 10 כי טווח מתחיל מ-0, אז מ-0 עד 9 יש 10 חזרות או סיבובים של הלולאה.

ידיעת Range() מאפשרת לנו, במקום לשים מספר בפנים, לשים משתנה, כך שתהיה לנו הרבה יותר שליטה.

var = 10
for element in Range(var):
    instructions

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

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

הפסקת הצהרות והמשך

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

הם עובדים בלולאות אחרות, ויש עוד אמירה מעניינת שהיא pass, שהיא הצהרה שמתבצעת אבל לא עושה כלום ואידיאלית כשאנחנו רוצים להגדיר מבנה שדורש פקודות אבל אנחנו רוצים לשים אותן מאוחר יותר (ההערות הן לא שימושי בשביל זה)

לשבור

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

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        break
else:
    print('No se encontró el número 3')

להמשיך

זה גורם לנו ללכת לאלמנט הבא בלופ.

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
    if n == 3:
        continue
else:
    print('No se encontró el número 3')

https://j2logo.com/bucle-for-en-python/

עבור... אחר

יש מבנה שנגזר מ-For, שהוא עבור... אחר

datos = [1, 2, 3, 4, 5]
for n in datos:
    if n == 2:
        break
else:
    print('No hay 2')

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

עבור _ ב-Ierable

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

כאשר אנו חוזרים על אובייקט, רשימה, מילון וכו', אך התוכן של אותם אלמנטים אינו מעניין אותנו, אנו יכולים לציין זאת באמצעות _

דוגמא:

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

h2=[ 'Valencia', 'Castellón', 'Alicante']
count = 0
for _ in h2:
    cont += 1

באתרים רבים ממליצים לא לעשות שימוש לרעה בנוהג זה. אני באמת לא יודע מה היתרונות שהוא מציג, האם זה מהיר יותר?

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

בלולאה לאחור

אחורה עבור לולאה. לחזור על הסוף להתחלה

הוא משתמש בפונקציה reversed() שהוצגה ב-python 3

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j in reversed(h2):
    print (j)

לולאה עם שני מדדים, ערך החזרה ואינדקס

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

h2=[ 'Valencia', 'Castellón', 'Alicante']

for j, h in enumerate(h2):
    print j, '-->', h2[i] 

חוזר על 2 רשימות

אפשרות נוספת מאוד מעניינת היא zip() שתקל על העבודה שלנו ותהפוך את הקוד שלנו לפשוט וקריא יותר.

h2=[ 'Valencia', 'Castellón', 'Alicante']
cod=[100, 200, 300]

for j, h in zip(h2, cod):
    print h2, '-->', cod 

ב-Python 2.x נעשה שימוש ב-izip() כדי לשפר את הפונקציה הזו, אך ב-Python 3 izip הוא zip()

לולאה בסדר ממוין

חזרו לפי הסדר לפי הערך של האובייקט במקום לפי האינדקס שלו. נעשה שימוש ב- sorted().

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors):
    print color

ואם אנחנו רוצים לעשות את זה לאחור

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, reverse=True):
    print color

סדר מיון מותאם אישית

colors = ['rojo', 'amarillo', 'verde']

for color in sorted(colors, key=len):
    print color

ערך זקיף בלולאה

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

blocks = []
for block in iter(partial(f.read, 32), ''):
    blocks.append(block)
    print (block)

חצו מילונים עם עבור

מילונים הם כלים חיוניים לביטוי מערכות יחסים וליצירת קבוצות.

אתה יכול לעבור על המילון בצורה מסורתית עם for, אבל זה לא יחזיר את כל המידע, לא נוכל לעבוד עם ערכים ומדדים כמו זה, אם לא נתחיל להוסיף מונים ואלמנטים אחרים.

d = {'casa': 'azul', 'coche': 'rojo', 'hombre': 'verde'}

for k in d.keys():
    if k.startswith('r'):
        del d[k]

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

d.keys() קורא לארגומנטים ויוצר עותק שהוא מאחסן ברשימה שאנו יכולים לשנות.

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

for k in d:
    print k, '-->', d[k]

אנו נשתמש באפשרות הזו הרבה יותר מהירה

for k, v in d.items():
    print k, '-->', v

iteritems() מאשר פריטים()

דברו על לולאות בפייתון מאת ריימונד הטינגר

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