יסודות פייתון

מאמר זה מסביר את יסודות השפה פייתון.

YouTube Video

הרצת "שלום עולם!"

1print("Hello World!")

משתנים בפייתון

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

 1# 1. Assigning values to variables
 2# Integer type variable
 3age = 25
 4print("Age:", age)  # Output: Age: 25
 5
 6# Floating-point type variable
 7height = 175.5
 8print("Height:", height, "cm")  # Output: Height: 175.5 cm
 9
10# String type variable
11name = "John"
12print("Name:", name)  # Output: Name: John
13
14# Boolean type variable
15is_student = True
16print("Are you a student?", is_student)  # Output: Are you a student? True
17
18# 2. Assigning values to multiple variables simultaneously
19# You can assign multiple variables at once
20x, y, z = 5, 10, 15
21print("x =", x, ", y =", y, ", z =", z)  # Output: x = 5 , y = 10 , z = 15
22
23# 3. Updating the value of a variable
24# The value of a variable can be updated by reassignment
25age = 26
26print("Updated age:", age)  # Output: Updated age: 26
27
28# 4. Updating multiple variables at once
29# Example of swapping values between variables
30a, b = 1, 2
31a, b = b, a
32print("a =", a, ", b =", b)  # Output: a = 2 , b = 1
33
34# 5. Type conversion
35# Type conversion allows operations between different types
36count = "5"  # String "5"
37count = int(count)  # Convert to integer type
38print("Handling count as an integer:", count * 2)  # Output: Handling count as an integer: 10
39
40# Conversion to floating-point number
41pi_approx = "3.14"
42pi_approx = float(pi_approx)
43print("Approximation of pi:", pi_approx)  # Output: Approximation of pi: 3.14

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

סוגי נתונים בפייתון

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

סוג מספר שלם

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

1# Example of integer type
2x = 10
3print(x)        # Output: 10
4print(type(x))  # Output: <class 'int'>

סוג מספר עשרוני (נקודה צפה)

סוג המספר העשרוני משמש לעבודה עם מספרים שיש להם נקודה עשרונית.

1# Floating Point Number Example
2y = 3.14
3print(y)        # Output: 3.14
4print(type(y))  # Output: float

סוג מחרוזת

סוג המחרוזת מייצג רצף של תווים. מחרוזות יכולות להיות כלואות במרכאות יחידות ' או במרכאות כפולות ".

1# Example of String
2s = "Hello, World!"
3print(s)        # Output: Hello, World!
4print(type(s))  # Output: <class 'str'>

סוג הבוליאני

לסוג הבוליאני יש שני ערכים: אמת (True) ושקר (False).

1# Example of Boolean
2b = True
3print(b)        # Output: True
4print(type(b))  # Output: <class 'bool'>

סוג רשימה

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

1# Example of List
2lst = [1, 2, 3, "four", 5.0]
3print(lst)        # Output: [1, 2, 3, 'four', 5.0]
4print(type(lst))  # Output: <class 'list'>

סוג טופלה

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

1# Example of Tuple
2tup = (1, "two", 3.0)
3print(tup)        # Output: (1, 'two', 3.0)
4print(type(tup))  # Output: <class 'tuple'>

סוג מילון

סוג המילון הוא אוסף המכיל זוגות של מפתח-ערך. המפתחות חייבים להיות ייחודיים.

1# Example of Dictionary
2dct = {"one": 1, "two": 2, "three": 3}
3print(dct)        # Output: {'one': 1, 'two': 2, 'three': 3}
4print(type(dct))  # Output: <class 'dict'>

סוג קבוצה

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

1# Example of Set
2st = {1, 2, 2, 3}
3print(st)        # Output: {1, 2, 3}
4print(type(st))  # Output: <class 'set'>

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

סקירה של Python

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

1. קל לקריאה ופשוט

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

2. ספריות ומסגרות עשירות:

   • יש לה ספריית סטנדרט עשירה, שמאפשרת ביצוע קל של משימות רבות.
   • ישנן ספריות ייעודיות ומסגרות עבודה זמינות לתחומים מגוונים, כמו חישוב נומרי (NumPy), ניתוח נתונים (Pandas), למידת מכונה (scikit-learn, TensorFlow), ופיתוח אתרים (Django, Flask).

3. גמישות שימושית:

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

4. תמיכה בחוצה פלטפורמות:

   • השפה אינה תלויה בפלטפורמה וניתנת להרצה במערכות הפעלה שונות, כולל Windows, macOS ו-Linux.

5. מקור פתוח וקהילה:

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

6. סוגי משתנים דינמיים וניהול זיכרון אוטומטי:

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

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

תווי בריחה בפייתון

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

יסודות תווי הבריחה

בפייתון, תווי בריחה מוגדרים באמצעות סלש הפוך (\). תווי הבריחה מציינים התנהגות ספציפית בתוך מחרוזת רגילה. לדוגמה, \n מייצג שורה חדשה, ו-\t מייצג רווח טאב.

