1. Primeiros Passos com Python

Bem-vindo à sua jornada na programação em Python! Este capítulo vai te guiar pelos primeiros passos essenciais: entender o que é Python, instalá-lo no seu computador e executar seu primeiro código em Python. Ao final deste capítulo, você vai se sentir à vontade usando o shell interativo do Python, criando e executando arquivos de script e entendendo as mensagens de erro básicas que o Python te mostra.

1.1) O Que é um Programa e o Que o Python Faz?

Antes de mergulhar especificamente em Python, vamos entender o que é um programa e qual é o papel do Python na criação de programas.

1.1.1) Entendendo Programas

Um programa é um conjunto de instruções que diz ao computador o que fazer. Assim como uma receita te diz passo a passo como assar um bolo, um programa diz ao computador passo a passo como realizar uma tarefa. Essas tarefas podem ir desde cálculos simples até operações complexas, como exibir páginas da web, processar imagens ou controlar robôs.

Computadores não entendem diretamente línguas humanas como inglês ou espanhol. Eles só entendem código de máquina—sequências de números binários (0s e 1s) que representam operações bem básicas. Escrever programas diretamente em código de máquina seria extremamente difícil e sujeito a erros para humanos.

É aí que entram as linguagens de programação. Uma linguagem de programação é uma maneira legível para humanos escreverem instruções que podem ser traduzidas para código de máquina. Python é uma dessas linguagens de programação, projetada para ser particularmente fácil de ler e escrever para humanos.

1.1.2) O Que Torna o Python Especial

Python é uma linguagem de programação de alto nível, o que significa que ela abstrai muitos dos detalhes complexos que você precisaria lidar em linguagens de mais baixo nível. Aqui está o que torna Python especialmente atrativo tanto para iniciantes quanto para profissionais:

Sintaxe legível: O código Python quase parece inglês. Por exemplo, para imprimir "Hello, World!" em Python, você escreve:

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

Saída:

Hello, World!

Compare isso com linguagens como C ou Java, que exigem mais código boilerplate para a mesma tarefa.

Linguagem interpretada: Python é uma linguagem interpretada. Isso significa que você não precisa compilar seu código para código de máquina antes de executá-lo. Em vez disso, um programa chamado interpretador Python lê seu código e o executa linha por linha. Isso torna o desenvolvimento mais rápido, porque você pode ver imediatamente o resultado das mudanças no seu código.

Versátil e poderosa: Apesar de ser amigável para iniciantes, Python é usada profissionalmente para:

• Desenvolvimento web (sites e aplicações web)
• Análise e visualização de dados
• Machine learning e inteligência artificial
• Computação científica
• Automação e scripting
• Desenvolvimento de jogos
• E muito mais

Grande comunidade e bibliotecas: Python tem uma comunidade enorme de usuários e milhares de bibliotecas de código prontas que ampliam suas capacidades. Isso significa que soluções para problemas comuns geralmente estão a apenas um import de distância.

1.1.3) Como o Python Executa Seu Código

Quando você escreve código Python e o executa, é isso que acontece nos bastidores:

1. Você escreve código: Você cria um arquivo contendo instruções em Python ou as digita diretamente no shell interativo do Python.

2. O interpretador lê seu código: O interpretador Python verifica seu código em busca de erros de sintaxe (erros na forma como você escreveu o código).

3. Tradução para bytecode: Se não houver erros de sintaxe, o Python traduz seu código para uma forma intermediária chamada bytecode. Bytecode é uma forma intermediária do seu código—uma tradução para uma linguagem que está no meio do caminho entre Python e código de máquina. Ela é mais simples que Python para o computador executar, mas mais abstrata do que o código de máquina puro.

4. Execução: A Máquina Virtual Python (PVM) executa o bytecode, realizando as operações que você especificou.

5. Saída: Você vê o resultado do seu programa—seja texto impresso na tela, um arquivo criado ou qualquer outra ação.

A beleza desse processo é que você não precisa se preocupar com a maior parte desses passos. Você escreve o código, executa e vê o resultado. O interpretador cuida do resto.

1.2) Instalando Python e Executando o Interpretador

Para começar a programar em Python, você primeiro precisa instalar o Python no seu computador. Nesta seção, vamos passar pelo processo de instalação e verificar se tudo está funcionando corretamente.

1.2.1) Verificando se o Python Já Está Instalado

Alguns sistemas operacionais vêm com Python pré-instalado. Antes de baixar qualquer coisa, vamos verificar se o Python já está no seu sistema.

No Windows:

1. Abra o Prompt de Comando:

   • Pressione Windows + R para abrir a janela Executar
   • Digite cmd e pressione Enter

2. Digite o seguinte comando e pressione Enter:

python --version

Se o Python estiver instalado, você verá algo como:

Python 3.11.5

Se você vir uma mensagem de erro como 'python' is not recognized as an internal or external command, o Python não está instalado ou não está no PATH do sistema.

No macOS:

1. Abra o aplicativo Terminal:

   • Pressione Command + Space para abrir o Spotlight
   • Digite Terminal e pressione Enter

2. Digite o seguinte comando e pressione Enter:

python3 --version

Note: No macOS, você normalmente usa python3 em vez de python, porque python pode se referir ao Python 2, que está ultrapassado.

Se o Python 3 estiver instalado, você verá algo como:

Python 3.11.5

No Linux:

1. Abra o aplicativo de terminal (varia conforme a distribuição)

2. Digite o seguinte comando e pressione Enter:

python3 --version

A maioria das distribuições Linux modernas já vem com Python 3 pré-instalado.

1.2.2) Baixando E Instalando o Python

Se o Python não estiver instalado ou você tiver uma versão antiga, siga estes passos para instalar a versão mais recente.

Instalação no Windows:

1. Visite o site oficial do Python: https://www.python.org/downloads/

2. Clique no botão "Download Python" (ele mostrará a versão mais recente, como "Download Python 3.11.5")

3. Execute o instalador baixado (arquivo .exe)

4. Important: On the first screen of the installer, check the box that says "Add Python to PATH". This is crucial—it allows you to run Python from any command prompt.

   What happens if you forget: If you don't check "Add Python to PATH", you won't be able to run Python from the command line, and you'll see an error like 'python' is not recognized as an internal or external command. If this happens, you'll need to either reinstall Python (checking the box this time) or manually add Python to your PATH, which is more complex for beginners.

