הבנת רשימות ב־Python 3

הקדמה

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

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

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

נדרשים

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

רשימות מחרוזות

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

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

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

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

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

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

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

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

עבור הרשימה sea_creatures, הפירוט של האינדקס נראה כך:

הפריט הראשון, מחרוזת 'shark', מתחיל באינדקס 0, והרשימה נגמרת באינדקס 4 עם הפריט 'anemone'.

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

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

print(sea_creatures[1])

Output
cuttlefish

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

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

אם ננסה לקרוא לרשימה sea_creatures עם מספר אינדקס שהוא גדול מ-4, זה יהיה מחוץ לטווח מכיוון שזה לא יהיה תקף:

print(sea_creatures[18])

Output
IndexError: list index out of range

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

לאותה רשימה sea_creatures, הפירוט השלילי של האינדקס נראה כך:

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

print(sea_creatures[-3])

Output
squid

אנו יכולים לשרשר פריטי מחרוזת ברשימה עם מחרוזות אחרות באמצעות אופרטור +:

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

הצלחנו לקבץ את פריט המחרוזת במספר אינדקס 0 עם המחרוזת 'סמי הוא '. נוכל גם להשתמש באופרטור + כדי לקבץ 2 או יותר רשימות יחד.

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

שינוי פריטים ברשימות

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

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

sea_creatures[1] = 'octopus'

עכשיו כשנדפיס את מצורים_בים, הרשימה תהיה שונה:

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

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

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

עכשיו 'דג רטיב' החליף את 'טנטקול' במספר האינדקס השלילי של -3 (שמתאים למספר האינדקס החיובי של 2).

היכולת לשנות פריטים ברשימות נותנת לנו את היכולת לשנות ולעדכן רשימות בדרך יעילה.

חיתי החיתי

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

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

בעת יצירת חתיכה, כמו ב-[1:4], המספר הראשון הוא המקום ממנו מתחילה החתיכה (כולל), והמספר השני הוא המקום בו החתיכה מסתיימת (באופן בלעדי), ולכן בדוגמתנו לעיל הפריטים במיקום, 1, 2, ו- 3 הם הפריטים שמודפסים.

אם רוצים לכלול אחד משני קצוות הרשימה, אפשר להשאיר חסר אחד מהמספרים בתחביר list[x:y]. לדוגמה, אם רוצים להדפיס את שלושת הפריטים הראשונים ברשימה sea_creatures – שיהיו 'שארק', 'תמנון', 'דג גומקס' – ניתן לעשות זאת על ידי הקלדת:

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

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

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

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

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

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

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

התחביר לבניית זה הוא list[x:y:z], עם z המתייחס לקפיצה. בואו ניצור רשימה גדולה יותר, ואז נגרום לה להתקצר, ונקבע ל stride ערך של 2:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

הבנייה שלנו numbers[1:11:2] מדפיסה את הערכים בין מספרי האינדקס כולל את 1 ואינטרקטיבי של 11, ואז הערך של 2 מודיע לתוכנית להדפיס רק פריט כל משונה.

נוכל לדלג על הפרמטרים הראשונים שניים ולהשתמש רק בstride כפרמטר בלבד עם התחביר list[::z]:

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

על ידי הדפסת הרשימה numbers עם ה-stride המוגדר כ-3, רק פריט כל שלישי מודפס:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

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

שינוי רשימות עם אופרטורים

המפעילים יכולים לשמש לביצוע שינויים ברשימות. נבחן את השימוש באופרטורים + ו־* ובצורות המרכיבות שלהם += ו־*=.

האופרטור + ניתן לשימוש על מנת לחבר שתי רשימות או יותר יחד:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

מאחר שהאופרטור + יכול לשרשר, אפשר להשתמש בו כדי להוסיף פריט (או מספר פריטים) בצורת רשימה לסוף רשימה אחרת. חשוב לשים את הפריט בתוך סוגריים מרובעים:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

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

בואו נכפיל את רשימת מפלצות_ים ב־2 ואת רשימת אוקיינוסים ב־3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

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

ניתן גם להשתמש בצורות מרכיבות של האופרטורים + ו־* עם אופרטור ההשמה =. האופרטורים המרכיבים += ו־*= ניתן להשתמש בהם על מנת למלא רשימות בדרך מהירה ואוטומטית. ניתן להשתמש באלו כדי למלא רשימות עם מקומות ריקים שניתן לשנות במועד מאוחר יותר עם קלט מצורף מהמשתמש, לדוגמה.

בואו נוסיף פריט בצורת רשימה לרשימה מפלצות_ים. הפריט הזה ישמש כמציין מקום, ונרצה להוסיף את הפריט הזה מספר פעמים. על מנת לעשות זאת, נשתמש באופרטור += עם לולאת for.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

לכל איטרציה של לולאת ה- for, נוסף פריט רשימה נוסף של 'דג' לרשימה המקורית sea_creatures.

האופרטור *= פועל בדרך דומה:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

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

הסרת פריט מרשימה

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

מרשימת sea_creatures, נסיר את הפריט 'octopus'. הפריט הזה נמצא במיקום האינדקס 1. כדי להסיר את הפריט, נשתמש בהצהרת del ואז נקרא למשתנה הרשימה ולמספר האינדקס של הפריט הזה:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

עכשיו הפריט במיקום האינדקס 1, המחרוזת 'octopus', כבר לא נמצא ברשימת הדגים שלנו sea_creatures.

ניתן גם לציין טווח עם הפקודה del. אם נרצה להסיר לא רק את הפריט 'octopus', אלא גם 'blobfish' ו־'mantis shrimp' כמו כן. אנו יכולים לקרוא לטווח ב־sea_creatures עם הפקודה del כדי לבצע זאת:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

על ידי שימוש בטווח עם ההצהרה del, הצלחנו להסיר את הפריטים בין מספר האינדקס 1 (כולל) ומספר האינדקס 4 (לא כולל), וכתוצאה השארנו רשימה של 3 פריטים לאחר הסרת 3 פריטים.

ההצהרה del מאפשרת לנו להסיר פריטים ספציפיים מסוג הרשימה.

בניית רשימה עם פריטי רשימה

רשימות יכולות להיות מוגדרות עם פריטים המורכבים מרשימות, עם כל רשימה מסוגלת להיות סגורה בתוך הסוגריים הגדולים של הרשימה האב:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

רשימות אלו בתוך רשימות נקראות רשימות מקוננות.

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

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

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

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

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

מסקנה

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

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