פייתון/פייתון גרסה 3/רשימת פונקציות מערכת built-in

מתוך ויקיספר, אוסף הספרים והמדריכים החופשי
קפיצה לניווט קפיצה לחיפוש
פונקציות סוג הסבר דוגמה
פונקצית print פונקצית להצגת מלל
type טיפוסים הפונקצית מצייגת בפניו את סוג הטיפוס שהוקלד
input
פונקצית int פונקציות להמרת טיפוסים המרת מחרוזת לערך מספרי (שלם)
>>>7.0
>>>type(7.0)
float
>>>int(7)
7
פונקצית float פונקציות להמרת טיפוסים המרת מחרוזת לערך מספרי (עשרוני)
>>>7
>>>type(7)
int
>>>float(7)
7.0
פוקנצית bool פונקציות להמרת טיפוסים המרת ביטוים בוליאנים. הפונקצית יכולה לקבל את גם את הביטוים: boll("") , boll(0) ו-boll(1) ולהמירם לביטוי בוליאני.
>>>bool(1)
True
>>>bool()
Flase
פונקצית len חישוב אורך מחרוזת מחשבת כמה תווים יש במחרוזת וברשימות
>>> user="Tamar oling"
>>> len(user)
11
>>>user=" "
>>>len(user)
0
>>> names=['alex', 'Dani','Yossi']
>>> len(names)
3
  • להבדיל מ-range הפוקנציה len מתחילה בספירה מאחד.
פונקצית str פונקציות להמרת טיפוסים הופכת ביטוי שאינו מחרוזת למחרוזת.
>>>32332243
32332243
>>>str(32332243)
'32332243'

המרנו טיפוס מסוג int למחרוזת.

פונקצית lower פונקציות גופן, str הופכת אותיות גדולות לקטנות (שמו המחרוזת שלפני הפונקצית מומרת)
>>>"HELLO".lower()
hello

ניתן גם לבצע פעולה זו עבור משתנים:

>>>a=HELLO
>>>a.lower()
hello
פונקצית upper פונקציות גופן הופכת אותיות קטנות לגדולות
>>> "HELLO".lower()
'hello'

ניתן גם לבצע פעולה זו עבור משתנים:

>>>a=hello
>>>a.upper()
HELLO
פונקצית strip() פונקצית גופן פונקצית אשר מוחקת ממחרוזת תווים אותם בוחר המשתמש מהתחלה ומהסוף, ומייצרת מחרוזת חדשה בלעדיהם.
>>> str="00000Hello worl000d!0000"
>>> print(str.strip('0'))
Hello worl000d!
>>> a = ' hello world    '
>>> b = a.strip()
>>> b
'hello world'
>>> id(a)
58368080
>>> id(b)
58362600

>>> c = b.strip('d')
>>> c
'hello worl'
>>>
פונקצית rstrip חפונקצית lstrip מיצרת העתק של מחרוזת לאחר הסרת כל התווים מקצה ימין (rstrip) או מקצה שמאל (lstrip). ברירת המחדל להסרת תווים הם רווחים
>>> a= '    hello world     '
>>> b = a.rstrip()
>>> b
'    hello world'
>>> c = a.lstrip()
>>> c
'hello world     '
פונקצית ord() יוניקוד התווים במחשב מוגדרים בידי מספרים בלבד (ASCII) שמייצרים לבסוף סימנים ומערכות שלמות עם תמונות. בכדי לדעת מה היוניקוד של פרמטר נעזר בפונקצית ord()
>>> ord("a")
97
פונקצית chr() יוניקוד פונקצית chr היא הפונקצית ההפוכה של ord ומצייגה את הפרמטר של מספר
>>>chr(97)
'a'
פונקצית .capitalize() פונקצית גופן פונקצית שהופכת את הראשונה לגדולה
>>>"hello".capitalize()
'Hello'

בדומה לפונקציות הגופן ניתן להשתמש גם על משתנים.

פונקצית center() פונקצית גופן ועיצוב הפונקצית מדפיסה כיתוב במרכז של מספר תווים המוקלדים בידי המשתמש
>>>"hello".center(14)
'    hello     '
פונקצית help פונקצית תיעוד פונקצית help מדפיסה את הערות בגרשים
>>>help(int)
Help on class int in module builtins:

class int(object)
 |  int(x=0) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero...
פונקצית quit() פקודה לסגירת ה-idle ללא שמירה סגירת פיתון
פונקצית pow() פונקציות לפעולות ארתימיות פונקצית המעלה בחזקה מספרים שלמים
>>>pow(2,5)
32
פונקצית count() פונקצית מחזירה את כמות המופיעים, הלא מתנגשים של תו בתת מחרוזת
>>>sen="hello word! how are you today?"
>>>sen.count('o')
5

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

>>>sen="hello word! how are you today?"
>>> sen.count('o', 2,6)
1

האות "o" מופיע בין התווים במיקום השני ועד השישי פעם אחת.

פונקצית round () מספרים פונקצית אשר מעגלת את המספר. ניתן להגדיר כמה נקודות אחרי הנקודה באמצעות פסיק ואחריו מיקומו של המספר העשרוני האחרון שנרצה שיופיע
print(round(2.3334))
print(round(2.3334, 2))

>>>2
>>>2.33
פונקצית find פונקצית המוצאת תת מחרוזת. אם תת מהחרוזת קיימת ברצף היא מחזירה את מיקום התו הראשון. אם תת המחרוזת אינה קיימת היא מחזירה את הערך
>>>sen="hello word! how are you today?"
>>> sen.find('how')
12

בדומה לפונקצית count ניתן להגביל את החיפוש בין תווים.

פונקצית rfind() פונקצית rfind מתפקדת בדיוק כמו פונקצית find רק מתחילה את החיפוש מימן לשמאל (בספירה אחורית)
>>>sen="hello word! how are you today?"
>>> sen.rfind('how')
12
פונקצית index פונקצית Index פועל בדומה לפונקצית find אך במקרה והתו אינו במחרוזת היא מחזירה הודעת שגיאה ValueError
>>>sen="hello word! how are you today?"
>>> sen.index('today')
24
פונקצית rindex() פונקצית rindex פועלת בדומה לפונקצית rfind() אך במקרה והתו אינו במחרוזת מחזירה הודעת שגיאה ValueError
>>>sen="hello word! how are you today?"
>>>sen.rindex('today')
24
פונקצית replace() פונקצית replace מבצעת החלפה של תו בתו אחר
>>>sen="hello word! how are you today?"
>>> sen.replace('e', 'z')
'hzllo word! how arz you today?'

ניתן להגביל את מספר התווים שיחלפו.

>>> sen.replace('e','z',1)
'hzllo word! how are you today?'

התו הראשון בלבד יוחלף.

פונקצית eval פונקצית eval מבצעת חישוב של משתנים
>>> x=5
>>> y=7
>>> eval('x+y')
12
פונקצית dir פונקצית תיעוד
>>>dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
פונקצית isinstance פונקצית הפוכה ל-type. הפונקצית מבררת האם טיפוס הוא אכן מסוג מסוים
>>> isinstance(2, int)
True
>>> isinstance('a',int)
False
>>>isinstance('a',(int,str))
True

בדוגמה לעיל הפונקצית בודקת האם "2" הוא מטיפוס int

ניתן לבצע בדיקה עבור שני ערכים כאשר בניהם יש קשר של "או". האם a היא Int או str

פונקצית insert() list פונקצית המאפשרת להכניס פריט לתוך רשימה בכדי להכניס פריט אל תוך רשימה נרשום את שם הרשימה, נפתח סוגרים מעוגלים ואחריהם את מיקום הפריט אותו נרצה לשנות, פסיק ושם הפריט החדש:
>>> list_1.insert(5,'alex')
>>> list_1
['a', 'b', 'c', 'd', 'e', 'alex']

ניתן להוסיף איבר בסוף הרשימה בקלות באמצעות פונקצית len שמציינת את סופה של הרשימה:

>>> list_1.insert(len(list_1), "7")
>>> list_1
['a', 'b', 'c', 'd', 'e', '7']

לחילופין באמצעות מינוס:

>>> L.insert(-2,'y')
>>> print(L)
[1, 2, 3, 'y', 4, 5]
פונקצית append list פונקצית המאפשרת להכניס פריט יחיד לסופה של רשימה
>>> list_1=['a','b','c','d','e']
>>> list_1.append("3")
>>> list_1
['a', 'b', 'c', 'd', 'e', '3']


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

>>> L=[1,2,3]
>>> L[0]=1,2
>>> L
[(1, 2), 2, 3]

נשם לב כאשר אנו חותכים רשימה ומוסיפי אותה אל תוך רשימה אחרת באמצעות append נקבל רשימה מקוננת:

L1=list(range(5))
L2=[1,2,3]
L_new=[]

while L1: #existent
    L_new.append(L2[:2])
    L1=L1[2:]

print(L_new)

>>>[[1, 2], [1, 2], [1, 2]]

שמו לב אילו היינו מבקשים לצרף איבר אחר מהרשימה לא הינו מקבלים רשימה מקוננת:

L1=list(range(5))
L2=[1,2,3]
L_new=[]

while L1: #existent
    L_new.append(L2[2])
    L1=L1[2:]

print(L_new)
  
>>>[3, 3, 3]
פונקצית extend list פונקצית המאפשרת הוספת איברים לסוף רשימה להבדיל מ-append פונקצית extend יכולה להוסיף יותר מערך אחד לרשימה ולכן אם נרשום עבורה רשימה של ערכים, כל ערך יהיה אוביקט חדש ברשימה אליה צרפנו. לעומת זאת, ב-append, אם נוסיף שני איברים, הפונקציה תכניס אותם לרשימה החדשה כרשומה מקוננת.
>>> list_1=['a','b','c','d','e']
>>> list_1.extend(["5","6","7"])
>>> list_1
['a', 'b', 'c', 'd', 'e', '5', '6', '7']
פונקצית remove list פונקצית המאפשרת מחיקת פרטים על פי מופיעים
>>>
>>> list_1=['a','b','c','d','e']
>>> list_1.remove('c')
>>> list_1
['a', 'b', 'd', 'e']
פונקצית sort list פונקצית המאפשרת למיין פרטים
>>> list=[1,5,7,9,17,4,0,2]
>>> list.sort()
>>> list
[0, 1, 2, 4, 5, 7, 9, 17]

ראה גם את ההבדל עם sorted

פונקצית sorted רשימות, מילונים, טפלים, מחרוזות פונקצית המאפשרת למיין פרטים
#function sorted:
>>> L1=[3,2,1]
>>> print(sorted(L1))
[1, 2, 3]

# L1 is the same 
>>> print(L1)
[3, 2, 1]

# function sort:

# returns None
>>> print(L1.sort())
None

#changes the list:
>>> print(L1)
[1, 2, 3]

שמו לב להבדל בין פונקצית sort() לפונקצית sorted. פונקצית sorted:

  1. אינה משנה את הטיפוס המקורי אותו היא ממינת אלא מייצרת רשימה חדשה.
  2. ניתן למיין איתה מילונים, טיפוסים, מחרוזות ורשימות להבדיל מ-sort שממינת רק מילונים.
פונקצית split list פונקצית המפרידה מחרוזות ויוצרת מהן רשימות יש לרשום את שם הטיפוס לפני הפונקצית. בסוף הפונקצית ניתן לרשום בסוגרים את סוג המפריד ואחריו מספר הפעמים שיש לבצע חיתוך. אם לא ציין פרמטרים אלו הפונקצית תפריד בין מחרוזות על סמן הרווחים הריקים עד סוף הטיפוס.
>>>
>>> sen="Hello world! How are you?"
>>> sen.split()
['Hello', 'world!', 'How', 'are', 'you?']

>>> sen.split('o')
['Hell', ' w', 'rld! H', 'w are y', 'u?']

>>> sen.split('o',2)
['Hell', ' w', 'rld! How are you?']

upcaking split:

ניתן לבצע unpacking לאחר חיתוך וזאת בתנאים שאנו יודעים כמה איברים נקבל לאחר החיתוך:

first_word, second_word = "hello world".split()
print(first_word)
print(second_word)

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

