Naming with Underscores in Python

Az aláhúzás _ különleges a Pythonban. Bár az aláhúzást sok nyelvben csak kígyózó változókra és függvényekre használják, de a Pythonban különleges jelentése van. Kiterjedten használják különböző helyzetekben, többek között olyan esetekben, amikor valamilyen értéket szeretnénk figyelmen kívül hagyni, vagy változók, metódusok stb. deklarációjában.

Az egyszerű és a dupla aláhúzásnak a Python változó- és metódusnevekben van jelentése. A jelentés egy része pusztán konvencióból adódik, míg egy részét a Python-értelmező kényszeríti ki.

Ebben a cikkben az öt aláhúzási mintát és elnevezési konvenciót tárgyaljuk, valamint azt, hogy ezek hogyan befolyásolják Python-programjaink viselkedését. Ezeknek a fogalmaknak a megértése sokat segít, különösen haladó kódok írásakor.

A bejegyzés végére tisztában leszünk azzal, hogy melyik aláhúzási mintát hogyan és hol használjuk a névadási konvenciónkban. Tehát kezdjük el.

Egyetlen vezető aláhúzás: Az aláhúzás előtag célja, hogy egy másik programozó számára jelezze, hogy az egyetlen aláhúzással kezdődő változó vagy metódus belső használatra szolgál. Ezt a konvenciót a PEP 8 határozza meg.

Az aláhúzással előtagolt nevet (pl. _spam) az API nem nyilvános részeként kell kezelni (legyen szó függvényről, metódusról vagy adattagról). Implementációs részletnek kell tekinteni, és előzetes értesítés nélkül megváltoztatható.

Nézzük meg a következő példát:

class Person:
def __init__(self):
self.name = 'Sarah'
self._age = 26

Elkészítsük a fenti osztályt, és próbáljuk meg elérni a name és _age attribútumokat.

>>> p = Person()>>> p.name
Sarah>>> p._age
26

Az egyszerű aláhúzás előtag a Pythonban tehát csupán egy elfogadott konvenció, és nem jelent semmilyen korlátozást az adott változó értékének elérésére.

Dupla vezető aláhúzás: __var

A dupla aláhúzás (__) használata egy név (konkrétan egy metódus neve) előtt nem egy konvenció; az értelmező számára konkrét jelentése van.

A Python elrontja ezeket a neveket, és az alosztályok által definiált nevekkel való névütközés elkerülésére használják.

Ezt nevezik névmanglingnak is – az értelmező úgy változtatja meg a változó nevét, hogy az osztály későbbi bővítésekor nehezebb legyen ütközést létrehozni.

A jobb megértés érdekében hozzuk létre játékosztályunkat a kísérletezéshez:

class Person:
def __init__(self):
self.name = 'Sarah'
self._age = 26
self.__id = 30

Nézzük meg az objektumának attribútumait a beépített dir() függvény segítségével:

>>> p = Person()
>>> dir(p)
>>> p.name
Sarah
>>> p._age
26>>> p.__id
AttributeError: 'Person' object has no attribute '__id'>>> p._Person__id
30

Az objektum attribútumainak fenti listájából láthatjuk, hogy a self.name és a self._age változatlanul megjelenik és ugyanúgy viselkedik.

A __id azonban _Person__id-re mangalizálódott. Ezt a névmangulázást a Python-értelmező alkalmazza. Ezt azért teszi, hogy megvédje a változót attól, hogy alosztályokban felülírják.

Ha most létrehozzuk a Person egy alosztályát, mondjuk a Employee-t, nem tudjuk könnyen felülírni a Person __id változóját.

A tervezett viselkedés itt majdnem megegyezik a végleges változókkal a Java-ban és a nem virtuálisakkal a C++-ban.

Single Trailing Underscore: var_

A PEP 8 dokumentációban leírtak szerint:

Az egyszerű végű aláhúzás névkonvenciót a Python kulcsszavakkal való konfliktusok elkerülésére használjuk.

Ha egy változó legmegfelelőbb neve már foglalt egy kulcsszóval, akkor az egyszerű aláhúzás hozzáadása a névkonvenciót követi a névkonfliktus feloldására. Tipikus példa a class vagy más kulcsszavak változóként való használata.

>>> def method(name, class='Classname'): # ❌
SyntaxError: "invalid syntax">>> def method(name, class_='Classname'): # ✅
... pass

Kettős elő- és utólagos aláhúzás: __var__

A vezető és követő dupla aláhúzással (“dunders”) ellátott nevek speciális használatra vannak fenntartva, mint például a__init__ módszer az objektumkonstruktorok számára, vagy a __call__ módszer az objektum hívhatóvá tételére. Ezeket a metódusokat dunder metódusoknak nevezzük.

Az ember számára ez csak egy konvenció, egy módja annak, hogy a Python rendszer olyan neveket használjon, amelyek nem ütköznek a felhasználó által definiált nevekkel. Ezért a dunderek csak egy konvenció, és a Python-értelmező nem érinti őket.

class Person:
def __init__(self):
self.__name__ = 'Sarah'>>> Person().__name__
Sarah

A dunderek elérik a kívánt célt, hogy bizonyos metódusok különlegesek legyenek, ugyanakkor a névkonvenció kivételével minden szempontból ugyanolyanok, mint a többi sima metódus.

Az igazat megvallva semmi sem akadályoz meg minket abban, hogy saját dunder nevet írjunk, de a legjobb, ha távol maradunk a használatuktól a programjainkban, hogy elkerüljük az ütközést a Python nyelv jövőbeli változásaival. (Lásd ezt a történetemet, amely átfogóan részletezi a dundereket).

Single Underscore: A következő ciklusban például nincs szükségünk a futó indexhez való hozzáférésre, és használhatjuk a “_“-t, hogy jelezzük, hogy ez csak egy ideiglenes érték:

>>> for _ in range(10):
... print('Welcome Sarah!!')

Ismétlem, ez a jelentés csak “per convention”, és nem vált ki különleges viselkedést a Python-értelmezőben. Az egyszerű aláhúzás egyszerűen egy érvényes változónév, amelyet néha erre a célra használnak.

Következtetések:

A különböző aláhúzási minták ismerete segíteni fog a kódunk pythoniasabb megírásában. 😄

Itt van egy gyors összefoglaló az 5 aláhúzási mintánkról az elnevezési konvenciókhoz, amelyekkel fentebb foglalkoztunk.

• Single Leading Underscore _var: Névkonvenció, amely jelzi, hogy a név belső használatra szolgál. Egy tipp a programozók számára, és a programozók nem kényszerítik ki.
• Double Leading Underscore __var: A név elrontását váltja ki, ha osztálykörnyezetben használják. A Python-értelmező kényszeríti ki.
• Egyszeres hátulról történő aláhúzás var_: A Python kulcsszavakkal való névkonfliktusok elkerülése érdekében használatos.
• Double Trailing Underscore __var__: A Python nyelv által meghatározott speciális módszereket jelzi.
• Underscore _: Ideiglenes változók neveként használatos.