10 Comandos Essenciais em Python Para Iniciantes

Introdução

Python conquistou o mundo da programação por uma boa razão: é simples, poderoso e versátil. Se você está dando os primeiros passos nessa linguagem, aprender alguns comandos básicos fará toda a diferença na sua jornada de aprendizado. Este artigo apresenta os 10 comandos mais importantes que todo iniciante em Python deve conhecer.

Criada por Guido van Rossum e lançada em 1991, a linguagem Python foi desenhada para ser fácil de ler e escrever. Seu nome é uma homenagem ao grupo de comédia britânico Monty Python, mostrando desde o início seu lado mais descontraído. Hoje, Python é usado em análise de dados, inteligência artificial, desenvolvimento web, automação e muitas outras áreas.

A filosofia do Python prioriza a clareza e a simplicidade. Diferente de outras linguagens, Python usa espaços em branco (indentação) para definir blocos de código, tornando os programas naturalmente organizados e legíveis. Esta característica, junto com sua sintaxe intuitiva, faz de Python uma excelente escolha para quem está aprendendo a programar.

Vamos mergulhar nos 10 comandos fundamentais que darão início à sua jornada com Python!

1. print() – Exibindo informações na tela

O comando print() é provavelmente o primeiro que você aprenderá em Python, e por um bom motivo. Ele permite mostrar informações na tela, tornando-se essencial para visualizar resultados ou depurar seu código.

Como funciona o print()

O print() exibe na tela (console) qualquer valor que você coloque entre seus parênteses. Podem ser textos, números, ou resultados de operações.

print("Olá, mundo!")  # Exibe: Olá, mundo!
print(42)             # Exibe: 42
print(10 + 5)         # Exibe: 15

Concatenando valores no print()

Você pode combinar diferentes tipos de dados em um único print():

nome = "Ana"
idade = 25
print("Nome:", nome, "- Idade:", idade)  # Exibe: Nome: Ana - Idade: 25

Formatando textos com print()

Para mensagens mais elaboradas, o Python oferece diferentes maneiras de formatar textos:

# Usando f-strings (Python 3.6+)
nome = "João"
print(f"Bem-vindo, {nome}!")  # Exibe: Bem-vindo, João!

# Usando o método format()
idade = 30
print("Você tem {} anos.".format(idade))  # Exibe: Você tem 30 anos.

O comando print() é sua janela para ver o que está acontecendo no programa. Domine-o, e você terá uma ferramenta valiosa para entender e depurar seu código.

2. input() – Recebendo dados do usuário

Programas interativos precisam receber informações do usuário, e o comando input() é a forma mais básica de fazer isso em Python. Ele pausa a execução do programa e aguarda que o usuário digite algo.

Funcionamento básico do input()

Quando o programa encontra um input(), ele espera que o usuário digite alguma informação e pressione Enter:

nome = input("Digite seu nome: ")
print(f"Olá, {nome}!")

Quando esse código for executado, aparecerá a mensagem “Digite seu nome: ” e o programa aguardará que você digite algo. Depois de pressionar Enter, sua entrada será armazenada na variável nome.

Convertendo a entrada para outros tipos

Um detalhe importante: o input() sempre retorna a entrada como texto (string), mesmo que o usuário digite números. Para trabalhar com entradas numéricas, é necessário converter o valor recebido:

# Convertendo para número inteiro
idade = int(input("Digite sua idade: "))
print(f"Daqui a 5 anos você terá {idade + 5} anos")

# Convertendo para número decimal
altura = float(input("Digite sua altura em metros: "))
print(f"Sua altura é {altura} metros")

Tratando erros de entrada

Quando convertemos a entrada do usuário, devemos considerar que a pessoa pode digitar algo inesperado. Uma boa prática é usar tratamento de exceções:

try:
    idade = int(input("Digite sua idade: "))
    print(f"Você tem {idade} anos")
except ValueError:
    print("Por favor, digite apenas números para a idade")

O comando input() é essencial para criar programas interativos, permitindo que seus usuários forneçam dados e informações durante a execução.

3. if, elif e else – Tomando decisões

A habilidade de tomar decisões é fundamental na programação. Com as estruturas condicionais if, elif (abreviação de “else if”) e else, você pode fazer seu programa seguir caminhos diferentes com base em condições.

Estrutura básica do if

O if verifica se uma condição é verdadeira e, caso seja, executa o bloco de código indentado logo abaixo:

