3.5 מודולים הרצאה

מודולים בפייתון

• מה הם מודולים בפייתון?
• מודולים הם קבצי פייתון, בפייתון אנחנו יכולים לחלק את הקוד שלנו לקבצים שונים (מודולים שונים).

יצירת מודול

• צרו קובץ פייתון למשל - module.py
• הגדירו פונקציות או משתנים בקובץ כמו בדוגמה הבאה:

# Module.py 
number = 3

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

def square(x):
    return x ** 2

שימוש במודול:

• כדי להשתמש במודול החדש שיצרנו במודול אחר למשל בmain.py אנחנו נשתמש בimport

# Main.py 
import module  

module.greet("Alice")  # Output: Hello, Alice! 
result = module.square(5) 
print(result)  # Output: 25
print(module.number) # Output: 3

- באמצעות import module יבאנו משתנה בשם module שמכיל את כל הפונקציות והמשתנים מהמודול module.py.

• אפשר לציין בimport בדיוק איזה משתנים/פונקציות אנחנו רוצים לייבא לקוד שלנו

# Main.py 
from module import greet, number

greet("Alice")  # Output: Hello, Alice! 
square(5) #  will raise an error  
print(number) # Output: 3

- באמצעות from module import greet, number ייבאנו רק את המשתנה number והפונקציה greet לקוד שלנו.

חבילה - Package

מה היא חבילה?

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

mypackage/
|-- __init__.py
|-- module1.py
|-- module2.py
main.py

שימוש בחבילה

• אפשר להשתמש בimport כדי לייבא מודולים מחבילות

# Main.py
from mypackage import module1, module2

module1.function1()
module2.function2()

• אפשר גם לעשות import בצורה הבאה:

# Main.py
from mypackage.module1 import function1

function1()

• נניח הפרויקט שלנו היה נראה ככה:
  

  myproject/
  │-- __init__.py
  │-- module1.py
  │-- mypackage/ 
  │-- │-- __init__.py
  │-- │-- module2.py
  

• היינו יכולים גם לעשות ככה:
  

  # Module1.py
  from myproject.mypackage import module2
  

• וכדי להימנע מנתיבים ארוכים כמו למעלה, נוכל גם לעשות נתיבים קצרים יותר ככה:
  

  # Module1.py
  from .mypackage import module2  # Importing module2 from the same package
  

• זה עובד בגלל שמודול 1 נמצא באותה תקייה עם החבילה שמכילה את מודול 2.

תלות מעגלית - Circular dependency

• תלות מעגלות קורת כאשר שני מודולים עושים import אחד לשני.

module_a.py

# Module_a.py
from module_b import function_b

def function_a():
    print("Function A")

function_b()

module_b.py

# Module_b.py
from module_a import function_a

def function_b():
    print("Function B")

function_a()

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

טיפים אחרונים

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

• תתעדו את המודולים שלכם עם doc-string - זה אפשרי:
  

  # Module exmaple.py
  """
  This is a doc string for exmaple.py module :)
  """
  
  def something():
      """
      This is a doc string for something function :)
      """
      return
  

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

• מודול לא אמור להכיל רק פונקציה אחת, אלה כמה - אבל מצד שני מודול לא אמור להיות ארוך מקסימום 100 שורות. תנסו לדאוג שכל מודול יהיה עד 50 שורות קוד.
• בנוסף בדרך כלל נהוג שבמודול main יהיה את הפונקציית main ורק אותה. וזה אמור להיות המודול היחידי שיש בו בדרך כלל רק פונקציה אחת.
• שימו לב שכשאתם עושים import, תעשו תמיד from. תמיד תעשו import רק לפונקציות שאתם משתמשים בהם, למשל כמו בדוגמה הבאה:
  

  # operation.py
  def add(x, y):
      return x + y
  
  def sub(x, y):
      return x - y
  

# main.py
from operation import add, sub