DEV Community: Bruno Teixeira Lopes

Python Data Model - Part 1

Bruno Teixeira Lopes — Tue, 28 Jul 2026 22:54:43 +0000

Leia a versão em português deste artigo aqui.

1. Introduction

Ever wondered why modifying a list inside a function changes the original list, but modifying a number doesn't? You've just run into one of the most fundamental — and most misunderstood — concepts in Python: its data model.

Understanding how Python represents, identifies, and compares objects isn't just theory: it's what saves you from subtle bugs related to aliasing, incorrect comparisons, and unexpected side effects in mutable containers.

In this first article of the series, we'll build the foundation you need for that: what an object actually is in Python, the difference between identity and equality, what mutability really means, how an object is born and dies, and how all of this connects once objects live inside containers.

This article assumes you're already comfortable with basic Python syntax (variables, lists, dictionaries, functions). If that's you, let's get straight to it.

2. Everything is an object

The data model defines how values are represented and how they behave in Python. Every piece of data your program handles is an object: numbers, strings, lists, functions, classes, and even modules (PYTHON SOFTWARE FOUNDATION, 2026a).

Every Python object has three essential characteristics:

Identity: the object's address in memory. Checked with id(object_name).
Type: defines which values and operations the object supports. Checked with type(object_name).
Value: the content the object represents, which may or may not change depending on the object's mutability.

Type affects nearly every aspect of an object's behavior. That's even true for identity: some types have a single instance shared across the entire program, which is why the correct way to compare them is by identity (is), not equality (==):

None represents the absence of a value;
NotImplemented signals that a special operation doesn't support the operands it received;
..., also called Ellipsis, can be used as a sentinel and in extended slicing operations.

type(None)            # <class 'NoneType'>
type(NotImplemented)  # <class 'NotImplementedType'>
type(...)             # <class 'ellipsis'>

For single-instance types, is is always the recommended way to check for absence of value:

x ==  None # WRONG
x is None # CORRECT

3. Identity vs Equality

As we just saw, an object's identity refers to its memory address: id(x) returns an int representing the memory location where x is stored. Equality, on the other hand, checks whether the values of two objects are the same, using the magic method __eq__ — we'll dig deeper into that method in upcoming chapters.

is: compares identity.
==: compares content or value.

This distinction between identity and equality is the foundation for understanding mutability.

4. Mutable vs Immutable

An object's mutability is determined by its type. A mutable object can have its value changed after creation. An immutable object cannot be modified; any operation on it produces a new object (PYTHON SOFTWARE FOUNDATION, 2026b).

Immutable	Mutable
`NoneType`	`list`
`bool`	`dict`
`int`, `float`, `complex`	`set`
`str`, `tuple`, `range`	`bytearray`
`bytes`, `frozenset`

Mutation changes the object itself; reassignment makes the name point to a new object.

Example with a mutable object:

items = ['a', 'b']  # list is mutable
alias = items
items.append('c')
items  # ['a', 'b', 'c']
alias  # ['a', 'b', 'c']

Example with an immutable object:

total = 10  # int is immutable
alias = total
total += 5  # a new object with value 15 is created; total now points to it
total  # 15
alias  # 10

Immutable objects can hold references to mutable objects, because immutability in Python affects only the object's reference structure, not the content it points to.

record = ("Alyne", ["Python"])
record[1].append("SQL")
record  # ("Alyne", ["Python", "SQL"])

The tuple record still points to the same references — only the inner list was changed.

5. Object life cycle

An object's life cycle in Python has four main phases: creation and memory allocation, attribute initialization, active use throughout the program via references, and destruction with memory release controlled by reference counting and the garbage collector.

import sys

a = [1, 2, 3]
sys.getrefcount(a)  # number of active references to the object (includes getrefcount's own temporary reference)

b = a  # new reference to the same object
sys.getrefcount(a)  # the count goes up, since 'a' and 'b' now point to the same object

When an object becomes unreachable — that is, when its reference count reaches zero — it can be garbage collected by CPython through a reference-counting scheme with delayed detection of cyclically linked garbage. This cyclic collection is optional and doesn't guarantee that all garbage containing circular references will actually be collected.

6. Containers

Container objects are data structures capable of holding other objects — in other words, objects that contain references to others.

They can hold values of different types at the same time, support iteration through loops, and it's common to use the in operator to efficiently check whether an item is present in a container — a check that, internally, relies on equality (==), not identity.

Main container types:

Lists (list): ordered, mutable sequences, defined with square brackets [].
Tuples (tuple): ordered, immutable sequences, defined with parentheses ().
Dictionaries (dict): collections of key-value pairs, defined with curly braces {}.
Sets (set): collections of unique, unordered elements, also defined with curly braces {}.

