חיפוש

מדריך Python מקיף

מיסודות ועד מתקדם - כל מה שצריך לדעת על Python

יסודות Python

💡 מה זה Python?
Python היא שפת תכנות פשוטה וקלה ללמידה, מושלמת למתחילים ולמקצוענים כאחד. היא נקראת כך על שם הסדרה "Monty Python" ולא על שם הנחש! Python משמשת לפיתוח אתרים, ניתוח נתונים, בינוי מלאכותי, אוטומציה ועוד.

הדפסה וקלט

הדפסה בסיסית:

print("Hello, World!")

הדפסה עם משתנים:

name = "Python" print(f"Hello, {name}!") # f-string print("Hello, {}!".format(name)) # format print("Hello, " + name + "!") # concatenation

קבלת קלט מהמשתמש:

name = input("Enter your name: ") age = int(input("Enter your age: "))

הדפסה ללא שורה חדשה:

print("Hello", end=" ") print("World")

משתנים

מה זה משתנה?
משתנה הוא כמו קופסה שאפשר לשים בה מידע. אפשר לתת לקופסה שם (כמו "age" או "name") ולשים בה ערך (כמו 25 או "Alice"). ב-Python לא צריך להגדיר מראש איזה סוג מידע יהיה במשתנה - Python מבין את זה לבד!

הגדרת משתנים:

x = 5 y = "Hello" z = 3.14 is_valid = True

השמה מרובה:

x, y, z = 1, 2, 3 a = b = c = 0

החלפת ערכים:

a, b = 5, 10 a, b = b, a # swap

בדיקת טיפוס:

x = 5 print(type(x)) # print(isinstance(x, int)) # True

אופרטורים

אופרטורים אריתמטיים:

x = 10 + 5 # חיבור x = 10 - 5 # חיסור x = 10 * 5 # כפל x = 10 / 5 # חילוק (תמיד float) x = 10 // 3 # חילוק שלם (3) x = 10 % 3 # שארית (1) x = 2 ** 3 # חזקה (8)

אופרטורי השוואה:

x == y # שווה x != y # לא שווה x > y # גדול מ x < y # קטן מ x >= y # גדול או שווה x <= y # קטן או שווה

אופרטורים לוגיים:

x and y # וגם x or y # או not x # לא

אופרטורי השמה:

x += 5 # x = x + 5 x -= 5 # x = x - 5 x *= 5 # x = x * 5 x /= 5 # x = x / 5

הערות

הערה בשורה אחת:

# This is a comment x = 5 # This is also a comment

הערה מרובת שורות:

""" This is a multi-line comment or docstring """

טיפוסי נתונים

💡 מה זה טיפוס נתונים?
טיפוס נתונים קובע איזה סוג מידע המשתנה מחזיק.
int - מספרים שלמים (1, 2, 100, -5)
float - מספרים עשרוניים (3.14, 2.5, -0.1)
str - טקסט ("Hello", "Python")
bool - אמת או שקר (True, False)
למה זה חשוב? לא אפשר לחבר מספר עם טקסט ישירות - צריך להמיר קודם!

מספרים

מספרים שלמים (int):

x = 5 y = -10 z = 1000000

מספרים עשרוניים (float):

x = 3.14 y = -2.5 z = 1.5e2 # 150.0 (scientific notation)

מספרים מרוכבים (complex):

x = 3 + 4j print(x.real) # 3.0 print(x.imag) # 4.0

המרות בין טיפוסים:

x = int(3.14) # 3 y = float(5) # 5.0 z = str(123) # "123" w = int("100") # 100

Boolean

ערכי אמת:

is_valid = True is_empty = False

המרה ל-Boolean:

bool(1) # True bool(0) # False bool("") # False bool("text") # True bool([]) # False bool([1, 2]) # True

None

ערך ריק:

x = None if x is None: print("x is empty")

פעולות מתמטיות

פונקציות מובנות:

abs(-5) # 5 (ערך מוחלט) pow(2, 3) # 8 (חזקה) round(3.14159, 2) # 3.14 (עיגול) max(1, 5, 3) # 5 min(1, 5, 3) # 1 sum([1, 2, 3]) # 6

מודול math:

import math math.sqrt(16) # 4.0 (שורש) math.ceil(3.2) # 4 (עיגול למעלה) math.floor(3.8) # 3 (עיגול למטה) math.pi # 3.141592... math.e # 2.718281... math.sin(math.pi/2) # 1.0 math.log(10) # 2.302... (לוגריתם טבעי) math.log10(100) # 2.0 (לוגריתם בסיס 10)

מספרים אקראיים

מודול random:

import random random.random() # מספר אקראי בין 0 ל-1 random.randint(1, 10) # מספר שלם אקראי בין 1 ל-10 random.uniform(1.0, 10.0) # מספר עשרוני אקראי random.choice([1, 2, 3]) # בחירה אקראית מרשימה random.shuffle([1, 2, 3]) # ערבוב רשימה

מחרוזות (Strings)

💡 מה זו מחרוזת?
מחרוזת (String) - פשוט טקסט! כל דבר בין גרשיים או גרשיים כפולים.
למה זה חשוב? רוב התוכניות עובדות עם טקסט - שמות, כתובות, הודעות, תוכן מאתרים...
טיפ: מחרוזות ב-Python הן immutable - לא ניתן לשנות אותן, רק ליצור חדשות.
f-strings - הדרך המודרנית והנוחה ביותר לשלב משתנים בטקסט!

יצירת מחרוזות

מחרוזות בסיסיות:

s1 = 'Hello' s2 = "World" s3 = '''Multi line string''' s4 = """Another multi-line"""

תווים מיוחדים:

s = "Hello\nWorld" # שורה חדשה s = "Hello\tWorld" # Tab s = "He said \"Hi\"" # גרש כפול s = 'It\'s nice' # גרש יחיד s = "C:\\Users\\Name" # Backslash s = r"C:\Users\Name" # Raw string (ללא escape)

פעולות על מחרוזות

חיבור ושכפול:

s1 = "Hello" s2 = "World" s3 = s1 + " " + s2 # "Hello World" s4 = "Ha" * 3 # "HaHaHa"

אורך וגישה לתווים:

s = "Python" len(s) # 6 s[0] # 'P' (תו ראשון) s[-1] # 'n' (תו אחרון) s[1:4] # 'yth' (slicing) s[:3] # 'Pyt' (מההתחלה) s[3:] # 'hon' (עד הסוף) s[::2] # 'Pto' (כל תו שני)

בדיקות:

s = "Hello World" "Hello" in s # True "hello" in s # False s.startswith("He") # True s.endswith("ld") # True

מתודות מחרוזת

שינוי רישיות:

s = "Hello World" s.upper() # "HELLO WORLD" s.lower() # "hello world" s.capitalize() # "Hello world" s.title() # "Hello World" s.swapcase() # "hELLO wORLD"

חיפוש והחלפה:

s = "Hello World" s.find("World") # 6 (מיקום) s.find("Python") # -1 (לא נמצא) s.index("World") # 6 (זורק שגיאה אם לא נמצא) s.count("l") # 3 s.replace("World", "Python") # "Hello Python"

פיצול וחיבור:

s = "apple,banana,orange" s.split(",") # ['apple', 'banana', 'orange'] s.split(",", 1) # ['apple', 'banana,orange'] (מקסימום פיצולים) words = ["Hello", "World"] " ".join(words) # "Hello World" "-".join(words) # "Hello-World"

הסרת רווחים:

s = " Hello World " s.strip() # "Hello World" s.lstrip() # "Hello World " s.rstrip() # " Hello World" s.strip("H") # "ello World" (הסרת תווים ספציפיים)

יישור:

s = "Hello" s.center(10) # " Hello " s.ljust(10) # "Hello " s.rjust(10) # " Hello" s.zfill(10) # "00000Hello"

בדיקות תוכן:

s = "Hello123" s.isalpha() # False (רק אותיות?) s.isdigit() # False (רק ספרות?) s.isalnum() # True (אותיות או ספרות?) s.isspace() # False (רק רווחים?) s.isupper() # False (כולו אותיות גדולות?) s.islower() # False (כולו אותיות קטנות?)

עיצוב מחרוזות

f-strings (Python 3.6+):

name = "Alice" age = 25 print(f"My name is {name} and I'm {age} years old") print(f"Next year I'll be {age + 1}") print(f"{name:>10}") # יישור ימינה print(f"{age:05d}") # 00025 (padding)

format():

"Hello, {}!".format("World") "Hello, {0}! {0}".format("World") "Hello, {name}!".format(name="Alice") "{:.2f}".format(3.14159) # 3.14

% formatting (ישן):

"Hello, %s!" % "World" "I'm %d years old" % 25 "Pi is %.2f" % 3.14159

רשימות (Lists) ו-Tuples

💡 מה ההבדל בין List ל-Tuple?
List (רשימה) - כמו מחברת שאפשר למחוק ולהוסיף בה דפים. משתמשים בסוגריים מרובעים [ ]
Tuple - כמו ספר קבוע שלא ניתן לשנות אותו. משתמשים בסוגריים עגולים ( )
מתי להשתמש במה? List כשצריך לשנות את הנתונים, Tuple כשהנתונים קבועים (כמו קואורדינטות).

רשימות - יצירה וגישה

יצירת רשימות:

numbers = [1, 2, 3, 4, 5] mixed = [1, "hello", 3.14, True] empty = [] nested = [[1, 2], [3, 4], [5, 6]]

