Ugrás a tartalomhoz

Python syntax and semantics

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

Python syntax and semantics (tsz. Python syntax and semanticses)

  1. (informatika) A Python programozási nyelv szintaxisa azon szabályok összessége, amelyek meghatározzák, hogy hogyan kell egy Python programot megírni, illetve hogyan értelmezi azt a futtatórendszer és az olvasó ember is.

A Python sok hasonlóságot mutat például a Perl, C és Java nyelvekkel, de természetesen jelentős különbségek is vannak. A nyelv támogatja a többféle programozási paradigmát: strukturált, objektum-orientált (OOP) és funkcionális programozást is. Dinamikus típuskezelést alkalmaz, és automatikusan menedzseli a memóriát (pl. szemétgyűjtéssel).

A Python szintaxisa egyszerű, konzisztens, és követi az alapelvet:

„Csak egy nyilvánvaló módja legyen valaminek — és lehetőleg tényleg csak egy.” (There should be one — and preferably only one — obvious way to do it.)

A nyelv tartalmaz beépített adattípusokat, adatstruktúrákat, vezérlési szerkezeteket, első osztályú függvényeket (first-class functions), és modulokat a kód újrafelhasználhatósága érdekében.

A Python angol nyelvű kulcsszavakat használ, ahol más nyelvek gyakran írásjeleket — ezzel is olvashatóbb a kód.

A nyelv robosztus hibakezelést kínál (kivételkezelés), és a standard könyvtárban beépített debugger is található.

A Python olvasható, könnyen tanulható szintaxisa miatt nagyon népszerű kezdők és profik körében is.


Tervezési filozófia

A Python célja a magas olvashatóság. Tiszta vizuális elrendezést alkalmaz, angol kulcsszavakat használ írásjelek helyett.

A nyelv szintaxisának tervezése során az volt a cél, hogy egyszerű és konzisztens legyen.

A mottó (Zen of Python egyik sora):

„There should be one — and preferably only one — obvious way to do it.”

Ez ellentétes például a Perl vagy Ruby filozófiájával:

„There’s more than one way to do it.” (Többféleképpen is meg lehet csinálni valamit.)


Kulcsszavak

A Pythonban 35 kulcsszó (rezervált szó) van, amelyeket nem lehet azonosítóként használni (változónévként sem).

Példák:

and, as, assert, async, await, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield

Ezen kívül léteznek soft keywords is — pl.: match, case, _ — amelyek csak bizonyos szintaktikai környezetekben viselkednek kulcsszóként.


Behúzás (Indentation)

A Python whitespace-et (üres karaktereket, behúzást) használ a vezérlési blokkok kijelölésére.

  • Más nyelvekben { } vagy BEGIN / END szavakat használnak.
  • A Pythonban behúzással jelöljük, hogy egy blokk meddig tart.

Példa:

def foo(x):
    if x == 0:
        bar()
    else:
        baz(x)
        foo(x - 1)

Hibás behúzás váratlan viselkedéshez vezethet:

def foo(x):
    if x == 0:
        bar()
    else:
        baz(x)
    foo(x - 1)  # Mindig végrehajtódik — végtelen rekurzió!

Ajánlott 4 szóköz behúzást használni (nem tabulátort!).


Adatszerkezetek

A Python dinamikusan típusos — a változók nem, hanem az értékek hordozzák a típust.

A változók referenciát tartalmaznak objektumokra. Ez a „call by object reference” hívásmodell.

Példa:

alist = ['a', 'b', 'c']

def my_func(al):
    al.append('x')
    print(al)

my_func(alist)
print(alist)
# ['a', 'b', 'c', 'x']

Ha viszont új objektumot hozunk létre, az nem befolyásolja az eredeti listát:

def my_func(al):
    al = al + ['x']  # Új lista, nem módosítja a régit
    print(al)

Alap típusok

  • Egész számok (int) — tetszőleges méretű
  • Valós számok (float) — pl. 3.14, 5e-10
  • Komplex számok (complex) — pl. 3 + 4j
  • Sztringek (str) — immutable (nem módosítható)
  • Logikai értékek: True, False


Gyűjtemény típusok

Szekvenciák (sequences):

✅ list → módosítható lista ✅ tuple → nem módosítható lista (immutable) ✅ str → karakterlánc (immutable)

Leképezések (mappings):

✅ dict → kulcs-érték párok (kulcs: immutable típus)

Halmazok (sets):

✅ set → halmaz, duplikátumok nélkül ✅ frozenset → nem módosítható halmaz


Objektum rendszer

Minden a Pythonban objektum.

  • Osztályok is objektumok
  • Támogatott a többszörös öröklés
  • Minden objektumhoz tartozik egy metaklassz

Például a műveletek túlterhelhetők:

class MyNumber:
    def __add__(self, other):
        return "Hozzáadás történt!"

Literálok

Sztringek:

  • ‘valami’ vagy “valami”
  • Többsoros sztringek: """ ... """ vagy ...
  • Raw string: r”valami” → nem értelmezi a \ jelet → regexnél hasznos


Lista, tuple, set, dict

a_list = [1, 2, 3, "kutya"]
a_tuple = (1, 2, 3, "négy")
a_set = {1, 2, 3, 4}
a_dict = {"kulcs1": "érték1", 2: 3}

Operátorok

Aritmetikai:

  • , - , * , / (float osztás), // (egész osztás), % (maradék), ** (hatványozás)

Összehasonlító:

==, !=, <, >, <=, >=, is, is not, in, not in

Logikai:

and, or, not → pl.: x and y, x or y


Funkcionális programozás

A Python támogatja a funkcionális stílust is.

✅ List comprehension:

powers_of_two = [2**n for n in range(1, 6)]

✅ Generator:

def generate_primes(stop_at):
    for n in range(2, stop_at + 1):
        # Prímvizsgálat itt
        yield n

✅ First-class functions — a függvények átadhatók, változóhoz rendelhetők.

✅ Lambda:

f = lambda x: x**2
print(f(5))

✅ Closure:

def derivative(f, dx):
    def inner(x):
        return (f(x + dx) - f(x)) / dx
    return inner

Dekorátorok

A dekorátor olyan függvény, ami egy másik függvényt módosít.

@my_decorator
def my_function():
    pass

Ugyanez:

def my_function():
    pass

my_function = my_decorator(my_function)

Hibakezelés (Exceptions)

A Pythonban a hibakezelést kivételkezeléssel oldjuk meg:

try:
    x = 1 / 0
except ZeroDivisionError:
    print("Nullával nem lehet osztani.")
finally:
    print("Mindig lefut.")

Alapelv: EAFP (Easier to Ask for Forgiveness than Permission) → próbáld meg, ha baj van, kapd el a kivételt.


Kommentek és docstringek

Komment:

# Ez egy soros komment

Többsoros komment (általában docstring):

"""
Ez egy többsoros
dokumentációs sztring.
"""

A docstring automatikusan elérhető az objektum __doc__ attribútumában.

print(my_function.__doc__)

Összegzés

A Python szintaxisa:

✅ Egyszerű, olvasható, következetes ✅ Behúzást használ blokkjelölésre ✅ Angol kulcsszavakat használ ✅ Erős adatszerkezetekkel és funkcionális eszközökkel rendelkezik ✅ Objektum-orientált, de nem kényszerít szigorú OOP stílust ✅ Hibakezelés kivételmechanizmussal ✅ Első osztályú függvényeket, dekorátorokat támogat


További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=Python_syntax_and_semantics&oldid=3499927”