Python é uma linguagem de programação de alto nível, interpretada, de tipagem dinâmica e forte, criada por Guido van Rossum e lançada em 1991. É amplamente utilizada em ciência de dados, automação, desenvolvimento web, inteligência artificial e ensino de programação. Além disso, para competições de programação, é a melhor opção depois do C++.
Um dos princípios centrais do Python é a legibilidade do código.
# Meu primeiro programa em Python print("Olá, mundo!") # Variáveis não precisam de declaração de tipo nome = "Python" versao = 3.12 print(f"Bem-vindo ao {nome} {versao}!")
Python possui diversos tipos de dados integrados. Os mais comuns são números, strings e booleanos.
10, -53.14, -0.01"Olá"True, FalseNoneInteiros em Python têm precisão arbitrária (limitada apenas pela memória). Podem ser representados em decimal, binário, octal ou hexadecimal.
x = 10 y = -42 grande = 10**100 # sem overflow! # Operações soma = x + y div_inteira = 10 // 3 # 3 resto = 10 % 3 # 1
Números reais seguem o padrão de 64 bits. Podem usar notação científica com e.
pi = 3.14159 gravidade = 9.8 nano = 1e-9 # Divisão sempre retorna float em Python 3 print(10 / 2) # 5.0
Strings são sequências imutáveis de caracteres Unicode. Podem ser criadas com aspas simples, duplas ou triplas (para múltiplas linhas).
s = "Python" multilinha = """Esta é uma string de várias linhas.""" # Métodos comuns print(s.upper()) # PYTHON print(s.replace("P", "J")) # Jython print(s[0:2]) # Py (slicing)
Representam valores lógicos: True ou False. Internamente, True vale 1 e False vale 0.
ativo = True logado = False # Operadores print(ativo and logado) # False print(ativo or logado) # True print(not ativo) # False
O None é um objeto especial que representa a ausência de valor. É o "null" do Python.
valor = None if valor is None: print("Nada aqui")
Python oferece quatro estruturas de dados nativas poderosas para organizar coleções de itens.
[1, 2, 2](1, 2, 2){"id": 1}{1, 2}Listas são coleções ordenadas e mutáveis. Permitem itens duplicados e de tipos diferentes.
frutas = ["maçã", "banana", "uva"] numeros = [1, 2, 3] mista = [1, "texto", True] # Métodos frutas.append("laranja") frutas.insert(0, "morango") frutas.pop() # remove o último frutas.sort() # ordena # List Comprehension (forma pythônica) quadrados = [x**2 for x in range(10)]
Tuplas são coleções ordenadas e imutáveis. São mais rápidas que listas e seguras para dados que não devem mudar.
ponto = (10, 20) cores = ("vermelho", "verde", "azul") # Desempacotamento (Unpacking) x, y = ponto # Tupla de um único elemento (precisa da vírgula) sozinho = (42,)
Dicionários armazenam pares chave → valor. A partir do Python 3.7, mantêm a ordem de inserção. As chaves devem ser imutáveis (strings, números, tuplas).
pessoa = {
"nome": "David",
"idade": 25,
"cidade": "São Paulo"
}
# Acesso
print(pessoa["nome"]) # David
print(pessoa.get("email", "N/A"))
# Modificação
pessoa["idade"] = 26
pessoa["email"] = "david@gmail.com"
# Iteração
for chave, valor in pessoa.items():
print(f"{chave}: {valor}")
# Dict comprehension
quadrados = {x: x**2 for x in range(5)}
Conjuntos armazenam elementos únicos e sem ordem definida. São ideais para eliminar duplicatas e realizar operações de teoria dos conjuntos.
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
# Operações de conjunto
print(a | b) # união → {1,2,3,4,5,6}
print(a & b) # interseção → {3,4}
print(a - b) # diferença → {1,2}
print(a ^ b) # diferença simétrica → {1,2,5,6}
# Remover duplicatas de uma lista
numeros = [1, 2, 2, 3, 3, 3]
unicos = list(set(numeros))
print(unicos) # [1, 2, 3] (ordem pode variar)
Python usa print() para saída no terminal e input() para leitura de dados do usuário.
# Saída básica print("Olá!") print("a", "b", sep="-") # a-b print("linha", end="") # sem quebra de linha # Entrada do usuário nome = input("Seu nome: ") print(f"Olá, {nome}!")
A função print() exibe valores no terminal. Aceita múltiplos argumentos e parâmetros opcionais sep, end e file.
# Formas de formatar saída nome = "Lucas" nota = 9.75 # f-string print(f"{nome} tirou {nota:.1f}") # .format() print("{} tirou {:.1f}".format(nome, nota)) # % é o legado, ou seja, o especificador de qual tipo de variável vai ser trabalhado. print("%s tirou %.1f" % (nome, nota)) # sep e end print(1, 2, 3, sep=" | ") # 1 | 2 | 3 print("sem newline", end=" → ")
input() Lê uma linha da entrada padrão e sempre retorna uma string. Para obter outros tipos, é necessário converter explicitamente.
# Leitura simples nome = input("Digite seu nome: ") # Convertendo para inteiro idade = int(input("Digite sua idade: ")) # Convertendo para float altura = float(input("Digite sua altura: ")) # Lendo vários valores na mesma linha a, b = map(int, input("Dois números: ").split()) # Com tratamento de erros try: n = int(input("Número inteiro: ")) except ValueError: print("Entrada inválida!")
Python utiliza if/elif/else para condicionais, for e while para laços, e o moderno match/case para correspondência de padrões.
Diferente de C, Python não usa chaves para delimitar blocos, ele usa indentação (geralmente 4 espaços).
Estrutura condicional do Python. Use elif para múltiplas condições (equivalente ao else if de outras linguagens). Não há parênteses obrigatórios na condição.
nota = 7.5 if nota >= 9: print("A") elif nota >= 7: print("B") elif nota >= 5: print("C") else: print("Reprovado") # Expressão condicional (ternário). O ternário é como um if simplificado e tem a mesma função. status = "aprovado" if nota >= 5 else "reprovado" # Operadores lógicos x = 15 if x > 0 and x % 2 == 1: print("positivo e ímpar")
O laço for do Python itera sobre qualquer objeto iterável (listas, strings, ranges, dicionários…). Use range() para laços baseados em contagem.
# Iterando sobre lista for fruta in ["maçã", "banana", "uva"]: print(fruta) # Com range for i in range(5): # 0 a 4 print(i) for i in range(1, 10, 2): # 1,3,5,7,9 print(i) # enumerate — índice + valor for i, v in enumerate(["a", "b", "c"]): print(i, v) # break e continue for n in range(10): if n == 3: continue # pula o 3 if n == 7: break # para no 7 print(n)
O laço while repete um bloco enquanto a condição for verdadeira. Python também suporta a cláusula else no while, executada quando a condição se torna falsa (sem break).
contador = 0 while contador < 5: print(contador) contador += 1 # Laço infinito com break while True: entrada = input("Digite 'sair': ") if entrada == "sair": break # while com else n = 0 while n < 3: print(n) n += 1 else: print("Laço concluído")
match/case é o structural pattern matching do Python, muito mais poderoso que o switch de outras linguagens. Permite comparar estruturas, tuplas, dicionários e mais.
comando = "sair" match comando: case "iniciar": print("Iniciando...") case "pausar": print("Pausado.") case "sair": print("Encerrando.") case _: print("Comando desconhecido") # Match com tuplas ponto = (0, 5) match ponto: case (0, 0): print("Origem") case (0, y): print(f"Eixo Y em {y}") case (x, 0): print(f"Eixo X em {x}") case (x, y): print()
Funções são definidas com a palavra-chave def. Python suporta parâmetros padrão, *args, **kwargs, anotações de tipo e funções de primeira classe.
def saudacao(nome, cumprimento="Olá"): return f"{cumprimento}, {nome}!" print(saudacao("Lucas")) print(saudacao("David", "Oi"))
Use def nome(parâmetros): para definir uma função. O corpo deve ser indentado. A docstring (string logo após o def) documenta a função.
def somar(a, b): """Retorna a soma de dois números.""" return a + b # Anotações de tipo (type hints) def potencia(base: float, exp: int) -> float: return base ** exp resultado = somar(3, 4) print(resultado) # 7 # Funções são objetos de primeira classe operacao = somar print(operacao(10, 5)) # 15
Python oferece grande flexibilidade na passagem de argumentos: parâmetros padrão, keyword arguments, *args (variádico posicional) e **kwargs (variádico nomeado).
# Valor padrão def conectar(host, porta=8080): print() conectar("localhost") # usa porta=8080 conectar("api.exemplo.com", 443) # *args — variádico posicional def somar_tudo(*nums): return sum(nums) print(somar_tudo(1, 2, 3, 4)) # 10 # **kwargs — variádico nomeado def info(**dados): for k, v in dados.items(): print() info(nome="Lucas", cidade="BH")
Funções lambda são funções anônimas de uma linha. Úteis quando se precisa de uma função simples como argumento (ex: sorted, map, filter).
# Lambda básica dobro = lambda x: x * 2 print(dobro(5)) # 10 # Como argumento de sorted pessoas = [("Lucas", 25), ("Ana", 30), ("Bia", 20)] ordenado = sorted(pessoas, key=lambda p: p[1]) print(ordenado) # ordena por idade # map e filter nums = [1, 2, 3, 4, 5] pares = list(filter(lambda x: x % 2 == 0, nums)) quadrados = list(map(lambda x: x**2, nums)) print(pares) # [2, 4] print(quadrados) # [1, 4, 9, 16, 25]
Funções em Python podem retornar qualquer objeto. O retorno de múltiplos valores é nativo — na verdade retorna uma tupla.
# Retorno simples def quadrado(x): return x ** 2 # Retorno múltiplo (tupla) def minmax(lista): return min(lista), max(lista) minimo, maximo = minmax([3, 1, 9, 2, 7]) print(minimo, maximo) # 1 9 # Função sem return → None def saudar(nome): print() resultado = saudar("David") print(resultado) # None