idade = 18

if idade >= 18:
    print("Você é maior de idade")

Adicionando alternativas com elif e else

Para verificar múltiplas condições ou definir um comportamento padrão quando nenhuma condição for atendida:

nota = 7.5

if nota >= 9:
    print("Excelente!")
elif nota >= 7:
    print("Bom trabalho!")
elif nota >= 5:
    print("Você passou, mas precisa melhorar")
else:
    print("Você não passou, estude mais")

O programa verifica cada condição em ordem. Quando encontra a primeira condição verdadeira, executa o bloco correspondente e ignora o restante.

Operadores de comparação

Nas condições, você pode usar vários operadores de comparação:

• == : igual a
• != : diferente de
• > : maior que
• < : menor que
• >= : maior ou igual a
• <= : menor ou igual a

x = 10
y = 5

if x == y:
    print("x é igual a y")
elif x > y:
    print("x é maior que y")
else:
    print("x é menor que y")

Operadores lógicos

Para combinar condições, use os operadores lógicos:

• and : ambas as condições devem ser verdadeiras
• or : pelo menos uma condição deve ser verdadeira
• not : inverte o valor da condição

idade = 25
tem_carteira = True

if idade >= 18 and tem_carteira:
    print("Você pode dirigir")
elif idade >= 18 and not tem_carteira:
    print("Você tem idade para dirigir, mas precisa tirar a carteira")
else:
    print("Você não pode dirigir")

Dominar as estruturas condicionais abre um mundo de possibilidades em seus programas, permitindo comportamentos dinâmicos baseados em diferentes situações.

4. for – Repetindo ações com loops

Repetir tarefas é algo comum na programação. O loop for permite executar um bloco de código várias vezes, percorrendo cada elemento de uma sequência.

Loop for com listas

A forma mais comum de usar o for é percorrer uma lista:

frutas = ["maçã", "banana", "laranja", "uva"]

for fruta in frutas:
    print(f"Eu gosto de {fruta}")

Este código exibirá cada fruta da lista em uma linha separada.

Loop for com range()

A função range() gera uma sequência de números, perfeita para usar com for:

# Contando de 0 a 4
for i in range(5):
    print(i)  # Exibe: 0, 1, 2, 3, 4

# Contando de 1 a 10
for i in range(1, 11):
    print(i)  # Exibe: 1, 2, 3, ..., 10

# Contando de 0 a 10, pulando de 2 em 2
for i in range(0, 11, 2):
    print(i)  # Exibe: 0, 2, 4, 6, 8, 10

Loop for com strings

Strings são sequências de caracteres, então também podem ser percorridas:

palavra = "Python"

for letra in palavra:
    print(letra)

Este código imprime cada letra da palavra “Python” em uma linha separada.

Loop for com enumerate()

Para obter tanto o índice quanto o valor durante a iteração, use a função enumerate():

frutas = ["maçã", "banana", "laranja"]

for indice, fruta in enumerate(frutas):
    print(f"Índice {indice}: {fruta}")

Saída:

Índice 0: maçã
Índice 1: banana
Índice 2: laranja

Controlando o loop com break e continue

• break: interrompe o loop completamente
• continue: pula para a próxima iteração

# Usando break
for i in range(10):
    if i == 5:
        break  # Sai do loop quando i é 5
    print(i)  # Exibe: 0, 1, 2, 3, 4

# Usando continue
for i in range(10):
    if i % 2 == 0:
        continue  # Pula números pares
    print(i)  # Exibe: 1, 3, 5, 7, 9

O loop for é uma das ferramentas mais poderosas e frequentemente usadas em Python, permitindo processar dados de forma eficiente e repetitiva.

5. while – Loops baseados em condições

Enquanto o loop for é ideal para percorrer sequências, o loop while continua executando enquanto uma condição específica for verdadeira. Isso o torna perfeito para situações onde não sabemos antecipadamente quantas vezes precisaremos repetir uma ação.

Estrutura básica do while

contador = 0

while contador < 5:
    print(contador)
    contador += 1  # Incrementa o contador para evitar loop infinito

Este código imprime os números de 0 a 4, incrementando o contador a cada iteração.

Loops infinitos controlados

Às vezes, queremos um loop que continue até que algo específico aconteça:

while True:
    resposta = input("Digite 'sair' para encerrar: ")
    if resposta.lower() == "sair":
        break
    print(f"Você digitou: {resposta}")

Este programa continuará pedindo entrada até que o usuário digite “sair”.

Validação de entrada com while

O while é útil para garantir que o usuário forneça uma entrada válida:

while True:
    try:
        idade = int(input("Digite sua idade (apenas números): "))
        if idade > 0:
            break  # Sai do loop se a entrada for válida
        else:
            print("A idade deve ser um número positivo")
    except ValueError:
        print("Por favor, digite apenas números")

print(f"Idade registrada: {idade} anos")

Uso do else com while

Curiosamente, o Python permite usar else com loops. O bloco else é executado quando o loop termina normalmente (sem break):

contador = 0

while contador < 5:
    print(contador)
    contador += 1
else:
    print("Loop concluído com sucesso!")

Cuidado com loops infinitos

É fácil criar acidentalmente loops infinitos com while. Sempre garanta que a condição eventualmente se torne falsa:

# Loop infinito incorreto
# while True:
#     print("Isso vai rodar para sempre!")

# Loop infinito controlado
limite = 0
while True:
    print("Iteração", limite)
    limite += 1
    if limite >= 5:
        print("Saindo do loop")
        break

O loop while dá mais flexibilidade para controlar repetições baseadas em condições dinâmicas, sendo especialmente útil quando a quantidade de iterações não é conhecida previamente.

6. def – Criando funções

Funções são blocos de código reutilizáveis que realizam tarefas específicas. Com a instrução def do Python, você pode criar suas próprias funções para organizar melhor seu código e evitar repetições.

Estrutura básica de uma função

def saudacao():
    print("Olá! Bem-vindo ao Python.")

# Chamando a função
saudacao()  # Exibe: Olá! Bem-vindo ao Python.

Funções com parâmetros

Parâmetros permitem que você passe informações para a função:

def saudacao_personalizada(nome):
    print(f"Olá, {nome}! Bem-vindo ao Python.")

# Chamando a função com um argumento
saudacao_personalizada("Maria")  # Exibe: Olá, Maria! Bem-vindo ao Python.

Parâmetros com valores padrão

Você pode definir valores padrão para parâmetros, tornando-os opcionais:

def saudacao_completa(nome, mensagem="Bem-vindo ao Python"):
    print(f"Olá, {nome}! {mensagem}")

# Usando apenas o parâmetro obrigatório
saudacao_completa("João")  # Exibe: Olá, João! Bem-vindo ao Python

# Sobrescrevendo o valor padrão
saudacao_completa("Ana", "É bom te ver novamente!")  # Exibe: Olá, Ana! É bom te ver novamente!

Retornando valores

Funções podem processar dados e retornar resultados usando a instrução return:

def soma(a, b):
    return a + b

# Armazenando o resultado da função
resultado = soma(5, 3)
print(resultado)  # Exibe: 8

# Usando o resultado diretamente
print(soma(10, 20))  # Exibe: 30

Múltiplos valores de retorno

Em Python, funções podem retornar múltiplos valores de forma simples:

def calcular_estatisticas(numeros):
    soma = sum(numeros)
    media = soma / len(numeros)
    maximo = max(numeros)
    minimo = min(numeros)
    return soma, media, maximo, minimo

# Desempacotando os valores retornados
total, media, maior, menor = calcular_estatisticas([1, 2, 3, 4, 5])
print(f"Total: {total}, Média: {media}, Maior: {maior}, Menor: {menor}")

Escopo de variáveis

Variáveis definidas dentro de funções têm escopo local, só existindo dentro da função:

def teste_escopo():
    x = 10  # Variável local
    print(f"Dentro da função: {x}")

teste_escopo()  # Exibe: Dentro da função: 10
# print(x)  # Isso causaria um erro, pois x não existe fora da função

Criar funções é essencial para escrever código organizado, reutilizável e modular. Elas são a base da programação estruturada e permitem construir programas complexos a partir de componentes simples.

7. import – Utilizando módulos e bibliotecas

Python tem uma grande vantagem: sua vasta coleção de módulos e bibliotecas. O comando import permite acessar essas funcionalidades prontas, economizando tempo e esforço.

Importando módulos completos

A forma mais simples de importar é trazer um módulo inteiro:

import math

# Usando funções do módulo math
raiz_quadrada = math.sqrt(16)
print(raiz_quadrada)  # Exibe: 4.0

