פייתון/פייתון גרסה 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)
6
>>>user=" "
>>>len(user)
0
>>> names=['alex', 'Dani','Yossi']
>>> len(names)
3
פונקצית 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

פונקצית range פונקציה המייצרת רשימה של מספרים
>>> name=list(range(0,10))
>>> name
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

בכדי לייצר רשימה נצטרך להכניס את הפונקציה לתוך משתנה ולהדפיס.

ניתן לייצר רשימות באמצעות הפונקציה בקפיצות וגם לבצע בספירה לאחור (יש לשנות את הגבול)

>>> name=list(range(0,10,2))
>>> name
[0, 2, 4, 6, 8]
>>> name=list(range(10,0,-2))
>>> name
[10, 8, 6, 4, 2]
פונקצית 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']
פונקצית extend list פונקציה המאפשרת הוספת איברים לסוף רשימה
>>> 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?']
פונקצית 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 ממירה רשימות ורשומות לקבוצות
>>>
>>> L=[1,2,3,1,'a','b']
>>> print(set(L))
{1, 2, 3, 'a', 'b'}

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


פונקציה 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">
>>>

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

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