5. Clique em "Install Now" e espere a instalação terminar

6. Verifique a instalação abrindo um novo Prompt de Comando e digitando:

python --version

Você deve ver o número da versão que acabou de instalar.

Instalação no macOS:

1. Visite https://www.python.org/downloads/

2. Clique no botão "Download Python" para a versão mais recente

3. Abra o arquivo .pkg baixado e siga o assistente de instalação

4. Verifique a instalação abrindo o Terminal e digitando:

python3 --version

Instalação no Linux:

A maioria das distribuições Linux vem com Python 3, mas se você precisar instalar ou atualizar:

Para sistemas baseados em Ubuntu/Debian:

sudo apt update
sudo apt install python3

Para sistemas baseados em Fedora/Red Hat:

sudo dnf install python3

Verifique com:

python3 --version

1.2.3) Executando o Interpretador Python

Depois que o Python estiver instalado, você pode executar o interpretador Python diretamente pela linha de comando ou terminal. O interpretador é o programa que executa o código Python. Executar o interpretador diretamente abre o shell interativo (REPL), que vamos explorar em detalhes na próxima seção. Isso é diferente de executar um arquivo de script, que veremos na Seção 1.4.

No Windows:

Abra o Prompt de Comando e digite:

python

No macOS e Linux:

Abra o Terminal e digite:

python3

Você deve ver algo como:

Python 3.11.5 (main, Sep 11 2023, 13:54:46) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

O prompt >>> indica que o Python está pronto para receber seus comandos. Isso é chamado de Python interactive shell ou REPL (Read-Eval-Print Loop), que vamos explorar em detalhes na próxima seção.

Para sair do interpretador, você pode:

• Digitar exit() e pressionar Enter
• Digitar quit() e pressionar Enter
• Pressionar Ctrl + D (no macOS/Linux) ou Ctrl + Z e depois Enter (no Windows)

Parabéns! Você instalou o Python com sucesso e verificou que o interpretador funciona. Agora você está pronto para começar a escrever código em Python.

1.3) Usando o Python Interactive Shell (REPL)

O Python interactive shell, comumente chamado de REPL (Read-Eval-Print Loop), é uma das funcionalidades mais úteis do Python para aprendizado e experimentação. Ele permite que você digite código Python e veja os resultados imediatamente, o que é perfeito para testar novos conceitos, experimentar pequenos trechos de código e explorar as capacidades do Python.

1.3.1) O Que é o REPL?

O Python interactive shell, comumente chamado de REPL (Read-Eval-Print Loop), é uma das funcionalidades mais úteis do Python para aprendizado e experimentação. O REPL também é chamado de Python interactive shell ou simplesmente interactive interpreter—todos esses termos se referem à mesma coisa: o prompt >>>, onde você pode digitar código Python e ver resultados imediatos.

REPL significa:

• Read: Python reads the code you type
• Eval: Python evaluates (executes) that code
• Print: Python prints the result
• Loop: Python loops back to read more code

Esse ciclo continua até você sair do REPL. É como ter uma conversa com o Python—você dá uma instrução, ele responde e você pode imediatamente dar outra instrução baseada nessa resposta.

1.3.2) Iniciando e Usando o REPL

Para iniciar o REPL, abra sua linha de comando ou terminal e digite python (Windows) ou python3 (macOS/Linux), como fizemos na seção anterior.

Quando você ver o prompt >>>, pode começar a digitar código Python. Vamos tentar alguns exemplos básicos:

Aritmética simples:

>>> 5 + 3
8
>>> 10 * 2
20
>>> 15 / 3
5.0

Note que você não precisa usar print() no REPL—o Python mostra automaticamente o resultado de cada expressão. Essa é uma das conveniências do REPL.

Trabalhando com texto:

>>> "Hello, World!"
'Hello, World!'
>>> "Python" + " is " + "great"
'Python is great'

Quando você digita apenas uma string (texto entre aspas), o Python a mostra com aspas—esse é o jeito do Python representar a string. Se você quiser exibir o texto sem aspas, use a função print():

>>> print("Hello, World!")
Hello, World!

Note a diferença: digitar só a string faz o Python mostrá-la com aspas (a representação do Python), mas print() exibe sem aspas (o texto em si).

Armazenando valores em variáveis:

Embora digitar valores diretamente seja útil para testes rápidos, você vai querer com frequência armazenar valores em variáveis—containers nomeados que guardam dados que você pode reutilizar ao longo do programa.

>>> name = "Alice"
>>> name
'Alice'
>>> age = 25
>>> age
25

Quando você atribui um valor a uma variável (como name = "Alice"), o Python não imprime nada. Mas quando você digita apenas o nome da variável, o Python mostra o valor dela.

Usando o Python como calculadora:

>>> 2 + 2
4
>>> (10 + 5) * 2
30
>>> 100 / 4
25.0
>>> 7 % 3
1

O REPL é excelente para cálculos rápidos e testar expressões matemáticas.

1.3.3) Entrada em Múltiplas Linhas no REPL

Às vezes você precisa escrever código que ocupa várias linhas, como definições de função. O REPL lida bem com isso mudando o prompt. Quando você começa uma instrução de múltiplas linhas, o prompt muda de >>> para ... para indicar que o Python está esperando você completar a instrução.

Aqui vai um exemplo simples usando uma função (Observação: Vamos aprender sobre funções em detalhes no Capítulo 19. Este exemplo apenas mostra como o REPL lida com entrada em múltiplas linhas com o prompt de continuação ...):

>>> def greet():
...     print("Hello!")
...
>>> greet()
Hello!

Depois de digitar a primeira linha e pressionar Enter, o prompt vira .... Você digita a linha indentada, pressiona Enter e então pressiona Enter novamente em uma linha vazia para executar o código.

1.3.4) Acessando Comandos Anteriores

O REPL mantém um histórico dos comandos que você digitou. Você pode usar as setas para cima e para baixo para navegar pelo histórico:

• Seta para cima: Mostra o comando anterior
• Seta para baixo: Mostra o próximo comando (se você voltou no histórico)