seno = math.sin(math.pi/2)
print(seno)  # Exibe: 1.0

Importando funções específicas

Para importar apenas o que você precisa:

from math import sqrt, pi

# Agora você pode usar as funções diretamente
raiz_quadrada = sqrt(16)
print(raiz_quadrada)  # Exibe: 4.0

print(pi)  # Exibe: 3.141592653589793

Usando aliases

Para facilitar o uso ou evitar conflitos de nomes:

import matplotlib.pyplot as plt
import numpy as np

# Agora usamos os aliases
x = np.array([1, 2, 3, 4])
y = x * 2

# plt.plot(x, y)  # Cria um gráfico (comentado porque não exibiria no console)

Módulos da biblioteca padrão

Python vem com uma biblioteca padrão rica. Alguns módulos úteis incluem:

1. random – para geração de números aleatórios

import random

# Número aleatório entre 1 e 10
numero = random.randint(1, 10)
print(numero)

# Escolhendo um item aleatório de uma lista
frutas = ["maçã", "banana", "laranja", "uva"]
escolha = random.choice(frutas)
print(f"Fruta escolhida: {escolha}")

2. datetime – para manipulação de datas e horas

from datetime import datetime, timedelta

# Data e hora atual
agora = datetime.now()
print(f"Data e hora atual: {agora}")

# Adicionando dias
amanha = agora + timedelta(days=1)
print(f"Amanhã será: {amanha.date()}")

3. os – para interações com o sistema operacional

import os

# Diretório atual
diretorio_atual = os.getcwd()
print(f"Você está em: {diretorio_atual}")

# Listar arquivos no diretório
arquivos = os.listdir()
print("Arquivos no diretório:")
for arquivo in arquivos[:5]:  # Mostra até 5 arquivos
    print(f"- {arquivo}")

Instalando bibliotecas externas

Além da biblioteca padrão, existem milhares de pacotes disponíveis para Python. Você pode instalá-los usando o pip, o gerenciador de pacotes do Python:

pip install nome_do_pacote

Alguns pacotes populares incluem:

• pandas – para análise de dados
• matplotlib e seaborn – para visualização de dados
• requests – para fazer requisições HTTP
• flask e django – para desenvolvimento web
• scikit-learn – para aprendizado de máquina

O comando import abre as portas para todo o ecossistema Python, permitindo que você aproveite códigos prontos e soluções bem testadas para diversos problemas.

8. list, dict e tuple – Trabalhando com coleções de dados

Armazenar e manipular coleções de dados é fundamental na programação. Python oferece vários tipos de coleções, sendo as três principais: listas, dicionários e tuplas.

Listas – Coleções ordenadas e mutáveis

Listas são sequências ordenadas de itens que podem ser modificadas:

# Criando listas
frutas = ["maçã", "banana", "laranja"]
numeros = [1, 2, 3, 4, 5]
misturada = [1, "dois", 3.0, [4, 5]]  # Listas podem conter diferentes tipos

# Acessando elementos (índices começam em 0)
primeira_fruta = frutas[0]  # "maçã"
ultimo_numero = numeros[-1]  # 5 (índices negativos contam de trás para frente)

# Modificando elementos
frutas[1] = "morango"  # Agora a lista é ["maçã", "morango", "laranja"]

# Adicionando elementos
frutas.append("uva")  # Adiciona ao final
frutas.insert(1, "abacaxi")  # Insere na posição 1

# Removendo elementos
frutas.remove("maçã")  # Remove pelo valor
fruta_removida = frutas.pop(0)  # Remove pelo índice e retorna o valor

# Operações úteis
tamanho = len(frutas)  # Número de elementos
frutas.sort()  # Ordena a lista
frutas.reverse()  # Inverte a ordem

Dicionários – Mapeamentos de chave-valor

Dicionários armazenam pares de chave-valor, permitindo acesso rápido por chave:

# Criando dicionários
pessoa = {
    "nome": "Carlos",
    "idade": 28,
    "profissão": "Engenheiro"
}

# Acessando valores
nome = pessoa["nome"]  # "Carlos"

# Método get (mais seguro, pois não causa erro se a chave não existir)
email = pessoa.get("email", "Não informado")  # Retorna "Não informado" se a chave não existir

# Adicionando ou alterando valores
pessoa["email"] = "carlos@exemplo.com"
pessoa["idade"] = 29  # Alterando valor existente

