Entendendo Variáveis em Python: Um Guia Completo

Uma variável é um rótulo nomeado que aponta para um valor armazenado na memória. As variáveis são a principal forma de guardar, passar e transformar dados em qualquer programa Python. Ao contrário de algumas linguagens, Python não exige que você declare um tipo — basta atribuir um valor e o Python descobre o tipo para você.

Esta página cobre:

• Como criar e atribuir variáveis
• Tipagem dinâmica — o que isso significa na prática
• Atribuição múltipla e desempacotamento de tuplas
• Operadores de atribuição aumentada
• Verificando o tipo de uma variável com type()
• O valor especial None
• Excluindo variáveis com del
• Noções básicas de escopo de variáveis

Capítulos relacionados: Nomes de Variáveis · Variáveis de Saída · Atribuir Múltiplos Valores · Tipos de Dados Python · Variáveis Globais · Escopo Python

Criando uma Variável

Para criar uma variável, escreva um nome, depois =, depois o valor. Python cria a variável e a vincula a esse valor imediatamente.

Atribuir uma string e imprimi-la

John Doe

Aqui name é o nome da variável e "John Doe" é o valor. O sinal = é o operador de atribuição — não é um teste de igualdade (isso é ==).

Os nomes de variáveis seguem algumas regras:

• Devem começar com uma letra ou um sublinhado (_), nunca com um dígito.
• Podem conter letras, dígitos e sublinhados.
• São sensíveis a maiúsculas e minúsculas — score, Score e SCORE são três variáveis diferentes.
• Não podem ser uma palavra-chave Python como if, for, while ou class.

O estilo Python (PEP 8) recomenda snake_case para nomes de variáveis: palavras em minúsculas unidas por sublinhados, como first_name ou total_price. Para práticas recomendadas de nomenclatura, consulte Nomes de Variáveis.

Tipagem Dinâmica

Python é dinamicamente tipado: uma variável não tem tipo fixo. O tipo é determinado pelo valor atualmente atribuído a ela e pode mudar quando você a reatribui.

x = 10
print(type(x))   # <class 'int'>

x = "hello"
print(type(x))   # <class 'str'>

x = 3.14
print(type(x))   # <class 'float'>

<class 'int'>
<class 'str'>
<class 'float'>

Essa flexibilidade é conveniente, mas também uma fonte comum de erros: se você sobrescrever acidentalmente uma variável com um valor do tipo errado, Python não vai avisá-lo — apenas um TypeError (ou resultado incorreto) em tempo de execução aparecerá. Dicas de tipo (ex.: x: int = 10) são uma forma de documentar a intenção e detectar esses erros cedo com um verificador de tipos. Consulte Dicas de Tipo Python para mais detalhes.

Verificando o Tipo de uma Variável

Use a função embutida type() para inspecionar qual tipo uma variável contém atualmente:

name = "Alice"
age = 30
price = 9.99
active = True

print(type(name))    # <class 'str'>
print(type(age))     # <class 'int'>
print(type(price))   # <class 'float'>
print(type(active))  # <class 'bool'>

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

type() é especialmente útil ao depurar — quando uma variável contém um tipo inesperado, print(type(x)) é a forma mais rápida de confirmar o que ela realmente contém.

Variáveis para Cada Tipo de Dado

Python possui um rico conjunto de tipos embutidos. Aqui está um bloco único que cria uma variável de cada tipo comum para que você possa ver o padrão de nomenclatura de uma vez:

Atribuir variáveis de diferentes tipos

integer_val  = 10                          # int
float_val    = 10.5                        # float
complex_val  = 10 + 5j                     # complex
string_val   = "Hello, World!"             # str
bool_val     = True                        # bool
list_val     = [1, 2, 3, 4, 5]            # list  (mutable, ordered)
tuple_val    = (1, 2, 3, 4, 5)            # tuple (immutable, ordered)
dict_val     = {"key1": "value1"}          # dict  (key-value pairs)
set_val      = {1, 2, 3, 4, 5}            # set   (unique, unordered)
none_val     = None                        # NoneType

