Nominare con i trattini in Python

L’underscore _ è speciale in Python. Mentre il trattino basso è usato solo per variabili e funzioni in molti linguaggi, ma ha significati speciali in Python. Sono usati ampiamente in vari scenari, inclusi i casi in cui vorremmo ignorare qualche valore, o nella dichiarazione di variabili, metodi ecc.

I trattini bassi singoli e doppi hanno un significato nei nomi di variabili e metodi in Python. Alcuni di questi significati sono solo per convenzione, mentre altri sono imposti dall’interprete Python.

In questo articolo discuteremo i cinque modelli di underscore e le convenzioni di denominazione e come influenzano il comportamento dei nostri programmi Python. Capire questi concetti ci aiuterà molto soprattutto quando scriviamo codice avanzato.

Alla fine di questo articolo, avremo una discreta comprensione di come e dove usare quale pattern di underscore nella nostra convenzione di denominazione. Quindi cominciamo.

Single Leading Underscore: _var

Il prefisso di sottolineatura è inteso come un suggerimento per un altro programmatore che una variabile o un metodo che inizia con una singola sottolineatura è destinato all’uso interno. Questa convenzione è definita in PEP 8.

Un nome preceduto da un trattino basso (ad esempio _spam) dovrebbe essere trattato come una parte non pubblica dell’API (che sia una funzione, un metodo o un membro dei dati). Dovrebbe essere considerato un dettaglio dell’implementazione e soggetto a cambiamenti senza preavviso.

Guardate il seguente esempio:

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

Istanziamo la classe precedente e proviamo ad accedere agli attributi name e _age.

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

Quindi, il prefisso underscore singolo in Python è semplicemente una convenzione concordata e non impone alcuna restrizione all’accesso al valore di quella variabile.

Double Leading Underscore: __var

L’uso del doppio trattino basso (__) davanti ad un nome (in particolare il nome di un metodo) non è una convenzione; ha un significato specifico per l’interprete.

Python maciulla questi nomi ed è usato per evitare scontri con nomi definiti da sottoclassi.

Questo è anche chiamato name mangling – l’interprete cambia il nome della variabile in un modo che rende più difficile creare collisioni quando la classe viene estesa in seguito.

Per capire meglio, creiamo la nostra classe giocattolo per la sperimentazione:

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

Diamo un’occhiata agli attributi del suo oggetto usando la funzione integrata dir():

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

Dalla lista degli attributi dell’oggetto, possiamo vedere che self.name e self._age appaiono invariati e si comportano allo stesso modo.

Tuttavia, __id è maciullato in _Person__id. Questo è il name mangling che l’interprete Python applica. Lo fa per proteggere la variabile dall’essere sovrascritta nelle sottoclassi.

Ora se creiamo una sottoclasse di Person, diciamo Employee non possiamo facilmente sovrascrivere la variabile __id di Person.

Il comportamento previsto qui è quasi equivalente alle variabili finali in Java e non virtuali in C++.

Single Trailing Underscore: var_

Come spiegato nella documentazione del PEP 8:

La convenzione di denominazione con singolo underscore è usata per evitare conflitti con le parole chiave di Python.

Quando il nome più appropriato per una variabile è già preso da una parola chiave, si segue la convenzione del singolo underscore per interrompere il conflitto di denominazione. Un esempio tipico include l’uso di class o altre parole chiave come variabili.

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

Doppio trattino basso iniziale e finale: __var__

Nomi che hanno doppi underscore iniziali e finali (“dunders”) sono riservati per usi speciali come il metodo__init__ per i costruttori di oggetti, o il metodo __call__ per rendere gli oggetti richiamabili. Questi metodi sono conosciuti come metodi dunder.

Per quanto ci riguarda, questa è solo una convenzione, un modo per il sistema Python di usare nomi che non vadano in conflitto con i nomi definiti dall’utente. Pertanto, i dunders sono solo una convenzione e sono lasciati inalterati dall’interprete Python.

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

I dunders raggiungono l’obiettivo desiderato di rendere certi metodi speciali e allo stesso tempo renderli uguali agli altri metodi semplici in ogni aspetto eccetto la convenzione di denominazione.

Ad essere onesti, non c’è nulla che ci impedisca di scrivere il nostro nome dunder ma è meglio stare lontani dall’usarli nei nostri programmi per evitare collisioni con futuri cambiamenti al linguaggio Python. (Fate riferimento alla mia storia che illustra dettagliatamente i dunder).

Single Underscore: _

Per convenzione, un singolo underscore autonomo è talvolta usato come nome per indicare che una variabile è temporanea o insignificante.

Per esempio, nel seguente ciclo non abbiamo bisogno di accedere all’indice di esecuzione e possiamo usare “_” per indicare che è solo un valore temporaneo:

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

Ancora una volta, questo significato è solo “per convenzione” e non c’è nessun comportamento speciale attivato nell’interprete Python. Il singolo underscore è semplicemente un nome di variabile valido che a volte viene usato per questo scopo.

Conclusioni:

Conoscere i vari pattern di underscore ci aiuterà a scrivere il nostro codice in modo più pitonico. 😄

Ecco un rapido riassunto dei nostri 5 pattern di underscore per le convenzioni di denominazione, che abbiamo coperto sopra.

• Single Leading Underscore _var: convenzione di denominazione che indica che il nome è inteso per uso interno. Un suggerimento per i programmatori e non imposto dai programmatori.
• Doppio trattino basso iniziale __var: innesca la manipolazione del nome quando viene usato nel contesto della classe. Applicato dall’interprete Python.
• Singolo trattino basso var_: Usato per convenzione per evitare conflitti di nome con le parole chiave Python.
• Doppio trattino sottopunto __var__: Indica metodi speciali definiti dal linguaggio Python.
• Sottopunto _: Usato come nome per variabili temporanee.