# Removendo pares
del pessoa["profissão"]
item_removido = pessoa.pop("email")  # Remove e retorna o valor

# Operações úteis
chaves = pessoa.keys()  # Obtém todas as chaves
valores = pessoa.values()  # Obtém todos os valores
itens = pessoa.items()  # Obtém pares de (chave, valor)

# Verificando se uma chave existe
if "nome" in pessoa:
    print("A chave 'nome' existe!")

Tuplas – Coleções ordenadas e imutáveis

Tuplas são similares às listas, mas não podem ser modificadas após a criação:

# Criando tuplas
coordenadas = (10, 20)
cores = ("vermelho", "verde", "azul")
singleton = (42,)  # Tupla com um elemento precisa da vírgula!

# Acessando elementos
x = coordenadas[0]  # 10
y = coordenadas[1]  # 20

# Desempacotamento
r, g, b = cores  # r="vermelho", g="verde", b="azul"

# Operações
tamanho = len(cores)  # 3
contagem = cores.count("verde")  # Conta quantas vezes o valor aparece
indice = cores.index("azul")  # Encontra o índice de um valor

Quando usar cada tipo de coleção

• Listas: Quando você precisa de uma coleção ordenada que pode mudar ao longo do tempo.
• Dicionários: Quando você precisa associar valores a chaves para acesso rápido.
• Tuplas: Quando você precisa de uma coleção que não deve ser alterada, como coordenadas ou constantes.

Combinando estruturas

É comum combinar esses tipos para estruturas mais complexas:

# Lista de dicionários
alunos = [
    {"nome": "Ana", "notas": [8.5, 9.0, 7.5]},
    {"nome": "Bruno", "notas": [7.0, 8.0, 6.5]}
]

# Dicionário com tuplas como chaves
distancias = {
    (0, 0): 0,
    (0, 1): 1,
    (1, 0): 1,
    (1, 1): 1.4
}

Dominar essas estruturas de dados é fundamental para programar em Python, pois elas são usadas constantemente para organizar e manipular informações.

9. with – Trabalhando com arquivos

Manipular arquivos é uma tarefa comum em programação. O comando with do Python oferece uma maneira elegante e segura de trabalhar com arquivos, garantindo que eles sejam fechados corretamente, mesmo se ocorrerem erros.

Lendo arquivos com with

# Lendo um arquivo texto
with open("exemplo.txt", "r", encoding="utf-8") as arquivo:
    conteudo = arquivo.read()  # Lê todo o arquivo
    print(conteudo)

# O arquivo é automaticamente fechado quando sai do bloco with

Lendo arquivo linha por linha

Para arquivos grandes, ler linha por linha é mais eficiente:

with open("exemplo.txt", "r", encoding="utf-8") as arquivo:
    for linha in arquivo:
        # remove o caractere de nova linha
        linha = linha.strip()
        print(f"Linha: {linha}")

Escrevendo em arquivos

# Escrevendo em um arquivo (substitui o conteúdo existente)
with open("saida.txt", "w", encoding="utf-8") as arquivo:
    arquivo.write("Olá, mundo!\n")
    arquivo.write("Esta é a segunda linha.")

# Adicionando ao final do arquivo (modo append)
with open("saida.txt", "a", encoding="utf-8") as arquivo:
    arquivo.write("\nEsta linha foi adicionada depois.")

Trabalhando com arquivos CSV

CSV (Comma-Separated Values) é um formato comum para dados tabulares:

# Lendo um arquivo CSV
with open("dados.csv", "r", encoding="utf-8") as arquivo:
    linhas = arquivo.readlines()
    for linha in linhas[1:]:  # Pula o cabeçalho
        valores = linha.strip().split(",")
        print(f"Nome: {valores[0]}, Idade: {valores[1]}")

# Escrevendo um arquivo CSV
dados = [
    ["Nome", "Idade", "Cidade"],
    ["Ana", "25", "São Paulo"],
    ["Carlos", "30", "Rio de Janeiro"]
]

with open("pessoas.csv", "w", encoding="utf-8", newline="") as arquivo:
    for linha in dados:
        arquivo.write(",".join(linha) + "\n")

Usando módulos especializados

Para trabalho mais avançado com arquivos, existem módulos especializados:

# Usando o módulo csv para arquivos CSV
import csv