Para uma análise aprofundada de quando escolher cada tipo, consulte Tipos de Dados Python.

Atribuição Múltipla

Atribuindo o Mesmo Valor a Várias Variáveis

Você pode encadear = para atribuir o mesmo valor a múltiplas variáveis em uma linha:

a = b = c = 0
print(a, b, c)

0 0 0

Isso é útil para inicializar contadores ou flags, mas tome cuidado com objetos mutáveis — a = b = c = [] faz com que os três nomes apontem para a mesma lista, então modificar uma altera todas as três.

Desempacotamento de Tupla

Atribua valores diferentes a múltiplas variáveis em uma linha separando-os por vírgulas:

x, y, z = 1, 2, 3
print(x, y, z)

1 2 3

Python associa os valores do lado direito aos nomes do lado esquerdo em ordem. O número de nomes deve ser igual ao número de valores, caso contrário você obtém um ValueError. Para desempacotamento com asterisco (*) e aninhado, consulte Atribuir Múltiplos Valores.

Operadores de Atribuição Aumentada

Uma atribuição aumentada combina uma operação com a atribuição em um único passo. Em vez de escrever count = count + 1, você escreve count += 1:

count = 0
count += 1    # same as count = count + 1
print(count)  # 1

total = 100
total -= 25   # same as total = total - 25
print(total)  # 75

price = 10.0
price *= 1.2  # same as price = price * 1.2
print(price)  # 12.0

1
75
12.0

O conjunto completo de operadores de atribuição aumentada é +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, >>= e <<=. Eles funcionam em qualquer tipo que suporte o operador subjacente — por exemplo, += em uma string concatena:

message = "Hello"
message += ", World!"
print(message)

Hello, World!

Aritmética com Variáveis

Variáveis que contêm números podem ser usadas em expressões aritméticas. Python avalia a expressão e retorna um novo valor:

Matemática com variáveis

a = 10
b = 20

print(a + b)   # addition       → 30
print(b - a)   # subtraction    → 10
print(a * b)   # multiplication → 200
print(b / a)   # division       → 2.0  (always float in Python 3)
print(b // a)  # floor division → 2
print(b % a)   # modulo         → 0

30
10
200
2.0
2
0

Observe que / sempre retorna um float em Python 3, mesmo quando o resultado é um número inteiro. Use // quando precisar de um quociente inteiro.

Para a lista completa de operadores (bit a bit, comparação, lógicos, pertinência, identidade), consulte Operadores Python.

O Valor Especial None

None é a forma de Python representar "nenhum valor" ou "nada". É o único valor do tipo NoneType:

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>
print(result is None) # True

None
<class 'NoneType'>
True

Sempre teste None com is None (verificação de identidade), não com == None (verificação de igualdade). Funções que não retornam explicitamente um valor retornam None por padrão.

Excluindo uma Variável

Use o comando del para remover um nome de variável do escopo atual. Após a exclusão, referenciar o nome gera um NameError:

temp = "temporary value"
print(temp)  # temporary value

del temp
# print(temp)  # NameError: name 'temp' is not defined

del é usado com mais frequência para liberar memória explicitamente (ex.: após processar um grande conjunto de dados) ou para limpar o estado local. Ele remove o vínculo do nome, não necessariamente o objeto subjacente — o coletor de lixo do Python recupera a memória do objeto quando nenhum nome aponta para ele.

Noções Básicas de Escopo de Variáveis

Onde uma variável é acessível depende de onde ela está definida. Os dois escopos mais comuns são:

• Escopo local — uma variável criada dentro de uma função existe apenas durante o tempo de vida dessa chamada de função.
• Escopo global — uma variável criada no nível superior de um módulo é acessível de qualquer lugar nesse módulo.

message = "I am global"   # global variable

def greet():
    greeting = "Hello"    # local variable — not accessible outside
    print(greeting)
    print(message)        # can read global variable

greet()
# print(greeting)  # NameError — greeting does not exist here

Hello
I am global

Modificar uma variável global de dentro de uma função requer a palavra-chave global. Consulte Variáveis Globais e Escopo Python para a regra LEGB completa.

Prática