Isso é extremamente útil quando você quer modificar e executar novamente um comando, ou quando quer lembrar o que digitou antes.

1.3.5) Obtendo Ajuda no REPL

O REPL do Python tem recursos de ajuda embutidos. Você pode obter informações sobre objetos, funções e módulos Python diretamente.

Esses recursos de ajuda são mais úteis quando você está explorando o Python e quer saber o que está disponível. Por exemplo, se você estiver trabalhando com strings e quiser saber quais métodos existem, dir(str) mostra todas as opções. À medida que você avançar neste livro, esses recursos vão se tornar cada vez mais valiosos para exploração independente.

>>> help()

Isso entra no sistema de ajuda. Você pode então digitar o nome de algo sobre o qual quer ajuda ou digitar quit para sair do sistema de ajuda.

Você também pode obter ajuda diretamente sobre coisas específicas:

>>> help(print)

Isso mostra a documentação da função print(). Pressione q para sair da tela de ajuda.

Outra função útil é dir(), que lista os atributos e métodos disponíveis em um objeto. (Observação: Atributos e métodos são recursos e ações disponíveis em um objeto—vamos aprender mais sobre isso no Capítulo 43. Também vamos aprender a importar módulos no Capítulo 22. Este exemplo mostra como o REPL ajuda a explorar as capacidades do Python.)

>>> dir(str)

Isso mostra todos os métodos disponíveis para objetos do tipo string.

1.3.6) Quando o REPL é Mais Útil

O REPL é excelente para:

1. Aprendizado e exploração: Quando você está aprendendo um conceito novo, o REPL te permite experimentar imediatamente sem criar arquivos.

2. Testar pequenos trechos de código: Antes de adicionar código ao seu programa, você pode testá-lo no REPL para garantir que funciona como esperado.

3. Cálculos rápidos: O REPL é uma poderosa calculadora que está sempre disponível.

4. Depuração: Quando o seu programa não está funcionando, você pode usar o REPL para testar partes individuais do seu código isoladamente.

5. Explorar bibliotecas: Ao aprender uma nova biblioteca, você pode importá-la no REPL e testar suas funções de forma interativa.

No entanto, o REPL tem limitações. O código que você escreve no REPL desaparece quando você fecha a sessão—não há como salvar uma sessão do REPL como um programa. Para qualquer código que você queira guardar e executar novamente, vai precisar criar arquivos de script, o que veremos na próxima seção.

1.3.7) Saindo do REPL

Quando você terminar de usar o REPL, pode sair de várias formas:

>>> exit()

Ou:

>>> quit()

Ou usando atalhos de teclado:

• Windows: Pressione Ctrl + Z e depois Enter
• macOS/Linux: Pressione Ctrl + D

Depois de sair, você volta ao prompt normal da linha de comando ou do terminal.

1.4) Criando e Executando Arquivos de Script em Python

O REPL é excelente para experimentação e testes rápidos, mas e se você quiser salvar seu código e executá-lo novamente depois? E se quiser escrever um programa mais longo, com dezenas ou centenas de linhas? Para essas situações, você precisa de arquivos de script—arquivos permanentes contendo código Python que você pode editar, salvar e executar quantas vezes quiser.

Embora o REPL seja ótimo para experimentação, a maior parte da programação em Python envolve escrever arquivos de script—arquivos de texto contendo código Python que podem ser salvos, editados e executados repetidas vezes. Nesta seção, você vai aprender a criar seu primeiro script Python e executá-lo a partir da linha de comando.

1.4.1) O Que é um Script Python?

Um script Python é simplesmente um arquivo de texto contendo código Python, salvo com a extensão .py. Diferente do código digitado no REPL, arquivos de script:

• São permanentes—você pode salvá-los e executá-los depois
• Podem ser editados e modificados facilmente
• Podem conter quanto código você precisar
• Podem ser compartilhados com outras pessoas
• Podem ser executados automaticamente ou em um agendamento

Pense em um arquivo de script como uma receita que você escreve, enquanto o REPL é como cozinhar inventando a receita na hora. Os dois têm seu lugar, mas para qualquer coisa mais substancial, você vai querer um arquivo de script.

1.4.2) Escolhendo um Editor de Texto

Para criar scripts em Python, você precisa de um editor de texto. Não use editores de texto ricos (word processors) como Microsoft Word ou Google Docs—eles adicionam formatação que o Python não entende.

Boas opções para iniciantes:

1. IDLE: Vem junto com o Python. Simples e pensado para aprendizado.

   • No Windows: Procure por "IDLE" no menu Iniciar
   • No macOS/Linux: Digite idle3 no terminal

2. Visual Studio Code (VS Code): Gratuito, poderoso e amplamente usado por profissionais. Excelente suporte a Python com extensões.

   • Baixe em: https://code.visualstudio.com/

3. PyCharm Community Edition: Um IDE (Integrated Development Environment) completo específico para Python.

   • Baixe em: https://www.jetbrains.com/pycharm/

4. Notepad++ (apenas Windows): Leve e simples.

   • Baixe em: https://notepad-plus-plus.org/

5. Sublime Text: Rápido e elegante, com bom suporte a Python.

   • Baixe em: https://www.sublimetext.com/

Neste livro, vamos usar exemplos simples que funcionam com qualquer editor de texto. Escolha o editor com o qual você se sinta mais confortável.

1.4.3) Criando Seu Primeiro Script Python

Vamos criar um script simples em Python que imprime mensagens de saudação.

Passo 1: Crie um novo arquivo

Abra o editor de texto escolhido e crie um novo arquivo. Salve-o como hello.py em um local fácil de lembrar (como sua Área de Trabalho ou uma pasta dedicada a projetos Python).

Importante: A extensão .py é crucial. Ela informa ao sistema operacional e ao editor de texto que este é um arquivo Python.

Passo 2: Escreva seu código

Digite o seguinte código no arquivo:

# hello.py
# My first Python script
 
print("Hello, World!")
print("Welcome to Python programming!")

Linhas que começam com # são comentários—anotações para humanos que leem o código. O Python as ignora completamente. Comentários ajudam você a lembrar o que seu código faz e ajudam outras pessoas a entender seu trabalho. Vamos explorar comentários em mais detalhes no Capítulo 2.

