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

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

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 = "Taro"
12print("Name:", name)  # Output: Name: Taro
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# Simple 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# List comprehension
2squares = [x * x for x in range(5)]
3print squares
4
5# Unicode string (u"...")
6greet = u"Hello"
7print greet

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

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

1# print is now a function
2print("Hello, world!")
3
4# Unicode text is handled natively
5message = "Hello"
6print(message)

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

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

1import asyncio
2
3async def say_hello():
4    await asyncio.sleep(1)
5    print("Hello, async world!")
6
7asyncio.run(say_hello())

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

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

1name = "Alice"
2age = 30
3print(f"{name} is {age} years old.")  # f-string makes formatting simple

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

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

1from dataclasses import dataclass
2
3@dataclass
4class Person:
5    name: str
6    age: int
7
8p = Person("Bob", 25)
9print(p)

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

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

1# Assignment inside an expression
2if (n := len("hello")) > 3:
3    print(f"Length is {n}")

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

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

1a = {"x": 1}
2b = {"y": 2}
3c = a | b  # merge two dicts
4print(c)   # {'x': 1, 'y': 2}

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

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

 1def handle(value):
 2    match value:
 3        case 1:
 4            return "One"
 5        case 2:
 6            return "Two"
 7        case _:
 8            return "Other"
 9
10print(handle(2))

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

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

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

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

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

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

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

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

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

YouTube Video