modular programming

modular programming (tsz. modular programmings)

1. (informatika) A moduláris programozás olyan szoftvertervezési technika, amely során a programot különálló, független modulokra bontjuk, ahol minden modul egy-egy jól meghatározott feladatért felelős.

👉 Egyszerűen fogalmazva: nem egyetlen nagy, átláthatatlan programot írunk, hanem kisebb, önállóan fejleszthető és tesztelhető modulokat készítünk.

✅ Olvashatóság → kisebb fájlok, könnyebben átlátható ✅ Karbantarthatóság → könnyebb hibát keresni és javítani ✅ Újrafelhasználhatóság → modulok más programban is használhatók ✅ Csapatmunka → több fejlesztő dolgozhat párhuzamosan ✅ Tesztelhetőség → modulokat külön is lehet tesztelni ✅ Absztrakció → elrejti a belső részleteket más modulok elől

Egy modul:

• Egy fájl vagy funkciók, osztályok, változók gyűjteménye, amely egy adott feladatot lát el.
• Pythonban egy modul általában egy .py fájl.

Példa:

math_utils.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

Felhasználása másik fájlban:

import math_utils

print(math_utils.add(3, 5))
print(math_utils.subtract(10, 4))

A Python nyelvet eleve úgy tervezték, hogy moduláris legyen. A kódot az alábbi módokon bonthatjuk modulokra:

✅ Függvények ✅ Osztályok ✅ Modulok (külön .py fájlok) ✅ Csomagok (mappák, amelyek modulokat tartalmaznak + __init__.py)

my_project/
├── main.py          # főprogram
├── utils.py         # segédfüggvények (modul)
├── data_processing.py  # adatműveletek (modul)
├── models/
│   ├── __init__.py
│   ├── model1.py    # almodul
│   ├── model2.py
└── README.md

• A main.py a koordináló főprogram.
• Az egyes modulok különböző logikai egységeket tartalmaznak.

Minden modulnak egy jól meghatározott feladata legyen.

Például:

• math_utils.py → matematikai műveletek
• file_io.py → fájlkezelés
• network_utils.py → hálózati műveletek

❌ Ne keverjük az egymástól független logikát ugyanabba a modulba.

Egy modul csak a szükséges dolgokat tegye publikusan elérhetővé.

Privát függvényeket konvenció szerint _ aláhúzással jelezzük:

# my_module.py

def public_function():
    ...

def _private_helper():
    ...

Egy jól megírt modul:

✅ független → nem függ globális változóktól ✅ újrafelhasználható → más programokban is gond nélkül használható

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Nullával nem lehet osztani.")
    return a / b

import math_operations

def main():
    print("Egyszerű Számológép")
    print("1. Összeadás")
    print("2. Kivonás")
    print("3. Szorzás")
    print("4. Osztás")

    choice = input("Válassz (1-4): ")
    a = float(input("Első szám: "))
    b = float(input("Második szám: "))

    if choice == '1':
        print("Eredmény:", math_operations.add(a, b))
    elif choice == '2':
        print("Eredmény:", math_operations.subtract(a, b))
    elif choice == '3':
        print("Eredmény:", math_operations.multiply(a, b))
    elif choice == '4':
        print("Eredmény:", math_operations.divide(a, b))
    else:
        print("Hibás választás.")

if __name__ == "__main__":
    main()

• A matematikai logika külön modulban van.
• A főprogram a felhasználói interakcióra koncentrál.

Előnyök:

✅ A math_operations.py külön is tesztelhető ✅ Más programban is felhasználható ✅ A főprogram tiszta és átlátható marad

Ha a projekt nő, a modulokat csomagokba lehet rendezni.

Példa mappa:

my_calculator/
├── main.py
├── math_operations/
│   ├── __init__.py
│   ├── basic.py
│   ├── advanced.py
└── utils/
    ├── __init__.py
    ├── logger.py

A main.py importálhatja így:

from math_operations import basic
from utils import logger

import math_operations

from math_operations import add, subtract

import math_operations as mo

print(mo.add(3, 5))

❌ Szoros összekapcsolás (tight coupling) → A modulok túlságosan egymásra támaszkodnak.

❌ Rossz felelősségi kör → Egy modulba több, egymástól független feladatot is beleraknak.

❌ Globális változók használata → Tesztelhetetlen, nem újrafelhasználható modulokat eredményez.

✅ Egy modul egy dolgot csináljon jól ✅ Következetes elnevezések ✅ Minden publikus függvényhez írjunk docstringet ✅ Minimalizáljuk a publikus interfészt ✅ Modulokat külön is teszteljünk ✅ Kapcsolódó modulokat csomagokba rendezzük

A moduláris programozás lényege:

✅ A nagy programot kisebb, átlátható modulokra bontjuk ✅ A modulok függetlenek és újrafelhasználhatók ✅ A program karbantarthatóbb, tesztelhetőbb és skálázhatóbb lesz ✅ A Python ezt természetesen támogatja (modulok, csomagok)

Röviden: A moduláris programozás lehetővé teszi, hogy összetett programokat hozzunk létre jól definiált, önálló modulok összeillesztésével, így növelve a kód tisztaságát, rugalmasságát és újrafelhasználhatóságát.

Ha kéred, szívesen mutatok:

✅ példát egy nagy, monolitikus program modulárissá alakítására ✅ hogyan érdemes egy valódi Python projektet modulokra bontani ✅ hogyan lehet dokumentációt generálni a modulokból ✅ hogyan lehet a modulokat egységtesztelni (unit test)

• modular programming - Szótár.net (en-hu)
• modular programming - Sztaki (en-hu)
• modular programming - Merriam–Webster
• modular programming - Cambridge
• modular programming - WordNet
• modular programming - Яндекс (en-ru)
• modular programming - Google (en-hu)
• modular programming - Wikidata
• modular programming - Wikipédia (angol)