פונקצית rsplit list פונקצית המפרידה בין מחרוזות ויוצרת מהן רשימות כשהחיפוש מכיוון ימין לשמאל.
>>>
פונקצית splitlines list יודעת להפריד מחרוזות שיורדות שורה לפריטים ברשימה
>>> sen="hello \n every one \n how"
>>> sen
'hello \n every one \n how'
>>>sen.splitlines()
['hello ', ' every one', 'how']
פונקצית join list פונקצית אשר מדביקה פריטים מתוך רשימה למחרוזת
>>> list=['hello ', ' every ', ' one']
>>> new=''.join(list)
>>> new
'hello  every  one'
פונקצית abs פעולות מתמטיות מציאת ערך מוחלט עבור משתנה
>>>
>>> abs(-1)
1
פונקצית Min פעולות מתמטיות : list, מחרוזת, מספר פונקצית המחשבת את המספר המינמלי
>>> L=[1,2,3,4,5,23,7,8]
>>>min_of_L=min(L)
>>> print(min(L))
1
פונקצית max פעולות מתמטיות : list, מחרוזת, מספר פונקצית המחשבת את המספר המקסימלי
>>> L=[1,2,3,4,5,23,7,8]
>>> max_of_L=max(L)
>>> print(max_of_L)
23
פונקצית sum פעולות מתמטיות ו-list פונקצית המחשבת את סכומה של רשימה
>>> L=[1,2,3,4,5,23,7,8]
>>> print(sum(L))
53
פונקצית tuple טיפוסים, רשומה פונקצית tuple ממירה רשימה, מחרוזת ומספרים לרשומה:
>>> L=[1,2,3,4,5]
>>> T=tuple(L)
>>> type(T)
<class 'tuple'>

פונקציה זו בדומה לפונקצית רשימה מפרידה בין כל תו ותו :

>>> tuple('hello')
('h', 'e', 'l', 'l', 'o')
פונקצית union קבוצה הפונקצית מבצעת איחוד של קבוצה או רשימה אל קבוצה אחרת:
>>> a={1,3,56,57,543}
>>> c={244,'a','b'}
>>> a.union(c)
{1, 3, 'a', 244, 'b', 56, 57, 543}
פונקצית difference קבוצה הפונקצית מבצעת חיסור של קבוצה או רשימה מקבוצה:
>>> a={1,2,3,4,5}
>>> b={6,7,5,3,8}
>>> a.difference(b)
{1, 2, 4}
פונקצית intersection קבוצה פונקצית המבצעת חיתוך של קבוצה עם רשימה, מחרוזת או קבוצה
>>> a={1,2,3,4,5}
>>> b={6,7,5,3,8}
>>> a.intersection(b)
{3, 5}
פונקצית set טיפוס, קבוצה פונקצית set ממירה רשימות ורשומות לקבוצות. שמו לב שכל אוביקט בה בדומה לפונצקית TUPLE ו-LIST מפרקת לתווים
>>>>>> word='apple'
>>> set(word)
{'e', 'a', 'p', 'l'}
#set on a list
>>> L=[1,2,3,1]
>>> print(set(L))
{1, 2, 3}

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


פונקצית dict() פונקצית הממירה רשומה למילון טיפוסים : מילון
>>>
>>> a=('alex','1'),('Dani','2'),('ron','3')
>>> r=dict(a)
>>> print(r)
פונקצית del מילון, רשימה פונקצית אשר מוחקת מפתחות ממילון
>>>
>>> d={a:1,b:2,c:3}
>>> del d[a]
>>> d
{4: 2, 5: 3}