Watch out for a common gotcha: an empty {} creates a dict, not a set. To create an empty set, you need to use set() explicitly.

Since containers hold references, not copies, everything we've covered about identity, equality, and mutability applies directly here: modifying a mutable object inside a container affects every variable that references that same object — even if the container itself is immutable, as we saw with the tuple example in section 4.

7. Conclusion

Identity, equality, mutability, life cycle, and containers aren't isolated topics — they're facets of the same core concept: in Python, variables are references to objects, not boxes holding values. Understanding that is what lets you predict, with confidence, when a change will propagate and when it will produce a brand-new object.

That foundation is what the next step of the series builds on: magic methods (dunder methods), the protocol Python uses behind seemingly simple operations like len(obj), obj[key], or for item in obj. In Part 2, we'll see how these methods let objects you create behave just like the language's built-in types.

References

PYTHON SOFTWARE FOUNDATION. 3. Data model. In: Python 3.14.6 Documentation. [S. l.]: Python Software Foundation, 2026a. Available at: https://docs.python.org/3/reference/datamodel.html. Accessed on: Jul. 28, 2026.

PYTHON SOFTWARE FOUNDATION. Built-in Types. In: Python 3.14.6 Documentation. [S. l.]: Python Software Foundation, 2026b. Available at: https://docs.python.org/3/library/stdtypes.html. Accessed on: Jul. 28, 2026.

Modelo de Dados Python - Parte 1

Bruno Teixeira Lopes — Tue, 28 Jul 2026 22:51:54 +0000

Read this article in English here.

1. Introdução

Se você já se perguntou por que alterar uma lista dentro de uma função muda a lista original, mas alterar um número não, você esbarrou em um dos conceitos mais fundamentais (e mais mal compreendidos) de Python: o modelo de dados da linguagem.

Entender como Python representa, identifica e compara objetos não é só teoria: é o que evita bugs sutis relacionados a aliasing, comparações incorretas e efeitos colaterais inesperados em containers mutáveis.

Neste primeiro artigo da série, vamos construir a base necessária para isso: o que é um objeto em Python, a diferença entre identidade e igualdade, o que realmente significa mutabilidade, como um objeto nasce e morre, e como tudo isso se conecta quando objetos são armazenados em containers.

Este artigo assume que você já tem familiaridade com a sintaxe básica de Python (variáveis, listas, dicionários, funções). Se esse é o seu caso, vamos direto ao ponto.

2. Tudo é objeto

O modelo de dados define como os valores são representados e como se comportam em Python. Todo dado manipulado pelo programa é um objeto: números, strings, listas, funções, classes e até módulos (PYTHON SOFTWARE FOUNDATION, 2026a).

Um objeto Python conta com três características essenciais:

Identidade: representa o endereço do objeto em memória. Consultada com id(nome_objeto).
Tipo: define quais valores e operações o objeto aceita. Consultado com type(nome_objeto).
Valor: conteúdo representado pelo objeto, podendo ou não ser alterado a depender da mutabilidade do objeto.

Os tipos afetam quase todos os aspectos do comportamento do objeto. Isso vale até para a identidade: alguns tipos possuem uma única instância em todo o programa, e por isso a forma correta de compará-los é por identidade (is), não por igualdade (==):

None representa ausência de valor;
NotImplemented informa que uma operação especial não oferece suporte aos operandos recebidos;
..., também chamado de Ellipsis, pode ser usado como uma sentinela e em operações especiais de fatiamento.

type(None)            # <class 'NoneType'>
type(NotImplemented)  # <class 'NotImplementedType'>
type(...)             # <class 'ellipsis'>

Para instâncias únicas, o operador is é sempre a forma recomendada de checar ausência de valor:

x ==  None # ERRADO
x is None # CORRETO

3. Identidade vs Igualdade

Como visto anteriormente, a identidade de um objeto refere-se ao seu endereço de memória: id(x) retorna um int representando o espaço de memória em que x está armazenado. Já a igualdade verifica se os valores de dois objetos são iguais, utilizando o método mágico __eq__ — voltaremos a estudar mais sobre este método nos próximos capítulos.

is: compara identidades.
==: compara conteúdo ou valores.

Essa distinção entre identidade e igualdade é a base para entender mutabilidade.

4. Mutável vs Imutável

A mutabilidade de um objeto é determinada pelo seu tipo. Um objeto mutável pode ter seu valor alterado depois de criado. Um objeto imutável não pode ser modificado; uma operação sobre ele produz outro objeto (PYTHON SOFTWARE FOUNDATION, 2026b).

