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) מחזיר ערך ברירת מחדל כאשר המקרא חסר — ללא שגיאה.
קוד יכול לכשל בשלושה אופנים. שגיאת סינטקס מספקת את חוקי Python, ולכן לעולם לא תופעל. שגיאת זמן ריצה קורה בזמן הריצה, כמו חלוקה באפס. שגיאת לוגיקה פועלת אך מחזירה תשובה שגויה.
שגיאות 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
פייתון מדפיס תרגיל עקבות המראה היכן שהכשל התרחש. קרא אותו מלמטה למעלה.
9.2
ניסיון / טיפול בחריגות / השקת שגיאה
שים קוד סיכון בtry; אם הוא כושל, except לוכד את השגיאה במקום להתמוטט.
לכד סוג ספציפי (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
9.3
בדיקות ויציבות
בדיקה בודקת שקוד מחזיר את התשובה הנכונה. נסה מקרים רגילים וגם מקרי קצה — קלט ריק, אפס, ערכים גדולים מאוד.
קובץ טקסט מאחסן טקסט בכונן. פתח אותו עם 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
מצב
משמעות
"r"
קריאה (ברירת מחדל)
"w"
כתיבה (מחקר תחילה)
"a"
הוספה (הוספה לסוף)
שגיאות נפוצות
תמיד סגור קובץ, או השתמש ב-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(...) מבלי לקרוא מחדש כיצד זה עובד.
11.2
סימולציות ותרשימי זרימה
סימולציה היא אנגלית פשוטה ומבוצעת לאלגוריתם, שנכתבת לפני הכתב הקוד האמיתי. היא אינה מופעלת.
SET best TO first number
FOR Each number n
IF n > best
THEN
SET best TO n
OUTPUT best
תרשים זרימה מצייר את אותו תוכנית: תיבה לכל צעד, יהלום לכל החלטה, וחצים לסדר.
11.3
רקורסיה וערימת ההתקשרות
רקורסיה היא כאשר פונקציה קוראת לעצמה. היא דורשת מקרה בסיס (קלט פשוט שמחזיר מיד) ומקרה רקורסיבי (היא קוראת לעצמה על קלט קטן יותר).
מערך קריאות עבור factorial(3): כל קריאה מחכה, ולאחר מכן מחזירה ערך בסדר הפוך
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)
12.2
ערוכים
ערך הוא אחרון-נכנס, ראשון-יוצא (LIFO). מדחפים על העליון ומוצאים מהעליון.
ערך מוצא מהעליון (LIFO); תור מוצא מהחלון (FIFO)
stack = []
stack.append("a")
stack.append("b")
print(stack.pop()) # b
print(stack.pop()) # a
12.3
תוריות
תורית היא סדרה בהם-ראשון, יוצא-ראשון (FIFO). מוסיפים לתורית מהגב ומסירים ממנה מהחזית.
queue = []
queue.append("a") # enqueue
queue.append("b")
print(queue.pop(0)) # a (dequeue the front)
print(queue.pop(0)) # b
12.4
רשימות מקשרות
רשימה מקשרת היא שרשרת של צמתים. כל צומח מכיל נתונים ומצביע לצומח הבא; האחרון מצביע על None.
רשימה מקשרת: כל נודה מכילה נתונים וקישור לנודה הבאה, והסיום הוא ב-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
12.5
טבלאות פריטור
טבלת TODO maps מפתח למיקום באמצעות פונקציית TODO hash. שני מפתחות יכולים ליפול אותו מקום — התנגשות. ה-dict של Python היא טבלת TODO hash, ולכן חיפוש מהיר.
פונקציית פריטור מתאמת כל מקדף למיקום; שני מקדפים שונים עשויים להתנגש במיקום אחד
חיפוש מוצא את המקום בו נמצא ערך. חיפוש ליני בודק כל פריט בסדר, ולכן הוא עובד בכל רשימה.
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
חיפוש בינארי חוצה את הטווח למחצית בכל צעד — O(log n) ברשימה מסודרת
13.2
מיון (בוער והכנסה)
מיון הוא סידור פריטים בסדר. מיון בוער מבצע חילופים חוזרים של שכנים הסדורים באופן שגוי.
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]
13.3
יעילות אלגוריתמית
יעילות שואפת כיצד העבודה גדלה ככל שהקלט גדל. אנו מתארים זאת באמצעות Big-O.
איך מספר הצעדים גדל בהתאם לגודל הקלט עבור מורכבויות נפוצות
Big-O
שם
דוגמה
$O(1)$
קבוע
חיפוש מקלד במילון
$O(\log n)$
לוגריתמי
חיפוש בינארי
$O(n)$
ליניארי
חיפוש ליניארי
$O(n^2)$
ריבועי
מיון בוער
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)
13.4
אקראיות וסימולציה
המודול 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
מחלקה היא תבנית; קריאה שלה יוצרת אובייקט
14.2
ירושיות, encapsulation ופולימורפיזם
ירושית מאפשרת למחלקת בת להשתמש במחלקת האב. השתמש בsuper() כדי לקרוא להורה; העלמת שיטה כדי לשנות אותה.
class Animal:
def speak(self):
return "some sound"
class Cat(Animal):
def speak(self): # override
return "meow"
print(Cat().speak()) # meow
היקפוף מקבץ נתונים עם שיטות וחושף ממשק מתוכנן. בפיתון, קו תחתון ראשוני מסמן שמדובר בשם שאינו ציבורי (הנקרא לעיתים פרטי) לפי המוסכמות; הוא אינו מונע לקוד חיצוני לגשת אליו. שינוי שמות עם שני קווים תחתונים ראשוניים עוזר למנוע התנגשות שמות באבטחה, ולא להטיל ביטחון.
class Account:
def __init__(self):
self._balance = 0 # non-public by convention
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
14.3
פרדיגמות תכנות
פרדיגמה היא סגנון כתיבת תוכנות. קוד פרוצדורלי הוא רצף של צעדים ופונקציות. קוד ממוקד-אובייקטים מקבץ נתונים ושיטות לתוך אובייקטים. קוד הצהרתי אומר מה אתה רוצה, לא איך (רשימת הבנאה או 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) היא המספרים הרגילים שלנו.
דחיסה הופכת את הנתונים לקטנים יותר. דחיסה ללא אובדן שומרת על כל ביט, כך שהמקור נבנה מחדש בדיוק. דחיסה מאבדת פרטים — קטנה יותר אך לא מדויקת — ומוכרזת לתמונות ולמוזיקה.
הצפנת רצף (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.
דחיסה מאבדת פרטים ואינה ניתנת לחזור בה; דחיסה ללא אובדן ניתנת להפכה בדיוק.
חישוב הוא פתרון בעיות באמצעות מחשבים: כניסה, עיבוד, תוצאה. תוכנה טובה נבנית במעגל עיצוב — תכנון, כתיבה, בדיקה, שיפור — המוחזר מספר פעמים רבות.
פצל את הבעיה לחלקים, בנה חלק קטן, בדוק אותו, ולאחר מכן הוסף עוד.
מתכננים עובדים בצוות ומשתפים זה בזה בקוד.
16.2
האינטרנט
האינטרנט הוא רשת של רשתות. נתונים מחולקים לחבילות שעוברות בנפרד ומתחברות מחדש בקצה השני. תקנונים משותפים הנקראים פרוטוקולים (כמו TCP/IP) מאפשרים זאת. אם מסלול אחד נשבר, חבילות נוטלות מסלול אחר — זהו עודפות, שמעניקה סבילות לשגיאות.
מפת האינטרנט: כל קו הוא מסלול בין שתי רשתות
שכבה
משימה
HTTP
בקשה ושליחת דפי אינטרנט
TCP
אספקה אמינה, בסדר
IP
כתובות וניהול מסלולים
16.3
חיבוץ מקביל ומפוזר
קוד רציף מבצע צעד אחד בכל פעם. חיבוץ מקביל מבצע מספר צעדים בו-זמנית על גבי ליבות מרובות, מה שיכול לתת זריזות. חיבוץ מפוזר מפזר את העבודה על פני מחשבים רבים, כמו בענן.
לא הכל יכול לרוץ במקביל: חלק מהצעדים חייבים להמתין לתוצאה קודמת.
16.4
השפעת החיבוץ
חיבוץ מביא גם יתרונות וגם נזקים. הפער הדיגיטלי אומר שלא לכל אחד יש גישה שווה אליו. תוכנה יכולה לשאת עומס של הטיה מהנתונים ממם היא למדה. יש לכבד רכוש רוחני (רישיונות), ולהגן על הנתונים הפרטיים והפרטיות של אנשים.
שגיאות נפוצות
האינטרנט והאינטרנט העולמי (World Wide Web) אינם אותו דבר: ה-Web הוא שירות אחד הפועל מעל האינטרנט.
ליבה נוספת במעבד מועילה רק אם העבודה ניתנת לחלוקה חלקים שניתן לייצר בו זמנית.
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 דורשת רשימה, פרוצדורה פרמטרית המשתמשת בבחירה ובאיטרציה, וכמות מסוימת של כניסה/יציאה. כל מיזם לעיל הוא בדיוק באותו מבנה — בנה חלקים קטנים, ואז חבר אותם.
שגיאות נפוצות
בנה בשלבים קטנים ובדוק כל חלק לפני מעבר הבא — אל תכתוב הכל יחד.
קרא את המשימה כולה תחילה, ולאחר מכן תכנן את הכניסה → העיבוד → הפלט לפני שתתחיל לתכנן.