גישה לאיברים:

numbers = [10, 20, 30, 40, 50] numbers[0] # 10 (ראשון) numbers[-1] # 50 (אחרון) numbers[1:4] # [20, 30, 40] (slicing) numbers[:3] # [10, 20, 30] numbers[2:] # [30, 40, 50] numbers[::2] # [10, 30, 50] (כל שני)

שינוי איברים:

numbers = [1, 2, 3, 4, 5] numbers[0] = 10 # [10, 2, 3, 4, 5] numbers[1:3] = [20, 30] # [10, 20, 30, 4, 5]

מתודות רשימה

הוספת איברים:

numbers = [1, 2, 3] numbers.append(4) # [1, 2, 3, 4] numbers.insert(0, 0) # [0, 1, 2, 3, 4] numbers.extend([5, 6]) # [0, 1, 2, 3, 4, 5, 6] numbers += [7, 8] # [0, 1, 2, 3, 4, 5, 6, 7, 8]

הסרת איברים:

numbers = [1, 2, 3, 4, 5] numbers.remove(3) # [1, 2, 4, 5] (מסיר ערך) numbers.pop() # מסיר ומחזיר אחרון numbers.pop(0) # מסיר ומחזיר לפי אינדקס del numbers[0] # מחיקה לפי אינדקס numbers.clear() # מרוקן את הרשימה

חיפוש ומיון:

numbers = [3, 1, 4, 1, 5, 9, 2] numbers.index(4) # 2 (מיקום) numbers.count(1) # 2 (כמה פעמים) numbers.sort() # [1, 1, 2, 3, 4, 5, 9] (ממיין במקום) sorted(numbers) # מחזיר רשימה ממוינת חדשה numbers.reverse() # הופך את הסדר reversed(numbers) # מחזיר iterator הפוך

העתקה:

original = [1, 2, 3] copy1 = original.copy() # העתקה רדודה copy2 = original[:] # העתקה רדודה copy3 = list(original) # העתקה רדודה import copy deep = copy.deepcopy(original) # העתקה עמוקה

פעולות על רשימות

פונקציות מובנות:

numbers = [1, 2, 3, 4, 5] len(numbers) # 5 (אורך) sum(numbers) # 15 (סכום) max(numbers) # 5 (מקסימום) min(numbers) # 1 (מינימום) any([False, True]) # True (האם יש True?) all([True, True]) # True (האם הכל True?)

לולאות על רשימות:

numbers = [1, 2, 3, 4, 5] # לולאה רגילה for num in numbers: print(num) # עם אינדקס for i, num in enumerate(numbers): print(f"Index {i}: {num}") # התחלה מאינדקס אחר for i, num in enumerate(numbers, start=1): print(f"Position {i}: {num}")

Tuples

יצירת Tuples:

t1 = (1, 2, 3) t2 = 1, 2, 3 # ללא סוגריים t3 = (1,) # tuple עם איבר אחד t4 = tuple([1, 2]) # המרה מרשימה

גישה ל-Tuples:

t = (10, 20, 30, 40) t[0] # 10 t[-1] # 40 t[1:3] # (20, 30) # t[0] = 5 # שגיאה! tuple הוא immutable

Unpacking:

t = (1, 2, 3) a, b, c = t # a=1, b=2, c=3 # עם * a, *b, c = (1, 2, 3, 4, 5) # a=1, b=[2,3,4], c=5 # החלפת ערכים x, y = 5, 10 x, y = y, x # swap

מתודות Tuple:

t = (1, 2, 3, 2, 1) t.count(2) # 2 t.index(3) # 2

טיפים שימושיים

יצירת רשימות מיוחדות:

zeros = [0] * 5 # [0, 0, 0, 0, 0] range_list = list(range(5)) # [0, 1, 2, 3, 4] range_list = list(range(1, 6)) # [1, 2, 3, 4, 5] range_list = list(range(0, 10, 2)) # [0, 2, 4, 6, 8]

שילוב רשימות:

list1 = [1, 2, 3] list2 = [4, 5, 6] # שילוב combined = list1 + list2 # [1, 2, 3, 4, 5, 6] # zip - שילוב מקביל pairs = list(zip(list1, list2)) # [(1,4), (2,5), (3,6)]

מילונים (Dictionaries) ו-Sets

💡 מה זה Dictionary?
Dictionary (מילון) - כמו מילון אמיתי! יש מילה (key) ויש הסבר (value).
לדוגמה: {"name": "Alice", "age": 25} - "name" זה המפתח, "Alice" זה הערך.
Set (קבוצה) - אוסף של פריטים ייחודיים ללא כפילויות, כמו קבוצה במתמטיקה.
למה זה שימושי? מילון מאפשר לחפש מידע מהר מאוד לפי שם, במקום לחפש לפי מיקום.

