CS Fundamentals Trainer · Guias

Como o Python funciona

Nomes como etiquetas em objetos, mutabilidade e o argumento padrão mutável, o modelo de dados por trás de operadores e laços, geradores (1,4 KB contra 409 MB), closures e ligação tardia, contagem de referências e o coletor de ciclos, __slots__ e custos medidos.

24 min de leitura

A maioria das surpresas do Python vem de uma ideia fácil de enunciar e fácil de esquecer: um nome é uma etiqueta colada em um objeto, não uma caixa que guarda um valor. O argumento padrão mutável, a lista de listas que muda todas as suas linhas de uma vez, as lambdas que retornam todas o mesmo número, o objeto que continua vivo depois de você apagá-lo: cada um decorre diretamente de como nomes, objetos, escopos e memória funcionam. Este guia explica essa maquinaria em ordem e roda um pequeno experimento para cada afirmação. Os experimentos rodaram no CPython 3.13 (a implementação padrão, que é o que "Python" significa abaixo); os scripts estão no apêndice, e tempos e tamanhos vêm de uma única máquina pequena, então o que vale levar é o comportamento, não os dígitos.

1. O que executa o seu código

O Python não é "interpretado" nem "compilado" no sentido simples. O CPython faz as duas etapas:

Diagram: From source file to running code in CPython

