Nesta primeira aula prática vamos percorrer a sintaxe básica do Python: como declarar variáveis, quais são os tipos de dados nativos e, principalmente, onde a linguagem se afasta daquilo que você já conhece de outras linguagens. Se você vem de Java, C#, C++ ou JavaScript, boa parte do caminho será desaprender hábitos antes de aprender construções novas.

Vale começar entendendo por que Python virou a linguagem dominante em IA e Machine Learning, porque as razões são práticas e não acidentais. A sintaxe é simples e legível o suficiente para você gastar energia no problema e não na linguagem. O ecossistema de bibliotecas científicas é gigantesco — NumPy, Pandas, PyTorch e dezenas de outras que vamos usar ao longo do curso. A comunidade é ativa e a documentação, abundante. E a integração com ferramentas de produção é direta, o que importa quando o modelo precisa sair do notebook.

Na prática, você vai perceber que Python remove muito do boilerplate a que está acostumado. Não há declaração de tipos obrigatória, não há ponto e vírgula, não há chaves delimitando blocos. O código é delimitado por indentação, e isso é regra da linguagem, não convenção de estilo.

Antes de escrever a primeira linha, você precisa do Python instalado. Para quem trabalha com dados e IA, a forma recomendada é via Anaconda, que já traz o interpretador junto com as principais bibliotecas científicas. Depois de instalar, confirme no terminal:

python --version

Para esta aula basta um editor de texto simples, o terminal interativo do Python ou o Jupyter Notebook. Para abrir o terminal interativo, digite python ou python3 e você verá o prompt >>>.

Começando pelas variáveis: em Python você não declara o tipo. Basta atribuir um valor com o sinal de igual.

nome = "Carlos"
idade = 32
altura = 1.78
ativo = True

Diferente de Java ou C#, não existe int x = 5 ou String nome = "Carlos". O Python infere o tipo automaticamente — é o que se chama de tipagem dinâmica. Sempre que quiser confirmar o tipo de algo, a função type() responde:

print(type(nome))
print(type(idade))
print(type(altura))
print(type(ativo))

Saída:

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

Esses quatro tipos que apareceram acima, mais o None, formam o conjunto de tipos nativos que você vai usar o tempo todo. Vale olhar cada um com calma.

Os inteiros (int) são números positivos ou negativos e, ao contrário da maioria das linguagens, não têm limite de tamanho em Python:

x = 10
y = -5
z = 1000000000000

Os números de ponto flutuante (float) carregam casas decimais. Internamente usam representação binária de 64 bits, o padrão IEEE 754, o que provoca pequenas imprecisões que surpreendem quem vê pela primeira vez:

preco = 19.99
pi = 3.14159
resultado = 0.1 + 0.2
print(resultado)

Saída:

0.30000000000000004

Isso é uma limitação de hardware, não do Python — qualquer linguagem que use IEEE 754 se comporta assim. Guarde bem esse detalhe: ele volta a importar em cálculos financeiros e em comparações de floats dentro de modelos de ML.

As strings (str) guardam texto e aceitam aspas simples ou duplas, que são equivalentes. Três aspas abrem uma string de múltiplas linhas:

mensagem = "Olá, mundo"
outra = 'Também funciona'
multilinha = """
Isso é uma
string com múltiplas linhas
"""

Elas vêm com uma coleção generosa de métodos embutidos:

texto = "inteligencia artificial"
print(texto.upper())
print(texto.capitalize())
print(texto.replace("artificial", "generativa"))
print(len(texto))
print(texto.split(" "))

Saída:

INTELIGENCIA ARTIFICIAL
Inteligencia artificial
inteligencia generativa
24
['inteligencia', 'artificial']

Para montar texto com variáveis dentro, a forma moderna e recomendada são as f-strings, disponíveis desde o Python 3.6. Note que dá para colocar expressões e formatação dentro das chaves:

nome = "Ana"
nota = 9.5
print(f"A aluna {nome} tirou {nota} na prova.")
print(f"O dobro da nota é {nota * 2}.")
print(f"Nota formatada: {nota:.2f}")

Saída:

A aluna Ana tirou 9.5 na prova.
O dobro da nota é 19.0.
Nota formatada: 9.50

Os booleanos (bool) têm apenas dois valores possíveis, True e False, e aqui vai um detalhe que pega quem vem de outras linguagens: a primeira letra é maiúscula, sempre.

ligado = True
desligado = False
print(type(ligado))
print(10 > 5)
print(10 == 5)

Saída:

<class 'bool'>
True
False

Por fim, None representa ausência de valor — o equivalente ao null de outras linguagens. A forma idiomática de testá-lo é com is, não com ==:

resultado = None
print(resultado)
print(type(resultado))
print(resultado is None)

Saída:

None
<class 'NoneType'>
True

Como os tipos são inferidos, converter de um para outro é uma operação frequente. Cada tipo tem uma função de conversão com o próprio nome:

x = int("42")
y = float(10)
z = str(3.14)
b = bool("texto")

print(x, type(x))
print(y, type(y))
print(z, type(z))
print(b, type(b))

Saída:

42 <class 'int'>
10.0 <class 'float'>
3.14 <class 'str'>
True <class 'bool'>

Atenção ao caso do bool: bool("") retorna False, porque string vazia é considerada falsa, enquanto bool("qualquer texto") retorna True.

Os operadores aritméticos não trazem grandes surpresas, com duas exceções que vale memorizar — a divisão real e a divisão inteira são operadores distintos:

a = 10
b = 3

