2. Seus Primeiros Programas em Python

No Capítulo 1, você aprendeu como instalar o Python, usar o shell interativo (REPL) e executar arquivos de script simples. Você também teve seu primeiro contato com erros e tracebacks. Agora é hora de escrever seus primeiros programas reais em Python—programas que exibem informações, aceitam entrada de usuários e produzem resultados significativos.

Este capítulo apresenta os blocos de construção fundamentais que você vai usar em praticamente todo programa Python que escrever: a função print() para exibir saída, comentários para documentar seu código, variáveis para armazenar dados, e a função input() para obter informações dos usuários. Ao final deste capítulo, você será capaz de criar programas interativos simples, porém completos, que seguem o clássico padrão entrada-processamento-saída.

2.1) Imprimindo Texto com a função print()

A função print() é uma das ferramentas mais essenciais do Python. Ela exibe texto (e outras informações) na tela, permitindo que seus programas se comuniquem com os usuários. Você já viu print() rapidamente no Capítulo 1, mas agora vamos explorá-la em profundidade.

2.1.1) Impressão Básica

Na sua forma mais simples, print() exibe texto colocado entre aspas. Vamos criar um arquivo de script para ver como isso funciona:

# hello.py
print("Hello, World!")

Quando você executa esse script, o Python exibe:

Hello, World!

O texto dentro das aspas—"Hello, World!"—é chamado de string. Uma string é uma sequência de caracteres (letras, números, símbolos, espaços) que o Python trata como texto. Vamos explorar strings com muito mais detalhes no Capítulo 5, mas por enquanto, pense nelas como a forma de representar texto em Python.

Você pode imprimir qualquer texto que quiser colocando-o entre aspas:

# greetings.py
print("Welcome to Python programming!")
print("This is your first real program.")
print("Python makes programming fun and accessible.")

Saída:

Welcome to Python programming!
This is your first real program.
Python makes programming fun and accessible.

Perceba que cada instrução print() produz saída em uma linha separada. O Python adiciona automaticamente uma quebra de linha (newline) após cada chamada de print(), movendo o cursor para a próxima linha.

2.1.2) Imprimindo Vários Itens

A função print() pode exibir vários itens em uma única chamada, separando-os com vírgulas:

# multiple_items.py
print("Python", "is", "awesome!")
print("I", "am", "learning", "to", "code")

Saída:

Python is awesome!
I am learning to code

Quando você separa itens com vírgulas, print() insere automaticamente um espaço entre eles. Isso é conveniente para combinar vários pedaços de texto sem precisar adicionar espaços manualmente.

Você também pode misturar tipos diferentes de dados. Por exemplo, pode imprimir texto e números:

# mixed_output.py
print("The answer is", 42)
print("Python version", 3.12, "is powerful")

Saída:

The answer is 42
Python version 3.12 is powerful

O Python converte automaticamente números em texto ao imprimi-los, então você não precisa se preocupar com os detalhes técnicos ainda. Vamos aprender mais sobre tipos de dados diferentes no Capítulo 3.

2.1.3) Aspas Simples vs Duplas

O Python aceita tanto aspas simples (') quanto aspas duplas (") para strings. Elas são completamente intercambiáveis para texto simples:

# quotes.py
print("This uses double quotes")
print('This uses single quotes')
print("Both work exactly the same way")

Saída:

This uses double quotes
This uses single quotes
Both work exactly the same way

No entanto, as aspas se tornam importantes quando seu texto contém apóstrofos ou aspas. Se o seu texto contiver um apóstrofo (que é o mesmo caractere que uma aspa simples), use aspas duplas para envolvê-lo:

# apostrophes.py
print("It's a beautiful day!")
print("Python's syntax is clean")

Saída:

It's a beautiful day!
Python's syntax is clean

Se você tentasse usar aspas simples aqui, o Python ficaria confuso:

# This causes an error:
print('It's a beautiful day!')  # Error! Python sees three separate quotes

O erro ocorre porque o Python vê o apóstrofo em "It's" como o fim da string, deixando "s a beautiful day!" como código inválido.

Da mesma forma, se o seu texto contiver aspas duplas, use aspas simples para envolvê-lo:

# quotations.py
print('She said, "Hello!"')
print('The book is called "Python Basics"')

Saída:

She said, "Hello!"
The book is called "Python Basics"

Diretriz prática: Escolha um estilo (aspas simples ou duplas) e use-o consistentemente em todo o seu código. A maioria dos programadores Python prefere aspas duplas para strings comuns, mas qualquer escolha é válida. Mude para o outro estilo apenas quando o seu texto contiver o caractere de aspa que você normalmente usa.

2.1.4) Imprimindo Linhas Vazias

Às vezes você quer adicionar linhas em branco à sua saída para deixá-la mais legível. Você pode fazer isso chamando print() sem argumentos:

# spacing.py
print("First section of output")
print("More information here")
print()  # Empty line
print("Second section of output")
print("This is separated from the first section")

Saída:

First section of output
More information here
 
Second section of output
This is separated from the first section

A chamada vazia de print() cria uma linha em branco, tornando a saída mais fácil de ler ao separar visualmente seções diferentes.

2.1.5) Caracteres Especiais em Strings