O código-fonte é compilado em bytecode, uma lista compacta de instruções para uma máquina virtual baseada em pilha, e a VM a executa uma instrução por vez. Os módulos importados têm o bytecode guardado em cache em __pycache__/*.pyc, então a etapa de compilação é pulada na vez seguinte. Você pode ver o bytecode com o módulo dis. Para def f(a, b): return a + b no Python 3.13:

RESUME                   0
LOAD_FAST_LOAD_FAST      1 (a, b)
BINARY_OP                0 (+)
RETURN_VALUE

Duas coisas decorrem disso. Primeiro, + não é uma soma da CPU: a VM olha os tipos dos dois operandos em tempo de execução e pergunta ao da esquerda como se somar ao da direita (seção 4). Essa flexibilidade é o que torna o Python agradável, e também o motivo de um laço sobre números ser muito mais lento que o mesmo laço em uma linguagem compilada. Segundo, o bytecode exato muda de uma versão do Python para a seguinte (a saída acima é da 3.13), então trate-o como uma explicação, não como uma interface.

2. Nomes, objetos e mutabilidade

Todo valor em Python é um objeto: tem uma identidade (id(), seu endereço no CPython), um tipo e um valor. Uma variável é um nome ligado a um objeto. A atribuição nunca copia o objeto; ela faz o nome se referir a ele.

Diagram: Two names, one object

Rodei isto:

a = [1, 2, 3]
b = a            # a second name for the same list
b.append(4)
print(a)         # [1, 2, 3, 4]   a changed, because there is only one list
c = list(a)      # a new list with the same items
c.append(5)
print(a, c)      # [1, 2, 3, 4] [1, 2, 3, 4, 5]

a is b foi True e a is c foi False. is pergunta "o mesmo objeto?" e == pergunta "valores iguais?": duas listas separadas [1] e [1] eram ==, mas não is. Use is para None (x is None) e para mais nada. Ele também pode enganar: o CPython mantém um único objeto compartilhado para cada inteiro pequeno de -5 a 256, então int("256") is int("256") foi True e int("257") is int("257") foi False. Isso é um detalhe de implementação, não algo em que se apoiar.

Mutável e imutável

Alguns objetos podem mudar no lugar (mutáveis: list, dict, set, a maioria das classes) e outros não (imutáveis: int, float, str, tuple, frozenset, bytes). Com objetos imutáveis, "mudar" uma variável liga o nome a um novo objeto. O mesmo operador pode se comportar de forma diferente nos dois tipos:

OperaçãoO que aconteceu
t = (1, 2); t += (3,)uma nova tupla foi criada (o id mudou)
l = [1, 2]; l += [3]a mesma lista foi estendida no lugar (o id não mudou)
n = 10; n += 1um novo objeto int

É por isso que passar uma lista a uma função deixa a função alterar a lista de quem chamou, enquanto passar uma string nunca altera. O Python passa referências a objetos por valor (às vezes chamado de "chamada por compartilhamento"): a função recebe um novo nome para o mesmo objeto.

O argumento padrão mutável

Os valores padrão são avaliados uma vez, quando a instrução def é executada, e guardados no objeto da função. Se o padrão é mutável, toda chamada que omite o argumento o compartilha:

def add(item, bucket=[]):
    bucket.append(item)
    return bucket

add(1)   # [1]
add(2)   # [1, 2]   the same list as before
add(3)   # [1, 2, 3]
add.__defaults__   # ([1, 2, 3],)

A lista mora em add.__defaults__. A correção padrão usa None como marcador e cria a lista dentro da função (if bucket is None: bucket = []); duas chamadas então retornaram [1] e [2].

Linhas compartilhadas e cópias rasas

[[0] * 3] * 3 não constrói três linhas; constrói uma linha e três referências a ela. Depois de grid[0][0] = 9 o resultado foi [[9, 0, 0], [9, 0, 0], [9, 0, 0]]. Uma compreensão, [[0] * 3 for _ in range(3)], avalia a expressão interna para cada linha e deu [[9, 0, 0], [0, 0, 0], [0, 0, 0]].

A mesma ideia explica as cópias rasas e profundas. copy.copy (e list(x), x[:], dict(x)) copia o contêiner externo mas compartilha os objetos de dentro; copy.deepcopy copia recursivamente. Com orig = {"tags": ["a"], "n": 1}, depois de orig["tags"].append("b") a cópia rasa mostrou {'tags': ['a', 'b'], 'n': 1} e a profunda {'tags': ['a'], 'n': 1}.

Uma armadilha relacionada mora nas classes: um atributo definido no corpo da classe (items = []) pertence à classe e é compartilhado por todas as instâncias. Depois de a1.items.append(1), o items de uma segunda instância também era [1]. Crie o estado por instância em __init__.

3. O modelo de dados: como a sintaxe vira métodos

Os operadores e instruções do Python são uma fina camada de sintaxe sobre métodos especiais ("dunder"). A linguagem pede ao objeto que faça o trabalho, então suas próprias classes podem se comportar como as embutidas.

Você escreveO Python chama
a + ba.__add__(b) (e tenta b.__radd__(a) se isso não for suportado)
a == ba.__eq__(b)
len(x)x.__len__()
bool(x), if x:x.__bool__(), ou __len__() se não houver __bool__
for v in x:iter(x), depois next(...) repetidamente até StopIteration
with x as r:x.__enter__(), depois x.__exit__(...) de qualquer jeito que o bloco termine
d[key]d.__getitem__(key)
repr(x)x.__repr__()

Escrevi uma pequena classe Money com __add__, __eq__, __hash__, __repr__, __len__ e __bool__: Money(5) + Money(7) imprimiu Money(12), Money(5) == Money(5) foi True e bool(Money(0)) foi False.

Igualdade e hash andam juntas

Um dict ou set encontra um item pelo seu hash, e depois confirma com ==. A regra: objetos que são iguais devem ter o mesmo hash, e o hash de um objeto não pode mudar enquanto ele estiver em um dict ou set. É por isso que contêineres mutáveis não são hasheáveis: {[1]: 1} levantou TypeError: unhashable type: 'list'. Se você define __eq__ em uma classe, o Python define __hash__ como None a menos que você também o defina, e as instâncias deixam de servir como chaves. Defina os dois, com base nos mesmos campos imutáveis (o Money acima faz isso).

O hash também é o motivo de as buscas serem rápidas. Testar a pertinência do último de 100.000 números levou cerca de 700 microssegundos em uma lista (uma varredura que compara um item após o outro) e cerca de 50 nanossegundos em um set (calcula o hash, salta para a posição): uma razão na casa dos milhares. O custo de x in some_list cresce com a lista; o custo de x in some_set não.

Iteradores, geradores e preguiça

Um laço for é o protocolo do iterador: chama iter() sobre o objeto e depois next() até StopIteration. Escrevi uma classe Countdown com __iter__ e __next__, e list(Countdown(3)) deu [3, 2, 1]. Uma função geradora (uma que usa yield) constrói esse iterador para você e só executa quando é pedido o próximo valor. Duas propriedades importam:

A preguiça é uma otimização de memória. Calculei a soma dos quadrados de 10 milhões de inteiros de duas maneiras e medi o pico de alocação com tracemalloc:

AbordagemPico de memória
sum([i * i for i in range(10_000_000)]) (monta a lista primeiro)cerca de 409 MB
sum(i * i for i in range(10_000_000)) (expressão geradora)cerca de 1,4 KB

(Para o gerador, o próprio sys.getsizeof informou 200 bytes.) Use uma lista quando precisar indexar, reutilizar ou tomar o tamanho dos dados; use um gerador quando só for passar por eles uma vez.

Gerenciadores de contexto

O with garante que o código de saída rode de qualquer jeito que o bloco termine. Uma classe com __enter__ e __exit__ imprimiu enter e depois exit ValueError quando o corpo levantou uma exceção, e a exceção então se propagou, porque __exit__ retornou False. Retornar um valor verdadeiro de __exit__ engoliria a exceção, então faça isso só de propósito. Para arquivos, locks e conexões de banco de dados, prefira with a um close() manual que uma exceção pode pular. contextlib.contextmanager transforma um gerador em um gerenciador de contexto quando escrever uma classe é demais.

4. Escopo e closures

O Python decide em tempo de compilação se um nome é local a uma função: se a função atribui a ele em qualquer lugar, ele é local em toda a função. As buscas seguem a ordem LEGB: Local, Enclosing (função envolvente), Global (módulo), Built-in (embutido).

x = "global"
def bad():
    print(x)       # looks for a local x, because x is assigned below
    x = "local"
bad()
# UnboundLocalError: cannot access local variable 'x' where it is not associated with a value

Para religar um nome de uma função externa você precisa de nonlocal (para um global, global). Ler um nome externo não precisa de nada. Uma função que lembra as variáveis da função que a criou é uma closure; fiz um contador com nonlocal n e três chamadas deram 3, e c.__closure__[0].cell_contents também foi 3: a variável vive em uma "célula" compartilhada, não em uma cópia.

Ligação tardia

Uma closure captura a variável, não o valor que ela tinha na hora. Assim, isto imprime o último valor para toda função:

fs = [lambda: i for i in range(3)]
[f() for f in fs]            # [2, 2, 2]   all three see the same i, now 2
fs = [lambda i=i: i for i in range(3)]
[f() for f in fs]            # [0, 1, 2]   i=i binds the value when each lambda is made

O argumento padrão i=i é avaliado na hora da definição (a mesma regra do padrão mutável acima), e é por isso que ele congela o valor. functools.partial faz o mesmo trabalho de forma mais legível.

5. Memória: contagem de referências e o coletor de ciclos

O CPython libera objetos com dois mecanismos que cooperam.

A contagem de referências é o principal. Cada objeto conta quantas referências apontam para ele. sys.getrefcount de uma lista recém-criada (menos a referência temporária que a própria chamada faz) foi 1; depois de w = v foi 2; depois de del w voltou a 1. Quando a contagem chega a zero, o objeto é liberado imediatamente. É por isso que um objeto de arquivo que sai de escopo é fechado logo no CPython e que os destrutores são previsíveis, embora você não deva depender disso: outras implementações do Python não se comportam assim, e o traceback de uma exceção pode manter objetos vivos.

O coletor de lixo cíclico cuida do que a contagem não consegue: objetos que se referem uns aos outros mantêm as contagens uns dos outros acima de zero. Criei dois objetos Node que apontam um para o outro e apaguei os dois nomes. Uma referência fraca para um deles ainda o encontrou vivo. Depois de gc.collect() ele tinha sumido. Um objeto que não faz parte de um ciclo foi liberado no instante em que seu último nome foi apagado. O coletor roda automaticamente, com base em contagens de alocações de contêineres (a tupla de limiares padrão no 3.13 imprimiu (2000, 10, 10)); raramente é preciso chamá-lo. Para os detalhes dos coletores por rastreamento em geral, veja o guia de coleta de lixo.

Use uma referência fraca (weakref) quando quiser se referir a um objeto sem mantê-lo vivo, por exemplo em um cache.

Quão grande é um objeto?

Tudo é um objeto, então coisas pequenas são maiores do que você esperaria. sys.getsizeof no 3.13:

ObjetoBytes
0 ou 1 (um int)28
2**10040
"" (string vazia)41
"hello"46
[]56
[1, 2, 3]88
(1, 2, 3)64
{}64
set()216

Uma lista guarda ponteiros, então uma lista de dez milhões de ints custa bem mais que dez milhões de vezes 8 bytes: foi aí que foi a maior parte dos 409 MB acima. getsizeof não inclui os objetos a que um contêiner se refere.

Para classes com muitas instâncias, um dicionário por instância pesa. Declarar __slots__ = ("a", "b") o remove. Um milhão de instâncias com dois atributos ocuparam cerca de 96 MB como classe comum e cerca de 56 MB com __slots__, medido com tracemalloc. O preço: nenhum atributo novo pode ser adicionado, e alguns recursos (como referências fracas ou herança múltipla) exigem cuidado extra. Recorra a isso quando você realmente tiver milhões de objetos pequenos; para código comum a classe normal basta.

6. Desempenho: o que a maquinaria implica

Monte strings com join, mas conheça a regra real. O folclore diz que s += "x" em um laço é quadrático. No CPython muitas vezes não é: quando a string não tem outra referência, o interpretador a estende no lugar. Medi três versões:

Tamanhos += "x"+= enquanto um segundo nome guarda a string antiga"".join(...)
10.0000,5 ms1,2 ms0,1 ms
100.0003,9 ms187 ms1,3 ms
200.00015,4 ms587 ms2,6 ms

O truque no lugar é uma otimização de uma implementação e desaparece quando existe qualquer outra referência (dobrar o tamanho deixou a segunda coluna cerca de três vezes mais lenta aqui, pois a cópia passou a dominar). O join é rápido em qualquer caso, então use-o ao montar uma string a partir de muitos pedaços.

Mais dois hábitos:

Threads e a GIL, em um parágrafo

Na build padrão, o CPython tem um bloqueio global do interpretador (GIL): só uma thread executa bytecode Python por vez. As threads ainda ajudam em E/S (uma thread esperando a rede libera o bloqueio), mas código Python limitado pela CPU não fica mais rápido com mais threads; use processos (multiprocessing, concurrent.futures.ProcessPoolExecutor) ou extensões nativas para isso. O Python 3.13 acrescentou uma build experimental sem GIL (free-threaded) (PEP 703); a build que rodei informou o GIL como ativado, como na maioria das instalações. Para condições de corrida, deadlocks e asyncio, veja o guia de concorrência.

7. Erros comuns

8. Perguntas que os entrevistadores gostam de fazer

"O Python é passagem por valor ou por referência?"

Nenhuma das duas exatamente. A função recebe um novo nome ligado ao mesmo objeto (chamada por compartilhamento). Mutar o objeto é visível para quem chamou; religar o parâmetro não é.

"Por que def f(x=[]) se comporta mal?"

O padrão é avaliado uma vez, quando a função é definida, e guardado na função, então todas as chamadas sem o argumento compartilham uma só lista. Use None como padrão e crie a lista dentro.

"Qual é a diferença entre is e ==?"

is compara identidade (o mesmo objeto), == compara valor por meio de __eq__. Use is apenas para singletons como None.

"Como o Python gerencia a memória?"

A contagem de referências libera a maioria dos objetos imediatamente quando a última referência some; um coletor de lixo cíclico encontra grupos de objetos que só se referem uns aos outros. Referências weakref não mantêm objetos vivos.

"O que é um gerador, e por que usar um?"

Uma função que faz yield produz valores de forma preguiçosa, um de cada vez. Usa memória constante (1,4 KB contra 409 MB na soma acima), mas só pode ser consumido uma vez.

"Por que listas não são hasheáveis?"

O hash não pode mudar enquanto o objeto está em um dict ou set, e objetos iguais devem ter hashes iguais. Uma lista mutável pode mudar, então seu hash seria instável. Tuplas de itens hasheáveis são hasheáveis.

"O que a GIL faz?"

Ela deixa apenas uma thread executar bytecode Python por vez na build padrão do CPython. Threads limitadas por E/S ainda se sobrepõem; trabalho limitado pela CPU precisa de processos ou código nativo.

9. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Python 3.13 (CPython), apenas biblioteca padrão. Rode cada arquivo com python3 file.py. Tamanhos e tempos dependem da máquina e da versão do Python (os números do guia vêm de uma máquina pequena); os comportamentos, como quais nomes compartilham um objeto, devem ser os mesmos em qualquer CPython 3.

names.py: nomes, aliasing, is contra ==, padrões mutáveis, linhas compartilhadas, cópias e contagens de referências:

import sys, copy
# 1. names and aliasing
a = [1, 2, 3]
b = a
b.append(4)
print("alias:", a, a is b, id(a) == id(b))
c = list(a)
c.append(5)
print("copy:", a, c, a is c)

# 2. is vs ==
x = 1000; y = 1000
print("== :", x == y)
s1 = [1]; s2 = [1]
print("lists == / is:", s1 == s2, s1 is s2)
print("small ints cached:", (lambda p, q: p is q)(int("5"), int("5")))

# 3. mutable default
def add(item, bucket=[]):
    bucket.append(item)
    return bucket
print("default:", add(1)); print("default:", add(2)); print("default:", add(3))
print("default object:", add.__defaults__)
def add_ok(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket
print("fixed:", add_ok(1), add_ok(2))

# 4. [[0]*3]*3
grid = [[0] * 3] * 3
grid[0][0] = 9
print("shared rows:", grid)
grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 9
print("separate rows:", grid)

# 5. shallow vs deep
orig = {"tags": ["a"], "n": 1}
sh = copy.copy(orig); dp = copy.deepcopy(orig)
orig["tags"].append("b")
print("shallow:", sh, "deep:", dp)

# 6. immutable "changes" create objects; += on list vs tuple
t = (1, 2); id0 = id(t); t += (3,)
print("tuple += new object:", id(t) != id0, t)
l = [1, 2]; id0 = id(l); l += [3]
print("list += same object:", id(l) == id0, l)
n = 10; id0 = id(n); n += 1
print("int += new object:", id(n) != id0)

# 7. refcount
v = []
print("refcount:", sys.getrefcount(v) - 1)
w = v; print("refcount after alias:", sys.getrefcount(v) - 1)
del w; print("refcount after del:", sys.getrefcount(v) - 1)

model.py: métodos dunder, o protocolo do iterador, geradores, with, e a memória de uma lista contra a de um gerador (precisa de algumas centenas de MB de memória livre para a lista):

import sys, tracemalloc, dis

# dunder protocol
class Money:
    def __init__(self, cents): self.cents = cents
    def __add__(self, other): return Money(self.cents + other.cents)
    def __eq__(self, other): return isinstance(other, Money) and self.cents == other.cents
    def __hash__(self): return hash(self.cents)
    def __repr__(self): return f"Money({self.cents})"
    def __len__(self): return self.cents
    def __bool__(self): return self.cents != 0
print(Money(5) + Money(7), Money(5) == Money(5), len(Money(5)), bool(Money(0)))
print({Money(1): "a"}[Money(1)])

# for loop is iterator protocol
class Countdown:
    def __init__(self, n): self.n = n
    def __iter__(self): return self
    def __next__(self):
        if self.n == 0: raise StopIteration
        self.n -= 1
        return self.n + 1
print(list(Countdown(3)))
it = iter([10, 20]); print(next(it), next(it)); 
try: next(it)
except StopIteration: print("StopIteration")

# generator is lazy and one-shot
def squares(n):
    for i in range(n):
        yield i * i
g = squares(5)
print(list(g), list(g))

# with = __enter__/__exit__
class Res:
    def __enter__(self): print("enter"); return self
    def __exit__(self, et, ev, tb): print("exit", et.__name__ if et else None); return False
try:
    with Res(): raise ValueError("x")
except ValueError: print("propagated")

# memory: list vs generator for 10 million
N = 10_000_000
tracemalloc.start()
lst = [i * i for i in range(N)]
cur, peak = tracemalloc.get_traced_memory(); print(f"list of {N}: peak {peak/1e6:.0f} MB")
del lst
tracemalloc.reset_peak()
tot = sum(i * i for i in range(N))
cur, peak = tracemalloc.get_traced_memory(); print(f"generator sum: peak {peak/1e3:.1f} KB")
tracemalloc.stop()
print("getsizeof gen:", sys.getsizeof(i*i for i in range(N)), "list:", sys.getsizeof(list(range(1000))))

# bytecode
def f(a, b): return a + b
dis.dis(f)

scope.py: closures, LEGB, atributos de classe, tamanhos de objetos, __slots__, ciclos de referência, buscas em set contra lista e montagem de strings:

import gc, sys, weakref, timeit
# late binding
fs = [lambda: i for i in range(3)]
print("late binding:", [f() for f in fs])
fs = [lambda i=i: i for i in range(3)]
print("bound at definition:", [f() for f in fs])

# LEGB + UnboundLocalError
x = "global"
def outer():
    x = "enclosing"
    def inner():
        return x
    return inner()
print("LEGB:", outer())
def bad():
    print(x)
    x = "local"
try: bad()
except UnboundLocalError as e: print("UnboundLocalError:", e)

def counter():
    n = 0
    def inc():
        nonlocal n
        n += 1
        return n
    return inc
c = counter(); c(); c()
print("closure cell:", c(), c.__closure__[0].cell_contents)

# class attr vs instance attr
class A:
    items = []
a1, a2 = A(), A()
a1.items.append(1)
print("shared class attr:", a2.items)

# memory of objects
class Plain:
    def __init__(self): self.a = 1; self.b = 2
class Slotted:
    __slots__ = ("a", "b")
    def __init__(self): self.a = 1; self.b = 2
p, s = Plain(), Slotted()
print("sizeof obj / dict:", sys.getsizeof(p), sys.getsizeof(p.__dict__), "slotted:", sys.getsizeof(s))
import tracemalloc
for cls in (Plain, Slotted):
    tracemalloc.start()
    objs = [cls() for _ in range(1_000_000)]
    cur, _ = tracemalloc.get_traced_memory(); tracemalloc.stop()
    print(f"{cls.__name__}: 1M objects {cur/1e6:.0f} MB")
    del objs

# sizes of builtins
print("sizes:", {k: sys.getsizeof(v) for k, v in dict(int0=0, int1=1, big=2**100, empty_list=[], list3=[1,2,3], empty_dict={}, empty_set=set(), tup=(1,2,3), s="", s5="hello").items()})

# cycles: refcount alone does not free
class Node:
    def __init__(self): self.other = None
n1, n2 = Node(), Node(); n1.other = n2; n2.other = n1
r = weakref.ref(n1)
del n1, n2
print("alive after del (cycle):", r() is not None)
print("collected objects:", gc.collect() > 0, "alive now:", r() is not None)
m = Node(); r2 = weakref.ref(m); del m
print("no cycle, freed at once:", r2() is None)
print("gc thresholds:", gc.get_threshold())

# hash / dict / set lookup
N = 100_000
lst = list(range(N)); st = set(lst)
t_l = timeit.timeit(lambda: (N - 1) in lst, number=200) / 200
t_s = timeit.timeit(lambda: (N - 1) in st, number=200000) / 200000
print(f"in list {t_l*1e6:.1f} us, in set {t_s*1e9:.0f} ns, ratio {t_l/t_s:.0f}x")
try: {[1]: 1}
except TypeError as e: print("unhashable:", e)

# string concat
def cat(n):
    s = ""
    for i in range(n): s += "x"
    return s
def join(n): return "".join("x" for _ in range(n))
for n in (10_000, 100_000, 1_000_000):
    print(n, f"+= {timeit.timeit(lambda: cat(n), number=3)/3*1e3:.1f} ms", f"join {timeit.timeit(lambda: join(n), number=3)/3*1e3:.1f} ms")
# interning
a = "hello"; b = "hel" + "lo"; print("interned literals:", a is b)

concat.py: por que += em strings é rápido até deixar de ser:

import timeit
def plain(n):
    s = ""
    for _ in range(n): s += "x"
    return s
def held(n):
    s = ""; keep = s
    for _ in range(n):
        keep = s          # a second reference defeats the in-place optimisation
        s += "x"
    return s
def join(n): return "".join(["x"] * n)
for n in (10_000, 100_000, 200_000):
    r = [timeit.timeit(lambda: f(n), number=3) / 3 * 1e3 for f in (plain, held, join)]
    print(n, "plain += %.1f ms | += with 2nd reference %.1f ms | join %.1f ms" % tuple(r))

Fontes

  1. Documentação do Python, The Python Language Reference: Data model. Objetos, identidade, métodos especiais, __slots__, __hash__.
  2. Documentação do Python, Execution model. Nomeação e ligação, escopos, nonlocal.
  3. Documentação do Python, dis: Disassembler for Python bytecode, gc, copy, weakref e tracemalloc.
  4. Documentação do Python, Programming FAQ. Argumentos padrão, ligação tardia em lambdas, como os argumentos são passados.
  5. Ned Batchelder, Facts and myths about Python names and values.
  6. Python Enhancement Proposals, PEP 3104: Access to names in outer scopes (nonlocal) e PEP 703: Making the Global Interpreter Lock optional in CPython.

Pratique este tema: Python

Mais guias