Passo 3: Salve o arquivo

Salve o arquivo. Certifique-se de que ele foi salvo como hello.py, e não hello.py.txt ou com qualquer outra extensão.

Vamos entender o que esse código faz:

• print("Hello, World!") diz ao Python para exibir o texto "Hello, World!" na tela.
• print("Welcome to Python programming!") exibe outra mensagem.

Vamos adicionar mais um exemplo para fazer a ponte antes de irmos para scripts mais complexos:

# greetings.py
# A script with multiple print statements
 
print("Python is fun!")
print("Let's learn together.")
print("This is exciting!")

Salve isso como greetings.py. Este exemplo usa três instruções print, mas ainda não usa variáveis, ajudando você a ficar confortável com a estrutura básica antes de passar para conceitos mais complexos.

1.4.4) Executando Seu Script pela Linha de Comando

Agora que você criou seu script, vamos executá-lo.

Passo 1: Abra sua Linha de Comando/Terminal

• Windows: Abra o Prompt de Comando
• macOS/Linux: Abra o Terminal

Passo 2: Navegue até o local do seu script

Use o comando cd (change directory) para ir até o local onde você salvou hello.py. Por exemplo, se você salvou na Área de Trabalho:

Windows:

cd Desktop

macOS/Linux:

cd ~/Desktop

Se você receber um erro como "No such file or directory" ao tentar executar o script, provavelmente está na pasta errada. Use o comando cd para ir até a pasta onde o script foi salvo.

Para verificar se você está no lugar certo, pode listar os arquivos:

Windows:

dir

macOS/Linux:

ls

Você deve ver hello.py na lista.

Passo 3: Execute seu script

Windows:

python hello.py

macOS/Linux:

python3 hello.py

Você deve ver a saída:

Hello, World!
Welcome to Python programming!

Parabéns! Você acabou de criar e executar seu primeiro script Python.

1.4.5) Entendendo a Execução de um Script

Quando você executa um script Python, é isso que acontece:

1. Você digita o comando para rodar o script
2. Seu sistema operacional inicia o interpretador Python
3. O interpretador lê todo o arquivo de script
4. Ele verifica se há erros de sintaxe (erros na forma como você escreveu o código)
5. Se houver erros, ele mostra uma mensagem de erro e para
6. Se não houver erros, ele executa o código linha por linha, de cima para baixo
7. Qualquer saída (de instruções print()) é mostrada
8. Quando o script termina, o controle volta para a linha de comando

1.4.6) Um Exemplo Mais Complexo

Vamos criar um script um pouco mais complexo que demonstre vários conceitos. Primeiro, vamos adicionar um exemplo intermediário que introduz variáveis de forma mais suave:

# simple_variable.py
# Using a variable for the first time
 
message = "Hello, Python!"
print(message)

Saída:

Hello, Python!

Isso faz a ponte entre instruções print puras e exemplos mais complexos. Agora vamos ver um script com múltiplas variáveis:

# student_info.py
# A script that uses variables and multiple print statements
 
name = "Alice"
age = 25
city = "New York"
 
print("Student Information")
print("-------------------")
print("Name:", name)
print("Age:", age)
print("City:", city)

Salve isso como student_info.py e execute:

Windows:

python student_info.py

macOS/Linux:

python3 student_info.py

Saída:

Student Information
-------------------
Name: Alice
Age: 25
City: New York

Este script demonstra:

• Criação de variáveis (vamos aprender mais sobre variáveis no Capítulo 3)
• Uso de múltiplas instruções print()
• Impressão de texto literal e valores de variáveis

1.4.7) Boas Práticas para Arquivos de Script

Mesmo neste início, é bom desenvolver alguns hábitos:

1. Use nomes de arquivo descritivos: Dê nomes aos arquivos baseados no que eles fazem. student_info.py é melhor do que test.py ou program1.py, porque você vai lembrar o que ele faz quando olhar a lista de arquivos daqui a seis meses.

2. Mantenha os scripts organizados: Crie uma pasta dedicada para seus projetos Python. Não espalhe scripts pelo computador todo. Isso facilita achar seu trabalho e mantém seus arquivos organizados.

3. Adicione comentários: Comece cada script com um comentário explicando o que ele faz. Isso ajuda você a lembrar depois e ajuda outras pessoas a entender seu código.

4. Um script, um propósito: Cada script deve fazer uma coisa principal. Não tente juntar várias tarefas sem relação em um único arquivo. Isso torna o código mais fácil de entender e manter.

5. Teste com frequência: Execute seu script com frequência enquanto o escreve. Não espere ter 100 linhas para testar—teste a cada poucas linhas. Isso ajuda a encontrar erros mais cedo, quando são mais fáceis de corrigir.

1.5) Um Primeiro Olhar em Erros e Tracebacks

Erros são parte natural da programação. Todo programador, de iniciante a especialista, encontra erros regularmente. Aprender a ler e entender mensagens de erro é uma habilidade crucial que vai te ajudar a corrigir problemas rapidamente e se tornar um(a) programador(a) mais confiante.

1.5.1) Tipos de Erros

O Python distingue duas categorias principais de erros:

Syntax Errors: Mistakes in how you've written the code—violations of Python's grammar rules. Python detects these before running your code. Think of syntax errors like grammar mistakes in writing—Python can't even understand what you're trying to say.

Exceptions: Errors that occur while your code is running. The syntax is correct, but something goes wrong during execution. Exceptions are like runtime problems—Python understands your instructions but can't carry them out.

Vamos explorar ambos os tipos com exemplos.

1.5.2) Erros de Sintaxe

Um erro de sintaxe acontece quando você escreve código que não segue as regras do Python. O Python nem consegue começar a executar o código porque não entende o que foi escrito.

Exemplo 1: Dois-pontos faltando

Crie um arquivo chamado syntax_error1.py:

# syntax_error1.py
# This code has a syntax error
 
if 5 > 3
    print("Five is greater than three")

Quando você tentar executar:

python syntax_error1.py

Você verá:

  File "syntax_error1.py", line 4
    if 5 > 3
            ^
SyntaxError: expected ':'

