<h2>O Que São Variáveis em Python</h2>
<p>Uma variável é um espaço na memória do computador destinado a armazenar um valor. Em Python, diferentemente de linguagens como Java ou C, você não precisa declarar explicitamente o tipo da variável — a linguagem identifica automaticamente qual tipo de dado você está armazenando. Pense em uma variável como uma caixa etiquetada: você coloca algo dentro e, posteriormente, pode recuperar ou modificar o conteúdo.</p>
<p>A sintaxe para criar uma variável é simples: basta atribuir um valor usando o sinal de igualdade (<code>=</code>). O identificador (nome da variável) fica à esquerda, e o valor à direita. Python segue algumas convenções de nomenclatura: nomes devem começar com letra ou underscore, podem conter números, e preferencialmente usamos <code>snake_case</code> (letras minúsculas com underscore separando palavras).</p>
<pre><code class="language-python"># Exemplos de atribuição simples
nome = "Alice"
idade = 28
altura = 1.65
ativo = True
Atribuição múltipla
x, y, z = 10, 20, 30
Reatribuição (variável muda de valor)
contador = 0
contador = 5
print(contador) # Output: 5</code></pre>
<p>Note que quando você reatribui uma variável, o valor anterior é descartado. Python gerencia automaticamente a memória, liberando espaço quando o dado não é mais necessário — esse processo é chamado de garbage collection.</p>
<h3>Identidade vs. Valor</h3>
<p>Toda variável em Python possui três características: o <strong>nome</strong> (identificador), o <strong>tipo</strong> (qual classe de dado representa) e o <strong>valor</strong> (conteúdo). Além disso, existe a <strong>identidade</strong>, que é um identificador único em memória — você pode verificá-la com a função <code>id()</code>.</p>
<pre><code class="language-python">a = 100
b = 100
print(a == b) # True (mesmo valor)
print(a is b) # True (mesma identidade, porque inteiros pequenos são cacheados)
print(id(a), id(b)) # Pode mostrar o mesmo ID para inteiros entre -5 e 256
Exemplo com valores maiores
x = 1000
y = 1000
print(x is y) # False (identidades diferentes, embora valores iguais)</code></pre>
<h2>Tipos Primitivos em Python</h2>
<p>Python possui vários tipos de dados primitivos (ou built-in types). Entender cada um é fundamental para escrever código robusto e eficiente. Os principais são: inteiros, ponto flutuante, booleanos e strings.</p>
<h3>Inteiros (int)</h3>
<p>O tipo <code>int</code> representa números inteiros, sem casas decimais. Python 3 não possui limite teórico de tamanho para inteiros — você pode trabalhar com números absurdamente grandes sem perder precisão.</p>
<pre><code class="language-python">numero_pequeno = 42
numero_grande = 99999999999999999999999999999
Operações com inteiros
resultado = 10 + 5
divisao_inteira = 10 // 3 # Output: 3 (arredonda para baixo)
resto = 10 % 3 # Output: 1 (resto da divisão)
Conversão para inteiro
texto = "123"
numero = int(texto)
print(numero + 1) # Output: 124
Inteiros em diferentes bases
binario = 0b1010 # 10 em decimal
octal = 0o12 # 10 em decimal
hexadecimal = 0xa # 10 em decimal</code></pre>
<h3>Ponto Flutuante (float)</h3>
<p>O tipo <code>float</code> representa números decimais. Internamente, Python usa o padrão IEEE 754 de ponto flutuante, o que significa que existem limitações de precisão.</p>
<pre><code class="language-python">preco = 19.99
temperatura = -3.5
pi_aproximado = 3.14159
Operações com floats
resultado = 10.5 / 2.0 # Output: 5.25
potencia = 2.0 ** 3 # Output: 8.0
Cuidado com precisão
print(0.1 + 0.2) # Output: 0.30000000000000004
print(0.1 + 0.2 == 0.3) # Output: False
Use o módulo decimal para precisão exata
from decimal import Decimal
valor = Decimal('0.1') + Decimal('0.2')
print(valor == Decimal('0.3')) # Output: True
Notação científica
numero_muito_grande = 1.5e6 # 1.500.000
numero_muito_pequeno = 2.3e-4 # 0.00023</code></pre>
<h3>Booleanos (bool)</h3>
<p>O tipo <code>bool</code> possui apenas dois valores possíveis: <code>True</code> e <code>False</code>. Booleanos são úteis em condicionais e lógica de controle de fluxo.</p>
<pre><code class="language-python">usuario_ativo = True
produto_em_estoque = False
Operações lógicas
resultado1 = True and False # False
resultado2 = True or False # True
resultado3 = not True # False
Booleanos e valores "truthy" / "falsy"
Qualquer valor não-booleano pode ser avaliado como True ou False
if 5: # 5 é "truthy"
print("Número diferente de zero é True")
if 0: # 0 é "falsy"
print("Isto não será executado")
if "": # String vazia é "falsy"
print("Isto não será executado")
if "texto": # String não-vazia é "truthy"
print("Isto será executado")</code></pre>
<h3>Strings (str)</h3>
<p>O tipo <code>str</code> representa texto. Strings em Python são imutáveis — uma vez criadas, não podem ser modificadas.</p>
<pre><code class="language-python">mensagem = "Olá, Mundo!"
frase = 'Python é incrível' # Aspas simples ou duplas são equivalentes
Strings multi-linha
poema = """
Linha 1
Linha 2
Linha 3
"""
Concatenação
saudacao = "Olá" + ", " + "Python"
Formatação com f-strings (Python 3.6+)
nome = "Bob"
idade = 25
apresentacao = f"Meu nome é {nome} e tenho {idade} anos"
Métodos úteis de string
texto = "python"
print(texto.upper()) # PYTHON
print(texto.capitalize()) # Python
print(texto.replace('o', '0')) # pyth0n
print(len(texto)) # 6
Índice e slicing
primeiro_caractere = texto[0] # p
ultimos_dois = texto[-2:] # on
intervalo = texto[1:4] # yth</code></pre>
<h2>Tipagem Dinâmica em Python</h2>
<p>Tipagem dinâmica significa que o tipo de uma variável é determinado em tempo de execução, não em tempo de compilação. Você pode atribuir um valor de um tipo, e depois reatribuir com um valor de outro tipo completamente diferente. Isso oferece flexibilidade, mas também requer cuidado.</p>
<pre><code class="language-python">variavel = 10 # tipo int
variavel = "texto" # agora é str
variavel = 3.14 # agora é float
variavel = True # agora é bool
print(type(variavel)) # <class 'bool'></code></pre>
<p>A vantagem da tipagem dinâmica é permitir código mais conciso e flexível. A desvantagem é que erros de tipo podem aparecer apenas durante a execução, não durante o desenvolvimento. Um erro comum é tentar operações incompatíveis com o tipo:</p>
<pre><code class="language-python">resultado = "5" + 2 # TypeError: can only concatenate str (not "int") to str
Para evitar isso, converta explicitamente
resultado = int("5") + 2 # 7
resultado = "5" + str(2) # "52"</code></pre>
<h3>Type Hints (Anotações de Tipo)</h3>
<p>Python oferece type hints (anotações de tipo) para documentar qual tipo uma variável ou função deveria ter. Essas anotações não são obrigatórias e não alteram o comportamento em tempo de execução, mas melhoram a legibilidade e permitem que ferramentas como <code>mypy</code> detectem erros potenciais.</p>
<pre><code class="language-python"># Variáveis com type hints
numero: int = 42
texto: str = "olá"
ativo: bool = True
preco: float = 19.99
Type hints em funções
def saudacao(nome: str) -> str:
return f"Olá, {nome}!"
def somar(a: int, b: int) -> int:
return a + b
resultado = somar(3, 5)
print(resultado) # 8
Tipo genérico para coleções
from typing import List, Dict
numeros: List[int] = [1, 2, 3, 4]
pessoas: Dict[str, int] = {"Alice": 25, "Bob": 30}</code></pre>
<h3>Função type() e isinstance()</h3>
<p>Para verificar o tipo de uma variável em tempo de execução, use <code>type()</code> ou <code>isinstance()</code>.</p>
<pre><code class="language-python"># Usando type()
print(type(42)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type("texto")) # <class 'str'>
print(type(True)) # <class 'bool'>
Comparando tipos
if type(42) == int:
print("É um inteiro")
Usando isinstance() (preferido)
if isinstance(42, int):
print("É um inteiro ou subclasse de int")
isinstance() permite verificar múltiplos tipos
valor = 3.14
if isinstance(valor, (int, float)):
print("É um número")</code></pre>
<h3>Conversão de Tipos (Casting)</h3>
<p>Frequentemente você precisa converter um tipo para outro. Python fornece funções built-in para isso.</p>
<pre><code class="language-python"># De string para outros tipos
numero_de_string = int("123")
decimal_de_string = float("3.14")
booleano_de_string = bool("True") # Cuidado: qualquer string não-vazia é True!
De inteiro para outros tipos
stringificado = str(42) # "42"
decimal = float(42) # 42.0
De float para outros tipos
inteiro = int(3.99) # 3 (trunca, não arredonda)
stringificado = str(3.14) # "3.14"
Conversões mais complexas
lista_de_numeros = [1, 2, 3, 4, 5]
como_string = str(lista_de_numeros) # "[1, 2, 3, 4, 5]"
Arredondamento correto de float para int
valor = 3.7
arredondado = round(valor) # 4</code></pre>
<h2>Boas Práticas e Armadilhas Comuns</h2>
<p>Trabalhar com variáveis e tipos em Python exige atenção a alguns detalhes que podem causar bugs subtis. Uma das armadilhas mais comuns envolve objetos mutáveis como listas e dicionários.</p>
<pre><code class="language-python"># Armadilha: compartilhamento de referência
lista_original = [1, 2, 3]
lista_copia = lista_original # Não cria cópia, apenas referencia o mesmo objeto
lista_copia.append(4)
print(lista_original) # [1, 2, 3, 4] — também foi modificada!
Solução: criar uma cópia real
lista_copia = lista_original.copy()
lista_copia.append(4)
print(lista_original) # [1, 2, 3] — intacta
Para cópias profundas (nested structures)
import copy
lista_aninhada = [[1, 2], [3, 4]]
copia_profunda = copy.deepcopy(lista_aninhada)</code></pre>
<p>Outra boa prática é usar nomes significativos para variáveis. Um nome bem escolhido documenta o código e reduz a necessidade de comentários.</p>
<pre><code class="language-python"># Ruim
x = 25
y = 3.5
z = "Alice"
Bom
idade_usuario = 25
altura_em_metros = 3.5
nome_completo = "Alice"
Ruim
dados = [1, 2, 3, 4, 5]
Bom
idades_dos_clientes = [1, 2, 3, 4, 5]</code></pre>
<h2>Conclusão</h2>
<p>Aprendemos que variáveis são contêineres para dados, identificadas por nomes e gerenciadas automaticamente por Python. Os tipos primitivos — <code>int</code>, <code>float</code>, <code>bool</code> e <code>str</code> — são os blocos fundamentais de qualquer programa Python, cada um com suas características e operações específicas. A tipagem dinâmica oferece flexibilidade mas exige cuidado: você pode mudar o tipo de uma variável a qualquer momento, porém deve estar atento aos erros que podem surgir em tempo de execução. Por fim, type hints são uma prática moderna que ajuda a documentar código e detectar erros sem sacrificar a natureza dinâmica da linguagem.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://docs.python.org/3/library/stdtypes.html" target="_blank" rel="noopener noreferrer">Python Official Documentation - Data Types</a></li>
<li><a href="https://realpython.com/python-type-checking/" target="_blank" rel="noopener noreferrer">Real Python - Python Type Checking</a></li>
<li><a href="https://www.python.org/dev/peps/pep-0484/" target="_blank" rel="noopener noreferrer">Python Enhancement Proposal 484 - Type Hints</a></li>
<li><a href="https://realpython.com/python-numbers/" target="_blank" rel="noopener noreferrer">Real Python - Numbers and Math in Python</a></li>
<li><a href="https://docs.python.org/3/tutorial/introduction.html" target="_blank" rel="noopener noreferrer">Official Python Tutorial - An Informal Introduction to Python</a></li>
</ul>
<p><!-- FIM --></p>