ויקיספר

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

< פייתון | פייתון גרסה 3
פונקציות סוג הסבר דוגמה
פונקציית print פונקציה להצגת מלל 
>>>print("Hello, World!")
Hello, World!
פונקציית type טיפוסים הפונקציה מייצגת בפניו את סוג הטיפוס שהוקלד 
>>> a = 0
>>> type(a)
<class 'int'>
פונקציית input פונקציה לקליטת קלט הפונקציה מקבלת קלט מהמשתמש 
>>> user = input('please type here: ')
please type here: Hello!
>>> user
'Hello!'
פונקציית 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)
1
>>> 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".upper()
'HELLO'

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

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

>>> 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 world! how are you today?"
>>>sen.count('o')
5

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

>>>sen="hello world! 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 world! how are you today?"
>>> sen.find('how')
12

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

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

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

>>> sen.replace('e','z',1)
'hzllo world! 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 פונקציה אשר מדביקה פריטים מתוך רשימה למחרוזת 
>>> lst=['hello ', ' every ', ' one']
>>> new='#'.join(lst)
>>> print(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 מפני שתחילה רושמים למשל רשימה, אחריה נקודה ושם הפונקציה. לבסוף פקודות ספציפיות בסוגרים.

מקורות חיצונים

עריכה
אוחזר מתוך "https://he.wikibooks.org/w/index.php?title=פייתון/פייתון_גרסה_3/רשימת_פונקציות_מערכת_built-in&oldid=174706"