Python Handout

Python מנפשת את הקוד שלך שורה אחר שורה. כל שורה היא הוראה. תוכנית היא פשוט רשימה של הוראות שנפשות מהלמעלה למטה.

הפונקציה print() מציגה טקסט על המסך. דבר זה נקרא תפוקה. טקסט בתוך סימני ציטוט הוא מחרוזת (string).

print("Hello, world!")
print("I am learning Python")

• כל print() מתחיל שורה חדשה.
• סימני ציטוט יכולים להיות "double" או 'single' — שניהם יוצרים מחרוזת.
• תוכנית לא עושה כלום עד שתפעיל אותה.

הערה מתחילה עם #. Python מתעלם מכל מה שמגיע אחרי ה# בשורה זו. הערות מסבירות את הקוד שלך לאנשים; הן אינן משנות את מה שהקוד עושה.

# This line is a note for humans
print("Hi")        # you can also comment at the end of a line

סגנון טוב הופך את הקוד לקריא:

• השתמש בשמות ברורים המבטאים מה המשמעות של ערך.
• הנח הוראה אחת בכל שורה.
• אל תוסיף רווחים בהתחלת שורה רגילה. ב-Python, רווחים בהתחלה (רווחי הזזה / indentation) הם בעלי משמעות מיוחדת, ולכן רווח שגוי גורם לשגיאה.

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

הפונקציה input() קוראת טקסט שהמשתמש מקליד. היא תמיד מחזירה מחרוזת.

name = input("What is your name? ")
print("Hello, " + name)

• input() מחכה למשתמש להקליד וללחוץ Enter.
• שמור את הטקסט שהוזן במשתנה כדי שתוכל להשתמש בו מאוחר.
• מכיוון ש-input() מחזיר מחרוזת, שינה אותו עם int(...) תחילה אם אתה זקוק למספר.

שגיאות נפוצות

• שכחת הפסקאות: print(Hello) מחפש משתנה בשם Hello ומפעיל NameError. טקסט צריך פסקאות: print("Hello").
• רווח יתר ב-תחלת שורה: Python קורא מקדמות כמבנה, ולכן מפעיל IndentationError.
• הנחה ש-input() מחזיר מספר. הוא תמיד מחזיר מחרוזת, לכן עטוף אותו ב-int(...) לפני ביצוע פעולות מתמטיות.

A variable 变量 is a name for a value 值. You make one with =, which is called assignment 赋值. The name goes on the left; the value goes on the right.

age = 17
name = "Mei"
price = 9.99
print(age, name, price)

Now age holds 17. Use the name anywhere you need the value, and change it later:

age = 17
age = age + 1   # age is now 18
print(age)

• The = sign does not mean "equal". It means "store the right side under the left name".
• To test if two values are equal, use == (see below).

Python has two main number types. An integer 整数 (int) is a whole number like 17. A float 浮点数 (float) has a decimal point like 9.99.

These operators 运算符 work on numbers:

• / always gives a float, so 4 / 2 is 2.0.
• // and % go together: 17 // 5 is 3, and 17 % 5 is 2.

An expression 表达式 is anything that has a value, like 3 + 4 * 2. Python uses normal maths order (* and / before + and -); add brackets to make the order clear.

input() gives a string, so convert it before doing maths. Changing a value from one type to another is type conversion 类型转换:

age = int("17")        # text "17" -> number 17
price = float("9.99")  # text -> 9.99
label = str(17)        # number -> text "17"
print(age, price, label)

• int("abc") fails, so only convert text that looks like a number.
• Mixing types fails too: "age: " + 17 is an error; write "age: " + str(17).

A Boolean 布尔值 is one of just two values: True or False. A comparison 比较 gives back a Boolean.

print(7 > 2)        # True
print(3 == 3.0)     # True
age = 20
print(age >= 18)    # True

Join comparisons with and, or, not:

age = 20
print(age >= 13 and age <= 19)   # True only for a teenager

Common mistakes

