Nomi delle Variabili in Python — Regole, Convenzioni e Buone Pratiche

Il nome di una variabile è l'etichetta che Python usa per trovare un valore in memoria. Scegliere nomi buoni rende il codice quasi leggibile come una frase; scegliere nomi scadenti farà sì che persino tu fatichi a capire il tuo stesso script una settimana dopo. Questo capitolo tratta le regole rigide applicate da Python, le convenzioni della comunità (PEP 8), le insidie come l'oscuramento dei built-in e gli schemi con il trattino basso — il tutto con esempi eseguibili.

Regole Rigide — Cosa Richiede Python

Prima delle convenzioni, ci sono le regole. Violarle causa un SyntaxError o un NameError.

Caratteri consentiti

Il nome di una variabile può contenere lettere (a-z, A-Z), cifre (0-9) e trattini bassi (_). Deve iniziare con una lettera o un trattino basso — mai con una cifra. Non sono ammessi spazi, trattini o caratteri speciali (%, #, @, -).

# Valid names
user_name = "Alice"
_private = 42
value1 = 3.14
MAX_RETRIES = 5

# Invalid names — these all raise SyntaxError
# 1user = "bad"     # starts with a digit
# user-name = "bad" # hyphens are subtraction
# user name = "bad" # space is not allowed

Python è case-sensitive

username, Username e USERNAME sono tre variabili completamente diverse. Questa è una fonte frequente di bug per i principianti.

score = 10
Score = 20
SCORE = 30

print(score)   # 10
print(Score)   # 20
print(SCORE)   # 30

Le parole chiave riservate non possono essere usate come nomi

Python riserva alcune parole per il linguaggio stesso. Usarne una come nome di variabile provoca un SyntaxError. Puoi elencare tutte le parole chiave riservate con il modulo keyword:

import keyword
print(keyword.kwlist)

Output (Python 3.12):

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

Errori comuni: usare list, str, int, type o input come nomi di variabile — questi sono nomi built-in, non parole chiave riservate, quindi Python non solleverà un SyntaxError, ma oscurerai silenziosamente il built-in e otterrai errori confusi in seguito (vedi Oscuramento dei Built-in qui sotto).

Convenzioni di Denominazione PEP 8

PEP 8 è la guida di stile ufficiale di Python. Seguirla rende il tuo codice immediatamente leggibile da qualsiasi sviluppatore Python.

Riepilogo delle convenzioni

snake_case per variabili e funzioni

snake_case usa tutte lettere minuscole con trattini bassi tra le parole. Questo è lo standard per variabili e funzioni in Python.

# PEP 8 compliant
first_name = "Alice"
last_name = "Smith"
total_price = 9.99
items_in_cart = 3

# Not PEP 8 (camelCase) — works, but avoid for variables
firstName = "Alice"   # JavaScript style, not Pythonic

ALL_CAPS per le costanti

Per convenzione, un nome scritto interamente in maiuscolo segnala "questo valore non dovrebbe essere modificato". Python non applica l'immutabilità, ma la convenzione è universalmente compresa.

MAX_CONNECTIONS = 100
TIMEOUT_SECONDS = 30
PI = 3.141592653589793

# Using the constant
if current_connections > MAX_CONNECTIONS:
    print("Connection limit reached")

CapWords per le classi

I nomi delle classi usano CapWords (detto anche PascalCase): ogni parola inizia con una lettera maiuscola, senza trattini bassi.

class UserProfile:
    pass

class HttpRequestError(Exception):
    pass

Nomi Descrittivi e Significativi

Il miglior nome di variabile dice al prossimo lettore cosa rappresenta il valore, non come è memorizzato. Punta a nomi che rendano una riga di codice leggibile come una frase.

# Unclear
r = 5
a = 3.14159 * r ** 2

# Clear
radius = 5
circle_area = 3.14159 * radius ** 2

print(circle_area)  # 78.53975

Quando i nomi brevi vanno bene

I nomi con una sola lettera (x, y, i, n) sono accettabili in contesti ristretti e ben compresi:

• Contatori di ciclo: for i in range(10):
• Formule matematiche: y = m * x + b
• Coordinate: (x, y) o (row, col)

Al di fuori di questi contesti, preferisci qualcosa di descrittivo anche se è più lungo.

Evita abbreviazioni non necessarie

Le abbreviazioni risparmiano battiture ma riducono la leggibilità. Usa parole complete a meno che l'abbreviazione non sia universalmente nota.

# Unclear abbreviations
usr_nm = "alice"
tot_amt = 49.95
n_itm = 7

# Clear full names
username = "alice"
total_amount = 49.95
number_of_items = 7

Abbreviazioni ampiamente accettate che va bene mantenere: url, id, http, db, idx, num.

Schemi con il Trattino Basso

Python usa i trattini bassi nei nomi delle variabili per comunicare l'intento. Comprendere questi schemi ti aiuta a leggere qualsiasi codebase Python.

_single_leading — uso interno

Un nome che inizia con un trattino basso è un segnale per gli altri sviluppatori: "questo è un dettaglio implementativo; non farci affidamento dall'esterno di questo modulo o classe." Python non lo applica — è puramente una convenzione.

class DataLoader:
    def __init__(self, path):
        self.path = path
        self._cache = {}   # internal; not part of the public API

    def load(self):
        if self.path not in self._cache:
            self._cache[self.path] = self._read_file()
        return self._cache[self.path]

    def _read_file(self):
        # "private" helper
        with open(self.path) as f:
            return f.read()

from module import * salta anche i nomi che iniziano con _.

__double_leading — name mangling

Due trattini bassi iniziali attivano il name mangling di Python: __attr all'interno della classe Foo viene memorizzato come _Foo__attr. Questo previene la sovrascrittura accidentale nelle sottoclassi.

class Base:
    def __init__(self):
        self.__secret = "hidden"

obj = Base()
# print(obj.__secret)      # AttributeError
print(obj._Base__secret)   # "hidden" — mangled name

Usa il name mangling con parsimonia; rende il debug più difficile.

__dunder__ — metodi speciali

I nomi circondati da doppi trattini bassi su entrambi i lati sono i metodi e gli attributi speciali ("dunder") built-in di Python. Non inventare mai variabili __nome__ personalizzate — Python riserva questo spazio dei nomi.

class Point:
    def __init__(self, x, y):   # called when an instance is created
        self.x = x
        self.y = y

    def __repr__(self):          # called by repr() and in the REPL
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)          # Point(3, 4)
print(repr(p))    # Point(3, 4)