O Python está te dizendo várias coisas:

• Qual arquivo tem o problema: syntax_error1.py
• Qual linha tem o problema: linha 4
• Onde na linha está o problema: o ^ aponta para a posição
• Qual tipo de erro: SyntaxError
• Uma descrição útil: expected ':'

O problema é que instruções if em Python devem terminar com dois-pontos (:). O código correto é:

# syntax_error1_fixed.py
# Fixed version
 
if 5 > 3:
    print("Five is greater than three")

Saída:

Five is greater than three

Exemplo 2: Aspas que não combinam

# syntax_error2.py
# Another syntax error example
 
message = "Hello, World!'
print(message)

Executar isso produz:

  File "syntax_error2.py", line 4
    message = "Hello, World!'
              ^
SyntaxError: unterminated string literal (detected at line 4)

O problema é que a string começa com aspas duplas (") mas termina com aspas simples ('). O Python exige aspas combinando. Corrija usando aspas iguais:

# syntax_error2_fixed.py
# Fixed version
 
message = "Hello, World!"
print(message)

Saída:

Hello, World!

1.5.3) Exceções em Tempo de Execução

Runtime exceptions (ou simplesmente "exceptions") acontecem quando o seu código está sintaticamente correto, mas algo dá errado durante a execução.

Exemplo 1: NameError

# name_error.py
# This code will cause a NameError
 
print(greeting)

Quando você executar:

python name_error.py

Você verá:

Traceback (most recent call last):
  File "name_error.py", line 4, in <module>
    print(greeting)
          ^^^^^^^^
NameError: name 'greeting' is not defined

Isso é chamado de traceback. Vamos destrinchar:

• "Traceback (most recent call last):" indica que o que vem a seguir é um traceback mostrando onde o erro ocorreu.
• Informações de arquivo e linha: File "name_error.py", line 4, in <module> diz qual arquivo e linha causaram o erro.
• O código problemático: print(greeting) mostra a linha exata que falhou.
• Tipo de erro: NameError diz que tipo de erro aconteceu.
• Descrição do erro: name 'greeting' is not defined explica o problema—você está tentando usar uma variável que não existe.

Para corrigir, você precisa definir a variável antes de usá-la:

# name_error_fixed.py
# Fixed version
 
greeting = "Hello!"
print(greeting)

Saída:

Hello!

Exemplo 2: TypeError

# type_error.py
# This code will cause a TypeError
 
number = 5
text = "The number is "
result = text + number
print(result)

Executar isso produz:

Traceback (most recent call last):
  File "type_error.py", line 6, in <module>
    result = text + number
             ~~~~~^~~~~~~~
TypeError: can only concatenate str (not "int") to str

A mensagem de erro diz que você não pode somar (concatenar) diretamente uma string e um inteiro. O Python não sabe se você quer fazer adição matemática ou concatenação de strings.

Para corrigir, converta o número para string:

# type_error_fixed.py
# Fixed version
 
number = 5
text = "The number is "
result = text + str(number)
print(result)

Saída:

The number is 5

Exemplo 3: ZeroDivisionError

O que acontece se você tentar dividir por zero?

# zero_division.py
# This code will cause a ZeroDivisionError
 
result = 10 / 0
print(result)

Executar isso produz:

Traceback (most recent call last):
  File "zero_division.py", line 4, in <module>
    result = 10 / 0
             ~~~^~~
ZeroDivisionError: division by zero

Esse erro é autoexplicativo: você não pode dividir por zero. Isso é matematicamente indefinido, então o Python lança um erro.

1.5.4) Lendo Tracebacks de Forma Eficiente

Quando você encontra um traceback, leia de baixo para cima. Lemos de baixo para cima porque a última linha mostra o que deu errado (o tipo de erro e a mensagem), enquanto as linhas acima mostram a sequência de chamadas de função que levou ao erro. Para programas simples como os nossos, a última linha já te diz tudo que você precisa saber.

1. Comece pelo final: Veja primeiro o tipo de erro e a mensagem.
2. Entenda o erro: O que o Python está dizendo que deu errado?
3. Encontre o local: Veja o arquivo e o número da linha onde o erro ocorreu.
4. Examine o código: Olhe essa linha no seu arquivo.
5. Volte algumas linhas se precisar: Às vezes o problema está em uma linha anterior à que o Python apontou.

1.5.5) Erros Comuns de Iniciantes

Aqui estão alguns erros que você provavelmente vai encontrar enquanto aprende Python:

Indentation Errors:

O Python usa indentação (espaços ou tabs no começo da linha) para definir blocos de código. Indentação incorreta causa erros:

# indentation_error.py
# Incorrect indentation
 
print("First line")
    print("Second line")  # This line is incorrectly indented

Erro:

  File "indentation_error.py", line 5
    print("Second line")
    ^
IndentationError: unexpected indent

Spelling Mistakes:

O Python diferencia maiúsculas de minúsculas. Print não é a mesma coisa que print:

# spelling_error.py
# Incorrect capitalization
 
Print("Hello")  # Should be print, not Print

Erro:

Traceback (most recent call last):
  File "spelling_error.py", line 4, in <module>
    Print("Hello")
    ^^^^^
NameError: name 'Print' is not defined

Missing Parentheses:

No Python 3, print exige parênteses:

# missing_parentheses.py
# Missing parentheses
 
print "Hello"  # Should be print("Hello")

Erro:

  File "missing_parentheses.py", line 4
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Repare quão útil é a mensagem de erro do Python aqui—ela até sugere a correção!

1.5.6) Estratégias para Lidar com Erros

Quando você encontrar um erro:

1. Não entre em pânico: Erros são normais. Todo programador os vê o tempo todo.

2. Leia a mensagem com atenção: As mensagens de erro do Python geralmente são úteis. Elas dizem o que deu errado e onde.

3. Verifique o número da linha: Vá até a linha que o Python indicou e procure o problema.

4. Olhe as linhas próximas: Às vezes o erro está na linha anterior à que o Python apontou.

5. Verifique erros comuns: Dois-pontos faltando, aspas que não combinam, indentação incorreta e typos são muito comuns.

6. Teste pequenas mudanças: Corrija uma coisa de cada vez e teste a cada mudança.