• / always gives a float, even 4 / 2 is 2.0. Use // when you want a whole number.
• Using = where you mean ==: = assigns a value, == tests whether two values are equal.
• Joining a string and a number: "age: " + 5 raises a TypeError. Convert first with str(5).
• Floats are not exact, so 0.1 + 0.2 is not exactly 0.3 — avoid == on float results.

מחרוזת היא טקסט בתוך סימני ציטוט. לכל תווית יש מיקום הנקרא האינדקס שלה. האינדקס הראשון הוא 0, לא 1.

קראו תווית אחת באמצעות סוגריים מרובעים:

word = "Python"
print(word[0])    # P  (the first character)
print(word[2])    # t
print(len(word))  # 6  (how many characters)

• הספירה מתחילה ב-0, ולכן האינדקס האחרון הוא len(word) - 1.
• אינדקס שלילי סופר מהסוף: word[-1] הוא התווית האחרונה.

word = "Python"
print(word[-1])   # n
print(word[-2])   # o

• אינדקס הגדול מדי גורם לשגיאה (שגיאת IndexError).

חיתוך לוקח חלק ממחרוזת. כתבו word[start:end]. החיתוך שומר על start אך עצור לפני end.

word = "Python"
print(word[0:3])   # Pyt   (positions 0, 1, 2)
print(word[2:5])   # tho

• השאירו את start ריק כדי להתחיל ב-0; השאירו את end ריק כדי להגיע לסוף.

word = "Python"
print(word[:3])    # Pyt
print(word[3:])    # hon

• מספר שלישי הוא הצעד. word[::-1] הופך את המחרוזת הפוכה.

print("Python"[::-1])   # nohtyP

שיטה היא פונקציה השייכת לערך. קוראים אותה עם נקודה:

name = "mei chen"
print(name.upper())     # MEI CHEN
print(name.title())     # Mei Chen
print(len(name))        # 8

מחרוזות בלתי ניתנות לשינוי: שיטה מחזירה מחרוזת חדשה ולא משנה מעולם את המקורית.

name = "mei"
print(name.upper())     # MEI  (the returned value)
print(name)             # mei  (the original is unchanged)

שיטות נפוצות (כל אחת מחזירה ערך חדש):

חבר מחרוזות באמצעות +. פעולה זו נקראת הדבקה:

first = "Mei"
last = "Chen"
print(first + " " + last)   # Mei Chen

מחרוזת f בונה טקסט מתוך ערכים. הוסף f לפני התגית, ולאחר מכן כתוב {...} סביב הערך.

name = "Mei"
age = 17
print(f"{name} is {age} years old")   # Mei is 17 years old

• כל ביטוי יכול להיכנס לתוך הסוגריים.
• {value:.2f} מעגל לש 2 ספרות אחרי הנקודה.

price = 9.5
print(f"Two cost {price * 2}")        # Two cost 19.0
print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14

שגיאות נפוצות

• מחרוזות אינן ניתנות לשינוי במקום: s[0] = "x" יגרום לשגיאה. במקום זאת, בנה מחרוזת חדשה.
• האינדוקס מתחיל ב-0; האות האחרונה היא s[-1], ו-s[len(s)] הוא מחוץ לתחום.
• חתיכה s[a:b] כוללת את a אך עצירה לפני b.
• שיטות מחרוזות מחזירות מחרוזת חדשה: s.upper() לא יעשה שום דבר אלא אם תאחסן את התוצאה.

תוכנית בוחרת מה לעשות עם if. היא מפעילה בלוק ממוקד רק כאשר תנאי הוא אמיתי. השורה if מסתיימת בקולון.

score = 72
if score >= 60:
    print("pass")
# pass

הוסף elif (else-if) למקרים נוספים והוסף else ל"כל שאר המקרים". Python מפעילה את הענף האמיתי הראשון בלבד, ואז מדלגת על שאר הענפים.

score = 72
if score >= 80:
    print("A")
elif score >= 60:
    print("B")
else:
    print("fail")
# B

• השוו ערכים באמצעות == (שווה ל-), != (שונה מ-), <, >, <=, >=.
• השוואה נותנת בוליאני — או True או False.