_ come variabile di scarto

Un trattino basso solitario _ viene usato per convenzione come variabile "non mi interessa" quando devi catturare un valore ma non lo userai.

# Unpack a tuple but only use two of three values
x, _, z = (1, 2, 3)
print(x, z)  # 1 3

# Loop counter when the index is not needed
for _ in range(5):
    print("hello")

Oscuramento dei Built-in

I nomi built-in di Python (list, str, int, dict, type, input, print, id, min, max, sum, open, …) non sono parole chiave, quindi Python ti permette silenziosamente di riutilizzarli come nomi di variabile. Questo è quasi sempre un bug.

# Dangerous — shadows the built-in list type
list = [1, 2, 3]
print(list)           # [1, 2, 3] — seems fine

new = list([4, 5])    # TypeError: 'list' object is not callable

Una volta che assegni list = [1, 2, 3], il nome list in quello scope non si riferisce più al costruttore built-in. La soluzione è semplicemente scegliere un nome diverso.

# Safe
numbers = [1, 2, 3]
more_numbers = list([4, 5])  # list() still works
print(more_numbers)          # [4, 5]

Built-in comuni che vengono accidentalmente oscurati: id, input, type, str, int, float, list, dict, set, tuple, min, max, sum, filter, map, open, print.

Scope e Nomi delle Variabili

Il nome di una variabile è visibile solo all'interno dello scope in cui è definita. Due variabili in scope diversi possono condividere lo stesso nome senza conflitti — ma questo può portare a confusione.

total = 0          # module-level variable

def calculate(prices):
    total = 0      # local variable — does NOT overwrite the module-level one
    for price in prices:
        total += price
    return total

result = calculate([10, 20, 30])
print(result)      # 60
print(total)       # 0  — unchanged

Per saperne di più su come Python risolve i nomi (la regola LEGB), vedi Python Scope. Per capire le variabili globali e la parola chiave global, vedi Variabili Globali in Python.

Riferimento Rapido

# Hard rules
user1 = "ok"        # letters, digits, underscores — fine
_private = "ok"     # leading underscore — fine
# 1user = "bad"     # SyntaxError: starts with digit
# my-var = "bad"    # SyntaxError: hyphens not allowed

# PEP 8 conventions
snake_case_var = 42           # variables and functions
MAX_VALUE = 100               # constants
# class names use CapWords (PascalCase)

# Underscore patterns
_internal = "internal use"    # single leading: hint "private"
_ = "throwaway"               # lone underscore: discard value

# What to avoid
# list = []      # shadows built-in
# str = "hello"  # shadows built-in
# if = True      # SyntaxError: reserved keyword

Per un'introduzione più ampia su come vengono create e assegnate le variabili in Python, vedi Variabili Python. Per scoprire come raggruppare variabili correlate, vedi Raggruppare Variabili in Python.

Esercitati