7. Use o REPL: Se estiver em dúvida sobre algo, teste primeiro no REPL.

8. Pesquise o erro: Se você não entender a mensagem de erro, pesquise-a na internet. Você normalmente vai encontrar explicações e soluções.

1.5.7) Um Exemplo Completo com Erro e Correção

Vamos ver um script com vários erros e corrigi-los passo a passo. Este programa foi feito para exibir informações sobre uma estudante e calcular a idade dela em 10 anos:

Original (com erros):

# buggy_student.py
# This program has several errors
 
student_name = "Alice
student_age = 25
 
print("Name:", student_name)
print("Age:" student_age)
print("In 10 years, you will be", student_age + "10")

Executar isso produz vários erros. Vamos corrigi-los um por um:

Erro 1: String não terminada

  File "buggy_student.py", line 4
    student_name = "Alice
                   ^
SyntaxError: unterminated string literal (detected at line 4)

Correção: adicionar a aspa de fechamento:

student_name = "Alice"

Depois de corrigir o Erro 1, temos o Erro 2: Vírgula faltando

  File "buggy_student.py", line 8
    print("Age:" student_age)
                 ^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

Correção: adicionar uma vírgula entre a string e a variável:

print("Age:", student_age)

Depois de corrigir o Erro 2, temos o Erro 3: Erro de tipo

Traceback (most recent call last):
  File "buggy_student.py", line 9, in <module>
    print("In 10 years, you will be", student_age + "10")
                                      ~~~~~~~~~~~~^~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Correção: converter "10" para inteiro:

print("In 10 years, you will be", student_age + 10)

Versão final corrigida:

# buggy_student_fixed.py
# Fixed version of the program
 
student_name = "Alice"
student_age = 25
 
print("Name:", student_name)
print("Age:", student_age)
print("In 10 years, you will be", student_age + 10)

Saída:

Name: Alice
Age: 25
In 10 years, you will be 35

Este exemplo mostra que corrigir erros é muitas vezes um processo iterativo. Você corrige um erro, executa o código de novo e descobre o próximo erro. Isso é completamente normal.

1.6) Quando Usar o Interactive Shell vs Arquivos de Script

Agora que você aprendeu tanto sobre o REPL quanto sobre arquivos de script, pode estar se perguntando quando usar cada um. Os dois são ferramentas valiosas, e programadores(as) Python experientes usam ambos com frequência. Entender quando usar cada um vai te deixar mais eficiente.

1.6.1) Use o Interactive Shell (REPL) Quando:

1. Estiver aprendendo conceitos novos

Quando você está aprendendo algo novo, o REPL fornece feedback imediato:

>>> # Testing string methods
>>> text = "hello world"
>>> text.upper()
'HELLO WORLD'
>>> text.title()
'Hello World'
>>> text.capitalize()
'Hello world'

Você pode experimentar métodos diferentes e ver os resultados instantaneamente, sem criar arquivos.

2. Estiver testando pequenos trechos de código

Antes de adicionar código ao seu programa, teste-o no REPL:

>>> # Testing a calculation
>>> price = 19.99
>>> quantity = 3
>>> total = price * quantity
>>> total
59.97
>>> # Looks good, now I can add this to my script

3. Precisar de cálculos rápidos

O REPL está sempre disponível como calculadora:

>>> # How many seconds in a day?
>>> 24 * 60 * 60
86400
>>> # What's 15% of 250?
>>> 250 * 0.15
37.5

4. Estiver depurando

Quando o seu script não está funcionando, use o REPL para testar partes individuais:

>>> # My script isn't working. Let me test this part:
>>> numbers = [1, 2, 3, 4, 5]
>>> sum(numbers) / len(numbers)
3.0
>>> # This works, so the problem must be elsewhere

Note: We'll learn about lists in Chapter 13. This example shows how the REPL helps test code snippets.

1.6.2) Use Arquivos de Script Quando:

1. Estiver escrevendo programas que você quer guardar

Qualquer coisa que você queira salvar e executar de novo deve estar em um arquivo de script:

# temperature_converter.py
# A program to convert Fahrenheit to Celsius
 
fahrenheit = 98.6
celsius = (fahrenheit - 32) * 5/9
print("Temperature:", fahrenheit, "°F is", round(celsius, 1), "°C")

Saída:

Temperature: 98.6 °F is 37.0 °C

Você pode executar esse script sempre que precisar e pode modificá-lo depois.

2. Estiver escrevendo programas de múltiplas linhas

Embora você possa escrever código de múltiplas linhas no REPL, isso fica desconfortável para qualquer coisa mais extensa. Use um arquivo de script:

# grade_calculator.py
# Calculate final grade from multiple scores
 
homework = 85
midterm = 78
final = 92
 
# Calculate weighted average
final_grade = (homework * 0.3) + (midterm * 0.3) + (final * 0.4)
 
print("Final Grade:", final_grade)

Saída:

Final Grade: 85.3

3. For compartilhar código com outras pessoas

Arquivos de script podem ser compartilhados com facilidade, enquanto sessões do REPL não podem:

# greeting.py
# A simple greeting program
 
name = input("What is your name? ")
print("Hello,", name + "! Welcome to Python.")

Note: We'll learn about the input() function in Chapter 2. This example shows how scripts can be shared.

Você pode enviar esse arquivo para outra pessoa e ela pode executá-lo no próprio computador.

4. Estiver criando ferramentas reutilizáveis

Se você estiver criando algo que vai usar repetidamente, faça um script:

# file_counter.py
# Count files in a directory
 
import os
 
directory = "."  # Current directory
files = [f for f in os.listdir(directory) if os.path.isfile(f)]
print("Number of files:", len(files))

Note: We'll learn about importing modules in Chapter 22 and list comprehensions in Chapter 34. This example shows how scripts can be reusable tools.

5. Estiver desenvolvendo lógica complexa

Para qualquer coisa com múltiplas funções, classes ou lógica complexa, use arquivos de script:

# password_checker.py
# Check password strength
 
def check_password_strength(password):
    """Check if a password meets basic requirements."""
    if len(password) < 8:
        return "Too short"
    if not any(c.isupper() for c in password):
        return "Needs uppercase letter"
    if not any(c.isdigit() for c in password):
        return "Needs number"
    return "Strong password"
 