חבר תנאים באמצעות and, or, not. and דורש ששתי הצדדים יהיו אמינים; or דורש שאחד מהצדדים יהיה אמיתי; not הופך בוליאני.

age = 16
has_ticket = True
if age >= 18 and has_ticket:
    print("entry allowed")
else:
    print("entry refused")
# entry refused

• השתמש בסוגריים כדי להבהיר את הסדר: (a or b) and c.

temp = 30
if temp > 25 and not temp > 35:
    print("warm but ok")
# warm but ok

שגיאות נפוצות

• כתוב elif, לא else if.
• כל קו if / elif / else מסתיים בנקודה-פסיק :, וגוף הקוד חייב להיות מוזז ימינה (ממוקם בתוך תוכנית).
• if x = 5: הוא שגיאה — השתמש ב== לערך השוואה.
• else אינו מקבל תנאי; רק if ו-elif עושים זאת.

לולאה חוזרת על קוד. לולאת for חוזרת פעם אחת עבור כל פריט ברצף. range(n) נותן את המספרים 0 ועד n - 1.

for i in range(5):
    print(i)
# 0, then 1, 2, 3, 4 (each on its own line)

• range(a, b) הולך מ-a ועד (אך אינו כולל) b.
• range(a, b, step) מוסיף צעד בכל פעם.

for n in range(2, 11, 2):
    print(n)        # 2 4 6 8 10

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

total = 0
for n in range(1, 6):
    total = total + n
print(total)        # 15

• אותה רעיון סופר כמה פריטים עומדים במבחן מסוים.

count = 0
for letter in "banana":
    if letter == "a":
        count = count + 1
print(count)        # 3

לולאת while חוזרת כל עוד תנאי נשאר אמת. שינה משהו בפנים, או שהיא לעולם לא תיעצר – לולאה אינסופית.

n = 1
while n <= 3:
    print(n)
    n = n + 1
# 1 2 3

• break יוצא מהלולאה מיידית.

total = 0
while True:
    total = total + 10
    if total >= 30:
        break
print(total)        # 30

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

for row in range(3):
    line = ""
    for col in range(3):
        line = line + "*"
    print(line)
# ***
# ***
# ***

שגיאות נפוצות

• range(n) הולך מ-0 עד n - 1, לא מ-1 עד n – הטעות הקלאסית באחד (off-by-one error).
• שינוי רשימה בזמן שחורצים עליה מדלג על פריטים; חרוץ על העתק אם אתה חייב להסיר דברים.
• לשכוח לשנות את משתנה הלולאה ב-while גורם לה להסתובב לנצח.
• הזזה (indentation) קובעת מה נמצא בתוך הלולאה; קו עם הזזה שגויה ירצה פעם אחת בלבד, לאחר הלולאה.

A list 列表 holds many values in order, inside []. Each item 元素 has an index (from 0).

scores = [88, 71, 95]
print(scores[0])      # 88
print(len(scores))    # 3
scores.append(60)     # add to the end
print(scores)         # [88, 71, 95, 60]

• Change an item by its index: scores[1] = 100.
• A list can grow and shrink; a string cannot.

The everyday list tools:

To traverse 遍历 a list is to visit each item. A for loop does this with no index needed.

scores = [88, 71, 95]
total = 0
for s in scores:
    total = total + s
print(total)          # 254

• Use enumerate when you also need the index.

for i, name in enumerate(["a", "b"]):
    print(i, name)    # 0 a  /  1 b

A 2-D list 二维列表 is a list of lists — a grid 网格 of rows and columns. Use two indexes: grid[row][col].

grid = [[1, 2, 3],
        [4, 5, 6]]
print(grid[0][2])     # 3
print(grid[1][0])     # 4

• A nested loop 嵌套循环 visits every cell.

grid = [[1, 2], [3, 4]]
for row in grid:
    for value in row:
        print(value, end=" ")
print()               # 1 2 3 4

A list comprehension 列表推导式 builds a new list in one line: [expression for item in sequence].

squares = [x * x for x in range(5)]
print(squares)        # [0, 1, 4, 9, 16]

• Add if to keep only some items.

evens = [n for n in range(10) if n % 2 == 0]
print(evens)          # [0, 2, 4, 6, 8]