Imutáveis	Mutáveis
`NoneType`	`list`
`bool`	`dict`
`int`, `float`, `complex`	`set`
`str`, `tuple`, `range`	`bytearray`
`bytes`, `frozenset`

A mutação altera o próprio objeto; a reatribuição faz o nome apontar para um novo objeto.

Exemplo com objeto mutável:

items = ['a', 'b']  # list é mutável
alias = items
items.append('c')
items  # ['a', 'b', 'c']
alias  # ['a', 'b', 'c']

Exemplo com objeto imutável:

total = 10  # int é imutável
alias = total
total += 5  # um novo objeto com valor 15 é criado; total passa a apontar para ele
total  # 15
alias  # 10

Objetos imutáveis podem conter referências a objetos mutáveis, pois a imutabilidade em Python afeta apenas a estrutura de referências do objeto, não o conteúdo interno ao qual ele aponta.

record = ("Alyne", ["Python"])
record[1].append("SQL")
record  # ("Alyne", ["Python", "SQL"])

A tupla record continua apontando para as mesmas referências — apenas a lista interna foi alterada.

5. Ciclo de vida dos objetos

O ciclo de vida de um objeto em Python compreende quatro fases principais: criação e alocação de memória, inicialização de atributos, uso ativo no programa por meio de referências, e destruição com liberação de memória controlada por contagem de referências e coletor de lixo.

import sys

a = [1, 2, 3]
sys.getrefcount(a)  # número de referências ativas ao objeto (inclui a referência temporária do próprio getrefcount)

b = a  # nova referência para o mesmo objeto
sys.getrefcount(a)  # o valor aumenta, pois agora 'a' e 'b' apontam para o mesmo objeto

Quando um objeto se torna inacessível — ou seja, quando sua contagem de referências chega a zero — ele pode ser coletado como lixo pelo CPython através de um esquema de contagem de referências, com detecção atrasada para referências circulares. Essa coleta cíclica é opcional e não garante que todo o lixo com referências circulares será efetivamente coletado.

6. Containers

Objetos containers são estruturas de dados capazes de armazenar outros objetos, ou seja, são objetos que contêm referências a outros.

Eles podem guardar dados de tipos diferentes ao mesmo tempo, permitem percorrer seus elementos usando laços de repetição, e é muito comum utilizar o operador in para verificar se um item está presente em um container de maneira eficiente — verificação essa que, internamente, usa igualdade (==), não identidade.

Tipos principais de containers:

Listas (list): sequências ordenadas e mutáveis, definidas por colchetes [].
Tuplas (tuple): sequências ordenadas e imutáveis, definidas por parênteses ().
Dicionários (dict): coleções de pares chave-valor, definidos por chaves {}.
Conjuntos (set): coleções de elementos únicos e não ordenados, também definidos por chaves {}.

Atenção a uma pegadinha comum: {} vazio cria um dict, não um set. Para criar um conjunto vazio, é preciso usar set() explicitamente.

Como containers guardam referências e não cópias, tudo o que vimos sobre identidade, igualdade e mutabilidade se aplica de forma direta aqui: alterar um objeto mutável dentro de um container afeta todas as variáveis que referenciam esse mesmo objeto — mesmo que o container em si seja imutável, como vimos no exemplo da tupla na seção 4.

7. Conclusão

Identidade, igualdade, mutabilidade, ciclo de vida e containers são faces do mesmo conceito central: em Python, variáveis são referências a objetos, não caixas que guardam valores. Entender isso é o que permite prever, com segurança, quando uma alteração vai se propagar e quando vai gerar um objeto novo.

Essa base é o que sustenta o próximo passo da série: os métodos mágicos (dunder methods), o protocolo que Python usa por trás de operações aparentemente simples como len(obj), obj[chave] ou for item in obj. Na Parte 2, vamos ver como esses métodos permitem que objetos criados por você se comportem como os tipos nativos da linguagem.

Referências

PYTHON SOFTWARE FOUNDATION. 3. Modelo de dados. In: Documentação Python 3.14.6. [S. l.]: Python Software Foundation, 2026a. Disponível em: https://docs.python.org/pt-br/3/reference/datamodel.html. Acesso em: 28 jul. 2026.

PYTHON SOFTWARE FOUNDATION. Tipos embutidos. In: Documentação Python 3.14.6. [S. l.]: Python Software Foundation, 2026b. Disponível em: https://docs.python.org/pt-br/3/library/stdtypes.html. Acesso em: 28 jul. 2026.