Às vezes você precisa incluir caracteres especiais na sua saída que não pode digitar diretamente ou que têm significado especial no Python. Por exemplo, como criar uma quebra de linha no meio de uma string? Ou incluir uma tabulação para alinhamento? O Python fornece sequências de escape—combinações especiais de dois caracteres que começam com uma barra invertida (\)—para representar esses caracteres.

Essas sequências de escape são particularmente úteis quando você precisa formatar a saída de maneiras específicas—criando mensagens com múltiplas linhas, alinhando colunas de dados ou trabalhando com caminhos de arquivos no Windows. Você vai usar \n com frequência à medida que escrever mais programas.

A sequência de escape mais comum é \n, que representa uma nova linha (quebra de linha):

# newlines.py
print("First line\nSecond line\nThird line")

Saída:

First line
Second line
Third line

O \n diz ao Python para ir para uma nova linha naquele ponto da string. Isso é útil quando você quer criar múltiplas linhas de saída com uma única instrução print().

Outra sequência de escape útil é \t, que representa uma tabulação (espaçamento horizontal):

# tabs.py
print("Name:\tJohn")
print("Age:\t25")
print("City:\tNew York")

Saída:

Name:	John
Age:	25
City:	New York

O \t cria um espaçamento consistente, alinhando os valores em um formato semelhante a uma coluna.

Se você precisar incluir uma barra invertida real na sua saída, use \\:

# backslash.py
print("The file path is C:\\Users\\Documents")

Saída:

The file path is C:\Users\Documents

Vamos explorar sequências de escape e manipulação de strings com muito mais profundidade no Capítulo 5. Por enquanto, basta saber que \n cria novas linhas e \t cria tabulações.

2.2) Usando Comentários para Explicar Código

À medida que seus programas ficam mais complexos, torna-se importante explicar o que seu código faz—tanto para outras pessoas que possam lê-lo quanto para o seu eu do futuro. O Python fornece comentários para esse propósito: anotações no seu código que o Python ignora completamente ao executar o programa.

2.2.1) Comentários de Uma Linha

No Python, qualquer texto após o símbolo # em uma linha é um comentário. O Python ignora tudo do # até o fim daquela linha:

# comment_example.py
# This is a comment. Python ignores this line completely.
print("This line runs")  # This comment explains the print statement
# print("This line does NOT run because it's commented out")
print("This line also runs")

Saída:

This line runs
This line also runs

Perceba que a segunda instrução print() não foi executada porque a linha inteira foi comentada. Isso é útil quando você quer desabilitar código temporariamente sem apagá-lo.

Comentários podem aparecer em uma linha própria ou ao final de uma linha de código. Ambos os estilos são comuns:

# display_info.py
# Display a welcome message to the user
print("Welcome to the program!")
 
print("Processing data...")  # Inform the user of progress

2.2.2) Quando e Como Escrever Bons Comentários

Comentários devem explicar por que você está fazendo algo, não apenas o que o código faz. Aqui está um exemplo de comentário ruim:

# Bad comment - just repeats what the code obviously does
print("Hello")  # Print "Hello"

Esse comentário não adiciona nenhum valor porque qualquer pessoa lendo o código já pode ver que ele imprime "Hello".

Aqui está uma abordagem melhor:

# Good comment - explains the purpose or context
# Greet the user before requesting their information
print("Hello")

Esse comentário explica por que estamos imprimindo "Hello"—isso faz parte de uma interação maior com o usuário.

Diretrizes para escrever comentários úteis:

1. Explique o propósito: Por que esse código existe? Que problema ele resolve?
2. Esclareça lógica complexa: Se algo não for imediatamente óbvio, explique
3. Registre decisões importantes: Explique por que você escolheu uma abordagem em vez de outra
4. Avise sobre pegadinhas: Aponte qualquer coisa que possa ser confusa ou inesperada
5. Mantenha-os atualizados: Atualize os comentários quando mudar o código

Aqui está um exemplo mostrando comentários eficazes:

# temperature_converter.py
# This program converts temperatures from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
# Display program title
print("Temperature Converter")
print("Fahrenheit to Celsius")
print()
 
# We'll learn how to get user input in section 2.4
# For now, we'll use a fixed temperature value
fahrenheit = 75  # Temperature in Fahrenheit to convert
 