A tuple 元组 is a fixed sequence in round brackets. It cannot be changed after it is made — use one for values that belong together, and unpack 解包 it into names.

point = (3, 4)
x, y = point            # unpacking
print(x, y)             # 3 4

A function that needs to hand back two results returns a tuple:

def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([5, 2, 9])
print(lo, hi)           # 2 9

A set 集合 stores each value once, with no order. It is perfect for removing duplicates and for fast membership tests 成员测试.

votes = ["red", "blue", "red", "green", "red"]
colours = set(votes)
print(len(colours))         # 3  (duplicates removed)
print("blue" in colours)    # True

Common mistakes

• b = a does not copy a list: both names point to the same list, so changing one changes the other. Use a.copy() or a[:].
• The last item is a[-1]; a[len(a)] is out of range.
• append adds ONE item; use extend or + to join another list.
• Building a grid with [[0]*3]*3 makes three copies of the same row. Build the rows in a loop instead.
• A tuple with one item needs a comma: (5,), not (5).
• A set has no order and no duplicates, so you cannot index it with s[0].

מילון (dict) מאחסן זוגות מפתח → ערך. אתה מחפש ערך לפי המפתח שלו, ולא לפי מדד מספרי.

student = {"name": "Mei", "score": 88}
print(student["name"])     # Mei
print(student["score"])    # 88

הוספה ועדכון

הערכה למפתח תוסיף אותו, או תעדכן קיים.

student = {"name": "Mei"}
student["score"] = 88      # add a new key
student["score"] = 90      # update the value
print(student)             # {'name': 'Mei', 'score': 90}

בדיקה ולולאה

השתמש בin לבדיקת נוכחות מפתח. לולאה על המפתחות, או על .items() כדי לקבל גם מפתח וגם ערך.

student = {"name": "Mei", "score": 90}
print("score" in student)  # True
for key, value in student.items():
    print(key, "=", value)
# name = Mei
# score = 90

• .get(key, default) מחזיר ערך ברירת מחדל כאשר המקרא חסר — ללא שגיאה.

student = {"name": "Mei"}
print(student.get("age", 0))   # 0

הדפוס הקלאסי במבחן — ספור כמה פעמים כל ערך מופיע:

word = "banana"
counts = {}
for letter in word:
    counts[letter] = counts.get(letter, 0) + 1
print(counts)   # {'b': 1, 'a': 3, 'n': 2}

• .get(letter, 0) מספק 0 בפעם הראשונה שמקרא נראה, ולכן אין KeyError.

שגיאות נפוצות

• קריאת מפתח חסר באמצעות d[key] גורמת לשגיאת KeyError; השתמש ב-d.get(key) או בדוק תחילה את if key in d.
• הצבת d[key] שוב מחקית את הערך הישן — המקראים הם ייחודיים.
• המקראים חייבים להיות בלתי משנים, כמו מחרוג או מספר — רשימה לא יכולה לשמש כמקרא.

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

def greet():
    print("Hello!")

greet()        # Hello!
greet()        # Hello!

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

פונקציה יכולה להחזיר ערך עם return. הקריאה אז מייצגת את הערך הזה.

def square(n):
    return n * n

print(square(5))          # 25
print(square(3) + 1)      # 10

• return מסתיימת בפונקציה מיידית. פונקציה ללא return מחזירה None.

פרמטר הוא השם בתוך ה-def. ארגומנט הוא הערך שעובר.

def power(base, exp):         # base, exp are parameters
    return base ** exp

print(power(2, 3))            # 8  (2 and 3 are arguments)

משתנה שנוצר בתוך פונקציה הוא מקומי — הוא קיים רק שם. האזור הזה הוא התחום שלו.

def f():
    x = 10            # local to f
    return x

print(f())            # 10
# print(x) here would be an error: x is not defined outside f

לפרמטר יכול להיות ערך ברירת מחדל, המשמש כאשר הקורא משאיר אותו מחוץ:

def greet(name, greeting="Hello"):
    return greeting + ", " + name