with open("dados.csv", "r", encoding="utf-8", newline="") as arquivo:
    leitor = csv.reader(arquivo)
    cabecalho = next(leitor)  # Lê o cabeçalho
    for linha in leitor:
        print(f"Nome: {linha[0]}, Idade: {linha[1]}")

# Usando o módulo json para arquivos JSON
import json

dados = {
    "nome": "Maria",
    "idade": 28,
    "cidade": "Belo Horizonte",
    "hobbies": ["leitura", "natação", "viagens"]
}

# Escrevendo JSON
with open("pessoa.json", "w", encoding="utf-8") as arquivo:
    json.dump(dados, arquivo, indent=4)

# Lendo JSON
with open("pessoa.json", "r", encoding="utf-8") as arquivo:
    dados_lidos = json.load(arquivo)
    print(f"Nome: {dados_lidos['nome']}, Hobbies: {dados_lidos['hobbies']}")

Benefícios do with

O uso do with tem várias vantagens:

1. Segurança: Garante que o arquivo seja fechado mesmo se ocorrer um erro
2. Clareza: Torna claro onde o arquivo está sendo usado
3. Brevidade: Elimina a necessidade de chamar close() explicitamente

Dominar o trabalho com arquivos é essencial para tarefas como processamento de dados, configurações de aplicações, logging e muito mais.

10. try e except – Tratando erros e exceções

Em qualquer programa, coisas podem dar errado: arquivos podem não existir, entradas podem ser inválidas, conexões podem falhar. O Python oferece um mecanismo robusto para lidar com esses problemas: blocos try e except.

Estrutura básica de tratamento de exceções

try:
    # Código que pode gerar um erro
    numero = int(input("Digite um número: "))
    resultado = 10 / numero
    print(f"10 dividido por {numero} é {resultado}")
except:
    # Código executado se ocorrer qualquer erro
    print("Ocorreu um erro!")

Capturando exceções específicas

É melhor capturar apenas as exceções que você espera:

try:
    numero = int(input("Digite um número: "))
    resultado = 10 / numero
    print(f"10 dividido por {numero} é {resultado}")
except ValueError:
    # Executado se o usuário não digitar um número válido
    print("Entrada inválida! Por favor, digite apenas números.")
except ZeroDivisionError:
    # Executado se o usuário digitar zero (divisão por zero)
    print("Não é possível dividir por zero!")

Usando else e finally

• else: Executado se nenhuma exceção ocorrer
• finally: Sempre executado, independentemente de ocorrer exceção ou não

try:
    arquivo = open("dados.txt", "r")
    conteudo = arquivo.read()
except FileNotFoundError:
    print("O arquivo não foi encontrado!")
else:
    # Executado se o arquivo for aberto com sucesso
    print(f"Conteúdo do arquivo:\n{conteudo}")
finally:
    # Executado sempre, garantindo que o arquivo seja fechado
    try:
        arquivo.close()
        print("Arquivo fechado com sucesso")
    except:
        # Caso o arquivo nem tenha sido aberto
        pass

Capturando informações da exceção

Você pode capturar e usar informações sobre a exceção:

try:
    idade = int(input("Digite sua idade: "))
    if idade < 0:
        raise ValueError("A idade não pode ser negativa")
except ValueError as erro:
    print(f"Erro: {erro}")

Conclusão

Começar a programar pode parecer desafiador, mas com os comandos certos e prática constante, o aprendizado se torna muito mais acessível e até divertido. Os 10 comandos apresentados aqui são apenas a ponta do iceberg, mas representam uma base sólida para quem está dando os primeiros passos com Python.

Dominar print(), input(), estruturas condicionais, loops, funções, coleções, manipulação de arquivos e tratamento de erros vai permitir que você crie programas úteis, dinâmicos e cada vez mais complexos. A cada nova linha de código, você estará mais preparado para explorar o vasto universo da programação.

Agora que você já conhece esses comandos essenciais, que tal dar o próximo passo na sua jornada?

💡 Se você quer aprender Python de forma completa, estruturada e com suporte personalizado, conheça o nosso Curso de Python Completo. São mais de 90 aulas do básico ao avançado, com projetos práticos, certificado reconhecido e acesso vitalício.

👉 Clique aqui e saiba mais sobre o curso!

Invista no seu conhecimento e abra novas portas no mundo da programação!

Bons estudos e boa codificação! 🚀🐍