# Perform the conversion using the standard formula
# Subtract 32 first (order matters due to the formula)
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print("Temperature:", fahrenheit, "°F =", celsius, "°C")

Saída:

Temperature Converter
Fahrenheit to Celsius
 
Temperature: 75 °F = 23.88888888888889 °C

Perceba como os comentários explicam o propósito do programa, a fórmula usada e a lógica por trás do cálculo. Eles tornam o código muito mais fácil de entender, especialmente para alguém que o vê pela primeira vez.

2.2.3) Comentários de Múltiplas Linhas e Docstrings

Para explicações mais longas, você pode usar vários comentários de uma linha:

# multi_line_comments.py
# This program demonstrates a longer explanation
# that spans multiple lines. Each line starts
# with a # symbol.
print("Program starts here")

O Python não tem uma sintaxe especial para comentários de múltiplas linhas como algumas outras linguagens. No entanto, existe uma abordagem alternativa usando strings entre aspas triplas. Vamos aprender mais sobre isso no Capítulo 19 quando discutirmos docstrings (strings de documentação para funções), mas aqui vai um prévia:

# docstring_preview.py
"""
This is a multi-line string that can serve as a comment.
It's not technically a comment—it's a string that Python
creates but doesn't use. However, it's often used for
longer explanations at the beginning of files.
"""
print("Program starts here")

Por enquanto, fique com # para comentários. Vamos explorar strings entre aspas triplas e seus usos adequados em capítulos posteriores.

2.2.4) Comentando Código para Testes

Comentários também são úteis para desabilitar código temporariamente enquanto você testa:

# testing.py
print("This always runs")
# print("This is disabled for testing")
print("This also always runs")

Essa técnica é chamada de "comentar" código. Ela é útil quando você quer testar como o programa se comporta sem determinadas linhas, mas não quer apagá-las permanentemente.

2.3) Introdução a Variáveis e Atribuição (Prévia)

Programas se tornam muito mais úteis quando podem armazenar e manipular dados. Variáveis são contêineres nomeados que guardam valores. Pense em uma variável como uma caixa etiquetada onde você pode guardar informações e recuperá-las depois.

Nota importante: Esta seção fornece uma prévia de variáveis para ajudar você a entender os exemplos deste capítulo. Vamos explorar variáveis em profundidade no Capítulo 3, incluindo regras de nomenclatura, tipos de dados e como o Python lida com variáveis internamente. Por enquanto, vamos focar no conceito básico e no uso.

2.3.1) Criando Variáveis com Atribuição

Você cria uma variável usando o operador de atribuição (=). O padrão básico é:

variable_name = value

O nome da variável vai à esquerda, o valor vai à direita e o = conecta os dois:

# variables_basic.py
message = "Hello, Python!"
print(message)

Saída:

Hello, Python!

Veja o que acontece:

1. O Python cria uma variável chamada message
2. O Python armazena a string "Hello, Python!" nessa variável
3. Quando usamos message na função print(), o Python recupera o valor armazenado e o exibe

Variáveis podem armazenar diferentes tipos de dados. Aqui estão alguns exemplos:

# variable_types.py
greeting = "Welcome!"  # A string (text)
age = 25  # A number (integer)
price = 19.99  # A number with a decimal point (float)
is_student = True  # A boolean (True or False)
 
print(greeting)
print(age)
print(price)
print(is_student)

Saída:

Welcome!
25
19.99
True

Vamos aprender sobre esses tipos de dados diferentes (strings, inteiros, floats, booleanos) no Capítulo 3. Por enquanto, basta entender que variáveis podem guardar vários tipos de informação.

2.3.2) Por que Variáveis São Úteis

Variáveis tornam seu código mais flexível e mais fácil de manter. Compare estas duas abordagens:

Sem variáveis:

# no_variables.py
print("Welcome, John!")
print("John, your account balance is $1000")
print("Thank you for banking with us, John!")

Com variáveis:

# with_variables.py
name = "John"
balance = 1000
 
print("Welcome,", name + "!")
print(name, "your account balance is $", balance)
print("Thank you for banking with us,", name + "!")

Ambos os programas produzem uma saída semelhante, mas a versão com variáveis tem vantagens significativas:

1. Atualizações fáceis: Para mudar o nome, você só precisa alterar uma linha (name = "John") em vez de três
2. Menos erros: Você não corre o risco de digitar o nome errado em um dos lugares
3. Mais flexível: Você pode, mais tarde, mudar como name recebe seu valor (por exemplo, perguntando ao usuário)

2.3.3) Reatribuindo Variáveis

Variáveis podem mudar de valor durante a execução do programa. Isso é chamado de reatribuição:

# reassignment.py
score = 0
print("Initial score:", score)
 
score = 10
print("After first update:", score)
 
score = 25
print("After second update:", score)

Saída:

Initial score: 0
After first update: 10
After second update: 25

Cada vez que você atribui um novo valor a uma variável, o Python substitui o valor antigo pelo novo. O valor anterior é descartado.

Você pode até usar o valor atual de uma variável para calcular seu novo valor:

# updating_values.py
count = 5
print("Starting count:", count)
 
count = count + 1  # Add 1 to count
print("After adding 1:", count)
 
count = count + 10  # Add 10 to count
print("After adding 10:", count)

Saída:

Starting count: 5
After adding 1: 6
After adding 10: 16

Esse padrão—count = count + 1—é extremamente comum em programação. Ele significa "pegue o valor atual de count, some 1 a ele e armazene o resultado de volta em count". Vamos aprender uma forma abreviada disso (count += 1) no Capítulo 4.

2.3.4) Prévia sobre Nomes de Variáveis

Nomes de variáveis em Python devem seguir certas regras:

• Podem conter letras, números e underlines (_)
• Devem começar com uma letra ou underline (não com número)
• Não podem conter espaços ou caracteres especiais como @, $, %, etc.
• Não podem ser palavras-chave do Python (palavras reservadas como print, if, for, etc.)

Aqui estão alguns nomes de variáveis válidos:

# valid_names.py
user_name = "Alice"
age2 = 30
_private_value = 42
totalPrice = 99.99

E alguns nomes inválidos:

# These cause errors:
# 2age = 30  # Cannot start with a number
# user-name = "Alice"  # Cannot contain hyphens
# total price = 99.99  # Cannot contain spaces
# print = "Hello"  # Cannot use Python keywords

Boa prática: Use nomes descritivos que expliquem o que a variável representa. user_age é melhor do que a, e total_price é melhor do que tp. Vamos discutir convenções de nomenclatura em detalhes no Capítulo 3.

2.3.5) Variáveis Tornam Programas Dinâmicos

O verdadeiro poder das variáveis aparece quando você as usa para tornar programas mais dinâmicos:

# dynamic_greeting.py
name = "Alice"
age = 28
city = "Seattle"
 
print("Personal Information")
print("====================")
print("Name:", name)
print("Age:", age)
print("City:", city)
print()
print("Summary:", name, "is", age, "years old and lives in", city)

Saída:

Personal Information
====================
Name: Alice
Age: 28
City: Seattle
 
Summary: Alice is 28 years old and lives in Seattle

Ao mudar os valores de name, age e city no início do programa, você pode personalizar toda a saída sem modificar as instruções print(). Essa separação de dados e lógica é um princípio fundamental de boa programação.

Olhando para frente: No Capítulo 3, vamos explorar variáveis de forma abrangente, incluindo tipos de dados, conversão de tipos, regras de nomenclatura e como o Python gerencia variáveis internamente. Por enquanto, você já tem entendimento suficiente para usar variáveis em programas simples.

2.4) Lendo Entrada do Teclado com input()

Até agora, todos os dados em nossos programas estavam fixos no código—escritos diretamente nele. Mas programas reais muitas vezes precisam interagir com usuários, aceitando informações que eles fornecem. A função input() do Python torna isso possível.

2.4.1) Entrada Básica

A função input() exibe uma mensagem (chamada de prompt) e espera o usuário digitar algo e pressionar Enter. Aqui está o padrão básico:

# basic_input.py
name = input("What is your name? ")
print("Hello,", name + "!")

Quando você executa esse programa, acontece o seguinte:

What is your name? Alice
Hello, Alice!

Vamos decompor isso:

1. O Python executa input("What is your name? ")
2. O Python exibe o prompt: What is your name?
3. O programa pausa e espera o usuário digitar algo
4. O usuário digita Alice e pressiona Enter
5. O Python armazena o texto "Alice" na variável name
6. O programa continua, imprimindo a saudação

O texto que você fornece para input() é o prompt—o que o usuário vê antes de digitar. Sempre inclua um espaço no final do prompt (perceba o espaço depois do ponto de interrogação) para separar o prompt da entrada do usuário, deixando tudo mais legível.

2.4.2) input Sempre Retorna uma String

Isso é crucial: input() sempre retorna uma string, mesmo que o usuário digite números:

# input_as_string.py
age = input("How old are you? ")
print("You entered:", age)
print("The type is:", type(age))

Quando você executa isso e digita 25:

How old are you? 25
You entered: 25
The type is: <class 'str'>

Mesmo que o usuário tenha digitado 25, o Python armazena isso como a string "25", não como o número 25. A função type() confirma isso—ela mostra que age é uma string (str), não um inteiro.

Isso é importante quando você quer fazer cálculos. Você não pode fazer operações matemáticas diretamente com strings:

# This causes an error:
age = input("How old are you? ")
next_year_age = age + 1  # Error! Can't add a number to a string