print(greet("Mei"))              # Hello, Mei
print(greet("Sam", "Welcome"))   # Welcome, Sam

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

def area_of_rectangle(w, h):
    return w * h

print(area_of_rectangle(4, 5))   # 20

• פונקציה טובה עושה משימה אחת, יש לה שם ברור, והיא נמנעת מהעתיקת קוד.

מודול הוא קובץ של פונקציות מוכנות. תביא אחד לתוך התוכנית באמצעות import.

import random
random.seed(0)               # makes the result repeatable
print(random.randint(1, 6))  # a dice roll

import math
print(math.sqrt(16))         # 4.0

שגיאות נפוצות

• פונקציה מחזירה None אלא אם כן כתבת return. הדפסה אינה זהה להחזרה.
• לעולם אל תשתמש בברירת מחדל מתוחברת כמו def f(x=[]) — אותה רשימה משותפת בין כל הקריאות.
• משתנה שמוגדרת בתוך פונקציה היא מקומית ואינה נראית מחוץ לה.
• הרץ פונקציה עם f(); כתיבת f לבדו רק מייחסת לה שם.

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

# A runtime error, caught so this block still finishes:
try:
    print(10 / 0)
except ZeroDivisionError:
    print("cannot divide by zero")
# cannot divide by zero

• Python מדפיסה מעקב (traceback) המראה היכן הכשל. קרא אותו מהתחתית למעלה.

עטוף קוד סיכון בtry. אם הוא מכשל, except לוכד את החריגה ומטפל בה, במקום לקרוס.

def to_int(text):
    try:
        return int(text)
    except ValueError:
        return 0

print(to_int("42"))    # 42
print(to_int("abc"))   # 0

• לכד סוג ספציפי (ValueError, ZeroDivisionError, …).
• raise יוצר שגיאה משלך במטרה.

def set_age(age):
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

try:
    set_age(-1)
except ValueError as err:
    print("error:", err)
# error: age cannot be negative

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

def average(nums):
    if len(nums) == 0:        # edge case: empty list
        return 0
    return sum(nums) / len(nums)

print(average([2, 4, 6]))     # 4.0
print(average([]))            # 0

• קוד חזק אינו מתמוטט על כניסה מוזרה; הוא מטפל בה בצורה מסודרת.

שגיאות נפוצות

• אל תשתמש ב-except: ריק — תלכד את השגיאה הספציפית, למשל except ValueError:.
• שגיאת סינטקס עצרת את כל התוכנית לפני ההפעלה, לכן תתקן אותן תחילה.
• בדוק את מקרי הקצה (כניסה ריקה, אפס, הערך הגדול ביותר), ולא רק את המקרה הפשוט.

קובץ טקסט מאחסן טקסט בכונן. פתח אותו עם open(name, mode) כאשר המצב מציין קריאה או כתיבה. תמיד השתמש ב-with, שיסגור עבורך את הקובץ.

כתיבה

מצב "w" כותב קובץ חדש ומחקר כל קובץ ישן.

with open("notes.txt", "w") as f:
    f.write("first line\n")
    f.write("second line\n")
print("saved")            # saved

קריאה

מצב "r" (ברירת מחדל) קורא. .read() מחזיר את כל הקובץ כמחרוזת אחת.

with open("notes.txt", "w") as f:
    f.write("hello\nworld\n")
with open("notes.txt") as f:
    print(f.read().strip())   # hello / world

שורה בשורה

לולוא על הקובץ כדי לקבל שורה אחת בכל פעם. .strip() מסיר את תווה החדש שורה בסוף.

with open("data.txt", "w") as f:
    f.write("Mei,88\nSam,71\n")
with open("data.txt") as f:
    for line in f:
        name, score = line.strip().split(",")
        print(name, "scored", score)
# Mei scored 88
# Sam scored 71

הוספה

מצב "a" מוסיף בהמשך — הוא מוסיף בסוף מבלי למחוק.

with open("log.txt", "w") as f:
    f.write("line 1\n")
with open("log.txt", "a") as f:
    f.write("line 2\n")
with open("log.txt") as f:
    print(f.read().strip())   # line 1 / line 2

