כיצד להוסיף מספרים לרשימה בפייתון


תשובה 1:

ראשית, קח את הקלט כ- raw_input () ברשימה nums והחל עליו פונקציה spilled ():

nums = raw_input ("הזן מספרים:"). רשימת split () # עם קלטות מחרוזת

שורה זו שומרת את המספרים השונים המופרדים במרחב במשתנה הרשימה מספרים בפורמט מחרוזת.

(אתה יכול להציג את הרשימה על ידי כתיבת:

הדפסת מספרים

אם הזנת את המספרים 1 2 3 כתשומות, תראה את הפלט הבא:

['1', '2', '3']

אך שורות אלה אינן צריכות להוות חלק מהקוד שלך.)

כעת עליך ליצור רשימה ריקה. מאוחר יותר רשימה זו תאחסן את הערכים של הרשימה הקודמת כ- ints

num = [] # זה אמור לכלול קלט ב'nums 'כ- ints

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

עבור i in nums: num.append (int (i))

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

בקיצור, אתה צריך קוד קטן זה:

nums = raw_input ("הזן מספרים:"). רשימת split () # עם קלטות מחרוזתnum = [] # זה אמור לכלול קלט ב'nums 'כ- intsעבור i in nums: num.append (int (i))הדפס מספר

הפלט שתראה יהיה כמו:

מקווה שזה עוזר!


תשובה 2:

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

נניח שהתחלת עם קוד שנראה בערך כך:

initial_value = [-3, -2, -1, 0]תוספת = raw_input ('אנא הזן סט מספרים תוחם רווח:')

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

initial_value.extend ([int (x) עבור x ב addenda.split ()])

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

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

הבנה מסוימת זו לוקחת את הרשימה / הרצף המוחזר בשיטת המחרוזת .split () וקוראת לפונקציה int () בכל אחת מהן. שיטת .split () היא ברירת מחדל לפיצול על שטח לבן ו- int () הוא הסוג / קונסטרוקטור למספרים שלמים. העברת טיעון מחרוזת יחיד ל- int () מנסה לנתח את המחרוזת כמספר שלם.

אם לא ניתן לנתח אחד מפריטי המיתרים הללו כמספר שלם מאשר int () יזרוק חריג והביטוי כולו יבוטל (initial_value לא ישתנה במקרה זה - אך החריג, אם לא נתפס, יגרום המתורגמן יסתיים במסלול ערימה.

אז קו אחד זה אינו חזק במיוחד. אתה יכול לעשות משהו כמו:

מתוך __future__ פונקצית הדפסת ייבואאם 'raw_input' לא ב- dir (__ builtins__): raw_input = קלטprompt = 'אנא הזן סט מספרים המופרש מרווח:'בעוד נכון: לְנַסוֹת: תוספת = raw_input (prompt) initial_value.extend ([int (x) עבור x ב addenda.split ()]) למעט ValueError כ- e: הדפס ('Bzzzt! נסה שוב') לְהַמשִׁיך לשבור

במקרה זה הפרדתי את ההנחיה רק ​​לקריאות. (הוספתי גם מעט boilerplate כדי לאפשר לדוגמא קוד זו לעבוד בשקיפות ב- Python 2.7 או 3.x).


תשובה 3:

אני מנחש שאתה רוצה קלט משתמש מהסוג הזה:

2 3 4 7 9

להילקח כקלט ואז לאחסן כל אחד מהם ברשימה.

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

ערכים = קלט (). פיצול ()

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

ערכים = רשימה (מפה (int, קלט (). split ()))

כעת "ערכים" יכילו מספרים שלמים.

>>> ערכים = קלט (). split ()2 3 4 7 9>>> ערכים['2', '3', '4', '7', '9']>>> ערכים = רשימה (מפה (int, קלט (). split ()))2 3 4 7 9>>> ערכים[2, 3, 4, 7, 9]

תשובה 4:

אם אתה מתכוון כיצד להוסיף כל מילה מחרוזת, אז split () צריך להיות מה שאתה מחפש:

>>> מחרוזת = "שלום עולם">>> string.split ()['שלום עולם']

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

>>> user_input = input ("הקלד את המספרים שלך \ n")הקלד את המספרים שלך1 2 3>>> [int (x) עבור x ב- user_input.split ()][1, 2, 3]

שים לב ש- split () לוקח מקום כמפריד ברירת מחדל, אך זה יכול להיות כל דבר. לדוגמה:

>>> user_input = input ("הקלד את המספרים שלך \ n")הקלד את המספרים שלך1,2,3>>> [int (x) עבור x ב- user_input.split (",")][1, 2, 3]

תשובה 5:

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

a = קלט ("אנא הזן אלמנטים")הדפס (a.split ())

עכשיו, נניח שהמשתמש מזין 1 2 3 4 5. אז הערך של "a" יהיה '1 2 3 4 5'. אבל, אתה רוצה להוסיף את הערכים לרשימה. אז פשוט בצע a.split () כאמור בשורה 2. פלט יהיה משהו כמו

['1', '2', '3', '4']

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


תשובה 6:
l = [x עבור x בקלט (). split ()]הדפס (l)

קלט:

>>> 1 2 ff 4 gg 6

פלט:

['1', '2', 'ff', '4', 'gg', '6']

אתה יכול גם להשתמש בפונקציית מפה עבור סוג נתונים מסוים כמו (Python 2x):

x = מפה (int, raw_input (). split ())

קלט:

>>> 1 2 3 4 5

פלט:

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

תשובה 7:

אתה יכול להשתמש בתחביר הבא:

l = רשימה (מפה (int, קלט (). split ()))

הדפס (l)

קלט: 1 2 3 4

פלט: [1, 2, 3, 4]

אני חושב שזו הדרך הפשוטה ביותר לעשות זאת.

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