ניתן להגדיר מחרוזת המכילה תווי בריחה בצורה הבאה:.

1# Example of escape characters
2print("Hello\nWorld")  # A newline is inserted after "Hello"
3
4# Output:
5# Hello
6# World

רשימת תווי הבריחה העיקריים

תווי הבריחה העיקריים המשמשים בפייתון הם כדלקמן:.

• \\: מייצג את הסלש ההפוך עצמו.
• \': מוסיף גרש יחיד במחרוזת.
• \": מוסיף גרשיים כפולים במחרוזת.
• \n: שורה חדשה
• \t: טאב
• \r: חזרה לתחילת השורה
• \b: מחיקת תו אחורה
• \f: האכלת טופס
• \a: צליל התראה (פעמון)
• \v: טאב אנכי
• \N{name}: תו לפי השם בבסיס הנתונים של Unicode
• \uXXXX: תו Unicode בן 16 ביט (מוגדר באמצעות 4 ספרות הקסדצימליות)
• \UXXXXXXXX: תו Unicode בן 32 ביט (מוגדר באמצעות 8 ספרות הקסדצימליות)
• \xXX: תו שצוין בהקסדצימלי

דוגמאות לתווים מיוחדים נפוצים

להלן מספר דוגמאות ספציפיות לשימוש בתווים מיוחדים.

מרכאות כפולות ומרכאות בודדות

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

 1# String containing double quotes
 2quote = "He said, \"Python is amazing!\""
 3print(quote)
 4
 5# String containing single quotes
 6single_quote = 'It\'s a beautiful day!'
 7print(single_quote)
 8
 9# Output:
10# He said, "Python is amazing!"
11# It's a beautiful day!

שורות חדשות ורווחי טאב

שורות חדשות ורווחי טאב משמשים לעתים קרובות לעיצוב טקסט.

 1# Example using newline
 2multiline_text = "First line\nSecond line"
 3print(multiline_text)
 4
 5# Example using tab
 6tabbed_text = "Column1\tColumn2\tColumn3"
 7print(tabbed_text)
 8
 9# Output:
10# First line
11# Second line
12# Column1	Column2	Column3

תווי יוניקוד מיוחדים

ב-Python, תווי Unicode מיוצגים באמצעות \u או \U. זה שימושי במיוחד כאשר מטפלים בתווים שאינם באנגלית.

1# Example of Unicode escape
2japanese_text = "\u3053\u3093\u306B\u3061\u306F"  # Hello in Japanese
3print(japanese_text)
4# Output:
5# こんにちは(Hello in Japanese)

אזהרות לגבי שימוש בתווים מיוחדים

יש לשים לב למספר אזהרות בעת שימוש בתווים מיוחדים.

1. מחרוזת גולמית: אם ברצונך להציג מחרוזת הכוללת קווים נטויים אחוריים () כפי שהם, הוסף את התו r לפני המחרוזת.

1raw_string = r"C:\Users\name\Documents"
2print(raw_string)
3# Output:
4# C:\Users\name\Documents

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

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

בריחת לוכסנים

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

1# Example containing backslash
2path = "C:\\Program Files\\Python"
3print(path)
4# Output:
5# C:\Program Files\Python

דוגמה מתקדמת: עיצוב מחרוזות מורכב

ניתן גם לשלב תווים מיוחדים לעיצוב מחרוזות מורכבות.

 1# Example of formatting a message
 2message = "Dear User,\n\n\tThank you for your inquiry.\n\tWe will get back to you shortly.\n\nBest Regards,\nCustomer Support"
 3print(message)
 4# Output:
 5# Dear User,
 6#
 7#     Thank you for your inquiry.
 8#     We will get back to you shortly.
 9#
10#     Best Regards,
11#     Customer Support

סיכום

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

גרסאות פייתון

בואו נסקור בקצרה את הגרסאות העיקריות של פייתון והתכונות שלהן.

1. פייתון 1.0 (1994)

1# Sample code that works in Python 1.0
2def greet(name):
3    print "Hello, " + name  # print was a statement
4
5greet("World")

הגרסה הרשמית הראשונה. תחביר הבסיס והספרייה הסטנדרטית של פייתון הונחו.

2. פייתון 2.0 (2000)

1# Sample code that works in Python 2.0
2
3# List comprehension
4squares = [x * x for x in range(5)]
5print squares
6
7# Unicode string (u"...")
8greet = u"Hello"
9print greet

תכונות חשובות נוספו כגון יצירת רשימות בתמציתיות, איסוף אשפה מלא, והתחלת תמיכה ב-Unicode. פייתון 2 שימשה במשך תקופה ארוכה אך התמיכה בה הסתיימה בשנת 2020.

3. פייתון 3.0 (2008)

1# Sample code that works in Python 3.0
2
3# print is now a function
4print("Hello, world!")
5
6# Unicode text is handled natively
7message = "Hello"
8print(message)

