01. שלום עולם
02. חבר שני מיתרים
03. עיצוב נקודה צפה במחרוזת
04. העלה מספר לעוצמה
05. עבודה עם טיפוסים בוליאנים
06. הצהרה אם אחרת
07. שימוש באופרטורים AND ו- OR
08. החלף הצהרת מקרה
09. בעוד לולאה
10. עבור לולאה
אחת עשרה. הפעל סקריפט פייתון אחד משני
12. שימוש בארגומנט שורת פקודה
13. שימוש ב- regex
14. שימוש ב- getpass
חֲמֵשׁ עֶשׂרֵה. שימוש בפורמט תאריך
16. הוסף והסר את הפריט מהרשימה
17. הבנת רשימה
18. נתח פרוסים
19. הוסף וחפש נתונים במילון
עשרים. הוסף וחיפש נתונים בערכה
עשרים ואחת. ספור פריטים ברשימה
22. הגדר וקרא פונקציה
2. 3. שימוש בחריגה של זריקה ותפיסה
24. לקרוא ולכתוב קובץ
25. רשימת קבצים בספרייה
26. לקרוא ולכתוב באמצעות מלפפון חמוץ
27. הגדר כיתה ושיטה
28. שימוש בפונקציית טווח
29. שימוש בפונקציית המפה
30. שימוש בפונקציית המסנן
צור והפעל את סקריפט הפיתון הראשון:
אתה יכול לכתוב ולבצע סקריפט פייתון פשוט מהמסוף מבלי ליצור קובץ פייתון. אם התסריט גדול, הוא דורש כתיבה ושומר את הסקריפט בכל קובץ פייתון באמצעות כל עורך. אתה יכול להשתמש בכל עורך טקסט או כל עורך קוד כמו נשגב, קוד Visual Studio או כל תוכנת IDE שפותחה עבור פייתון רק כמו PyCharm או Spyder לכתיבת התסריט. הסיומת של קובץ הפייתון היא .py . גרסת הפיתון 3.8 וה ספיידר 3 IDE של פייתון משמשים במאמר זה לכתיבת סקריפט הפיתון. אתה צריך להתקין ספיידר IDE במערכת שלך כדי להשתמש בה.
אם ברצונך לבצע סקריפט כלשהו מהמסוף, הפעל את ' פִּיתוֹן' או ' python3 ' פקודה לפתיחת פייתון במצב אינטראקציה. סקריפט הפיתון הבא ידפיס את הטקסט שלום עולם כתפוקה.
>>> הדפס(שלום עולם)
כעת, שמור את הסקריפט בקובץ בשם c1.py . עליך להריץ את הפקודה הבאה מהטרמינל לביצוע c1.py .
$ python3 c1.py
אם ברצונך להריץ את הקובץ מ ספיידר 3 IDE, לאחר מכן עליך ללחוץ על לָרוּץ לַחְצָן
של העורך. הפלט הבא יופיע בעורך לאחר ביצוע הקוד.
חלק עליוןחיבור לשני מחרוזות:
ישנן דרכים רבות להצטרף לערכי מחרוזת בפייתון. הדרך הפשוטה ביותר לשלב שני ערכי מחרוזת בפייתון היא שימוש באופרטור '+'. צור כל פייתון עם הסקריפט הבא כדי לדעת את הדרך להצטרף לשני מחרוזות. כאן, שני ערכי מחרוזת מוקצים בשני משתנים, ומשתנה אחר משמש לאחסון הערכים המצורפים שיודפסו מאוחר יותר.
c2.py
מחרוזת 1= 'לינוקס'מחרוזת 2= 'רֶמֶז'
join_string=מחרוזת 1 + מחרוזת 2
הדפס(join_string)
הפלט הבא יופיע לאחר הפעלת התסריט מהעורך. הנה שתי מילים, לינוקס ו רֶמֶז מצטרפים, ו LinuxHint מודפס כפלט.
אם אתה רוצה לדעת יותר על אפשרות ההצטרפות האחרת בפייתון, תוכל לבדוק את המדריך, שרשור מחרוזת פייתון.
עיצוב נקודה צפה במחרוזת:
מספר נקודה צפה נדרש בתכנות ליצירת מספרים שברים, ולפעמים הוא דורש עיצוב של מספר הנקודה הצפה לצורכי תכנות. ישנן דרכים רבות להתקיים בפייתון לעיצוב מספר הנקודות הצפות. עיצוב מחרוזות ואינטרפולציה של מחרוזות משמשים בתסריט הבא לעיצוב מספר נקודה צפה. פוּרמָט() שיטה עם רוחב פורמט משמשת בעיצוב מחרוזות, וסמל '% עם הפורמט עם הרוחב משמש באינטרפולציה של מחרוזות. על פי רוחב העיצוב, 5 ספרות נקבעות לפני הנקודה העשרונית, ו -2 ספרות נקבעות אחרי הנקודה העשרונית.
c3.py
# שימוש בעיצוב מחרוזותצף 1= 563.78453
הדפס('{: 5.2f}'.פוּרמָט(צף 1))
# שימוש באינטרפולציה של מחרוזות
float2= 563.78453
הדפס('%5.2f'% float2)
הפלט הבא יופיע לאחר הפעלת התסריט מהעורך.
אם אתה רוצה לדעת יותר על עיצוב מחרוזות בפייתון, תוכל לבדוק את ההדרכה, עיצוב מחרוזת פייתון.
העלה מספר לעוצמה:
קיימות דרכים רבות בפייתון לחישוב ה- איקסנ בפייתון. בתסריט הבא מוצגות שלוש דרכים לחישוב xn בפייתון. כפול ' * ' מַפעִיל, NS () שיטה, וכן math.pow () שיטה משמשת לחישוב ה- xn. הערכים של איקס ו נ מאותחלים עם ערכים מספריים. כפול ' * ' ו NS () שיטות משמשות לחישוב העוצמה של ערכי מספר שלם. math.pow () יכול לחשב את העוצמה של מספרים שברים; כמו כן, המוצג בחלק האחרון של התסריט.
c4.py
יְבוּא מתמטיקה# הקצה ערכים ל- x ו- n
איקס= 4
נ= 3
# שיטה 1
כּוֹחַ=x ** נ
הדפס(' %d לעוצמה %d הוא %d'%(איקס,נ,כּוֹחַ))
# שיטה 2
כּוֹחַ= NS(איקס,נ)
הדפס(' %d לעוצמה %d הוא %d'%(איקס,נ,כּוֹחַ))
# שיטה 3
כּוֹחַ= מתמטיקה.NS(2,6.5)
הדפס(' %d לעוצמה %d הוא %5.2f'%(איקס,נ,כּוֹחַ))
הפלט הבא יופיע לאחר הפעלת התסריט. שתי הפלטים הראשונים מראים את התוצאה של 43, והפלט השלישי מראה את התוצאה של 26.5 .
חלק עליוןעבודה עם סוגים בוליאניים:
השימושים השונים בסוגים בוליאניים מוצגים בתסריט הבא. הפלט הראשון ידפיס את הערך של val1 המכיל את הערך הבולאני, נָכוֹן. כל החיובי הם מספרים שליליים החזרה נָכוֹן כערך בוליאני ורק אפס החזרים שֶׁקֶר כערך בוליאני. אז, הפלט השני והשלישי יודפסו נָכוֹן למספרים חיוביים ושליליים. הפלט הרביעי ידפיס שקר עבור 0, והפלט החמישי יודפס שֶׁקֶר כי אופרטור ההשוואה חוזר שֶׁקֶר .
c5.py
# ערך בוליאניval1= נָכוֹן
הדפס(val1)
# מספר עד בוליאני
מספר= 10
הדפס(בול(מספר))
מספר=-5
הדפס(בול(מספר))
מספר= 0
הדפס(בול(מספר))
# בוליאני ממפעיל השוואה
val1= 6
val2= 3
הדפס(val1<val2)
הפלט הבא יופיע לאחר הפעלת התסריט.
חלק עליוןשימוש בהצהרת אם אחרת:
התסריט הבא מציג את השימוש בהצהרה מותנית בפייתון. ההכרזה של את אם-אחר הצהרה בפייתון קצת שונה משפות אחרות. אין צורך בסוגריים מתולתלים כדי להגדיר את בלוק ה- if-else בפייתון כמו שפות אחרות, אך יש להשתמש כבלוק הזחה כראוי אחרת התסריט יציג שגיאה. הנה, פשוט מאוד אחרת המשפט משמש בתסריט שיבדוק שהערך של משתנה המספרים גדול או שווה ל- 70 או לא. א המעי הגס(:) משמש לאחר ' אם' ו ' אַחֵר' block כדי להגדיר את תחילת הבלוק.
c6.py
# הקצה ערך מספרימספר= 70
# בדוק שהוא יותר מ -70 או לא
אם (מספר> = 70):
הדפס('עברת')
אַחֵר:
הדפס('לא עברת')
הפלט הבא יופיע לאחר הפעלת התסריט.
חלק עליוןשימוש במפעילים AND ו- OR:
התסריט הבא מציג את השימושים של וגם ו אוֹ אופרטורים בהצהרה המותנית. וגם מפעיל חוזר נָכוֹן כאשר שני התנאים חוזרים נָכוֹן, ו אוֹ מפעיל חוזר נָכוֹן כאשר כל מצב של שני תנאים חוזר נָכוֹן . שני מספרים צפים יובאו כסימני MCQ וסימני תיאוריה. אופרטורים AND ו- OR משמשים ב- ' אם' הַצהָרָה. על פי התנאי, אם סימני MCQ שווים יותר מ -40 וסימני תיאוריה גדולים מ- 30 שווים או אז 30 ' אם' ההצהרה תחזור נָכוֹן או אם סך MCQ והתיאוריה גבוהים או שווים ל- 70 אז ' אם' ההצהרה גם תחזור נָכוֹן .
c7.py
# קח סימני MCQmcq_marks= לָצוּף(קֶלֶט('הזן את סימני MCQ:'))
# קח סימני תיאוריה
סימני תיאוריה= לָצוּף(קֶלֶט('הזן את סימני התאוריה:'))
# בדוק את המצב החולף באמצעות אופרטור AND ו- OR
אם (mcq_marks> = 40 וסימני תיאוריה> = 30) אוֹ (mcq_marks + theory_marks) > =70:
הדפס(' nעברת ')
אַחֵר:
הדפס(' nנכשלת')
על פי הפלט הבא, אם ההצהרה מחזירה שֶׁקֶר לערכי הקלט 30 ו -35, ומחזירה נָכוֹן לערכי הקלט 40 ו -45.
חלק עליוןהחלף הצהרת מקרה:
פייתון אינו תומך מארז מתג משפט כמו שפות תכנות סטנדרטיות אחרות, אך ניתן ליישם סוג זה של הצהרה בפייתון באמצעות פונקציה מותאמת אישית. עובדים_פרטים () הפונקציה נוצרת בתסריט הבא כדי לעבוד כמו הצהרת המתג-מקרה. הפונקציה מכילה פרמטר אחד ומילון בשם מחליף. הערך של פרמטר הפונקציה נבדק בכל אינדקס של המילון. אם נמצאה התאמה כלשהי, הערך המתאים של האינדקס יוחזר מהפונקציה; אחרת, ערך הפרמטר השני של switcher.get () השיטה תוחזר.
c8.py
# מחליף ליישום אפשרויות מארז מתגיםdefעובד_פרטים(תְעוּדַת זֶהוּת):
מחליף= {
'1004':'שם העובד: MD. מהראב ',
'1009':'שם העובד: מיטה רחמן',
'1010':'שם העובד: סאקיב אל חסן',
}
'' 'הארגומנט הראשון יוחזר אם ההתאמה תמצא ו
שום דבר לא יוחזר אם לא נמצאה התאמה '' '
לַחֲזוֹרמחליף.לקבל(תְעוּדַת זֶהוּת, 'שום דבר')
# קח את תעודת הזהות של העובד
תְעוּדַת זֶהוּת= קֶלֶט('הזן את מזהה העובד:')
# הדפס את הפלט
הדפס(עובד_פרטים(תְעוּדַת זֶהוּת))
על פי הפלט הבא, הסקריפט מבוצע פעמיים ושני שמות עובדים מודפסים על בסיס ערכי המזהה.
חלק עליוןשימוש ב- while Loop:
השימוש בלולאת while ב- python מוצג בדוגמה הבאה. המעי הגס (:) משמש להגדרת בלוק ההתחלה של הלולאה, וכל ההצהרות של הלולאה חייבות להיות מוגדרות באמצעות הזחה נכונה; אחרת, תופיע שגיאת הזחה. בתסריט הבא, המונה הערך מאתחל ל 1 המשמש בלולאה. הלולאה תחזור על עצמה 5 פעמים ותדפיס את ערכי המונה בכל איטרציה. ה דֶלְפֵּק הערך עולה ב- 1 בכל איטרציה כדי להגיע למצב הסיום של הלולאה.
c9.py
# אתחל מונהדֶלְפֵּק= 1
# חזור על הלולאה 5 פעמים
בזמןדֶלְפֵּק< 6:
# הדפס את ערך המונה
הדפס ('ערך המונה הנוכחי: %d'מונה %)
# הגדל את הדלפק
דֶלְפֵּק=מונה +1
הפלט הבא יופיע לאחר הפעלת התסריט.
חלק עליוןשימוש ב- for Loop:
עבור לולאה משמש למטרות רבות בפייתון. בלוק ההתחלה של לולאה זו נדרש להגדיר באמצעות נקודתיים (:), וההצהרות מוגדרות באמצעות הזחה נכונה. בתסריט הבא, מוגדרת רשימת שמות של יום חול, ולולאה עבור משמשת לאיטרציה והדפסה של כל פריט ברשימה. כאן, שיטת len () משמשת לספירת סך הפריטים של הרשימה והגדרת הגבול של הפונקציה range ().
c10.py
# אתחל את הרשימהימי חול= ['יוֹם רִאשׁוֹן', 'יוֹם שֵׁנִי', 'יוֹם שְׁלִישִׁי','יום רביעי', 'יוֹם חֲמִישִׁי','יוֹם שִׁישִׁי', 'יום שבת']
הדפס('שבעה ימי חול הם: n')
# חזור על הרשימה באמצעות לולאה
ליְוֹםב טווח(len(ימי חול)):
הדפס(ימי חול[יְוֹם])
הפלט הבא יופיע לאחר הפעלת התסריט.
הפעל סקריפט פייתון אחד משני:
לפעמים נדרש להשתמש בסקריפט של קובץ פייתון מקובץ פייתון אחר. ניתן לעשות זאת בקלות, כמו ייבוא כל מודול באמצעות את היבוא מילת מפתח. פה, vacations.py קובץ מכיל שני משתנים המאתחלים על ידי ערכי מחרוזת. קובץ זה מיובא ב- c11.py קובץ בשם הכינוי ' v ' . רשימה של שמות חודש מוגדרת כאן. ה דֶגֶל משתנה משמש כאן להדפסת הערך של חופשה 1 משתנה פעם אחת במשך החודשים ' יוני' ו ' יולי'. הערך של ה חופשה 2 משתנה יודפס לחודש 'דֵצֶמבֶּר' . שמות תשעת החודשים האחרים יודפסו כאשר החלק האחר של אם-אחר-אחר ההצהרה תתבצע.
vacations.py
# אתחל ערכיםחופשה 1= 'חופשת קיץ'
חופשה 2= 'חופשת חורף'
c11.py
# ייבא סקריפט פייתון נוסףיְבוּאחופשותכפי שv
# אתחל את רשימת החודשים
חודשים= ['יָנוּאָר', 'פברואר', 'מרץ', 'אַפּרִיל', 'מאי', 'יוני',
'יולי', 'אוגוסט', 'סֶפּטֶמבֶּר', 'אוֹקְטוֹבֶּר', 'נוֹבֶמבֶּר', 'דֵצֶמבֶּר']
# משתנה דגל ראשוני להדפסת חופשת הקיץ פעם אחת
דֶגֶל= 0
# חזור על הרשימה באמצעות לולאה
לחוֹדֶשׁבחודשים:
אםחוֹדֶשׁ== 'יוני' אוֹחוֹדֶשׁ== 'יולי':
אםדֶגֶל== 0:
הדפס('עַכשָׁיו',v.חופשה 1)
דֶגֶל= 1
אליףחוֹדֶשׁ== 'דֵצֶמבֶּר':
הדפס('עַכשָׁיו',v.חופשה 2)
אַחֵר:
הדפס('החודש הנוכחי הוא',חוֹדֶשׁ)
הפלט הבא יופיע לאחר הפעלת התסריט.
חלק עליוןשימוש בארגומנט שורת הפקודה:
התסריט הבא מציג את השימוש בארגומנטים של שורת הפקודה בפייתון. מודולים רבים קיימים בפייתון כדי לנתח את הארגומנטים של שורת הפקודה 'Sys' מודול מיובא לכאן כדי לנתח את הארגומנטים של שורת הפקודה. len () שיטה משמשת לספירת סך הארגומנטים, כולל שם קובץ הסקריפט. לאחר מכן, ערכי הארגומנט יודפסו.
c12.py
# ייבוא מודול sysיְבוּא sys
# המספר הכולל של טיעונים
הדפס('סך הכל טיעונים:', len(sys.argv))
הדפס('ערכי הטיעון הם:')
# הפעל ארגומנטים של שורת הפקודה באמצעות לולאה
לאניב sys.argv:
הדפס(אני)
אם התסריט מבוצע ללא ארגומנטים של שורת הפקודה, יופיע הפלט הבא המציג את שם קובץ הסקריפט.
ניתן להגדיר את ערכי הארגומנט של שורת הפקודה בעורך spyder על ידי פתיחת הפעל תצורה לכל קובץ תיבת הדו -שיח על ידי לחיצה על לָרוּץ תַפרִיט. הגדר את הערכים עם רווח על ידי לחיצה על האפשרויות של שורת הפקודה של חלק מהגדרות כלליות בתיבת הדו -שיח.
אם הסקריפט מבוצע לאחר הגדרת הערכים המוצגים למעלה, הפלט הבא יופיע.
ניתן להעביר את ערכי הארגומנט של שורת הפקודה בתסריט הפיתון בקלות מהמסוף. הפלט הבא יופיע אם התסריט יופעל מהמסוף.
אם אתה רוצה לדעת יותר על ארגומנטים של שורת פקודה בפייתון, תוכל לבדוק את ההדרכה, כיצד לנתח ארגומנטים בשורת הפקודה ב- Python .
שימוש ב- regex:
ביטוי רגולרי או regex משמשים בפייתון להתאמה או לחיפוש והחלפה של חלק מסוים של מחרוזת המבוססת על התבנית המסוימת. 'מִחָדָשׁ' מודול משמש בפייתון לשימוש בביטוי רגיל. התסריט הבא מציג את השימוש ב- regex בפייתון. הדפוס המשמש בתסריט יתאים למחרוזת שבה התו הראשון של המחרוזת הוא אות גדולה. ערך מחרוזת ייקח ויתאים את התבנית באמצעות התאמה() שיטה. אם השיטה חוזרת נכונה, הודעת הצלחה תודפס אחרת הודעת הדרכה תודפס.
c13.py
# ייבוא מודול מחדשיְבוּא מִחָדָשׁ
# קח כל נתוני מחרוזת
חוּט = קֶלֶט('הזן ערך מחרוזת:')
# הגדר את תבנית החיפוש
תבנית= '^[א-ז]'
# התאם את התבנית עם ערך הקלט
מצאתי= מִחָדָשׁ.התאמה(תבנית, חוּט)
# הדפס הודעה על בסיס ערך ההחזרה
אםמצאתי:
הדפס('ערך הקלט מתחיל באות גדולה')
אַחֵר:
הדפס('עליך להקליד מחרוזת להתחיל באות גדולה')
התסריט מבוצע פעמיים בפלט הבא. התאמה() הפונקציה מחזירה שקר לביצוע הראשון ומחזירה נכונה לביצוע השני.
חלק עליוןשימוש ב- getpass:
getpass הוא מודול שימושי של פייתון המשמש לקלוט קלט סיסמה מהמשתמש. התסריט הבא מציג את השימוש במודול getpass. שיטת getpass () משמשת כאן בכדי לקחת את הקלט כסיסמה ו- ' אם' משפט משמש כאן להשוות את ערך הקלט עם הסיסמה המוגדרת. אתה מאומת ההודעה תודפס אם הסיסמה תואמת אחרת היא תודפס אינך מאומת הוֹדָעָה.
c14.py
מודול getpass יבואיְבוּא getpass
# קח סיסמא מהמשתמש
passwd= getpass.getpass('סיסמה:')
# בדוק את הסיסמה
אםpasswd== 'פחמידה':
הדפס('אתה מאומת')
אַחֵר:
הדפס('אינך מאומת')
אם הסקריפט פועל מעורך spyder, ערך הקלט יוצג מכיוון שמסוף העורך אינו תומך במצב סיסמה. לכן, הפלט הבא מציג את סיסמת הקלט בפלט הבא.
אם התסריט מבוצע מהמסוף, ערך הקלט לא יוצג כמו סיסמת לינוקס אחרת. התסריט מבוצע פעמיים מהמסוף עם סיסמה לא חוקית ותקפה המוצגת בפלט הבא.
שימוש בפורמט תאריך:
את ערך התאריך ניתן לעצב בפייתון בדרכים שונות. התסריט הבא משתמש ב- datetim מודול e כדי להגדיר את ערך התאריך הנוכחי והערך המותאם אישית. היום() שיטה משמשת כאן לקריאת התאריך והשעה הנוכחיים של המערכת. לאחר מכן, הערך המעוצב של התאריך מודפס באמצעות שמות נכסים שונים של אובייקט התאריך. כיצד ניתן להקצות ולהדפיס ערך תאריך מותאם אישית בחלק הבא של התסריט.
c15.py
מ תאריך שעה יְבוּאתַאֲרִיך# קרא את התאריך הנוכחי
דייט נוכחי=תַאֲרִיך.היום()
# הדפס את התאריך המעוצב
הדפס('היום הוא:%d-%d-%d'%(דייט נוכחי.יְוֹם,דייט נוכחי.חוֹדֶשׁ,דייט נוכחי.שָׁנָה))
# קבע את התאריך המותאם אישית
תאריך מותאם אישית=תַאֲרִיך(2020, 12, 16)
הדפס('התאריך הוא:',תאריך מותאם אישית)
הפלט הבא יופיע לאחר ביצוע התסריט.
הוסף והסר את הפריט מהרשימה:
אובייקט list משמש בפייתון לפתרון בעיות מסוגים שונים. לפייתון פונקציות מובנות רבות לעבודה עם אובייקט הרשימה. כיצד ניתן להכניס פריט חדש ולהסיר אותו מרשימה מוצג בדוגמה הבאה. רשימה של ארבעה פריטים מוצהרת בתסריט. לְהַכנִיס() שיטה משמשת להוספת פריט חדש במיקום השני של הרשימה. לְהַסִיר() שיטה משמשת לחיפוש והסרה של הפריט המסוים מהרשימה. הרשימה מודפסת לאחר ההוספה והמחיקה.
c16.py
# הכריז על רשימת פירותפירות= ['מנגו','תפוז','גויאבה','בננה']
# הכנס פריט במיקום השני
פירות.לְהַכנִיס(1, 'עַנָב')
# הצגת רשימה לאחר ההוספה
הדפס('רשימת הפירות לאחר הכנס:')
הדפס(פירות)
# הסר פריט
פירות.לְהַסִיר('גויאבה')
# הדפס את הרשימה לאחר המחיקה
הדפס('רשימת הפירות לאחר המחיקה:')
הדפס(פירות)
הפלט הבא יופיע לאחר ביצוע התסריט.
אם אתה רוצה לדעת פרטים נוספים על ההוספה והמחיקה של סקריפט הפייתון, תוכל לבדוק את ההדרכה, כיצד להוסיף ולהסיר פריטים מרשימה ב- Python .
הבנת רשימה:
הבנת רשימה משמשת בפייתון ליצירת רשימה חדשה המבוססת על כל מחרוזת או צמד או רשימה אחרת. ניתן לבצע את אותה משימה באמצעות פונקציית לולאה ולמבדה. התסריט הבא מציג שני שימושים שונים של הבנת רשימה. ערך מחרוזת הופך לרשימת תווים באמצעות הבנת רשימה. לאחר מכן, זוג הופך לרשימה באותו אופן.
c17.py
# צור רשימת תווים באמצעות הבנת רשימהchar_list= [לְהַשְׁחִירללְהַשְׁחִירב 'linuxhint' ]
הדפס(char_list)
# הגדר צמד אתרים
אתרים= ('Google com','yahoo.com', 'ask.com', 'bing.com')
# צור רשימה מתוך tuple באמצעות הבנת רשימה
site_list= [ אֲתַר ל אֲתַר באתרים]
הדפס(site_list)
נתח פרוסה:
פרוסה() שיטה משמשת בפייתון לחיתוך החלק המסוים של מחרוזת. לשיטה זו שלושה פרמטרים. פרמטרים אלה הם הַתחָלָה , תפסיק, ו שלב . ה תפסיק הוא הפרמטר החובה, ושני הפרמטרים האחרים הם אופציונליים. התסריט הבא מציג את השימושים של פרוסה() שיטה עם פרמטר אחד, שניים ושלושה. כאשר משתמשים בפרמטר אחד ב- פרוסה() שיטה, ואז היא תשתמש בפרמטר החובה, תפסיק . כאשר שני הפרמטרים משמשים ב- פרוסה() השיטה, אם כן הַתחָלָה ו תפסיק משתמשים בפרמטרים. כאשר משתמשים בכל שלושת הפרמטרים, אז הַתחָלָה , תפסיק , ו שלב משתמשים בפרמטרים.
c18.py
# הקצה ערך מחרוזתטֶקסט= 'למד תכנות פייתון'
# פרוסה באמצעות פרמטר אחד
פרוסה אוביי= פרוסה(5)
הדפס(טֶקסט[פרוסה אוביי])
# פרוסה באמצעות שני פרמטרים
פרוסה אוביי= פרוסה(6,12)
הדפס(טֶקסט[פרוסה אוביי])
# פרוסה באמצעות שלושה פרמטרים
פרוסה אוביי= פרוסה(6,25,5)
הדפס(טֶקסט[פרוסה אוביי])
הפלט הבא יופיע לאחר הפעלת התסריט. בראשון פרוסה() שיטה, 5 משמשת כערך הארגומנט. זה חתך את חמשת הדמויות של טֶקסט משתנים המודפסים כפלט. בשנייה פרוסה() שיטה, 6 ו -12 משמשים כטיעונים. החיתוך מתחיל ממיקום 6 ונעצר לאחר 12 תווים. בשלישית פרוסה() שיטה, 6, 25 ו- 5 משמשים כטיעונים. החיתוך מתחיל ממיקום 6, והחיתוך נעצר לאחר 25 תווים על ידי השמטת 5 תווים בכל שלב.
חלק עליוןהוסף וחפש נתונים במילון:
אובייקט מילון משמש בפייתון לאחסון נתונים מרובים כמו המערך האסוציאטיבי של שפות תכנות אחרות. התסריט הבא מראה כיצד ניתן להכניס פריט חדש, ולחפש כל פריט במילון. מילון של מידע על לקוחות מוכרז בתסריט שבו האינדקס מכיל את מזהה הלקוח, והערך מכיל את שם הלקוח. לאחר מכן, מידע על לקוח אחד חדש מוכנס בסוף המילון. מזהה לקוח נלקח כקלט לחיפוש במילון. 'ל' לולאה ו 'אם' התנאי משמש לאיטור אינדקסים של המילון ולחיפוש ערך הקלט במילון.
c19.py
# הגדר מילוןלקוחות= {'06753':'מהזבין אפרוס','02457':'אומנות. עלי ',
'02834':'מוסרוף אחמד','05623':'מילה חסן', '07895':'יעקב עלי'}
# הוסף נתונים חדשים
לקוחות['05634'] = 'מהובה פרדוס'
הדפס('שמות הלקוחות הם:')
# הדפס את ערכי המילון
לצרכןבלקוחות:
הדפס(לקוחות[צרכן])
# קח את זיהוי הלקוח כקלט לחיפוש
שֵׁם= קֶלֶט('הזן את מספר הלקוח:')
# חפש את המזהה במילון
לצרכןבלקוחות:
אםצרכן==שֵׁם:
הדפס(לקוחות[צרכן])
לשבור
הפלט הבא יופיע לאחר ביצוע התסריט ולקיחת ' 02457 ' כערך מזהה.
אם אתה רוצה לדעת יותר על השיטות השימושיות האחרות של המילון, תוכל לעיין במדריך, 10 שיטות מילון פייתון השימושיות ביותר.
הוסף וחיפש נתונים בסט:
התסריט הבא מציג את הדרכים להוספה ולחיפוש של נתונים בערכת פייתון. קבוצה של נתונים שלמים מוכרזת בתסריט. לְהוֹסִיף() שיטה משמשת להכנסת נתונים חדשים לסט. לאחר מכן, ערך שלם ייחשב כקלט לחיפוש הערך במערך באמצעות ל לולאה ו אם מַצָב.
c20.py
# הגדר את מספר המספריםמספרים= {2. 3, 90, 56, 78, 12, 3. 4, 67}
# הוסף נתונים חדשים
מספרים.לְהוֹסִיף(חמישים)
# הדפס את הערכים שנקבעו
הדפס(מספרים)
הוֹדָעָה= 'המספר לא נמצא'
# קח ערך מספר לחיפוש
מספר_חיפוש= int(קֶלֶט('הזן מספר:'))
# חפש את המספר בערכה
לשעותבמספרים:
אםשעות==מספר_חיפוש:
הוֹדָעָה= 'המספר נמצא'
לשבור
הדפס(הוֹדָעָה)
התסריט מבוצע פעמיים עם הערך שלם 89 ו -67. 89 אינו קיים במערך, ו- המספר לא נמצא מודפס. 67 קיים בערכה, ו- המספר נמצא מודפס.
אם אתה רוצה לדעת על הִתאַחֲדוּת הפעולה בסט, ואז תוכל לבדוק את ההדרכה כיצד להשתמש באיחוד על ערכת פייתון.
ספור פריטים ברשימה:
לספור() שיטה משמשת בפייתון לספור כמה פעמים מחרוזת מסוימת מופיעה במחרוזת אחרת. זה יכול לקחת שלוש טיעונים. הטיעון הראשון הוא חובה, והוא מחפש את המחרוזת המסוימת בכל החלק של מחרוזת אחרת. שני הטיעונים האחרים של שיטה זו משמשים להגבלת החיפוש על ידי הגדרת מיקומי החיפוש. בתסריט הבא, לספור() משתמשים בשיטה עם ארגומנט אחד שיחפש ויספור את המילה ' פִּיתוֹן ' בתוך ה חוּט מִשְׁתַנֶה.
c21.py
# הגדר את המחרוזתחוּט = 'Python Bash Java Python PHP PERL'
# הגדר את מחרוזת החיפוש
לחפש= 'פִּיתוֹן'
# שמור את ערך הספירה
לספור= חוּט.לספור(לחפש)
# הדפס את הפלט המעוצב
הדפס(' %s מופיע %d פעמים'%(לחפש,לספור))
הפלט הבא יופיע לאחר ביצוע התסריט.
אם אתה רוצה לדעת פרטים נוספים על שיטת הספירה (), תוכל לבדוק את ההדרכה, כיצד להשתמש בשיטת count () בפייתון .
הגדר וקרא פונקציה:
כיצד ניתן להכריז על פונקציה המוגדרת על ידי המשתמש ולהיקרא בפייתון מוצג בתסריט הבא. כאן, שתי פונקציות מוכרזות. חיבור() הפונקציה מכילה שני ארגומנטים לחישוב סכום שני מספרים והדפסת הערך. אֵזוֹר() פונקציה מכילה ארגומנט אחד לחישוב שטח המעגל והחזרת התוצאה למתקשר באמצעות השיבה הַצהָרָה.
c22.py
# הגדר את פונקציית ההוספהdefחיבור(מספר 1,מספר 2):
תוֹצָאָה=מספר 1 + מספר 2
הדפס('תוצאת תוספת:',תוֹצָאָה)
# הגדר את פונקציית האזור עם הצהרת החזרה
defאֵזוֹר(רַדִיוּס):
תוֹצָאָה= 3.14* רדיוס * רדיוס
לַחֲזוֹרתוֹצָאָה
# פונקציית הוספת שיחות
חיבור(400, 300)
# פונקציית אזור שיחה
הדפס('שטח המעגל הוא',אֵזוֹר(4))
הפלט הבא יופיע לאחר ביצוע התסריט.
אם אתה רוצה לדעת פרטים על ערכי ההחזרה מפונקציית פייתון, תוכל לבדוק את ההדרכה, החזר ערכים מרובים מפונקציית פייתון .
שימוש בחריגה של זריקה ותפיסה:
לְנַסוֹת ו לתפוס בלוק משמשים לזרוק ולתפוס את החריג. התסריט הבא מראה את השימוש ב- נסה לתפוס בלוק בפייתון. בתוך ה לְנַסוֹת בלוק, ערך מספר ייחשב כקלט ויבדוק שהמספר שווה או אי זוגי. אם מסופק ערך כלשהו שאינו מספרי כקלט, א ValueError ייווצר, וחריגה תיזרק אל לתפוס חסום כדי להדפיס את הודעת השגיאה.
c23.py
# נסה לחסוםלְנַסוֹת:
# קח מספר
מספר= int(קֶלֶט('הזן מספר:'))
אםמספר %2 == 0:
הדפס('המספר שווה')
אַחֵר:
הדפס('מספר מוזר')
# בלוק חריג
מלבד (ValueError):
# הודעת שגיאת הדפסה
הדפס('הזן ערך מספרי')
הפלט הבא יופיע לאחר ביצוע התסריט.
אם ברצונך לדעת פרטים נוספים אודות הטיפול בחריגים בפייתון, תוכל לעיין במדריך, טיפול חריגים בפייתון.
לקרוא ולכתוב קובץ:
התסריט הבא מציג את הדרך לקריאה וכתיבה לקובץ בפייתון. שם הקובץ מוגדר במשתנה, שם הקובץ. הקובץ נפתח לכתיבה באמצעות לִפְתוֹחַ() שיטה בתחילת התסריט. שלוש שורות נכתבות בקובץ באמצעות לִכתוֹב() שיטה. לאחר מכן, אותו קובץ נפתח לקריאה באמצעות לִפְתוֹחַ() שיטה, וכל שורה בקובץ נקראת ומודפסת באמצעות ל לוּלָאָה.
c24.py
#הקצה את שם הקובץשם קובץ= 'languages.txt'
# פתח קובץ לכתיבה
fileHandler= לִפְתוֹחַ(שם קובץ, 'ב')
# הוסף טקסט
fileHandler.לִכתוֹב('לַחֲבוֹט n')
fileHandler.לִכתוֹב('פִּיתוֹן n')
fileHandler.לִכתוֹב('PHP n')
# סגור את הקובץ
fileHandler.סגור()
# פתח קובץ לקריאה
fileHandler= לִפְתוֹחַ(שם קובץ, 'ר')
# קרא קובץ שורה אחר שורה
לקַובfileHandler:
הדפס(קַו)
# סגור את הקובץ
fileHandler.סגור()
הפלט הבא יופיע לאחר ביצוע התסריט.
אם אתה רוצה לדעת פרטים נוספים על קריאה וכתיבה של קבצים בפייתון, תוכל לבדוק את ההדרכה, כיצד לקרוא ולכתוב לקבצים ב- Python .
רשימת קבצים בספרייה:
ניתן לקרוא את התוכן של כל ספרייה באמצעות אתה מודול של פייתון. התסריט הבא מראה כיצד לקבל את רשימת הספרייה הספציפית בפייתון באמצעות אתה מודול. listdir () שיטה משמשת בתסריט כדי לברר את רשימת הקבצים והתיקיות של ספרייה. ל לולאה משמשת להדפסת תוכן הספרייה.
c25.py
# ייבא מודול OS לקריאת ספרייהיְבוּא אתה
# הגדר את נתיב הספרייה
נָתִיב= '/home/fahmida/projects/bin'
# קרא את תוכן הקובץ
קבצים= אתה.listdir(נָתִיב)
# הדפס את תוכן הספרייה
ל קוֹבֶץ בקבצים:
הדפס(קוֹבֶץ)
תוכן הספרייה יופיע לאחר ביצוע הסקריפט אם הנתיב המוגדר של הספרייה קיים.
חלק עליוןלקרוא ולכתוב באמצעות מלפפון חמוץ:
התסריט הבא מציג את דרכי הכתיבה והקריאה של נתונים באמצעות את החמוץ מודול של פייתון. בתסריט, אובייקט מוכרז ומתאתחל עם חמישה ערכים מספריים. הנתונים של אובייקט זה נכתבים לקובץ באמצעות המזבלה() שיטה. לאחר מכן, ה לִטעוֹן() שיטה משמשת לקריאת הנתונים מאותו קובץ ושמירתם באובייקט.
c26.py
# ייבא מודול מלפפון חמוץיְבוּא מלפפון חמוץ
# הצהירו על האובייקט לאחסון נתונים
dataObject= []
# חזור על לולאת ה- for במשך 5 פעמים
לעל אחדב טווח(10,חֲמֵשׁ עֶשׂרֵה):
dataObject.לְצַרֵף(על אחד)
# פתח קובץ לכתיבת נתונים
מטפל_קובץ= לִפְתוֹחַ('שפות', 'wb')
# זרוק את נתוני האובייקט לקובץ
מלפפון חמוץ.מזבלה(dataObject,מטפל_קובץ)
# סגור את מטפל הקבצים
מטפל_קובץ.סגור()
# פתח קובץ לקריאת הקובץ
מטפל_קובץ= לִפְתוֹחַ('שפות', 'rb')
# טען את הנתונים מהקובץ לאחר עריכה מחדש
dataObject= מלפפון חמוץ.לִטעוֹן(מטפל_קובץ)
# חזור על הלולאה כדי להדפיס את הנתונים
לשעותבdataObject:
הדפס('ערך הנתונים:',שעות)
# סגור את מטפל הקבצים
מטפל_קובץ.סגור()
הפלט הבא יופיע לאחר ביצוע התסריט.
אם אתה רוצה לדעת פרטים נוספים על קריאה וכתיבה באמצעות מלפפון חמוץ, תוכל לבדוק את ההדרכה, כיצד לכבוש אובייקטים בפייתון .
הגדר כיתה ושיטה:
התסריט הבא מראה כיצד ניתן להכריז על מחלקה ושיטה ולגשת אליה ב- Python. כאן, מחלקה מוכרזת עם משתנה מחלקה ושיטה. לאחר מכן, אובייקט מהמחלקה מוכרז כגישה למשתנה המחלקה ולשיטת המחלקה.
c27.py
# הגדר את הכיתהמעמדעוֹבֵד:
שֵׁם= 'מוסטק מחמוד'
# הגדר את השיטה
defפרטים(עצמי):
הדפס('פוסט: קצין שיווק')
הדפס('מחלקה: מכירות')
הדפס('שכר: $ 1000')
# צור את אובייקט העובד
emp=עוֹבֵד()
# הדפס את משתנה הכיתה
הדפס('שֵׁם:',emp.שֵׁם)
# התקשר לשיטת הכיתה
emp.פרטים()
הפלט הבא יופיע לאחר ביצוע התסריט.
חלק עליוןשימוש בפונקציית טווח:
התסריט הבא מציג את השימושים השונים של פונקציית הטווח בפייתון. פונקציה זו יכולה להכיל שלושה ארגומנטים. אלו הם הַתחָלָה , תפסיק , ו שלב . ה תפסיק הטיעון הוא חובה. כאשר משתמשים בארגומנט אחד, ערך ברירת המחדל של ההתחלה הוא פונקציית 0. range () עם ארגומנט אחד, שני ארגומנטים ושלושה ארגומנטים משמשים בשלושת ל לולאות כאן.
c28.py
טווח # (עם פרמטר אחדלשעותב טווח(6):
הדפס(שעות,סוֹף='')
הדפס(' n')
טווח # (עם שני פרמטרים
לשעותב טווח(5,10):
הדפס(שעות,סוֹף='')
הדפס(' n')
טווח # (עם שלושה פרמטרים
לשעותב טווח(0,8,2):
הדפס(שעות,סוֹף='')
הפלט הבא יופיע לאחר ביצוע התסריט.
שימוש בפונקציית המפה:
מַפָּה() פונקציה משמשת בפייתון להחזרת רשימה באמצעות כל פונקציה המוגדרת על ידי משתמש וכל אובייקט חוזר. בתסריט הבא, cal_power () פונקציה מוגדרת לחישוב איקסנ, והפונקציה משמשת בטיעון הראשון של מַפָּה() פוּנקצִיָה. רשימה בשם מספרים משמש בטיעון השני של מַפָּה() פוּנקצִיָה. הערך של איקס יילקח מהמשתמש, ו- מַפָּה() פונקציה תחזיר רשימה של ערכי הספק של איקס, מבוסס על ערכי הפריט של מספרים רשימה.
c29.py
# הגדר את הפונקציה לחישוב הספקdefcal_power(נ):
לַחֲזוֹרx ** נ
# קח את הערך של x
איקס= int(קֶלֶט('הזן את הערך של x:'))
# הגדר כפל מספרים
מספרים= [2, 3, 4]
# חשב את ה- x לעוצמה n באמצעות מפה ()
תוֹצָאָה= מַפָּה(cal_power,מספרים)
הדפס(רשימה(תוֹצָאָה))
הפלט הבא יופיע לאחר ביצוע התסריט.
שימוש בפונקציית המסנן:
לְסַנֵן() פונקציה של פייתון משתמשת בפונקציה מותאמת אישית כדי לסנן נתונים מאובייקט חוזר וליצור רשימה עם הפריטים עבור אלה שהפונקציה מחזירה true. בתסריט הבא, אדם נבחר () הפונקציה משמשת בסקריפט ליצירת רשימה של הנתונים המסוננים המבוססים על הפריטים של רשימה נבחרת .
c30.py
# הגדר רשימת משתתפים= ['המונה ליזה', 'אכבר חוסיין', 'ג'קיר חסן', 'זהדור רחמן', 'זניפר לופז']
# הגדר את הפונקציה לסנן מועמדים נבחרים
defאדם נבחר(מִשׁתַתֵף):
נבחר= ['אכבר חוסיין', 'זילור רחמן', 'המונה ליזה']
אם(מִשׁתַתֵףבנבחר):
לַחֲזוֹר נָכוֹן
רשימה נבחרת= לְסַנֵן(אדם נבחר,מִשׁתַתֵף)
הדפס('המועמדים שנבחרו הם:')
למוּעֲמָדברשימה נבחרת:
הדפס(מוּעֲמָד)
הפלט הבא יופיע לאחר ביצוע התסריט.
סיכום:
יסודות תכנות הפיתון נדונים באמצעות 30 נושאים שונים במאמר זה. אני מקווה שהדוגמאות של מאמר זה יעזרו לקוראים ללמוד פייתון בקלות מההתחלה.