# Test the function
test_password = "MyPass123"
result = check_password_strength(test_password)
print("Password '" + test_password + "':", result)

Saída:

Password 'MyPass123': Strong password

Note: We'll learn about functions in Chapter 19. This example shows how scripts handle complex logic.

6. Estiver automatizando tarefas

Scripts são perfeitos para automação:

# backup_reminder.py
# Remind user to backup files
 
import datetime
 
today = datetime.date.today()
day_of_week = today.strftime("%A")
 
if day_of_week == "Friday":
    print("Don't forget to backup your files!")
else:
    print("Backup reminder: Next backup on Friday")

Note: We'll learn about the datetime module in Chapter 39. This example shows how scripts can automate tasks.

1.6.3) Um Fluxo de Trabalho Prático

Programadores(as) Python profissionais normalmente usam tanto o REPL quanto arquivos de script de forma complementar:

Exemplo de fluxo de trabalho:

1. Explorar no REPL: Testar um conceito novo ou verificar um cálculo
2. Criar um protótipo no REPL: Montar uma versão pequena que funcione
3. Migrar para um script: Quando funcionar, colocar o código em um arquivo de script
4. Expandir no script: Adicionar mais recursos, tratamento de erros etc.
5. Depurar com o REPL: Se algo quebrar, testar partes do código no REPL
6. Finalizar o script: Completar, testar e salvar o programa

1.6.4) Um Exemplo Concreto

Vamos ver esse fluxo de trabalho em ação. Suponha que você queira escrever um programa que calcula a área de um círculo.

Passo 1: Explorar no REPL

>>> # What's the formula? Area = π * r²
>>> # Let me use a simple approximation for π
>>> 3.14159 * 5 * 5
78.53975
>>> # Looks right!

Passo 2: Criar um script

Agora que você sabe que funciona, crie circle_area.py:

# circle_area.py
# Calculate the area of a circle
 
radius = 5
pi = 3.14159
area = pi * radius * radius
 
print("Radius:", radius)
print("Area:", area)

Saída:

Radius: 5
Area: 78.53975

Passo 3: Melhorar o script

Faça com que funcione para vários raios:

# circle_area_enhanced.py
# Calculate area for multiple circles
 
radii = [3, 5, 7, 10]
pi = 3.14159
 
for radius in radii:
    area = pi * radius * radius
    print("Circle with radius", radius, "has area", round(area, 2))

Saída:

Circle with radius 3 has area 28.27
Circle with radius 5 has area 78.54
Circle with radius 7 has area 153.94
Circle with radius 10 has area 314.16

Note: We'll learn about for loops in Chapter 11. In Chapter 2, we'll learn how to make this interactive by getting input from the user.

Esse fluxo—experimentar no REPL e depois formalizar em um script—é como muitos programas em Python são desenvolvidos.

1.6.5) Pontos-Chave

Pontos fortes do REPL:

• Feedback imediato
• Ótimo para aprendizado
• Perfeito para testes rápidos
• Excelente para exploração
• Não exige gerenciar arquivos

Limitações do REPL:

• O código não é salvo
• Desconfortável para código de múltiplas linhas
• Difícil de compartilhar
• Não é adequado para programas complexos

Pontos fortes de arquivos de script:

• O código é salvo permanentemente
• Fácil de editar e modificar
• Pode ser compartilhado com outras pessoas
• Adequado para programas complexos
• Pode ser executado repetidas vezes
• Pode ser automatizado

Limitações de arquivos de script:

• Exige criar e gerenciar arquivos
• É preciso executar para ver resultados
• Mais "overhead" para testes rápidos

A melhor abordagem é usar ambos: o REPL para aprendizado, testes e exploração, e arquivos de script para qualquer coisa que você queira guardar, compartilhar ou executar repetidamente.

1.7) Qual Versão de Python Este Livro Usa (e Por Que Isso Importa)

O Python evoluiu bastante ao longo dos anos, e versões diferentes podem se comportar de maneiras diferentes. Entender as versões do Python vai te ajudar a evitar confusão e garantir que seu código funcione como esperado.

Você pode se perguntar por que estamos gastando tempo falando sobre versões do Python. A razão é simples: você vai encontrar código Python na internet, em tutoriais e em documentação. Entender versões te ajuda a reconhecer quando o código está desatualizado e a evitar confusão quando algo não funciona como o esperado.

1.7.1) Python 2 vs Python 3

A divisão mais importante na história do Python é entre Python 2 e Python 3.

Python 2 foi lançado em 2000 e foi a versão dominante por muitos anos. Porém, ele tinha alguns problemas de design que não podiam ser corrigidos sem quebrar código existente.

Python 3 foi lançado em 2008 como uma grande reformulação que corrigiu esses problemas. No entanto, ele não é compatível para trás com o Python 2, o que significa que código escrito para Python 2 muitas vezes não roda no Python 3 sem modificações.

Por muitos anos, as duas versões coexistiram. Porém, o Python 2 chegou ao fim de vida em 1º de janeiro de 2020. Isso significa:

• Não há mais atualizações ou correções de segurança para Python 2
• Todo desenvolvimento novo em Python usa Python 3
• Todas as principais bibliotecas migraram para Python 3
• Não é recomendado aprender Python 2 hoje

Este livro usa exclusivamente Python 3. Todos os exemplos de código são escritos para Python 3 e podem não funcionar em Python 2.

1.7.2) Versões Menores do Python 3

Dentro do Python 3, existem versões menores (3.6, 3.7, 3.8, 3.9, 3.10, 3.11, 3.12, etc.). Cada versão menor adiciona novos recursos e melhorias, mantendo a compatibilidade com versões anteriores do Python 3.

Este livro foi escrito para Python 3.11 e posteriores, mas a maioria dos exemplos vai funcionar em Python 3.8 e acima.

Para verificar a versão do seu Python:

python --version  # Windows
python3 --version  # macOS/Linux

Você deve ver algo como:

Python 3.11.5

Se você vir:

Python 2.7.18

Você está rodando Python 2, que está ultrapassado. Instale o Python 3 seguindo as instruções da Seção 1.2.