Isso produz um erro porque o Python não sabe como somar o número 1 com a string "25".

2.4.3) Convertendo Entrada para Números

Para usar a entrada como número, você deve convertê-la explicitamente usando int() (para números inteiros) ou float() (para números decimais):

# input_conversion.py
age_string = input("How old are you? ")
age = int(age_string)  # Convert string to integer
 
next_year = age + 1
print("Next year, you will be", next_year, "years old")

Quando você executa isso e digita 25:

How old are you? 25
Next year, you will be 26 years old

Você também pode combinar a entrada e a conversão em uma única linha:

# input_conversion_compact.py
age = int(input("How old are you? "))
next_year = age + 1
print("Next year, you will be", next_year, "years old")

Isso é mais conciso e é o estilo que você verá com mais frequência. Ele funciona de dentro para fora:

1. input("How old are you? ") obtém a entrada do usuário como string
2. int(...) converte essa string em inteiro
3. O inteiro é armazenado na variável age

Aqui está um exemplo usando float() para números decimais:

# float_input.py
price = float(input("Enter the price: $"))
tax_rate = 0.08
tax = price * tax_rate
total = price + tax
 
print("Price: $", price)
print("Tax: $", tax)
print("Total: $", total)

Quando você executa isso e digita 19.99:

Enter the price: $19.99
Price: $ 19.99
Tax: $ 1.5992
Total: $ 21.5892

Importante: Se o usuário digitar um texto que não possa ser convertido em número, o Python vai gerar um erro. Por exemplo, se você usar int(input("Enter a number: ")) e o usuário digitar "hello", o Python não consegue converter "hello" em inteiro e exibirá uma mensagem de erro. Vamos aprender como lidar com essas situações de forma elegante no Capítulo 27, quando estudarmos tratamento de exceções.

2.4.4) Entradas Múltiplas

Programas frequentemente precisam de várias informações do usuário. Basta chamar input() múltiplas vezes:

# multiple_inputs.py
print("Please enter your information:")
print()
 
first_name = input("First name: ")
last_name = input("Last name: ")
age = int(input("Age: "))
city = input("City: ")
 
print()
print("Summary")
print("=======")
print("Name:", first_name, last_name)
print("Age:", age)
print("Location:", city)

Exemplo de interação:

Please enter your information:
 
First name: John
Last name: Smith
Age: 30
City: Boston
 
Summary
=======
Name: John Smith
Age: 30
Location: Boston

Perceba como o programa solicita cada informação separadamente. Isso torna claro para o usuário o que ele precisa fornecer e em que ordem.

2.4.5) Criando Prompts Informativos

Prompts bem escritos tornam seus programas mais fáceis de usar. Aqui vão algumas diretrizes:

Seja específico sobre o que você quer:

# Good prompts
name = input("Enter your full name: ")
temperature = float(input("Enter temperature in Fahrenheit: "))
quantity = int(input("How many items do you want to purchase? "))

Inclua o formato ou a unidade esperada:

# format_prompts.py
date = input("Enter date (MM/DD/YYYY): ")
phone = input("Enter phone number (XXX-XXX-XXXX): ")
price = float(input("Enter price in dollars (without $): "))

Use linguagem clara e amigável:

# friendly_prompts.py
print("Welcome to the Temperature Converter!")
print()
temp = float(input("Please enter a temperature in Fahrenheit: "))

Prompts claros reduzem a confusão do usuário e deixam seus programas mais profissionais.

2.5) Programas Simples de Entrada-Processamento-Saída

A maioria dos programas segue um padrão comum chamado Input-Process-Output (IPO):

1. Input (Entrada): Obter dados do usuário ou de outra fonte
2. Process (Processamento): Fazer cálculos ou transformações nesses dados
3. Output (Saída): Exibir os resultados

Esse padrão é tão fundamental que você vai usá-lo em incontáveis programas ao longo da sua jornada de programação. Vamos explorá-lo com vários exemplos completos.

2.5.1) Exemplo: Conversor de Temperatura

Vamos criar um programa completo que converte temperaturas de Fahrenheit para Celsius:

# temperature_converter.py
# This program converts a temperature from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
print("Temperature Converter")
print("Fahrenheit to Celsius")
print("=" * 30)  # Print a line of equal signs
print()
 
# INPUT: Get temperature from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# PROCESS: Convert using the formula
celsius = (fahrenheit - 32) * 5 / 9
 
# OUTPUT: Display the result
print()
print("Result:", fahrenheit, "°F =", celsius, "°C")

Exemplo de interação:

Temperature Converter
Fahrenheit to Celsius
==============================
 
Enter temperature in Fahrenheit: 75
 
Result: 75.0 °F = 23.88888888888889 °C

Perceba como o programa segue claramente o padrão IPO:

• Input: Obtém a temperatura em Fahrenheit
• Process: Aplica a fórmula de conversão
• Output: Exibe o resultado em Celsius

Os comentários no código marcam explicitamente essas três seções, deixando clara a estrutura do programa.

2.5.2) Exemplo: Calculadora de Área de Retângulo

Aqui está outro exemplo de IPO que calcula a área de um retângulo:

# rectangle_area.py
# Calculate the area of a rectangle
# Formula: Area = length × width
 
print("Rectangle Area Calculator")
print("=" * 30)
print()
 
# INPUT: Get dimensions from user
length = float(input("Enter the length: "))
width = float(input("Enter the width: "))
 
# PROCESS: Calculate area
area = length * width
 
# OUTPUT: Display the result
print()
print("A rectangle with length", length, "and width", width)
print("has an area of", area, "square units")

Exemplo de interação:

Rectangle Area Calculator
==============================
 
Enter the length: 5.5
Enter the width: 3.2
 
A rectangle with length 5.5 and width 3.2
has an area of 17.6 square units

2.5.3) Exemplo: Calculadora de Total de Compras

Este exemplo calcula o total de uma compra com imposto:

# shopping_total.py
# Calculate total cost including tax
 
print("Shopping Total Calculator")
print("=" * 30)
print()
 
# INPUT: Get price and tax rate
price = float(input("Enter item price: $"))
tax_rate = float(input("Enter tax rate (as decimal, e.g., 0.08 for 8%): "))
 
# PROCESS: Calculate tax and total
tax_amount = price * tax_rate
total = price + tax_amount
 
# OUTPUT: Display itemized breakdown
# Note: Comma in print() adds a space after $
print()
print("Purchase Summary")
print("-" * 30)
print("Item price:    $", price)
print("Tax rate:      ", tax_rate * 100, "%")
print("Tax amount:    $", tax_amount)
print("-" * 30)
print("Total:         $", total)

Exemplo de interação:

Shopping Total Calculator
==============================
 
Enter item price: $49.99
Enter tax rate (as decimal, e.g., 0.08 for 8%): 0.08
 
Purchase Summary
------------------------------
Item price:    $ 49.99
Tax rate:       8.0 %
Tax amount:    $ 3.9992
------------------------------
Total:         $ 53.9892

2.6) Debugging Básico Lendo Mensagens de Erro Simples

Mesmo programadores experientes cometem erros. Aprender a ler e entender mensagens de erro é uma habilidade essencial que vai salvar você de inúmeras horas de frustração. As mensagens de erro do Python são, na verdade, bastante úteis—elas dizem o que deu errado e onde o problema ocorreu.

Os termos "mensagem de erro" e "traceback" são relacionados, mas um pouco diferentes: um traceback é o relatório completo que o Python mostra quando um erro ocorre, incluindo o tipo de erro, a descrição e o caminho através do seu código que levou ao erro. A mensagem de erro é a linha final do traceback que descreve o que deu errado. Na conversa do dia a dia, programadores frequentemente usam "mensagem de erro" para se referir ao traceback inteiro.

2.6.1) Entendendo Mensagens de Erro

Quando o Python encontra um erro, ele exibe um traceback—um relatório detalhado sobre o que deu errado. Vamos olhar um exemplo simples:

# error_example.py
print("Starting the program")
print("This line works fine"
print("This line might not be reached")

Quando você tenta executar isso, o Python exibe:

  File "error_example.py", line 2
    print("This line works fine"
                                ^
SyntaxError: '(' was never closed

Vamos decompor o que essa mensagem de erro nos diz:

1. Nome do arquivo: error_example.py - O arquivo onde o erro ocorreu
2. Número da linha: line 2 - Onde o Python detectou o problema
3. Trecho de código: Mostra a linha problemática com um ^ apontando para onde o Python percebeu o problema
4. Tipo de erro: SyntaxError - Que tipo de erro ocorreu
5. Descrição: '(' was never closed - Uma explicação em linguagem natural

O erro ocorreu porque esquecemos o parêntese de fechamento na linha 2. O Python tentou continuar lendo a próxima linha como parte da mesma instrução print() e se confundiu.

2.6.2) Tipos de Erro Comuns para Iniciantes

Vamos explorar os erros mais comuns que você encontrará como iniciante e como corrigi-los.

SyntaxError: Invalid Syntax

Este é o erro mais comum para iniciantes. Ele significa que o Python não conseguiu entender seu código porque ele não segue as regras de gramática do Python.

Falta de dois-pontos:

# missing_colon.py
name = input("What is your name? ")
if name == "Alice"  # Missing colon
    print("Hello, Alice!")

Erro:

  File "missing_colon.py", line 2
    if name == "Alice"
                     ^
SyntaxError: expected ':'

Note: We haven't learned about if statements yet—we'll cover them in Chapter 8. This example just shows what the error looks like.

Aspas incompatíveis:

# mismatched_quotes.py
message = "Hello, world!'
print(message)

Erro:

  File "mismatched_quotes.py", line 1
    message = "Hello, world!'
              ^
SyntaxError: unterminated string literal (detected at line 1)

O erro ocorre porque a string começa com aspas duplas (") mas termina com aspas simples ('). O Python espera o mesmo tipo de aspa nos dois lados.

NameError: Name Not Defined

Esse erro ocorre quando você tenta usar uma variável que não existe:

# name_error.py
print("Starting calculation")
result = total + 10  # 'total' was never created
print(result)

Erro:

Traceback (most recent call last):
  File "name_error.py", line 2, in <module>
    result = total + 10
             ^^^^^
NameError: name 'total' is not defined

O Python está dizendo que não sabe o que é total porque você nunca criou essa variável. A correção é definir total antes de usá-la:

# name_error_fixed.py
print("Starting calculation")
total = 0  # Define the variable first
result = total + 10
print(result)

Causas comuns de NameError:

• Erros de digitação em nomes de variáveis (totla em vez de total)
• Usar uma variável antes de atribuir um valor a ela
• Esquecer de criar a variável

TypeError: Unsupported Operand Type(s)

Esse erro acontece quando você tenta fazer uma operação com tipos incompatíveis:

# type_error.py
age = input("How old are you? ")
next_year = age + 1  # Can't add a number to a string
print("Next year:", next_year)

Erro:

Traceback (most recent call last):
  File "type_error.py", line 2, in <module>
    next_year = age + 1
                ~~~~^~~
TypeError: can only concatenate str (not "int") to str

O Python está dizendo que age é uma string (porque input() retorna strings), e você não pode somar um número a uma string. A correção é converter a entrada em inteiro:

# type_error_fixed.py
age = int(input("How old are you? "))  # Convert to integer
next_year = age + 1
print("Next year:", next_year)

ValueError: Invalid Literal

Esse erro acontece quando você tenta converter uma string em número, mas a string não representa um número válido:

# value_error.py
age = int(input("How old are you? "))
print("You are", age, "years old")

Se o usuário digitar texto em vez de um número:

How old are you? twenty
Traceback (most recent call last):
  File "value_error.py", line 1, in <module>
    age = int(input("How old are you? "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'twenty'

O Python está dizendo que não consegue converter a string "twenty" em inteiro. O usuário precisa digitar um número como 20.

Important: Right now, if users enter invalid input, your program will crash with an error. This is normal for beginner programs. In Chapter 27, we'll learn how to handle these situations gracefully using exception handling, allowing your program to recover from errors and ask the user to try again.

2.6.3) Lendo Tracebacks com Atenção

Quando um erro ocorre, o Python mostra um traceback que rastreia o erro pelo seu código. Para programas simples, o traceback é curto:

# simple_traceback.py
print("Starting program")
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello,", name)
print("Next year you'll be", age + 1)

Se o usuário digitar uma entrada inválida para a idade:

Starting program
Enter your name: Alice
Enter your age: abc
Traceback (most recent call last):
  File "simple_traceback.py", line 3, in <module>
    age = int(input("Enter your age: "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'abc'

O traceback mostra:

1. O nome do arquivo e o número da linha onde o erro ocorreu
2. A linha de código que causou o problema
3. O tipo de erro e uma descrição

Estratégia de leitura: Comece de baixo para cima no traceback. A última linha diz o que deu errado. As linhas acima mostram onde, no seu código, o erro ocorreu.

2.6.4) Estratégias Comuns de Debugging

Quando você encontrar um erro, siga estes passos:

1. Leia a mensagem de erro com cuidado

Não entre em pânico! A mensagem de erro está tentando ajudar você. Leia-a inteira e tente entender o que ela está dizendo.

2. Olhe o número da linha

A mensagem de erro diz em que linha o Python acha que está o problema. No entanto, às vezes o erro real está na linha anterior. Por exemplo, um parêntese de fechamento faltando na linha 2 pode não ser detectado até o Python ler a linha 3.

3. Verifique erros comuns

• Aspas faltando ou incompatíveis
• Parênteses ou colchetes faltando
• Dois-pontos faltando (para instruções que veremos depois como if, for, while)
• Erros de digitação em nomes de variáveis
• Esquecer de converter entrada em números

4. Use print() para inspecionar valores

Se você não tiver certeza do que está dando errado, adicione instruções print() para ver quais valores suas variáveis contêm:

# debugging_with_print.py
price = input("Enter price: ")
print("DEBUG: price =", price, "type =", type(price))  # Debugging line
 
tax = price * 0.08  # This will cause an error
print("Tax:", tax)

A linha de debug mostra para você que price é uma string, não um número, ajudando a identificar o problema.

5. Comente código para isolar o problema

Se você tiver múltiplas linhas e não souber qual está causando o erro, comente linhas até o erro desaparecer:

# isolating_error.py
name = input("Enter name: ")
# age = int(input("Enter age: "))  # Commented out for testing
# city = input("Enter city: ")  # Commented out for testing
print("Name:", name)

Quando o erro desaparecer, você sabe que o problema está em uma das linhas comentadas.

6. Comece com uma versão simples

Se o seu programa não estiver funcionando, simplifique-o ao mínimo:

# simplified_version.py
# Start with just the basic structure
print("Program starting")
# Add one feature at a time and test

Quando a versão simples estiver funcionando, adicione recursos um por vez, testando após cada adição.

2.6.5) Prevenindo Erros

Embora debugging seja importante, prevenir erros desde o início é ainda melhor:

Escreva código incrementalmente

Não escreva o programa inteiro e só então execute pela primeira vez. Escreva algumas linhas, execute o programa, verifique se essas linhas funcionam e só então adicione mais. Assim, quando um erro aparecer, você sabe que ele está no código que acabou de adicionar.

# incremental_development.py
# Step 1: Get input and test
name = input("Enter name: ")
print("DEBUG: Got name:", name)
 
# Step 2: Add more input and test
# age = int(input("Enter age: "))
# print("DEBUG: Got age:", age)
 
# Step 3: Add processing and test
# ... and so on

Use nomes de variáveis descritivos

Nomes claros ajudam a evitar erros:

# Clear variable names make errors less likely
user_age = int(input("Enter your age: "))
next_year_age = user_age + 1

Adicione comentários para explicar sua lógica

Comentários ajudam você (e outras pessoas) a entender o que o código deveria fazer, facilitando perceber quando ele está fazendo algo diferente:

# temperature_with_comments.py
# Get temperature in Fahrenheit from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# Convert to Celsius using the standard formula: C = (F - 32) × 5/9
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print(fahrenheit, "°F =", celsius, "°C")

Teste com entradas diferentes

Não teste seu programa apenas uma vez. Experimente entradas diferentes, incluindo casos extremos:

• Valores normais: 25, 100
• Zero: 0
• Números negativos: -10
• Números decimais: 3.14
• Números muito grandes: 1000000

Isso ajuda você a descobrir problemas antes que usuários encontrem esses erros.

2.6.6) Quando Pedir Ajuda

Às vezes você encontrará erros que não consegue resolver sozinho. Antes de pedir ajuda:

1. Leia a mensagem de erro com cuidado - Certifique-se de entender o que ela está dizendo
2. Pesquise o erro - Copie a mensagem de erro (sem nomes específicos de variáveis) e pesquise na internet. Muitos erros já foram encontrados e resolvidos por outras pessoas
3. Revise seu código com atenção - Procure erros de digitação, pontuação faltando e erros comuns
4. Crie um exemplo mínimo - Reduza seu código à menor versão que ainda produz o erro

Quando você for pedir ajuda, forneça:

• A mensagem de erro completa
• O código que produz o erro
• O que você esperava que acontecesse
• O que realmente aconteceu
• O que você já tentou

Lembre-se: Erros são uma parte normal da programação. Todo programador, de iniciante a especialista, encontra erros diariamente. A diferença é que programadores experientes aprenderam a ler mensagens de erro de forma eficiente e conhecem soluções comuns. Você vai desenvolver essas habilidades com a prática.

Você agora aprendeu os blocos de construção fundamentais da programação em Python: exibir saída com print(), documentar código com comentários, armazenar dados em variáveis, obter entrada do usuário com input(), seguir o padrão entrada-processamento-saída e fazer debugging de erros simples.

Esses conceitos formam a base para tudo o que você vai aprender em Python. No próximo capítulo, vamos nos aprofundar em variáveis e explorar os tipos de dados básicos do Python, dando a você uma compreensão mais completa de como o Python armazena e manipula diferentes tipos de informação.

Pontos principais deste capítulo:

• Use print() para exibir texto e outras informações para os usuários
• Use comentários (#) para explicar seu código e documentar seu raciocínio
• Armazene dados em variáveis usando atribuição (=)
• Obtenha entrada do usuário com input() e converta para números quando necessário
• Estruture programas usando o padrão entrada-processamento-saída
• Leia mensagens de erro com atenção—elas estão tentando ajudar você a corrigir problemas
• Escreva código de forma incremental e teste com frequência para detectar erros cedo

Com essas habilidades, você já pode escrever programas interativos simples, mas completos. À medida que continuar aprendendo, você vai construir sobre esses fundamentos para criar aplicações cada vez mais sofisticadas.