עדכון משמעותי ללא תאימות לאחור. print הפכה לפונקציה, Unicode הפכה למחרוזת ברירת המחדל, ומספרים שלמים (integers) אוחדו, דבר ששיפר באופן משמעותי את העקביות והשימושיות של פייתון. פייתון 3 היא הגרסה המרכזית הנוכחית.

4. פייתון 3.5 (2015)

1# Sample code that works in Python 3.5
2import asyncio
3
4async def say_hello():
5    await asyncio.sleep(1)
6    print("Hello, async world!")
7
8asyncio.run(say_hello())

התחביר async/await הוצג, מה שהפך את התכנות הא-סינכרוני לפשוט יותר לכתיבה.

5. פייתון 3.6 (2016)

1# Sample code that works in Python 3.6
2
3name = "Alice"
4age = 30
5print(f"{name} is {age} years old.")  # f-string makes formatting simple

מחרוזות בפורמט (f-strings) נוספו, מה שהפך את העיצוב של מחרוזות לנוח יותר. בנוסף, סוגי ההשערות (type hints) הורחבו.

6. פייתון 3.7 (2018)

 1# Sample code that works in Python 3.7
 2
 3from dataclasses import dataclass
 4
 5@dataclass
 6class Person:
 7    name: str
 8    age: int
 9
10p = Person("Bob", 25)
11print(p)

מחלקות נתונים (dataclasses) הוצגו, מה שהקל על הגדרת מחלקות דמויות-מבנה. הותעלה תמיכה עבור async/await.

7. פייתון 3.8 (2019)

1# Sample code that works in Python 3.8
2
3# Assignment inside an expression
4if (n := len("hello")) > 3:
5    print(f"Length is {n}")

הוצג אופרטור הוולארוס (:=), שמאפשר שימוש בביטויי השמה. הוצגו פרמטרים המוגבלים למיקום בלבד (positional-only parameters), שהוסיפו גמישות לארגומנטים של פונקציות.

8. פייתון 3.9 (2020)

1# Sample code that works in Python 3.9
2
3a = {"x": 1}
4b = {"y": 2}
5c = a | b  # merge two dicts
6print(c)   # {'x': 1, 'y': 2}

בוצעו שיפורים ב-type hints ונוסף אופרטור למיזוג (|) עבור רשימות ומילונים. ספריית הסטנדרט אורגנה מחדש.

9. פייתון 3.10 (2021)

 1# Sample code that works in Python 3.10
 2
 3def handle(value):
 4    match value:
 5        case 1:
 6            return "One"
 7        case 2:
 8            return "Two"
 9        case _:
10            return "Other"
11
12print(handle(2))

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

10. פייתון 3.11 (2022)

1# Sample code that works in Python 3.11
2
3# Improved performance (up to 25% faster in general)
4# More informative error messages
5try:
6    eval("1/0")
7except ZeroDivisionError as e:
8    print(f"Caught an error: {e}")

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

11. פייתון 3.12 (2023)

 1# Sample code that works in Python 3.12
 2
 3# Automatically shows exception chains with detailed traceback
 4def f():
 5    raise ValueError("Something went wrong")
 6
 7def g():
 8    try:
 9        f()
10    except Exception:
11        raise RuntimeError("Higher level error")  # Automatically chained
12
13try:
14    g()
15except Exception as e:
16    import traceback
17    traceback.print_exception(type(e), e, e.__traceback__)

הודעות השגיאה שופרו עוד יותר, ובוצעו שיפורי ביצועים. בנוסף, שרשור חריגות (exception chaining) מוצג אוטומטית, שמאפשר ניפוי שגיאות מפורט יותר. הוספו תכונות תחביר חדשות ושיפורים בספריית הסטנדרט, שמגביר את הפרודוקטיביות של המפתחים.

12. פייתון 3.13 (2024)

 1# Sample code that works in Python 3.13
 2
 3# Using the new 'except*' syntax for handling multiple exceptions in parallel
 4import asyncio
 5
 6async def raise_errors():
 7    raise ExceptionGroup("Multiple errors", [
 8        ValueError("Invalid value"),
 9        TypeError("Wrong type"),
10    ])
11
12async def main():
13    try:
14        await raise_errors()
15    except* ValueError as e:
16        print("Caught ValueError(s):", e.exceptions)
17    except* TypeError as e:
18        print("Caught TypeError(s):", e.exceptions)
19
20asyncio.run(main())

בפייתון 3.13, התחביר של ExceptionGroup ו-except* שופר, דבר המאפשר לטפל בכמה חריגות במקביל בתהליכי עיבוד אסינכרוניים. דבר זה הופך את הניפוי שגיאות וטיפול בשגיאות באפליקציות המנצלות עיבוד מקבילי או asyncio לאינטואיטיביים ועוצמתיים יותר. בנוסף, שיפורים ב-type hints ועדכונים לספריה הסטנדרטית שיפרו את יכולת התחזוקה והביטוי של הקוד.

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

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video