1.7.3) Diferenças-Chave que Você Pode Encontrar

Se você estiver lendo tutoriais antigos ou código na internet (especialmente tutoriais antigos e respostas antigas no Stack Overflow de antes de 2020), pode ver sintaxes que não funcionam no Python 3. Aqui estão as diferenças mais comuns:

1. A instrução print vs a função print

Python 2:

print "Hello, World!"  # No parentheses

Python 3:

print("Hello, World!")  # Parentheses required

No Python 3, print é uma função e precisa de parênteses. Essa é a diferença mais visível.

2. Comportamento da divisão

Essas mudanças foram feitas para tornar o Python mais consistente e seguro. Por exemplo, transformar print em uma função permite usá-la como qualquer outra função, e fazer com que / sempre faça divisão de ponto flutuante elimina uma fonte comum de bugs.

Python 2:

>>> 5 / 2
2  # Integer division
>>> 5.0 / 2
2.5  # Float division

Python 3:

>>> 5 / 2
2.5  # Always float division
>>> 5 // 2
2  # Integer division (floor division)

No Python 3, / sempre faz divisão de ponto flutuante. Use // para divisão inteira.

3. Função input()

Python 2:

name = raw_input("Enter your name: ")  # Returns string
age = input("Enter your age: ")  # Evaluates input as Python code (dangerous!)

Python 3:

name = input("Enter your name: ")  # Always returns string
age = int(input("Enter your age: "))  # Convert to int if needed

No Python 3, input() sempre retorna uma string, o que é mais seguro e mais consistente.

4. String e Unicode

O Python 3 lida com texto (Unicode) muito melhor do que o Python 2. Todas as strings no Python 3 são Unicode por padrão, o que facilita muito o trabalho com texto internacional.

1.7.4) Recursos por Versão do Python 3

Versões diferentes do Python 3 introduziram recursos diferentes. Aqui está o que você precisa saber:

Python 3.6 (December 2016):

• f-strings for string formatting (we'll use these extensively)

# f_string_example.py
name = "Alice"
print("Hello, " + name + "!")

Saída:

Hello, Alice!

Note: We'll learn about f-strings in Chapter 6. For now, we're using simple string concatenation with +.

Python 3.8 (October 2019):

• The walrus operator (:=) for assignment expressions (we'll cover this in Chapter 40)

Python 3.10 (October 2021):

• Structural pattern matching with match and case (we'll cover this in Chapter 12)

Python 3.11 (October 2022):

• Significantly improved error messages
• Better performance
• Enhanced exception handling

Python 3.12 (October 2023):

• Further performance improvements
• New type annotation features
• Improved f-string syntax

1.7.5) Qual Versão Você Deve Usar?

Recomendação: Use Python 3.11 ou mais recente se possível. Motivos:

1. Melhores mensagens de erro: O Python 3.11 tem mensagens de erro bem mais claras, ótimas para iniciantes.

2. Melhor performance: O Python 3.11 é mais rápido que versões anteriores.

3. Recursos modernos: Você terá acesso a todos os recursos mais recentes da linguagem.

4. Mais futuro: Código escrito para Python 3.11 vai funcionar em versões futuras.

No entanto, qualquer Python 3.8 ou mais recente é suficiente para aprender com este livro. Os conceitos centrais continuam os mesmos.

1.7.6) Verificando a Disponibilidade de Recursos

Se você estiver usando uma versão mais antiga e encontrar código que não funciona, pode verificar em qual versão um recurso foi introduzido.

Por exemplo, se estiver usando Python 3.5 ou anterior, talvez precise usar uma forma mais antiga de formatação de string:

# format_example.py
# Works in all Python 3 versions
name = "Alice"
print("Hello, {}!".format(name))

Saída:

Hello, Alice!

1.7.7) Mantendo-se Atualizado

O Python lança uma nova versão menor aproximadamente uma vez por ano. Embora você não precise atualizar imediatamente, é bom se manter razoavelmente atual:

• Verifique atualizações a cada alguns meses
• Leia as notas de versão para aprender os novos recursos
• Atualize quando for conveniente, especialmente por motivos de segurança
• Teste seu código após atualizar para garantir que tudo continua funcionando

Você encontra versões do Python e documentação em https://www.python.org/.

1.7.8) Compatibilidade de Versão Neste Livro

Ao longo deste livro:

• Todos os exemplos de código funcionam em Python 3.11+
• A maioria dos exemplos funciona em Python 3.8+
• Recursos específicos de versão são claramente indicados (por exemplo, "Isso requer Python 3.10+")
• Abordagens alternativas são fornecidas quando apropriado para versões mais antigas

Sempre que você vir código neste livro, pode digitar com confiança em Python 3.11 ou posterior e esperar que funcione exatamente como mostrado.

1.7.9) Uma Observação Sobre Código Python 2 que Você Pode Encontrar Online

Se você estiver procurando ajuda sobre Python na internet, pode encontrar código em Python 2. Veja como reconhecer:

Sinais de código Python 2:

• print sem parênteses: print "Hello"
• Função raw_input()
• Divisão que gera inteiros: 5 / 2 igual a 2
• Formatação antiga de strings: "Hello %s" % name
• Comentários dizendo "Python 2" ou mencionando versão 2.x

O que fazer:

• Procure alternativas para Python 3
• Adicione "python 3" às suas buscas
• Verifique a data—qualquer coisa antes de 2020 pode ser Python 2
• Use a documentação oficial do Python 3: https://docs.python.org/3/

Parabéns! Você concluiu o Capítulo 1 e deu seus primeiros passos com Python. Agora você sabe:

• O que é Python e como ele funciona
• Como instalar Python e executar o interpretador
• Como usar o Python interactive shell (REPL) para experimentação
• Como criar e executar arquivos de script em Python
• Como ler e entender mensagens de erro e tracebacks
• Quando usar o REPL e quando usar arquivos de script
• Qual versão de Python usar e por que isso importa

Agora você está pronto para seguir para o Capítulo 2, onde vai escrever seus primeiros programas completos em Python, aprender a função print() em detalhes e começar a trabalhar com entrada de usuário. A base que você construiu neste capítulo vai sustentar tudo que você aprender daqui para frente.