>>>L=['a', 'b', '1',6, '2',4, 'd', 'r', '3', 2, 9, 10]
>>>del L[0]
>>>print(L)
['b', '1', 6, '2', 4, 'd', 'r', '3', 2, 9, 10]
פונקצית keys מילון פונקצית המדפיסה את כל המפתחות של מילון (iterable)
>>> d={'a':1,'b':2,'c':3}
>>> d.keys()
dict_keys(['a', 'b', 'c'])
פונקצית item מילון מחזירה טפל של זוגות שהאיבר הראשון הוא איבר המפתח והשני הוא הערך המשויך למפתח.
>>> D= {1:'a', 2:'b'}
>>> D.items()
dict_items([(1, 'a'), (2, 'b')])
פונקצית enumerate טיפוסים שלא ניתנים לשינוי הפונקצית מחזירה זוגות, זוגות של טפלים כאשר הראשון הוא פריט שניתן לספירה (enumerate), דהינו מספור המתחיל מאפס, והשני ערך מטיפוס אותו לא ניתן לשינוי כמו רשומה או רשימה שאינה ניתנת לשינוי
>>>D={'alex':'a','Don':'b','Dror':'c','Michael':'r'}
>>>enumerate(D)
>>>r=list(enumerate(D))
print(r)
[(0, 'alex'), (1, 'Don'), (2, 'Dror'), (3, 'Michael')]

ואם נמיר לרשימה:

>>>for i, v in enumerate('hello world'):
       	print (i, v)

0 h
1 e
2 l
3 l
4 o
5  
6 w
7 o
8 r
9 l
10 d
פונקצית values מילון פונקצית המחזירה רשימה של כל הערכים של המילון
>>>
D={'alex':'a','Don':'b','Dror':'c','Michael':'r'}
V=D.values()
print(V)

dict_values(['a', 'b', 'c', 'r'])
פונקצית zip מייצר זוגות של טפלים מתוך שתי רשימות שמקבל:
>>> L_1=[1,2,3]
>>> L_2=['a','b','c']
>>> T=list(zip(L_1,L_2))
>>> print(T)
[(1, 'a'), (2, 'b'), (3, 'c')]

השימוש הנפוץ ביותר הוא שימוש בלולאת for ו-zip:

L1=[1,2,3]
L2=['a','b','c']
L3=['alex','ron','Avi']
for x in zip(L1,L2):
    print(x)
    print(type(x))

for x in zip(L1,L2,L3):
    print(x)
    print(type(x))


(1, 'a')
<class 'tuple'>
(2, 'b')
<class 'tuple'>
(3, 'c')
<class 'tuple'>
(1, 'a', 'alex')
<class 'tuple'>
(2, 'b', 'ron')
<class 'tuple'>
(3, 'c', 'Avi')
<class 'tuple'>
פונקצית list.reverse() רשימה פונקצית שהופכת את הסדר של רשימה
>>> L=[1,2,3,4,5]
>>> L.reverse()
>>> print(L)
[5, 4, 3, 2, 1]
פונקצית id Immutable פונקצית אשר מחזירה את "תעודת הזהות" של פריט. תעודת הזהות הוא ערך קבוע עבור תכנית בפיתון. ברב המחשבים מספר זה הוא מספר האחסון של הפריט במחשב.
>>>
>>> a=5
>>> b=5
>>> id(a)
1890047856
>>> id(b)
1890047856
>>> id([a])
97796464
פונקצית list פונקציות להמרת טיפוסים, רשימות פונקצית ההמירה טיפוסים לרשימה.לא ניתן לבצע המרה עבור מספרים. יש להמירם תחילה למחרוזת
>>>>>> list('hello')
['h', 'e', 'l', 'l', 'o']
פונקצית pop רשימות פונקצית המוחקת איבר ברשימה ומדפיסה אותו למשתמש. אם לא מוגדר מיקומו של האיבר בסוגרים, ברירת המחדל הוא מחיקת האיבר האחרון.
>>>>>> L=[1,2,3,4,5,6]
>>> L.pop()
6
>>> print(L)
[1, 2, 3, 4, 5]
#del L[2]
>>> L.pop(L[2])
4
>>> print(L)
[1, 2, 3, 5]

>>> L=[1, 2, 3, 'y', 4, 5]
>>> L.pop(L[-2])
4
>>> print(L)
[1, 2, 3, 'y', 5]
פונקצית assert פונקצית assert בודקת האם פועלה מתקיימת או אינה מתקיימת. במידה והפעולה אינה מתקיימת מתקבלת הודעת שגיאה.
text=int(input('insert a number: '))
assert(type(text)==str)
print('he')
           