מילונים - יצירה וגישה

יצירת מילונים:

person = {"name": "Alice", "age": 25, "city": "Tel Aviv"} empty = {} dict_from_list = dict([("a", 1), ("b", 2)]) dict_comp = {x: x**2 for x in range(5)}

גישה לערכים:

person = {"name": "Alice", "age": 25} person["name"] # "Alice" person.get("name") # "Alice" person.get("email", "N/A") # "N/A" (ברירת מחדל)

שינוי והוספה:

person = {"name": "Alice"} person["age"] = 25 # הוספה person["name"] = "Bob" # שינוי person.update({"city": "Tel Aviv", "age": 26}) # עדכון מרובה

מתודות מילון

הסרת איברים:

person = {"name": "Alice", "age": 25, "city": "Tel Aviv"} del person["age"] # מחיקה person.pop("city") # מחיקה והחזרת ערך person.popitem() # מחיקת זוג אחרון person.clear() # ריקון המילון

בדיקות:

person = {"name": "Alice", "age": 25} "name" in person # True "email" in person # False len(person) # 2

קבלת מפתחות וערכים:

person = {"name": "Alice", "age": 25} person.keys() # dict_keys(['name', 'age']) person.values() # dict_values(['Alice', 25]) person.items() # dict_items([('name', 'Alice'), ('age', 25)]) list(person.keys()) # ['name', 'age']

לולאות על מילונים:

person = {"name": "Alice", "age": 25} # לולאה על מפתחות for key in person: print(key, person[key]) # לולאה על מפתחות וערכים for key, value in person.items(): print(f"{key}: {value}")

Sets (קבוצות)

יצירת Sets:

numbers = {1, 2, 3, 4, 5} empty = set() # set ריק from_list = set([1, 2, 2, 3]) # {1, 2, 3} (ללא כפילויות)

הוספה והסרה:

numbers = {1, 2, 3} numbers.add(4) # {1, 2, 3, 4} numbers.remove(2) # {1, 3, 4} (שגיאה אם לא קיים) numbers.discard(5) # ללא שגיאה אם לא קיים numbers.pop() # מסיר איבר אקראי numbers.clear() # ריקון

פעולות קבוצות:

a = {1, 2, 3, 4} b = {3, 4, 5, 6} a | b # {1, 2, 3, 4, 5, 6} (איחוד) a & b # {3, 4} (חיתוך) a - b # {1, 2} (הפרש) a ^ b # {1, 2, 5, 6} (הפרש סימטרי) a.union(b) # איחוד a.intersection(b) # חיתוך a.difference(b) # הפרש a.issubset(b) # תת-קבוצה? a.issuperset(b) # על-קבוצה?

בקרת זרימה (Control Flow)

💡 מה זה בקרת זרימה?
בקרת זרימה קובעת איך התוכנית "זורמת" - באיזה סדר הקוד רץ.
if/else - "אם... אז..." - מאפשר לתוכנית להחליט מה לעשות בהתאם לתנאי.
for - לולאה שעוברת על רשימה או טווח מספרים.
while - לולאה שממשיכה כל עוד תנאי מסוים מתקיים.
למה זה חשוב? בלי בקרת זרימה, התוכנית רק תריץ שורה אחר שורה ללא החלטות.

תנאים - if/elif/else

תנאי בסיסי:

x = 10 if x > 5: print("x is greater than 5") elif x == 5: print("x is 5") else: print("x is less than 5")

תנאי בשורה אחת:

x = 10 result = "big" if x > 5 else "small" print("yes") if x > 5 else print("no")

תנאים מרובים:

x, y = 10, 20 if x > 5 and y < 30: print("Both conditions are true") if x > 5 or y > 30: print("At least one is true") if not x < 5: print("x is not less than 5")

לולאות - for

לולאת for בסיסית:

for i in range(5): print(i) # 0, 1, 2, 3, 4 for i in range(1, 6): print(i) # 1, 2, 3, 4, 5 for i in range(0, 10, 2): print(i) # 0, 2, 4, 6, 8

לולאה על רשימה:

fruits = ["apple", "banana", "orange"] for fruit in fruits: print(fruit) # עם אינדקס for i, fruit in enumerate(fruits): print(f"{i}: {fruit}")

לולאה על מילון:

person = {"name": "Alice", "age": 25} for key in person: print(key, person[key]) for key, value in person.items(): print(f"{key}: {value}")

לולאות - while

לולאת while בסיסית:

i = 0 while i < 5: print(i) i += 1

לולאה אינסופית:

while True: user_input = input("Enter 'quit' to exit: ") if user_input == "quit": break print(f"You entered: {user_input}")

break, continue, pass

break - יציאה מלולאה:

for i in range(10): if i == 5: break print(i) # 0, 1, 2, 3, 4

continue - דילוג על איטרציה:

for i in range(5): if i == 2: continue print(i) # 0, 1, 3, 4

pass - ביצוע ריק:

for i in range(5): if i == 2: pass # לא עושה כלום print(i)

else בלולאות:

for i in range(5): if i == 10: break else: print("Loop completed without break")

פונקציות (Functions)

💡 מה זו פונקציה?
פונקציה היא כמו מתכון בישול - אתה כותב פעם אחת איך לעשות משהו, ואז יכול להשתמש בזה שוב ושוב.
למה זה שימושי? במקום לכתוב את אותו קוד 10 פעמים, כותבים פונקציה אחת וקוראים לה 10 פעמים.
פרמטרים - זה המרכיבים שאתה נותן לפונקציה (כמו ביצים וקמח למתכון).
return - מה שהפונקציה מחזירה בסוף (כמו העוגה המוכנה).

הגדרת פונקציות

פונקציה בסיסית:

def greet(): print("Hello!") greet() # קריאה לפונקציה

פונקציה עם פרמטרים:

def greet(name): print(f"Hello, {name}!") greet("Alice")

פונקציה עם ערך החזרה:

def add(a, b): return a + b result = add(5, 3) # 8

פרמטרים עם ברירת מחדל:

def greet(name="Guest"): print(f"Hello, {name}!") greet() # "Hello, Guest!" greet("Alice") # "Hello, Alice!"

פרמטרים מתקדמים

*args - מספר משתנה של ארגומנטים:

def sum_all(*args): return sum(args) sum_all(1, 2, 3) # 6 sum_all(1, 2, 3, 4, 5) # 15

**kwargs - ארגומנטים עם שם:

def print_info(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") print_info(name="Alice", age=25, city="Tel Aviv")

שילוב של הכל:

def func(a, b=2, *args, **kwargs): print(f"a={a}, b={b}") print(f"args={args}") print(f"kwargs={kwargs}") func(1, 3, 4, 5, x=10, y=20)

פונקציות מתקדמות

Lambda - פונקציות אנונימיות:

square = lambda x: x ** 2 print(square(5)) # 25 add = lambda a, b: a + b print(add(3, 4)) # 7

פונקציות מקוננות:

def outer(x): def inner(y): return x + y return inner add_5 = outer(5) print(add_5(3)) # 8

Decorators:

def my_decorator(func): def wrapper(): print("Before function") func() print("After function") return wrapper @my_decorator def say_hello(): print("Hello!") say_hello()

פונקציות שימושיות

map, filter, reduce:

# map - החלת פונקציה על כל איבר numbers = [1, 2, 3, 4, 5] squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9, 16, 25] # filter - סינון evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4] # reduce - צמצום לערך אחד from functools import reduce sum_all = reduce(lambda x, y: x + y, numbers) # 15

עבודה עם קבצים

💡 למה צריך לעבוד עם קבצים?
שמירת מידע - כדי שהמידע לא יאבד כשהתוכנית נסגרת.
with open() - הדרך הבטוחה לפתוח קבצים. הקובץ נסגר אוטומטית בסוף!
מצבי פתיחה:
• "r" - קריאה (read) - רק לקרוא מהקובץ
• "w" - כתיבה (write) - מוחק את הקובץ הישן וכותב חדש
• "a" - הוספה (append) - מוסיף בסוף הקובץ הקיים
encoding="utf-8" - חשוב לעברית! מבטיח שהטקסט יוצג נכון.

קריאה וכתיבה בסיסית

קריאת קובץ:

# קריאת כל הקובץ with open("file.txt", "r", encoding="utf-8") as f: content = f.read() print(content) # קריאה שורה אחר שורה with open("file.txt", "r") as f: for line in f: print(line.strip())

כתיבה לקובץ:

# כתיבה (דורס קובץ קיים) with open("file.txt", "w", encoding="utf-8") as f: f.write("Hello, World!\n") f.write("Second line\n") # הוספה לסוף הקובץ with open("file.txt", "a") as f: f.write("Appended line\n")

קריאת שורות לרשימה:

with open("file.txt", "r") as f: lines = f.readlines() # רשימה של שורות # או lines = f.read().splitlines() # ללא \n

מצבי פתיחה

מצבים שונים:

"r" # קריאה (ברירת מחדל) "w" # כתיבה (דורס) "a" # הוספה "x" # יצירה (שגיאה אם קיים) "r+" # קריאה וכתיבה "rb" # קריאה בינארית "wb" # כתיבה בינארית

עבודה עם נתיבים

מודול os:

import os os.path.exists("file.txt") # בדיקה אם קיים os.path.isfile("file.txt") # האם זה קובץ? os.path.isdir("folder") # האם זו תיקייה? os.path.getsize("file.txt") # גודל בבתים os.path.join("folder", "file.txt") # חיבור נתיבים os.remove("file.txt") # מחיקת קובץ os.rename("old.txt", "new.txt") # שינוי שם

מודול pathlib (מודרני):

from pathlib import Path p = Path("file.txt") p.exists() # בדיקה אם קיים p.is_file() # האם זה קובץ? p.read_text() # קריאת תוכן p.write_text("Hello") # כתיבה p.unlink() # מחיקה p.stat().st_size # גודל

JSON ו-CSV

עבודה עם JSON:

import json # כתיבה data = {"name": "Alice", "age": 25} with open("data.json", "w") as f: json.dump(data, f, indent=2) # קריאה with open("data.json", "r") as f: data = json.load(f) # המרה למחרוזת json_string = json.dumps(data) data = json.loads(json_string)

עבודה עם CSV:

import csv # כתיבה with open("data.csv", "w", newline="") as f: writer = csv.writer(f) writer.writerow(["Name", "Age"]) writer.writerow(["Alice", 25]) # קריאה with open("data.csv", "r") as f: reader = csv.reader(f) for row in reader: print(row)

תכנות מונחה עצמים (OOP)

💡 מה זה תכנות מונחה עצמים?
מחלקה (Class) - תבנית או שרטוט. כמו תוכנית לבניית בית.
אובייקט (Object) - דוגמה ספציפית מהמחלקה. כמו בית אמיתי שנבנה לפי התוכנית.
מאפיינים (Attributes) - מאפיינים של האובייקט (צבע, גודל, שם).
מתודות (Methods) - פעולות שהאובייקט יכול לעשות (ללכת, לדבר, לחשב).
למה זה שימושי? מאפשר לארגן קוד מורכב בצורה הגיונית וקלה לתחזוקה.

מחלקות בסיסיות

הגדרת מחלקה:

class Person: def __init__(self, name, age): self.name = name self.age = age def greet(self): print(f"Hello, I'm {self.name}") # יצירת אובייקט person = Person("Alice", 25) person.greet()

מתודות ומאפיינים:

class Car: # מאפיין מחלקה wheels = 4 def __init__(self, brand, model): # מאפייני instance self.brand = brand self.model = model def info(self): return f"{self.brand} {self.model}" car = Car("Toyota", "Corolla") print(car.info())

ירושה (Inheritance)

ירושה בסיסית:

class Animal: def __init__(self, name): self.name = name def speak(self): pass class Dog(Animal): def speak(self): return f"{self.name} says Woof!" class Cat(Animal): def speak(self): return f"{self.name} says Meow!" dog = Dog("Buddy") print(dog.speak())

super() - קריאה למחלקת אב:

class Employee(Person): def __init__(self, name, age, salary): super().__init__(name, age) self.salary = salary def info(self): return f"{self.name}, {self.age}, ${self.salary}"

מתודות מיוחדות

Magic methods:

class Point: def __init__(self, x, y): self.x = x self.y = y def __str__(self): return f"Point({self.x}, {self.y})" def __repr__(self): return f"Point({self.x}, {self.y})" def __add__(self, other): return Point(self.x + other.x, self.y + other.y) def __eq__(self, other): return self.x == other.x and self.y == other.y p1 = Point(1, 2) p2 = Point(3, 4) p3 = p1 + p2 # Point(4, 6)

Properties ו-Encapsulation

@property decorator:

class Circle: def __init__(self, radius): self._radius = radius @property def radius(self): return self._radius @radius.setter def radius(self, value): if value < 0: raise ValueError("Radius cannot be negative") self._radius = value @property def area(self): return 3.14 * self._radius ** 2 circle = Circle(5) print(circle.area) # 78.5 circle.radius = 10

מודולים וחבילות

💡 מה זה מודול?
מודול - קובץ Python שמכיל פונקציות ומחלקות שאפשר להשתמש בהן.
חבילה (Package) - תיקייה שמכילה מספר מודולים.
למה זה שימושי? במקום לכתוב הכל מאפס, משתמשים בקוד שכבר נכתב!
pip - מנהל החבילות של Python. מאפשר להתקין אלפי ספריות בפקודה אחת.
דוגמה: צריך לעבוד עם תאריכים? יש מודול datetime. צריך מספרים אקראיים? יש מודול random.

ייבוא מודולים

דרכי ייבוא:

import math print(math.pi) import math as m print(m.pi) from math import pi, sqrt print(pi) from math import * # לא מומלץ print(pi)

יצירת מודול משלך:

# mymodule.py def greet(name): return f"Hello, {name}!" PI = 3.14159 # main.py import mymodule print(mymodule.greet("Alice")) print(mymodule.PI)

חבילות (Packages)

מבנה חבילה:

# מבנה תיקיות: # mypackage/ # __init__.py # module1.py # module2.py # ייבוא from mypackage import module1 from mypackage.module1 import function_name

התקנת חבילות

pip - מנהל חבילות:

# התקנה pip install package_name # הסרה pip uninstall package_name # רשימת חבילות מותקנות pip list # שמירת dependencies pip freeze > requirements.txt # התקנה מקובץ pip install -r requirements.txt

טיפול בשגיאות (Exception Handling)

💡 למה צריך לטפל בשגיאות?
שגיאות קורות! משתמש מזין טקסט במקום מספר, קובץ לא קיים, אין חיבור לאינטרנט...
try/except - "נסה לעשות משהו, ואם זה נכשל - עשה משהו אחר".
למה זה חשוב? במקום שהתוכנית תקרוס, היא תוכל להמשיך לרוץ ולהציג הודעה ידידותית למשתמש.
דוגמה מהחיים: כמו רשת ביטחון - אם משהו משתבש, יש לך תוכנית גיבוי.

try/except

טיפול בסיסי בשגיאות:

try: x = 10 / 0 except ZeroDivisionError: print("Cannot divide by zero!") try: num = int("abc") except ValueError: print("Invalid number!")

טיפול במספר שגיאות:

try: # code that might fail pass except ValueError: print("Value error!") except TypeError: print("Type error!") except (KeyError, IndexError): print("Key or Index error!") except Exception as e: print(f"Other error: {e}")

else ו-finally:

try: result = 10 / 2 except ZeroDivisionError: print("Error!") else: print("Success!") # רק אם אין שגיאה finally: print("Always runs") # תמיד מתבצע

זריקת שגיאות

raise - זריקת שגיאה:

def divide(a, b): if b == 0: raise ValueError("Cannot divide by zero") return a / b try: divide(10, 0) except ValueError as e: print(e)

שגיאות מותאמות אישית:

class NegativeNumberError(Exception): pass def sqrt(x): if x < 0: raise NegativeNumberError("Cannot calculate sqrt of negative") return x ** 0.5 try: sqrt(-5) except NegativeNumberError as e: print(e)

Comprehensions

💡 מה זה Comprehension?
Comprehension - דרך קצרה ואלגנטית ליצור רשימות, מילונים או קבוצות בשורה אחת!
במקום: לולאה של 4 שורות
כותבים: שורה אחת קצרה וברורה
למה זה מגניב? הקוד נראה יותר "פייתוני" (Pythonic) וקל יותר לקריאה אחרי שמתרגלים.
טיפ: אל תגזימו! אם ה-comprehension נהיה מסובך מדי, עדיף לולאה רגילה.

List Comprehension

יצירת רשימות:

# בסיסי squares = [x**2 for x in range(10)] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] # עם תנאי evens = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8] # עם if-else result = [x if x % 2 == 0 else -x for x in range(5)] # [0, -1, 2, -3, 4] # מקונן matrix = [[i*j for j in range(3)] for i in range(3)] # [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

Dictionary Comprehension

יצירת מילונים:

# בסיסי squares = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} # עם תנאי evens = {x: x**2 for x in range(10) if x % 2 == 0} # הפיכת מפתחות וערכים original = {"a": 1, "b": 2} swapped = {v: k for k, v in original.items()} # {1: 'a', 2: 'b'}

Set Comprehension

יצירת קבוצות:

squares = {x**2 for x in range(10)} # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81} # ללא כפילויות numbers = [1, 2, 2, 3, 3, 3] unique = {x for x in numbers} # {1, 2, 3}

Generator Expression

Generators - חסכוני בזיכרון:

# Generator expression squares = (x**2 for x in range(10)) # שימוש for square in squares: print(square) # המרה לרשימה list(squares)

נושאים מתקדמים

💡 מתי להשתמש בנושאים מתקדמים?
Generators - כשצריך לעבור על הרבה מאוד נתונים בלי לשמור הכל בזיכרון.
Iterators - כשרוצים ליצור אובייקט שאפשר לעבור עליו בלולאה.
Context Managers - כשצריך לוודא שמשאב (כמו קובץ) נסגר תמיד, גם אם יש שגיאה.
Type Hints - עוזר לתעד את הקוד ולמצוא באגים לפני שהתוכנית רצה.
טיפ: אלו כלים מתקדמים - אל תדאגו אם לא מבינים הכל בהתחלה!

Generators

פונקציית Generator:

def countdown(n): while n > 0: yield n n -= 1 for num in countdown(5): print(num) # 5, 4, 3, 2, 1

Generator עם yield from:

def chain(*iterables): for iterable in iterables: yield from iterable list(chain([1, 2], [3, 4], [5, 6])) # [1, 2, 3, 4, 5, 6]

Iterators

יצירת Iterator:

class Counter: def __init__(self, max): self.max = max self.current = 0 def __iter__(self): return self def __next__(self): if self.current < self.max: self.current += 1 return self.current raise StopIteration for num in Counter(5): print(num) # 1, 2, 3, 4, 5

Context Managers

יצירת Context Manager:

class FileManager: def __init__(self, filename): self.filename = filename def __enter__(self): self.file = open(self.filename, 'r') return self.file def __exit__(self, exc_type, exc_val, exc_tb): self.file.close() with FileManager('file.txt') as f: content = f.read()

Context Manager עם contextlib:

from contextlib import contextmanager @contextmanager def timer(): import time start = time.time() yield end = time.time() print(f"Time: {end - start:.2f}s") with timer(): # code to time pass

Type Hints

הוספת Type Hints:

def greet(name: str) -> str: return f"Hello, {name}!" def add(a: int, b: int) -> int: return a + b from typing import List, Dict, Optional, Union def process(items: List[int]) -> Dict[str, int]: return {"sum": sum(items)} def find(name: str) -> Optional[str]: return name if name else None

ספריית התקן (Standard Library)

💡 מה זו ספריית התקן?
ספריית התקן - אוסף ענק של מודולים שמגיעים עם Python, ללא צורך בהתקנה!
"Batteries Included" - הפילוסופיה של Python: הכל כבר מוכן לשימוש.
למה זה מעולה? רוב הדברים הבסיסיים שתצטרכו כבר קיימים - תאריכים, קבצים, רשת, ועוד.
טיפ: לפני שמתקינים ספרייה חיצונית, בדקו אם יש משהו דומה בספריית התקן!

datetime - תאריכים ושעות

עבודה עם תאריכים:

from datetime import datetime, date, time, timedelta # תאריך ושעה נוכחיים now = datetime.now() today = date.today() # יצירת תאריך d = date(2025, 12, 25) dt = datetime(2025, 12, 25, 14, 30) # פורמט now.strftime("%Y-%m-%d %H:%M:%S") datetime.strptime("2025-12-25", "%Y-%m-%d") # חישובים tomorrow = today + timedelta(days=1) week_ago = now - timedelta(weeks=1)

collections - מבני נתונים

מבני נתונים שימושיים:

from collections import Counter, defaultdict, deque, namedtuple # Counter - ספירה words = ["apple", "banana", "apple", "orange", "banana", "apple"] counter = Counter(words) # Counter({'apple': 3, 'banana': 2, 'orange': 1}) # defaultdict - ערך ברירת מחדל d = defaultdict(int) d['key'] += 1 # לא זורק שגיאה # deque - תור דו-כיווני q = deque([1, 2, 3]) q.append(4) # הוספה מימין q.appendleft(0) # הוספה משמאל # namedtuple - tuple עם שמות Point = namedtuple('Point', ['x', 'y']) p = Point(1, 2) print(p.x, p.y)

itertools - כלי איטרציה

פונקציות שימושיות:

from itertools import count, cycle, repeat, chain, combinations, permutations # count - ספירה אינסופית for i in count(10, 2): # 10, 12, 14, ... if i > 20: break # cycle - חזרה מחזורית for item in cycle([1, 2, 3]): # 1, 2, 3, 1, 2, 3, ... break # chain - שרשור list(chain([1, 2], [3, 4])) # [1, 2, 3, 4] # combinations - צירופים list(combinations([1, 2, 3], 2)) # [(1,2), (1,3), (2,3)] # permutations - תמורות list(permutations([1, 2, 3], 2)) # [(1,2), (1,3), (2,1), ...]

re - ביטויים רגולריים

Regex בסיסי:

import re # חיפוש match = re.search(r'\d+', 'Price: 100') if match: print(match.group()) # '100' # החלפה text = re.sub(r'\d+', 'X', 'Phone: 123-456') # 'Phone: X-X' # פיצול re.split(r'\s+', 'hello world') # ['hello', 'world'] # מציאת כל ההתאמות re.findall(r'\d+', 'I have 2 cats and 3 dogs') # ['2', '3'] # Compile לשימוש חוזר pattern = re.compile(r'\d+') pattern.findall('123 456')

שימושיים נוספים

מודולים שימושיים:

# sys - מערכת import sys sys.argv # ארגומנטים משורת הפקודה sys.exit() # יציאה מהתוכנית # time - זמן import time time.sleep(1) # המתנה שנייה time.time() # timestamp # subprocess - הרצת פקודות import subprocess result = subprocess.run(['ls', '-l'], capture_output=True) # shutil - פעולות קבצים import shutil shutil.copy('src.txt', 'dst.txt') shutil.move('old.txt', 'new.txt') # glob - חיפוש קבצים import glob files = glob.glob('*.txt') # כל קבצי txt