שגיאות נפוצות

• תמיד סגור קובץ, או השתמש ב-with open(...) as f: שיסגור עבורך.
• read() נותן את כל הקובץ כמחרוזת אחת, וכל שורה עדיין מסתיימת ב-\n.
• פתיחה עם "w" מוחקת את הקובץ תחילה; השתמש ב-"a" להוספה בסוף.

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

# Algorithm: find the largest number in a list
def largest(nums):
    best = nums[0]
    for n in nums:
        if n > best:
            best = n
    return best

print(largest([3, 9, 2, 7]))   # 9

• חוץ מהפרטים אומר להתעלם מפירוט: משתמשים ב-largest(...) מבלי לקרוא מחדש כיצד זה עובד.

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

SET best TO first number
FOR Each number n
    IF n > best
      THEN
        SET best TO n
        OUTPUT best

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

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

def fact(n):
    return 1 if n <= 1 else n * fact(n - 1)

print(fact(5))     # 120

• כל התקשרות השהוייה יושבת בערימת ההתקשרות עד שההתקשרות מעליה מחזירה ערך.

שגיאות נפוצות

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

סוג נתונים מ추적 (ADT) מתאר נתונים מסוימים ופעולות עליהם, נפרד מאופן הבנייה שלו. משתמשים בו דרך הפעולות שלו, ולא דרך אחסון הפנימי שלו.

# A stack ADT, built on a list
s = []
s.append(1)        # add
s.append(2)
print(s.pop())     # 2  (remove the most recent)

ערך הוא אחרון-נכנס, ראשון-יוצא (LIFO). מדחפים על העליון ומוצאים מהעליון.

stack = []
stack.append("a")
stack.append("b")
print(stack.pop())   # b
print(stack.pop())   # a

תורית היא סדרה בהם-ראשון, יוצא-ראשון (FIFO). מוסיפים לתורית מהגב ומסירים ממנה מהחזית.

queue = []
queue.append("a")     # enqueue
queue.append("b")
print(queue.pop(0))   # a  (dequeue the front)
print(queue.pop(0))   # b

רשימה מקשרת היא שרשרת של נודים. כל נודה מכילה נתונים וקישור לנודה הבאה; האחרונה מצביعة על None.

n3 = {"data": 3, "next": None}
n2 = {"data": 2, "next": n3}
n1 = {"data": 1, "next": n2}
node = n1
while node is not None:      # traverse to the end
    print(node["data"])
    node = node["next"]
# 1 2 3

טבלת TODO maps מפתח למיקום באמצעות פונקציית TODO hash. שני מפתחות יכולים ליפול אותו מקום — התנגשות. ה-dict של Python היא טבלת TODO hash, ולכן חיפוש מהיר.

table = {}
table["Mei"] = 88
table["Sam"] = 71
print(table["Mei"])   # 88  (fast lookup by key)

עץ חיפוש בינארי (BST) שומר על סדר: כל צאצא שמאלי קטן מהנודה שלו, וכל צאצא ימני גדול ממנה. החיפוש נשאר מהיר.

def insert(root, val):
    if root is None:
        return {"val": val, "left": None, "right": None}
    if val < root["val"]:
        root["left"] = insert(root["left"], val)
    else:
        root["right"] = insert(root["right"], val)
    return root

def inorder(root):
    if root is None:
        return []
    return inorder(root["left"]) + [root["val"]] + inorder(root["right"])

tree = None
for v in [5, 3, 8, 1, 4]:
    tree = insert(tree, v)
print(inorder(tree))   # [1, 3, 4, 5, 8]

גרף הוא קבוצת קודקודים המחוברים על ידי קשתות. רשימת שכנות – כפייה של רשימות שכנים – היא אופן נפוץ לאחסון גרף.

graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
for vertex in graph:
    print(vertex, "->", graph[vertex])
# A -> ['B', 'D']  (and so on for B, C, D)

שגיאות נפוצות