>>>insert a number: 1
>>>Traceback (most recent call last):
  File "C:/Users/user/Documents/אוניברסיטה עברית/סימסטר ב/intro/005/assert.py", line 2, in <module>
    assert(type(text)==str)
AssertionError

פקודה תקינה:

>>>
text=input('insert a number:')
assert(type(text)==str)
print('he')
           
insert a number: 12
he
פונקצית get() מילון, מחלקה פונקציה שמאפשרת לשלוף את המידע על האוביקט
>>>d={'1':'a','2':'b'}
>>>print(d.get('1'))
a
פונקציה map iter הפונקציה מקבלת iterable ופונקציה. מחזירה רשימה שהם תוצר של הפעלת הפונקציה על כל איבר ב- iterable
import math
L=[4,16, 25, 2, 9, 100]

#map recived an iterable number, in our case an item from a list
# than he made on the item acttion and 
a= list(map(math.sqrt, L))

print(L)
print(a)

[4, 16, 25, 2, 9, 100]
[2.0, 4.0, 5.0, 1.4142135623730951, 3.0, 10.0]
פונקצית filter iter הפונקציה מקבלת iterable ופונקצית פילטר, דהינו פקודה לפיה פייתון תסנן את כל האיברים ב- iterable שאינם עומדים בדרישות הפילטר, ותחזיר iterable חדש רק עם אלו שעומדו בדרישות.
number_list = range(-5, 5)
print(list(number_list))
greater_than_zero = list(filter(lambda x: x > 0, number_list))
print(greater_than_zero) 

>>>[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>>[1, 2, 3, 4]

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

פונקצית global הופכת משתנה לגלובלי
פונקצית object() מחלקה, ירושה פונקציה שמחזירה את האובייקט הקדמון ביותר של כל המחלקות הקיימות בפיתון.
פונקצית frozenset רשומה הפונקציה שמייצרת קבוצה שלא ניתן לשנותה.
# set
lst = [1,2,3,4,2]
a = set(lst)
print('before add a value', a)
a.add(7) # set is mutable

print('added to a the value', a)

# frozenset
b = frozenset(lst)
print(b)
b.add(7)


>>>before add a value {1, 2, 3, 4}
>>>added to a the value {1, 2, 3, 4, 7}
>>>frozenset({1, 2, 3, 4})
>>>Traceback (most recent call last):
  File "C:/Users/user/Downloads/de/x.py", line 10, in <module>
    b.add(7)
AttributeError: 'frozenset' object has no attribute 'add
פונקצית repr
פונקצית next גנרטור פונקצית next מחזירה את ערך האיטרטור הנוכחי ובכל קריאה מקדמת את המצביע לאיבר הבא באיטרטור
def hello_world_generator():
    yield "hello"
    yield "world"

calling_hello_world_fun = hello_world_generator()
>>>print(next(calling_hello_world_fun))
hello
>>>print(next(calling_hello_world_fun))
world
>>>print(next(calling_hello_world_fun))
Traceback (most recent call last):
  File "C:calling_hello_world.py", line 9, in <module> print(next(calling_hello_world_fun))
StopIteration
פונקצית iter איטרטור מחזירה את כל איברי ה-iterable
x = iter([1,2,3,5])
print(x)
>>><list_iterator object at 0x000001D884050AC8>
print(tuple(x))
>>>(1, 2, 3, 5)

דוגמה נוספת:

lst = [1,2,3,4]
x = iter(lst)
y = iter(lst)

print(next(x))
>>>1
print(next(y))
>>>1
פונקצית reversed איטרטור מחזירה את כל איברי ה-iterable בסדר הפוך
>>> lst = reversed(range(5))
>>> print(next(lst))
4
>>> print(next(lst))
3
>>> print(next(lst))
2
>>> print(next(lst))
1
>>> print(next(lst))
0
>>> print(next(lst))
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    print(next(lst))
StopIteration

פונקציות method[עריכה]

הן פונקציות מהצורה type.name_function(). לדוגמה, הפונקציה append היא פונקציה method מפני שתחילה רושמים למשל רשימה, אחריה נקודה ושם הפונקציה. לבסוף פקודות ספציפיות בסוגרים.

מקורות חיצונים[עריכה]