דף עזר

יחידות 2 עד 8 בעמוד אחד, ומילון מונחים.

בעמוד הזה

טיפוסים אופרטורים רצפים: מחרוזת, רשימה, טאפל רשימה מילון תנאים ולולאות פונקציות פקודות שגיאות PEP 8 מילון מונחים

טיפוסים

	דוגמה	הסבה	שינוי
`str`	`"Python"`	`str(3)` הוא `'3'`	לא
`int`	`2`	`int("5")` הוא `5`
`float`	`7.25`	`float("5")` הוא `5.0`
`bool`	`True`	`bool(0)` הוא `False`
`list`	`[1, "a"]`	`list("ab")`	כן
`tuple`	`(1, "a")`, `(1,)`	`tuple([1, 2])`	לא
`dict`	`{"k": 1}`	`dict()`	כן

אופרטורים


`+ - * / **`	חשבון. `**` חזקה
`%`	שארית. `n % 2 == 0` פירושו זוגי
`+=`, `-=`	`x += 1` הוא `x = x + 1`
`+` על רצפים	שרשור, רק מאותו טיפוס
`*` על רצף ומספר	הכפלה: `"ab" * 2` הוא `'abab'`
`== != < > <= >=`	השוואה
`not and or`	לוגיקה
`in`	הכלה: `"b" in "abc"`, `3 in [1, 3]`, `"k" in d`

רצפים: מחרוזת, רשימה, טאפל


`s[0]`, `s[-1]`	ראשון, אחרון
`s[a:b]`	מ-a עד b, בלי b
`s[:b]`, `s[a:]`, `s[:]`	מההתחלה, עד הסוף, הכל
`s[a:b:k]`	בקפיצות של k. `s[::-1]` הפוך
`len(s)`	אורך
`s.upper()`, `s.zfill(n)`	מחרוזת: גדולות, אפסים משמאל
`\n` `\t` `\\` `\"`	שורה, טאב, לוכסן, מרכאה
`"%s is %d" % (a, b)`	תבנית מחרוזת

רשימה


`lst.append(x)`	מוסיף בסוף. מחזיר `None`
`lst += [x, y]`	מוסיף כמה
`lst[i] = x`	מחליף. רק במיקום קיים
`lst.remove(x)`	מוחק מופע ראשון. לא קיים: `ValueError`
`lst.count(x)`	כמה פעמים
`lst.sort()`	ממיין את הרשימה עצמה
`sorted(lst, key=len)`	רשימה חדשה ממוינת
`max(lst)`, `sum(lst)`	הגדול, הסכום

מילון


`d["k"]`	ערך לפי מפתח. לא קיים: `KeyError`
`d["k"] = v`	מוסיף, או מעדכן אם קיים
`del d["k"]`	מוחק
`d.pop("k")`	מוחק ומחזיר את הערך
`d.keys()`, `d.values()`, `d.items()`	מפתחות, ערכים, זוגות כטאפלים

תנאים ולולאות


`if` / `elif` / `else`	הראשון שמתקיים, ורק הוא
`while תנאי:`	כל עוד
`for x in רצף:`	פעם לכל איבר
`range(start, stop, step)`	סדרה. `stop` לא נכלל
`break`	יוצא מהלולאה
`continue`	מדלג לאיטרציה הבאה
`pass`	בלוק ריק

פונקציות


`def f(a, b=2):`	הגדרה. ברירות מחדל בסוף
`return x, y`	מחזיר. כמה ערכים חוזרים כטאפל
בלי `return`	מחזיר `None`
`f(b=5, a=1)`	ארגומנטים לפי שם
`"""..."""`	docstring: `:param:` `:type:` `:return:` `:rtype:`
`global x`	משנה משתנה גלובלי. לא מומלץ
`if __name__ == "__main__": main()`	מבנה התוכנית

פקודות


`print(a, b, end=" ")`	הדפסה
`input("...")`	קלט. תמיד מחרוזת
`type(x)`	הטיפוס
`import math`, `math.sqrt(x)`	שורש, `float`
`help(f)`, `f.__doc__`	תיעוד. `q` יוצא
`dir(str)`	המתודות
`a, b = b, a`	החלפה

שגיאות


`SyntaxError`	כתיבה לא תקינה
`IndentationError`	הזחה לא במקום
`TypeError`	טיפוס לא מתאים לפעולה
`NameError`	שם לא מוכר, או מחוץ לטווח
`IndexError`	מיקום לא קיים
`ValueError`	ערך לא מתאים, למשל `remove`
`KeyError`	מפתח לא קיים

PEP 8


`snake_case`	משתנים ופונקציות
`UPPER_CASE`	קבועים
ארבעה רווחים	הזחה
`x = a + b`, `f(a, b)`	רווחים
שתי שורות ריקות	בין פונקציות

מילון מונחים

עברית	אנגלית	פירוש
משתנה	variable	שם שמצביע על אובייקט
השמה	assignment	`=`. קישור שם לערך
טיפוס	type	סוג האובייקט: `int`, `str` ועוד
מחרוזת	string	רצף תווים
בוליאני	boolean	`True` או `False`
הסבה	casting	המרה בין טיפוסים
קבוע	constant	ערך שלא משתנה. בקונבנציה, אותיות גדולות
קונבנציה	convention	מוסכמה. לא נאכפת על ידי השפה
תו בריחה	escape character	`\`. מנטרל את המשמעות של התו הבא
אינדקס	index	מיקום ברצף, מאפס
חיתוך	slicing	`[a:b]`
רצף	sequence	מחרוזת, רשימה, טאפל
ניתן לשינוי	mutable	רשימה, מילון
לא ניתן לשינוי	immutable	מחרוזת, טאפל
בלוק	block	שורות מוזחות שמתחת לשורה עם נקודתיים
הזחה	indentation	הרווחים בתחילת השורה
בקרת זרימה	flow control	`if`, לולאות, `break`
איטרציה	iteration	סבב אחד של לולאה
פונקציה	function	בלוק עם שם, שמבצע משימה
מתודה	method	פונקציה של טיפוס: `x.upper()`
פרמטר	parameter	השם בהגדרה
ארגומנט	argument	הערך בקריאה
ערך החזרה	return value	מה ש-`return` מחזיר
ברירת מחדל	default	ערך לפרמטר שלא נשלח
טווח הכרה	scope	איפה משתנה קיים
גלובלי, לוקאלי	global, local	מחוץ לפונקציה, בתוכה
תיעוד	docstring	ההסבר שבתוך הפונקציה
טאפל	tuple	רצף שלא ניתן לשינוי
מילון	dictionary	זוגות של מפתח וערך
שגיאה לוגית	logic error	בלי הודעה. התוכנית עושה משהו אחר
אינטרפרטר	interpreter	מקום להריץ שורה אחרי שורה