• ערימה היא אחרון-נכנס, ראשון-יוצא; תורית היא ראשון-נכנס, יוצא-ראשון. אל תבלבלו ביניהן.
• בדקו האם המבנה ריק לפני שתוציאו ממנו פריט בעזרת pop או dequeue.
• ברשימה מקשרת, איבוד הקישור ל-head מאבד את כל הרשימה.

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

def linear_search(items, target):
    for i in range(len(items)):
        if items[i] == target:
            return i
    return -1     # not found

print(linear_search([4, 8, 2, 9], 2))   # 2

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

def binary_search(items, target):
    lo, hi = 0, len(items) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if items[mid] == target:
            return mid
        elif items[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

print(binary_search([1, 3, 5, 7, 9], 7))   # 3

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

def bubble_sort(a):
    a = a[:]                          # work on a copy
    for i in range(len(a)):
        for j in range(len(a) - 1 - i):
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
    return a

print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]

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

def insertion_sort(a):
    a = a[:]                           # work on a copy
    for i in range(1, len(a)):
        key = a[i]
        j = i - 1
        while j >= 0 and a[j] > key:   # shift bigger values right
            a[j + 1] = a[j]
            j -= 1
        a[j + 1] = key                 # drop key into the gap
    return a

print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]

• בקוד אמיתי, השתמש במובנית sorted() של Python:

print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]

יעילות שואפת כיצד העבודה גדלה ככל שהקלט גדל. אנו מתארים זאת באמצעות Big-O.

def steps(n):           # how many steps a linear scan takes
    count = 0
    for i in range(n):
        count = count + 1
    return count

print(steps(100))       # 100  -> O(n)

המודול random מאפשר ייצור מספרים אקראיים. השתמש בזרע כדי להפוך תוצאות לחוזרות. סימולציה מנהלת ניסויים אקראיים רבים כדי להעריך תשובה.

import random
random.seed(0)
rolls = [random.randint(1, 6) for _ in range(1000)]
print(rolls.count(6))   # about 1/6 of 1000

שגיאות נפוצות

• חיפוש בינארי עובד רק ברשימה מסודרת.
• Big-O מספר איך הזמן גודל, לא את הזמן המדויק; שיטה O(n²) טובה יותר מ-O(n) רק לקלט קטן מאוד.
• מיון בוער הוא O(n²) — מתאים ללמידה, אך איטי ברשימות גדולות.

מחלקה היא תבנית. אובייקט הוא דבר אחד שנבנה ממנה (דוגמה). __init__ הוא הקונסטרוקטור שמגדיר כל אובייקט; self הוא האובייקט עצמו.

class Dog:
    def __init__(self, name):
        self.name = name            # an attribute
    def speak(self):
        return self.name + " says woof"

d = Dog("Rex")
print(d.speak())     # Rex says woof

• name הוא מאפיין (נתונים באובייקט); speak הוא שיטה (פעולה).

הוסף __str__ כדי לשלוט במוצג על ידי print(obj):

class Dog:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f"Dog named {self.name}"

print(Dog("Rex"))    # Dog named Rex

ירושית מאפשרת למחלקת בת להשתמש במחלקת האב. השתמש בsuper() כדי לקרוא להורה; העלמת שיטה כדי לשנות אותה.

class Animal:
    def speak(self):
        return "some sound"

class Cat(Animal):
    def speak(self):                # override
        return "meow"

print(Cat().speak())   # meow

Encapsulation נסתר נתונים מאחורי שיטות; קו תחתון ראשוני מסמן שהן פרטיות.

class Account:
    def __init__(self):
        self._balance = 0           # private
    def deposit(self, n):
        self._balance += n
    def balance(self):
        return self._balance

a = Account()
a.deposit(50)
print(a.balance())     # 50

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

class Cat:
    def speak(self):
        return "meow"

class Cow:
    def speak(self):
        return "moo"

for animal in [Cat(), Cow()]:
    print(animal.speak())   # meow, then moo

פרדיגמה היא סגנון כתיבת תוכנות. קוד פרוצדורלי הוא רצף של צעדים ופונקציות. קוד ממוקד-אובייקטים מקבץ נתונים ושיטות לתוך אובייקטים. קוד הצהרתי אומר מה אתה רוצה, לא איך (רשימת הבנאה או SQL).