print(a + b)   # 13 — soma
print(a - b)   # 7  — subtração
print(a * b)   # 30 — multiplicação
print(a / b)   # 3.3333... — divisão real (sempre float)
print(a // b)  # 3  — divisão inteira
print(a % b)   # 1  — módulo (resto)
print(a ** b)  # 1000 — potência

Os operadores de comparação retornam sempre um booleano:

print(10 == 10)  # True
print(10 != 5)   # True
print(10 > 5)    # True
print(10 < 5)    # False
print(10 >= 10)  # True
print(10 <= 9)   # False

E os de atribuição composta funcionam como você espera, aplicando a operação sobre o valor atual da variável:

x = 10
x += 5   # x = 15
x -= 3   # x = 12
x *= 2   # x = 24
x //= 5  # x = 4
print(x) # 4

Para ler dados digitados pelo usuário, a função input() resolve — lembrando que ela devolve sempre uma string, por isso a conversão explícita quando você espera um número:

nome = input("Qual o seu nome? ")
idade = int(input("Qual a sua idade? "))
print(f"Olá, {nome}! Você tem {idade} anos.")
print(f"Em 10 anos você terá {idade + 10} anos.")

Comentários de uma linha começam com #. Não existe sintaxe dedicada para comentário de bloco: por convenção usa-se uma string de três aspas, que tecnicamente é uma string solta que o interpretador descarta.

# Isso é um comentário de uma linha
x = 5  # Comentário no final da linha

"""
Isso tecnicamente é uma string multilinha,
mas é usada como comentário de bloco por convenção.
"""

Fechando a aula, vale reunir num só lugar as diferenças que mais causam tropeço em quem chega de outra linguagem. A indentação é obrigatória e define os blocos de código, sendo quatro espaços a convenção da PEP 8. Não existe ; ao final das linhas nem {} para delimitar blocos. Variáveis não precisam ser declaradas antes do uso, já que o tipo é inferido pelo valor atribuído. A comparação de valores é feita com ==, enquanto is compara identidade de objeto e deve ficar reservado ao teste contra None. True e False começam com maiúscula. E a divisão com / sempre devolve float, cabendo ao // o papel de divisão inteira.

Se você guardar apenas isto da aula, já é o suficiente para seguir: Python usa tipagem dinâmica, seus tipos básicos são int, float, str, bool e None, f-strings são a forma moderna de formatar texto, e a indentação carrega significado sintático.

Para fixar o conteúdo, resolva os seis problemas a seguir antes de conferir o gabarito — cada um traz a resposta comentada logo abaixo do enunciado.

  1. Declare três variáveis: seu nome (string), sua idade (inteiro) e sua altura em metros (float). Imprima uma frase usando f-string no formato: "Meu nome é [nome], tenho [idade] anos e meço [altura]m de altura."

    ✓ Resposta: 
    nome = "Carlos"
idade = 32
altura = 1.78
print(f"Meu nome é {nome}, tenho {idade} anos e meço {altura}m de altura.")

    Saída:

    Meu nome é Carlos, tenho 32 anos e meço 1.78m de altura.

  2. Dado o valor 7 dividido por 2, qual será o resultado de cada operação abaixo? Responda antes de testar.

    a) 7 / 2
b) 7 // 2
c) 7 % 2
d) 7 ** 2

    ✓ Resposta: 
    a) 7 / 2  → 3.5   (divisão real, sempre retorna float)
b) 7 // 2 → 3     (divisão inteira, descarta a parte decimal)
c) 7 % 2  → 1     (resto da divisão: 7 = 3×2 + 1)
d) 7 ** 2 → 49    (potência: 7 elevado a 2)

  3. Qual a diferença entre == e is em Python? Dê um exemplo em que == retorna True mas is retorna False.

    ✓ Resposta:

    == compara o valor dos objetos. is compara se os dois nomes apontam para o exato mesmo objeto na memória.

    a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # True — os valores são iguais
print(a is b)  # False — são objetos diferentes na memória

    Regra prática: use == para comparar valores. Use is apenas para comparar com None.

  4. O código abaixo tem um erro. Identifique e corrija:

    idade = input("Digite sua idade: ")
proxima_idade = idade + 1
print(f"No próximo ano você terá {proxima_idade} anos.")

    ✓ Resposta:

    O erro está em proxima_idade = idade + 1. O input() sempre retorna string. Somar string com inteiro causa TypeError. Correção:

    idade = int(input("Digite sua idade: "))
proxima_idade = idade + 1
print(f"No próximo ano você terá {proxima_idade} anos.")

  5. Sem rodar o código, diga o que será impresso:

    x = 10
x += 5
x *= 2
x //= 3
x -= 1
print(x)

    ✓ Resposta: 
    x = 10
x += 5   → x = 15
x *= 2   → x = 30
x //= 3  → x = 10
x -= 1   → x = 9
print(x) → 9

  6. Explique com suas palavras o que é tipagem dinâmica e qual a vantagem e desvantagem em comparação com linguagens de tipagem estática como Java.

    ✓ Resposta:

    Tipagem dinâmica significa que o tipo de uma variável é determinado em tempo de execução, pelo valor que ela recebe, sem necessidade de declaração prévia. A mesma variável pode mudar de tipo ao longo do programa:

    x = 10       # x é int
x = "texto"  # agora x é str — válido em Python

    Vantagem: código mais rápido de escrever, menos verboso, mais flexível para prototipagem. Ideal para ciência de dados onde se experimenta muito.

    Desvantagem: erros de tipo só aparecem em tempo de execução, não em compilação. Em projetos grandes isso pode gerar bugs difíceis de rastrear. Por isso, em Python moderno é recomendado usar type hints:

    def soma(a: int, b: int) -> int:
    return a + b

Para aprofundar: