Introdução à programação usando Python Um guia introdutório com conceitos fundamentais, exemplos práticos para o Google Co...
Programar é a arte de comunicar instruções precisas a um computador para que ele execute tarefas específicas. Trata-se de um processo criativo e lógico que envolve a decomposição de problemas complexos em etapas menores e bem definidas, que a máquina é capaz de compreender e executar. Assim como um chef de cozinha segue uma receita, o programador descreve, passo a passo, o que o computador deve fazer.
A programação está presente em praticamente todos os aspectos da vida moderna: nos aplicativos de celular, nos sistemas bancários, nos veículos autônomos e até nos eletrodomésticos inteligentes. Aprender a programar, portanto, é desenvolver uma habilidade fundamental para o século XXI. Conforme aponta (MATTHES, 2019), a programação é uma das competências mais valorizadas no mercado de trabalho atual, e Python se destaca como uma das linguagens mais acessíveis para quem está começando.
Antes de escrever qualquer linha de código, o programador precisa planejar a solução do problema. Esse planejamento é expresso por meio de um algoritmo: uma sequência finita, ordenada e não ambígua de passos que, quando seguidos, conduzem à solução de um problema ou à realização de uma tarefa.
Um algoritmo pode ser representado de diversas formas: em linguagem natural (texto), por meio de fluxogramas (diagramas visuais) ou em pseudocódigo (uma notação intermediária entre a linguagem humana e a linguagem de programação). O infográfico abaixo ilustra a estrutura básica de um algoritmo na forma de fluxograma:
Todo algoritmo deve possuir três características essenciais: finitude (deve terminar após um número finito de passos), definição (cada passo deve ser precisamente definido) e efetividade (cada passo deve ser suficientemente básico para ser executado) (CORMEN et al., 2009).
Passos:
1. Leia o primeiro número (N1).
2. Leia o segundo número (N2).
3. Calcule a soma: SOMA = N1 + N2.
4. Calcule a média: MEDIA = SOMA / 2.
5. Exiba o valor de MEDIA.
6. Fim.
Os computadores só entendem a linguagem de máquina, composta por sequências de zeros e uns (código binário). Escrever programas diretamente em binário seria extremamente trabalhoso e propenso a erros. Por isso, foram criadas as linguagens de programação, que funcionam como uma camada de abstração entre o programador e a máquina.
As linguagens são classificadas conforme seu nível de abstração em relação ao hardware:
| Nível | Descrição | Exemplos |
|---|---|---|
| Baixo nível | Próximas ao hardware; difíceis de ler e escrever | Assembly, Linguagem de Máquina |
| Médio nível | Combinam características de alto e baixo nível | C, C++ |
| Alto nível | Próximas da linguagem humana; mais fáceis de aprender e usar | Python, Java, JavaScript, Ruby |
As linguagens de alto nível possuem uma sintaxe mais próxima da linguagem humana, o que facilita a leitura, a escrita e a manutenção do código. Python é um excelente exemplo de linguagem de alto nível, pois sua sintaxe limpa e expressiva permite que o programador se concentre na resolução do problema, e não nos detalhes técnicos do hardware (PAIVA, 2021).
Python é uma linguagem de programação de propósito geral criada por Guido van Rossum e lançada em 1991. Seu nome é uma homenagem ao grupo de comédia britânico Monty Python. Desde então, Python cresceu exponencialmente em popularidade, tornando-se uma das linguagens mais utilizadas no mundo, com aplicações que vão do desenvolvimento web à inteligência artificial (MATTHES, 2019).
Conforme (PAIVA, 2021), Python é uma linguagem de programação de alto nível, interpretada, imperativa, orientada a objetos, funcional, de tipagem dinâmica e forte. Cada uma dessas características será explorada ao longo deste artigo.
Por tradição, o primeiro programa que se escreve em qualquer linguagem exibe a mensagem "Olá, Mundo!" na tela. Em Python, isso é feito com apenas uma linha:
# Meu primeiro programa em Python
print("Olá, Mundo!")
print("Bem-vindo ao universo da programação com Python!")Olá, Mundo!
Bem-vindo ao universo da programação com Python!
Uma das primeiras distinções importantes no estudo das linguagens de programação diz respeito à forma como o código-fonte é traduzido para a linguagem que o computador entende. Existem dois modelos principais: a compilação e a interpretação.
Figura 3 — Comparação entre o processo de compilação e interpretação. Fonte: elaborado pelo autor.
Em uma linguagem compilada, o código-fonte é traduzido integralmente para código de máquina por um programa chamado compilador, antes de ser executado. O resultado é um arquivo executável independente. Esse processo é mais rápido em tempo de execução, pois a tradução já foi feita. Exemplos: C, C++ e, em parte, Java (que compila para bytecode).
Em uma linguagem interpretada, o código-fonte é lido e executado linha por linha por um programa chamado interpretador, em tempo de execução. Isso torna o processo de desenvolvimento mais ágil, pois não é necessário compilar o programa a cada alteração. Python é uma linguagem interpretada, o que facilita a experimentação e o aprendizado (PAIVA, 2021).
.pyc), que é então executado pela Python Virtual Machine (PVM). Esse processo é transparente para o programador e ocorre automaticamente, combinando aspectos de compilação e interpretação para otimizar o desempenho (MATTHES, 2019).
| Característica | Compilada | Interpretada (Python) |
|---|---|---|
| Tradução | Antes da execução (toda de uma vez) | Durante a execução (linha a linha) |
| Velocidade de execução | Geralmente mais rápida | Pode ser mais lenta |
| Portabilidade | Executável depende do SO/hardware | Código roda em qualquer SO com o interpretador |
| Depuração | Erros apontados na compilação | Erros detectados em tempo de execução |
| Exemplos | C, C++, Rust | Python, Ruby, JavaScript |
Python possui um sistema de tipos com duas características fundamentais que todo iniciante precisa compreender: a tipagem dinâmica e a tipagem forte.
Em Python, você não precisa declarar o tipo de uma variável ao criá-la. O tipo é inferido automaticamente pelo interpretador com base no valor atribuído, e pode mudar ao longo da execução do programa. Isso contrasta com linguagens de tipagem estática, como C ou Java, onde o tipo deve ser declarado explicitamente e não pode ser alterado (PAIVA, 2021).
# Tipagem dinâmica: o tipo muda conforme o valor atribuído
x = 10
print(type(x)) # <class 'int'>
x = "Python"
print(type(x)) # <class 'str'>
x = 3.14
print(type(x)) # <class 'float'>Apesar de dinâmica, a tipagem em Python é forte: o interpretador não realiza conversões implícitas entre tipos incompatíveis. Isso significa que tentar somar um número com uma string, por exemplo, gera um erro (TypeError), ao contrário do que ocorre em linguagens de tipagem fraca, como JavaScript. Essa característica torna o código Python mais previsível e seguro (MATTHES, 2019).
# Tipagem forte: sem conversão implícita entre tipos incompatíveis
numero = 5
texto = "3"
# A linha abaixo causaria um TypeError:
# resultado = numero + texto # ERRO!
# A conversão deve ser explícita:
resultado = numero + int(texto) # Converte "3" para 3
print(resultado) # Saída: 8
resultado_texto = str(numero) + texto # Converte 5 para "5"
print(resultado_texto) # Saída: "53"Uma variável é um espaço nomeado na memória do computador onde um valor pode ser armazenado, recuperado e modificado durante a execução de um programa. Em Python, uma variável é criada no momento em que um valor é atribuído a ela, sem necessidade de declaração prévia de tipo (SWEIGART, 2020).
O operador de atribuição em Python é o sinal de igual (=). O nome da variável fica à esquerda e o valor a ser armazenado, à direita. Os nomes de variáveis devem seguir algumas regras: começar com uma letra ou sublinhado (_), não conter espaços e não ser palavras reservadas da linguagem (como if, for, print).
# Criando e usando variáveis em Python
nome = "Ana" # variável do tipo str
idade = 25 # variável do tipo int
altura = 1.68 # variável do tipo float
estudante = True # variável do tipo bool
print("Nome:", nome)
print("Idade:", idade)
print("Altura:", altura)
print("É estudante?", estudante)
# Atribuição múltipla
a, b, c = 1, 2, 3
print(a, b, c) # Saída: 1 2 3
# Verificando o tipo de uma variável
print(type(nome)) # <class 'str'>
print(type(idade)) # <class 'int'>nome_completo, ano_nascimento, total_vendas. Evite nomes genéricos como x ou a em programas reais — prefira nomes descritivos que indiquem o propósito da variável.
Os tipos primitivos são os blocos de construção fundamentais de qualquer programa. Em Python, os quatro tipos primitivos principais são: int, float, str e bool. Cada um representa uma categoria diferente de informação (MATTHES, 2019).
| Tipo | Nome | Descrição | Exemplos |
|---|---|---|---|
int |
Inteiro | Números inteiros, positivos ou negativos, sem parte decimal | 42, -10, 0 |
float |
Ponto Flutuante | Números reais com parte decimal (ponto flutuante) | 3.14, -0.5, 2.0 |
str |
String (Cadeia de Caracteres) | Sequência de caracteres (texto), delimitada por aspas simples ou duplas | "Olá", 'Python' |
bool |
Booleano | Valor lógico: verdadeiro (True) ou falso (False) |
True, False |
# Explorando os tipos primitivos em Python
# int: números inteiros
populacao_brasil = 215000000
temperatura_minima = -5
print(type(populacao_brasil)) # <class 'int'>
# float: números com decimais
pi = 3.14159
preco = 29.90
print(type(pi)) # <class 'float'>
# str: texto (strings)
linguagem = "Python"
mensagem = 'Aprender a programar é incrível!'
print(type(linguagem)) # <class 'str'>
print(len(linguagem)) # 6 (número de caracteres)
# bool: valores lógicos
aprovado = True
reprovado = False
print(type(aprovado)) # <class 'bool'>
# Conversão entre tipos (casting)
numero_str = "42"
numero_int = int(numero_str) # str → int
numero_float = float(numero_str) # str → float
print(numero_int, numero_float) # 42 42.0Os operadores são símbolos especiais que realizam operações sobre valores e variáveis (chamados de operandos). Python oferece quatro categorias principais de operadores, cada uma com uma finalidade específica (SWEIGART, 2020).
Realizam operações matemáticas sobre valores numéricos (int e float).
| Operador | Operação | Exemplo | Resultado |
|---|---|---|---|
+ | Adição | 10 + 3 | 13 |
- | Subtração | 10 - 3 | 7 |
* | Multiplicação | 10 * 3 | 30 |
/ | Divisão real | 10 / 3 | 3.333... |
// | Divisão inteira | 10 // 3 | 3 |
% | Módulo (resto) | 10 % 3 | 1 |
** | Potenciação | 2 ** 8 | 256 |
# Operadores Aritméticos
a = 10
b = 3
print("Adição:", a + b) # 13
print("Subtração:", a - b) # 7
print("Multiplicação:", a * b) # 30
print("Divisão real:", a / b) # 3.3333...
print("Divisão inteira:", a // b) # 3
print("Módulo (resto):", a % b) # 1
print("Potenciação:", 2 ** 8) # 256
# Exemplo prático: calcular área de um círculo
import math
raio = 5
area = math.pi * raio ** 2
print(f"Área do círculo: {area:.2f}") # 78.54Comparam dois valores e retornam um resultado booleano (True ou False). São amplamente utilizados em estruturas de decisão (if) e de repetição (while).
# Operadores Relacionais
x = 10
y = 5
print(x == y) # False (igual a)
print(x != y) # True (diferente de)
print(x > y) # True (maior que)
print(x < y) # False (menor que)
print(x >= y) # True (maior ou igual a)
print(x <= y) # False (menor ou igual a)
# Comparando strings
print("Python" == "python") # False (case-sensitive)
print("abc" < "abd") # True (ordem lexicográfica)Combinam expressões booleanas e retornam um valor booleano. São essenciais para criar condições compostas em estruturas de controle.
# Operadores Lógicos: and, or, not
p = True
q = False
# and: verdadeiro somente se AMBOS forem verdadeiros
print(p and q) # False
print(p and p) # True
# or: verdadeiro se PELO MENOS UM for verdadeiro
print(p or q) # True
print(q or q) # False
# not: inverte o valor lógico
print(not p) # False
print(not q) # True
# Exemplo prático: verificar se um número está em um intervalo
numero = 15
em_intervalo = numero >= 10 and numero <= 20
print("Está entre 10 e 20?", em_intervalo) # TrueCombinam uma operação aritmética com a atribuição, tornando o código mais conciso. Por exemplo, x += 5 é equivalente a x = x + 5.
# Operadores de Atribuição Compostos
contador = 10
contador += 5 # equivale a: contador = contador + 5
print(contador) # 15
contador -= 3 # equivale a: contador = contador - 3
print(contador) # 12
contador *= 2 # equivale a: contador = contador * 2
print(contador) # 24
contador //= 4 # equivale a: contador = contador // 4
print(contador) # 6
contador **= 2 # equivale a: contador = contador ** 2
print(contador) # 36
contador %= 5 # equivale a: contador = contador % 5
print(contador) # 1Quando uma expressão contém múltiplos operadores, Python segue uma ordem de avaliação chamada precedência de operadores, análoga à ordem de operações matemáticas. Operadores com maior precedência são avaliados primeiro. Parênteses () sempre têm a maior precedência e podem ser usados para forçar uma ordem específica de avaliação (MATTHES, 2019).
| Prioridade | Operador(es) | Descrição |
|---|---|---|
| 1 (maior) | () | Parênteses |
| 2 | ** | Potenciação |
| 3 | +x, -x | Sinal positivo/negativo (unário) |
| 4 | *, /, //, % | Multiplicação, divisão, módulo |
| 5 | +, - | Adição, subtração |
| 6 | ==, !=, >, <, >=, <= | Comparação |
| 7 | not | Negação lógica |
| 8 | and | E lógico |
| 9 (menor) | or | OU lógico |
# Precedência de Operadores
# Sem parênteses: * antes de +
resultado1 = 2 + 3 * 4
print(resultado1) # 14 (3*4=12, depois 2+12=14)
# Com parênteses: altera a ordem
resultado2 = (2 + 3) * 4
print(resultado2) # 20 (2+3=5, depois 5*4=20)
# Potenciação antes de multiplicação
resultado3 = 2 * 3 ** 2
print(resultado3) # 18 (3**2=9, depois 2*9=18)
# Expressão mista com operadores lógicos e relacionais
x = 10
resultado4 = x > 5 and x < 20
print(resultado4) # True
# Dica: use parênteses para deixar o código mais legível!
resultado5 = (x > 5) and (x < 20)
print(resultado5) # True (mesmo resultado, mais legível)input()Um programa se torna muito mais útil quando pode receber informações do usuário durante sua execução. Em Python, a função input() permite que o programa pause e aguarde que o usuário digite algo no teclado. O valor digitado é lido como uma string (str), independentemente do que for digitado (SWEIGART, 2020).
input() sempre retorna uma string. Se você precisar usar o valor digitado como número, é necessário convertê-lo explicitamente usando int() ou float(). Esquecer essa conversão é um dos erros mais comuns entre iniciantes.
# Entrada de Dados com input()
# Lendo um texto
nome = input("Qual é o seu nome? ")
print("Olá,", nome + "! Seja bem-vindo(a) ao Python!")
# Lendo um número inteiro
idade = int(input("Qual é a sua idade? "))
print("Daqui a 10 anos você terá", idade + 10, "anos.")
# Lendo um número decimal
altura = float(input("Qual é a sua altura em metros? "))
print(f"Sua altura é {altura:.2f} metros.")
# Calculando a média de duas notas
nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
media = (nota1 + nota2) / 2
print(f"Sua média é: {media:.1f}")print()A função print() é a principal forma de exibir informações na tela em Python. Ela aceita um ou mais argumentos separados por vírgula e os exibe na saída padrão (normalmente o terminal ou o console do Colab). A função print() possui parâmetros opcionais que permitem personalizar a saída (MATTHES, 2019).
# Saída de Dados com print()
# Uso básico
print("Olá, Mundo!")
# Múltiplos argumentos (separados por espaço por padrão)
nome = "Carlos"
idade = 22
print("Nome:", nome, "| Idade:", idade)
# Parâmetro sep: define o separador entre os argumentos
print("Python", "é", "incrível", sep="-") # Python-é-incrível
# Parâmetro end: define o que vem ao final (padrão é \n)
print("Linha 1", end=" | ")
print("Linha 2") # Linha 1 | Linha 2
# f-strings: a forma mais moderna e legível de formatar saída
produto = "Notebook"
preco = 3499.90
quantidade = 2
total = preco * quantidade
print(f"Produto: {produto}")
print(f"Preço unitário: R$ {preco:.2f}")
print(f"Quantidade: {quantidade}")
print(f"Total: R$ {total:.2f}") # Total: R$ 6999.80Para consolidar todos os conceitos estudados, veja a seguir um exemplo prático que combina entrada de dados, variáveis, tipos, operadores e saída de dados para calcular o Índice de Massa Corporal (IMC):
# ================================================
# Calculadora de IMC - Exemplo Integrador
# Conceitos: input, print, variáveis, tipos,
# operadores aritméticos e relacionais
# ================================================
# Entrada de dados
nome = input("Digite seu nome: ")
peso = float(input("Digite seu peso em kg: "))
altura = float(input("Digite sua altura em metros: "))
# Cálculo do IMC: peso / altura²
imc = peso / (altura ** 2)
# Saída de dados formatada
print(f"\n--- Resultado para {nome} ---")
print(f"Peso: {peso:.1f} kg")
print(f"Altura: {altura:.2f} m")
print(f"IMC: {imc:.2f}")
# Classificação (usando operadores relacionais e lógicos)
if imc < 18.5:
classificacao = "Abaixo do peso"
elif imc < 25.0:
classificacao = "Peso normal"
elif imc < 30.0:
classificacao = "Sobrepeso"
else:
classificacao = "Obesidade"
print(f"Classificação: {classificacao}")Ao longo deste artigo, percorremos os conceitos fundamentais do ensino introdutório de programação com Python. Partimos da definição de programação e algoritmo, passamos pela compreensão das linguagens de alto nível, interpretadas e compiladas, e exploramos as características de tipagem dinâmica e forte do Python. Em seguida, colocamos a mão na massa com variáveis, tipos primitivos, operadores, precedência de operadores, entrada e saída de dados.
Python, com sua sintaxe clara e expressiva, é uma porta de entrada excelente para o mundo da programação. Os exemplos apresentados foram projetados para serem executados no Google Colab, uma ferramenta gratuita e acessível que elimina a necessidade de instalação de qualquer software. O próximo passo natural é explorar as estruturas de controle de fluxo (condicionais e laços de repetição), que permitirão criar programas ainda mais poderosos e interessantes.
Comentários