def total(nums):           # procedural
    t = 0
    for n in nums:
        t += n
    return t
print(total([1, 2, 3]))    # 6

print(sum([1, 2, 3]))      # 6  (declarative: same result)

שגיאות נפוצות

• לכל שיטה יש לself כפרמטר הראשון.
• __init__ מגדיר אובייקט חדש ורץ אוטומטית כאשר אתה יוצר אותו.
• לשני אובייקטים מאותה מחלקה יש מאפיינים נפרדים; שינוי באחד אינו משנה את השני.

ביט הוא 0 או 1 יחיד. מערכת בסיס-2 היא מערכת המספרים: כל מקום שווה פי שניים מהמקום מימינו (1, 2, 4, 8, …). מערכת עשרונית (בסיס-10) היא המספרים הרגילים שלנו.

print(bin(13))         # 0b1101
print(int("1101", 2))  # 13

• 8 ביטים יוצרים בייט. רוחב קבוע יכול לגרום לעודף (wrap around) כאשר המספר גדול מדי.

x = 250
x = (x + 10) % 256     # one byte wraps at 256
print(x)               # 4

מערכת ספרותית מעוצשית (בסיס 16) היא דרך קומפקטית לקרוא מספרים בינאריים: דיgit מעוצשי אחד עומד בדיוק על ארבעה ביטים. Python כותב מעוצשי באמצעות 0x:

print(hex(255))        # 0xff
print(0xFF)            # 255
print(int("ff", 16))   # 255

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

הצפנת רצף (Run-length encoding) היא שיטה פשוטה ללא אובדן: מאחסנת רצף (חזרה חוזרת) כספירה יחד עם הערך.

def rle(text):
    out = ""
    i = 0
    while i < len(text):
        run = 1
        while i + run < len(text) and text[i + run] == text[i]:
            run += 1
        out += str(run) + text[i]
        i += run
    return out

print(rle("AAAABBBCCD"))   # 4A3B2C1D

שגיאות נפוצות

• n ביטים מאחסנים 2**n ערכים שונים, החל מ0 ועד ל2**n - 1.
• דחיסה מאבדת פרטים ואינה ניתנת לחזור בה; דחיסה ללא אובדן ניתנת להפכה בדיוק.

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

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

האינטרנט הוא רשת של רשתות. נתונים מחולקים לחבילות שעוברות בנפרד ומתחברות מחדש בקצה השני. תקנונים משותפים הנקראים פרוטוקולים (כמו TCP/IP) מאפשרים זאת. אם מסלול אחד נשבר, חבילות נוטלות מסלול אחר — זהו עודפות, שמעניקה סבילות לשגיאות.

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

• לא הכל יכול לרוץ במקביל: חלק מהצעדים חייבים להמתין לתוצאה קודמת.

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

שגיאות נפוצות

• האינטרנט והאינטרנט העולמי (World Wide Web) אינם אותו דבר: ה-Web הוא שירות אחד הפועל מעל האינטרנט.
• ליבה נוספת במעבד מועילה רק אם העבודה ניתנת לחלוקה חלקים שניתן לייצר בו זמנית.

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

מיזם: ציון ממוצע

def average(marks):
    if len(marks) == 0:
        return 0
    return round(sum(marks) / len(marks), 1)

print(average([88, 71, 95, 60]))   # 78.5

מיזם: ספירת הצלחות

def count_passes(marks, pass_mark=60):
    passes = 0
    for m in marks:                 # iteration
        if m >= pass_mark:          # selection
            passes += 1
    return passes

print(count_passes([88, 50, 95, 60]))   # 3

מיזם: סינון לרשימה חדשה

def merit(marks):
    return [m for m in marks if m >= 80]

print(merit([88, 71, 95, 60]))     # [88, 95]

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

שגיאות נפוצות

• בנה בשלבים קטנים ובדוק כל חלק לפני מעבר הבא — אל תכתוב הכל יחד.
• קרא את המשימה כולה תחילה, ולאחר מכן תכנן את הכניסה → העיבוד → הפלט לפני שתתחיל לתכנן.