פייתון/פייתון גרסה 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!
פונקצית 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'>
פונקצית 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 ממירה רשימות ורשומות לקבוצות
>>>>>> 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]
>>>

|-
|
|
|
|<source lang = "python">
>>>

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

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

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

  • פיתון, רשימת פונקציות bulit in