1 - Introdução ao Python

Python é uma linguagem de programação de alto nível, interpretada, de propósito geral e com uma sintaxe clara e legível.

Foi criada por Guido van Rossum e lançada pela primeira vez em 1991.

O nome "Python" foi inspirado no grupo de comédia britânico Monty Python, do qual Guido van Rossum é fã.

São características e vantagens:

• Simplicidade e Legibilidade: A sintaxe limpa e legível de Python permite que os programadores expressem conceitos complexos com menos linhas de código do que em outras linguagens. Isso torna o Python uma linguagem fácil de aprender e usar, especialmente para iniciantes.
• Multiplataforma: Python é compatível com diversos sistemas operacionais, incluindo Windows, Linux, macOS e outros. Isso permite que os programas escritos em Python sejam executados em diferentes plataformas sem a necessidade de grandes alterações.
• Interpretada e de Alto Nível: Python é uma linguagem interpretada, o que significa que o código-fonte é executado diretamente por um interpretador em vez de ser compilado para uma linguagem de máquina específica. Sendo uma linguagem de alto nível, os programadores podem se concentrar mais na lógica do programa e menos nos detalhes da máquina.
• Ampla Comunidade e Bibliotecas: Python possui uma comunidade ativa e engajada de desenvolvedores em todo o mundo. Essa comunidade contribui com uma grande quantidade de bibliotecas e módulos, conhecidos como "pacotes", que tornam mais fácil a implementação de diversas funcionalidades, desde desenvolvimento web até ciência de dados.
• Orientada a Objetos: Python suporta programação orientada a objetos, permitindo que os programadores criem classes e objetos para organizar e estruturar seus códigos de forma mais modular e reutilizável.
• Gratuita e de Código Aberto: Python é uma linguagem de código aberto e gratuita, o que significa que qualquer pessoa pode usar, modificar e distribuir seu código sem custo, de acordo com a licença Python Software Foundation (PSF).

O Python tem diversos usos e aplicações:

• Desenvolvimento Web: Python é amplamente usado em desenvolvimento web para criar sites e aplicativos web. Frameworks populares como Django e Flask tornam o desenvolvimento web rápido e eficiente.
• Análise de Dados e Ciência de Dados: Python é a escolha preferida para análise de dados e ciência de dados devido a suas bibliotecas robustas, como Pandas, Numpy e SciPy.
• Automação e Scripting: Python é frequentemente usado para automação de tarefas repetitivas, gerenciamento de sistemas e criação de scripts.
• Inteligência Artificial e Aprendizado de Máquina: Python é uma das principais linguagens para projetos de inteligência artificial e aprendizado de máquina, devido às bibliotecas como TensorFlow, Keras e PyTorch.
• Desenvolvimento de Jogos: Python também é utilizado no desenvolvimento de jogos, especialmente com a biblioteca Pygame.

Python é uma linguagem de programação poderosa, versátil e de fácil aprendizado, que atrai uma comunidade diversificada de desenvolvedores em todo o mundo.

Sua simplicidade, legibilidade e extensibilidade a tornam uma escolha ideal para projetos de todos os tamanhos, desde pequenos scripts até aplicativos web complexos e soluções de ciência de dados.

Ao embarcar na jornada de aprendizado de Python, você terá acesso a um universo de possibilidades para construir projetos criativos e resolver problemas do mundo real.

Antes de começar a programar em Python, é importante configurar o ambiente de desenvolvimento.

Isso envolve a instalação do Python e a configuração de um editor de código para escrever, testar e depurar seus programas.

Instalação do Python

A primeira etapa é instalar o interpretador do Python em seu sistema.

O Python está disponível para diferentes sistemas operacionais, como Windows, Linux e macOS.

• Windows e macOS: Você pode fazer o download do instalador no site oficial do Python em https://www.python.org/downloads/. Durante a instalação, certifique-se de marcar a opção "Adicionar Python x.x ao PATH" (onde x.x é versão específica do Python que você está instalando). Isso permitirá que você execute o Python a partir da linha de comando.
• Linux: O Python geralmente já vem pré-instalado na maioria das distribuições Linux. Caso não esteja instalado, você pode usar o gerenciador de pacotes da sua distribuição para instalar o Python.

Editor de Código

Para escrever código Python, você precisará de um editor de código ou ambiente de desenvolvimento integrado (IDE). Existem muitas opções disponíveis, e a escolha depende da sua preferência pessoal.

Algumas opções populares:

• Visual Studio Code (VSCode): Um editor de código gratuito e leve desenvolvido pela Microsoft, com suporte para extensões Python e depuração integrada.
• PyCharm: Uma IDE profissional para Python desenvolvida pela JetBrains. A versão Community Edition é gratuita e oferece recursos avançados para desenvolvimento em Python.
• Sublime Text: Um editor de código leve e altamente personalizável com suporte para Python e muitas outras linguagens.
• Atom: Um editor de código de código aberto e altamente personalizável, com suporte para pacotes Python e integração Git.

Verificação da Instalação

Para verificar se a instalação do Python foi feita corretamente e qual a versão instalada, abra o terminal ou prompt de comando e digite:

python --version

Isso exibirá a versão do Python instalada em seu sistema.

Com seu ambiente de desenvolvimento configurado, é o momento de escrever seu primeiro programa Python.

Abra o editor de código, crie um novo arquivo com extensão ".py" (por exemplo, "meu_programa.py") e digite o seguinte código:

print("Olá, mundo!")

Salve o arquivo e, em seguida, execute-o no terminal ou prompt de comando:

python meu_programa.py

Você verá a mensagem "Olá, mundo!" sendo impressa na tela.

Em Python, as variáveis são usadas para armazenar na memória do computador (RAM - Random Access Memory) os dados de diferentes tipos, para que possam ser manipulados nos programas.

Cada variável tem um nome único, usado para ser acessado para consulta ou atribuição do valor da variável.

Declaração de Variáveis

Em Python, as variáveis são criadas no momento em que atribuímos um valor a elas.

Não precisamos declarar explicitamente o tipo de dado que a variável irá armazenar, pois Python é uma linguagem de tipagem dinâmica.

O tipo da variável é inferido automaticamente com base no valor atribuído.

Declare variáveis.

numero_inteiro = 42
numero_decimal = 3.14
numero_complexo = 3 + 4j
texto = "Olá, mundo!"
booleano = True

Imprima os valores com tipo dos dados das variáveis.

print(f"numero_inteiro: {numero_inteiro} ({type(numero_inteiro)})")
print(f"numero_decimal: {numero_decimal} ({type(numero_decimal)})")
print(f"numero_complexo: {numero_complexo} ({type(numero_complexo)})")
print(f"texto: {texto} ({type(texto)})")
print(f"booleano: {booleano} ({type(booleano)})")

numero_inteiro: 42 (<class 'int'>)
numero_decimal: 3.14 (<class 'float'>)
numero_complexo: (3+4j) (<class 'complex'>)
texto: Olá, mundo! (<class 'str'>)
booleano: True (<class 'bool'>)

Tipos de Dados Básicos

Os tipos de dados básicos em Python incluem números, textos (strings) e booleanos (booleans), que são valores lógicos.

• Inteiros (int): Números inteiros, como 1, 10, -5.
• Números decimais (float): Números de ponto flutuante, como 3.14, 2.718.
• Números complexos (complex): Números na forma "a + bj", onde "a" e "b" são números reais e "j" representa a unidade imaginária (√-1).
• Strings: Strings são sequências de caracteres. Podem ser delimitadas por aspas simples (' '), aspas duplas (" ") ou até mesmo por três aspas para strings multilinhas.
• Booleanos: O tipo booleano representa os valores True (verdadeiro) e False (falso). São usados para lógica e controle de fluxo em programas.

Conversão de Tipos (type casting)

Você pode converter um tipo de dado para outro, usando a classe do tipo de destino para na conversão, como int() , float() e str().

Use o comando type() para verificar o tipo da variável.

# Converte o texto "10" para o inteiro 10
numero_texto = "10"
numero_texto_para_inteiro = int(numero_texto)  

print(f"numero_texto: {numero_texto} ({type(numero_texto)})")
print(f"numero_texto_para_inteiro: {numero_texto_para_inteiro} ({type(numero_texto_para_inteiro)})")

# Converte o texto "3.14" para o número de ponto flutuante 3.14
numero_decimal_texto = "3.14"
numero_texto_para_decimal = float(numero_decimal_texto)  

print(f"numero_texto: {numero_decimal_texto} ({type(numero_decimal_texto)})")
print(f"numero_texto_para_decimal: {numero_texto_para_decimal} ({type(numero_texto_para_decimal)})")

# Converte o inteiro 42 para o texto "42"
numero_inteiro = 42
numero_inteiro_para_texto = str(numero_inteiro)

print(f"numero_inteiro: {numero_inteiro} ({type(numero_inteiro)})")
print(f"numero_inteiro_para_texto: {numero_inteiro_para_texto} ({type(numero_inteiro_para_texto)})")

numero_texto: 10 (<class 'str'>)
numero_texto_para_inteiro: 10 (<class 'int'>)
numero_texto: 3.14 (<class 'str'>)
numero_texto_para_decimal: 3.14 (<class 'float'>)
numero_inteiro: 42 (<class 'int'>)
numero_inteiro_para_texto: 42 (<class 'str'>)

Existem diferentes tipos de operações com variáveis:

• Aritméticas: Operações matemáticas (+, -, *, /, %).
• Comparação: Operações de comparação (==, !=, >, <, >=, <=).
• Logica: Operações de lógica (and, or, not).
• Atribuição: Operações de atribuição (=, +=, -=, *=, /=, %=).
• Concatenação: Operações de concatenação (+).

1.5.1 - Operações Aritméticas

# Operações com variáveis numéricas
x = 10
y = 5.3
soma = x + y
subtracao = x - y
multiplicacao = x * y
divisao = x / y
resto = x % y

print(f"x             : {x} ({type(x)})")
print(f"y             : {y} ({type(y)})")
print(f"Soma          : {soma} ({type(soma)})")
print(f"Subtração     : {subtracao} ({type(subtracao)})")
print(f"Multiplicação : {multiplicacao} ({type(multiplicacao)})")
print(f"Divisão       : {divisao} ({type(divisao)})")
print(f"Resto         : {resto} ({type(resto)})")

x             : 10 (<class 'int'>)
y             : 5.3 (<class 'float'>)
Soma          : 15.3 (<class 'float'>)
Subtração     : 4.7 (<class 'float'>)
Multiplicação : 53.0 (<class 'float'>)
Divisão       : 1.8867924528301887 (<class 'float'>)
Resto         : 4.7 (<class 'float'>)

1.5.2 - Operações de Comparação

x = 10
y = 5.3
igual = x == y           # False
diferente = x != y       # True
maior = x > y            # True
menor = x < y            # False
maior_ou_igual = x >= y  # True
menor_ou_igual = x <= y  # False

print(f"x              : {x} ({type(x)})")
print(f"y              : {y} ({type(y)})")
print(f"igual          : {igual} ({type(igual)})")
print(f"diferente      : {diferente} ({type(diferente)})")
print(f"maior          : {maior} ({type(maior)})")
print(f"menor          : {menor} ({type(menor)})")
print(f"maior_ou_igual : {maior_ou_igual} ({type(maior_ou_igual)})")
print(f"menor_ou_igual : {menor_ou_igual} ({type(menor_ou_igual)})")

x              : 10 (<class 'int'>)
y              : 5.3 (<class 'float'>)
igual          : False (<class 'bool'>)
diferente      : True (<class 'bool'>)
maior          : True (<class 'bool'>)
menor          : False (<class 'bool'>)
maior_ou_igual : True (<class 'bool'>)
menor_ou_igual : False (<class 'bool'>)

1.5.3 - Operações de Logica

x = True
y = False
e = x and y
ou = x or y
não = not x

print(f"x: {x} ({type(x)})")
print(f"y: {y} ({type(y)})")
print(f"e: {e} ({type(e)})")
print(f"ou: {ou} ({type(ou)})")
print(f"não: {não} ({type(não)})")

x: True (<class 'bool'>)
y: False (<class 'bool'>)
e: False (<class 'bool'>)
ou: True (<class 'bool'>)
não: False (<class 'bool'>)

1.5.4 - Operações de Atribuição

x = 10
y = 5.3
print(f"x: {x} ({type(x)})")
print(f"y: {y} ({type(y)})")

x: 10 (<class 'int'>)
y: 5.3 (<class 'float'>)

x += y  # x = 15.3
x -= y  # x = 10
x *= y  # x = 53
x /= y  # x = 10
x %= y  # x = 4.7

print(f"x: {x} ({type(x)})")
print(f"y: {y} ({type(y)})")

x: 4.7 (<class 'float'>)
y: 5.3 (<class 'float'>)

1.5.5 - Conversão

x = 10
y = 5.3
k = int(5.3)
t = float(10)

print(f"x: {x} ({type(x)})")
print(f"y: {y} ({type(y)})")
print(f"k: {k} ({type(k)})")
print(f"t: {t} ({type(t)})")

x: 10 (<class 'int'>)
y: 5.3 (<class 'float'>)
k: 5 (<class 'int'>)
t: 10.0 (<class 'float'>)

1.5.6 - Operações de Concatenação

nome = "Pedro"
sobrenome = "Teixeira"
nome_completo = nome + " " + sobrenome
idade = 29
nome_idade = nome + " " + str(idade)

Comentários são trechos de texto que você pode adicionar em seu código para fornecer informações adicionais, explicações ou anotações, sem serem executadas pelo interpretador do Python.]

São usados para tornar o código mais compreensível e ajudar outros programadores (ou até mesmo a você mesmo, no futuro) a entender o que o código faz.

Em Python, existem duas maneiras de adicionar comentários:

• Comentário em linha: Iniciam com o símbolo "#" e se estendem até o final da linha. São usados para comentários curtos e rápidos.
• Comentário em bloco: Podem ser usados para comentários mais longos, abrangendo várias linhas. Iniciam e terminam com três aspas duplas (""").

Exemplo de código com os dois tipos de comentários:

# Este é um comentário em linha

valor = 42  # Aqui está uma atribuição de valor

"""
Este é um comentário em bloco.
Ele pode se estender por várias linhas
e é útil para comentários mais detalhados.
"""

valor = 3.14

Comentários e formatação adequada do código são práticas essenciais para desenvolver programas Python legíveis e de fácil manutenção.

Comentários ajudam a explicar a lógica do código, enquanto a formatação correta, com o uso adequado de indentação, melhora a estrutura do programa.

Ao seguir essas boas práticas, você estará criando códigos mais claros e mais fáceis de entender, tanto para você quanto para outros desenvolvedores que possam colaborar em seus projetos.

A formatação adequada do código é essencial para torná-lo elegante e legível, claro e de fácil compreensão. Ao adotar convenções e práticas recomendadas, os desenvolvedores podem criar código que não apenas funciona, mas também é agradável de ler e manter.

Em Python, a indentação não é apenas uma questão estética; é uma parte fundamental da sintaxe. A estruturação adequada do código é alcançada por meio da indentação consistente. Seja dentro de laços (loops), condicionais ou funções, a indentação clara ajuda a entender a estrutura do código.

# Exemplo de indentação em um bloco condicional
if condicao:
    print("Bloco verdadeiro")
else:
    print("Bloco falso")

Vamos explorar alguns aspectos essenciais da formatação em Python, incluindo indentação de listas, argumentos de função e dicionários.

Python enfatiza a indentação como parte da estrutura do código e utiliza os espaços em branco (espaços ou tabulações) para delimitar blocos de código.

Indentação

Python utiliza a indentação para determinar a estrutura do código. Blocos de código dentro de estruturas de controle (como loops e condicionais) ou funções devem ser recuados com espaços ou tabulações para deixar claro quais instruções pertencem ao mesmo bloco.

Exemplo com indentação correta:

x = 1
if x > 0:
    print("x é positivo")
    print("Este é o mesmo bloco de código do 'if'")

x é positivo
Este é o mesmo bloco de código do 'if'

Exemplo com indentação incorreta:

if x > 0:
print("x é positivo")  # Erro de indentação!
print("Este não está no mesmo bloco de código do 'if'")

IndentationError: expected an indented block after 'if' statement on line 1 (<string>, line 2) <traceback object at 0x0000018D434DC680>

Ponto e Vírgula

Em Python, não é comum utilizar ponto e vírgula (";") para separar instruções. Geralmente, cada instrução ocupa uma linha separada.

Entretanto, o uso do ";", embora não seja recomendável pra separar instruções, pode ser usado para separar e finalizar instruções.

# Exemplo sem ponto e vírgula (recomendado)
a = 10
b = 20

# Exemplo com ponto e vírgula (não é comum em Python)
a = 10;          # não causa erro
b = 20;          # não causa erro
a = 10; b = 20   # não causa erro
a = 10; b = 20;  # não causa erro
a = 10; b = 20;; # causa erro

Largura da Linha

Recomenda-se que as linhas do código não ultrapassem 79 ou 80 caracteres.

Se necessário, você pode quebrar uma linha longa em várias linhas usando a barra invertida ("").

# Exemplo de quebra de linha
texto_longo = "Esta é uma linha muito longa que pode ser " \
              "quebrada em várias linhas para melhorar a " \
              "legibilidade do código."

Imprima esta linha longa.

print(texto_longo)

Esta é uma linha muito longa que pode ser quebrada em várias linhas para melhorar a legibilidade do código.

Ao lidar com listas, a formatação adequada garante que cada elemento seja destacado de maneira clara. A indentação dos elementos de uma lista proporciona um código mais organizado e fácil de seguir.

Identação de Listas

# Lista formatada com indentação
frutas = [
    'Maçã',
    'Banana',
    'Laranja',
    'Morango'
]

Identação de Argumentos de Função

Ao chamar funções com múltiplos argumentos, o alinhamento elegante melhora a legibilidade do código. Manter argumentos alinhados verticalmente facilita a compreensão e manutenção do código.

# Argumentos de função alinhados
resultado = calcular_valor(
    argumento1,
    argumento2,
    argumento3,
    argumento4
)

Identação de Dicionários

Dicionários em Python, que consistem em pares chave-valor, podem ser estruturados de forma a proporcionar uma visão clara e concisa.

A indentação é fundamental para destacar os pares chave-valor, garantindo uma fácil leitura.

# Dicionário formatado com indentação
pessoa = {
    'nome'   : 'Rosana',
    'idade'  : 61,
    'cidade' : 'BH'
}

PEP 8

A Python Enhancement Proposal (PEP) 8 é o guia de estilo para código Python. Adotar as convenções sugeridas pelo PEP 8 contribui para uma formatação consistente e padronizada. Ferramentas como o autopep8 podem ser utilizadas para automatizar a conformidade com as diretrizes do PEP 8.

A formatação em Python não é apenas uma questão de estética; é uma prática que impacta diretamente a legibilidade e manutenibilidade do código.

Ao adotar indentação clara, alinhamento elegante e seguir as convenções do PEP 8, os desenvolvedores podem transformar seu código em uma obra de arte, onde a beleza está na organização e na clareza.

A formatação em Python é mais do que um conjunto de regras; é a expressão visual da elegância na programação.

O tratamento de exceções em Python é realizado usando blocos try, except, else e finally, permitindo o controle de erros e exceções no programa de maneira elegante, evitando que seu programa encerre abruptamente.

Aqui estão os principais elementos envolvidos no tratamento de exceções em Python:

Estrutura Básica:

try:
    # Código onde uma exceção pode ocorrer
    resultado = 10 / 0  # Exemplo de divisão por zero
except ZeroDivisionError:
    # Código a ser executado se uma exceção específica ocorrer
    print("Erro: Divisão por zero!")
except Exception as e:
    # Código a ser executado para outras exceções
    print(f"Erro inesperado: {e}")
else:
    # Código a ser executado se nenhuma exceção ocorrer
    print("Nenhuma exceção ocorreu.")
finally:
    # Código a ser executado independentemente de ocorrer uma exceção ou não
    print("Este bloco sempre será executado.")

Explicação dos Blocos:

• try: Contém o código que pode gerar exceções.
• except: Especifica o tipo de exceção que você deseja lidar. Pode haver vários blocos except para diferentes tipos de exceções.
• as e: Opcional. Permite atribuir a exceção a uma variável para obter informações detalhadas sobre ela.
• else: Opcional. Contém código a ser executado se nenhum erro ocorrer no bloco try.
• finally: Opcional. Contém código que será sempre executado, independentemente de ocorrer ou não uma exceção.

Exemplos Práticos:

Exemplo 1: Divisão por Zero

def dividir(a, b):
    try:
        resultado = a / b
    except ZeroDivisionError:
        print("Erro: Divisão por zero!")
    else:
        print(f"Resultado da divisão: {resultado}")
    finally:
        print("Fim da operação\n")

dividir(10, 2)
dividir(10, 0)
dividir(10, 5)

Resultado da divisão: 5.0
Fim da operação

Erro: Divisão por zero!
Fim da operação

Resultado da divisão: 2.0
Fim da operação

Exemplo 2: Manipulação Genérica de Exceções

def operacao(arr):
    try:
        resultado = arr[0] + 10
        resultado /= arr[1]
    except (IndexError, ZeroDivisionError) as e:
        print(f"Erro: {e}")
    else:
        print(f"Resultado da operação: {resultado}")
    finally:
        print("Fim da operação\n")

operacao([5, 2])
operacao([5])
operacao([5, 0])

Resultado da operação: 7.5
Fim da operação

Erro: list index out of range
Fim da operação

Erro: division by zero
Fim da operação

Levantando Exceções:

Você também pode levantar exceções explicitamente usando a instrução raise. Isso é útil quando você deseja indicar que algo inesperado ocorreu em seu código.

def verificar_numero_positivo(numero):
    if numero < 0:
        raise ValueError("O número deve ser positivo.")
    else:
        print("Número válido.")

try:
    verificar_numero_positivo(-5)
except ValueError as e:
    print(f"Erro: {e}")

verificar_numero_positivo(5)

Erro: O número deve ser positivo.
Número válido.

O tratamento de exceções em Python é uma prática importante para garantir a robustez do seu código e fornecer informações úteis sobre problemas que podem surgir durante a execução do programa. Certifique-se de lidar com exceções de maneira apropriada para garantir a confiabilidade e a facilidade de manutenção do seu código.

Abaixo estão alguns dos tipos de exceção embutidos mais comuns em Python, juntamente com exemplos de uso de blocos except:

• Exception as e: Erros em geral
• SyntaxError: Erros de Sintaxe
• TypeError: Erros de Tipo
• NameError: Erros de Nome
• AttributeError: Erros de Atribuição
• TypeError: Erros de Tipo (quando uma operação ou função é aplicada a um tipo incompatível)
• ValueError: Erros de Valor (quando um valor não é aceitável)
• ZeroDivisionError: Divisão por Zero
• IndexError: Erros de Indice
• KeyError: Erros de Chave

Erro de sintaxe (SyntaxError), quando você tenta executar um código inválido.

Para gerar um SyntaxError usando uma estrutura try-except, é necessário simular uma situação onde ocorra um erro de sintaxe.

Contudo, SyntaxError é normalmente detectado em tempo de compilação (antes da execução do código), o que significa que não podemos capturá-lo em tempo de execução usando try-except dentro do mesmo script.

No entanto, é possível simular esse erro executando uma instrução que contenha um erro de sintaxe por meio da função exec(), que permite a execução de código Python contido em strings durante a execução do programa.

try:
    exec("for i in range(5) print(i)")  # Faltando dois pontos (:)
except SyntaxError as e:
    print(f"Erro de sintaxe: {e}")

Erro de sintaxe: expected ':' (<string>, line 1)

Erro de tipo (TypeError), quando você tenta realizar uma operação ou função em um tipo incompatível.

try:
    resultado = 10 + '10'
except TypeError as e:
    print(f"Erro de tipo: {e}")

Erro de tipo: unsupported operand type(s) for +: 'int' and 'str'

Erro de nome (NameError), quando você tenta acessar uma variável que não existe.

try:
    resultado = variavel_que_não_existe
except NameError as e:
    print(f"Erro de nome: {e}")

Erro de nome: name 'variavel_que_não_existe' is not defined

Erro de atribuição (AttributeError), quando você tenta acessar um atributo que não existe em um objeto.

try:
    objeto = object()
    resultado = objeto.atributo_que_não_existe
except AttributeError as e:
    print(f"Erro de atribuição: {e}")

Erro de atribuição: 'object' object has no attribute 'atributo_que_não_existe'

Erro de tipo (TypeError), quando você tenta realizar uma operação ou função em um tipo incompatível.

def somar_numeros(a, b):
    try:
        resultado = a + b
        print(f"Resultado da soma: {resultado}")
    except TypeError as e:
        print(f"Erro de tipo: {e}")

# Exemplo de uso
somar_numeros(5, 3)  # Saída esperada: Resultado da soma: 8
somar_numeros("5", 3)  # Saída esperada: Erro de tipo: can only concatenate str (not "int") to str

Resultado da soma: 8
Erro de tipo: can only concatenate str (not "int") to str

Erro de valor (ValueError), quando você tenta realizar uma operação ou função em um valor incompatível.

def converter_para_int(texto):
    try:
        numero = int(texto)
        print(f"Número convertido: {numero}")
    except ValueError as e:
        print(f"Erro de valor: {e}")

# Exemplo de uso
converter_para_int("42")  # Saída esperada: Número convertido: 42
converter_para_int("abc")  # Saída esperada: Erro de valor: invalid literal for int() with base 10: 'abc'

Número convertido: 42
Erro de valor: invalid literal for int() with base 10: 'abc'

Erro de divisão por zero(ZeroDivisionError), quando você tenta dividir um número por zero.

try:
    resultado = 10 / 0
except ZeroDivisionError as e:
    print(f"Erro de divisão por zero: {e}")

Erro de divisão por zero: division by zero

Erro de Índice (IndexError), quando você tenta acessar um índice que está fora do alcance.

lista = [1, 2, 3]
try:
    elemento = lista[10]
except IndexError as e:
    print(f"Erro de índice: {e}")

Erro de índice: list index out of range

Erro de Chave (KeyError), quando você tenta acessar uma chave que não existe em um dicionário.

dicionario = {'nome': 'Alice'}
try:
    valor = dicionario['idade']
except KeyError as e:
    print(f"Erro de chave: {e}")

Erro de chave: 'idade'

Erro de Arquivo Não Encontrado (FileNotFoundError), quando você tenta abrir um arquivo que não existe.

try:
    with open('arquivo_inexistente.txt', 'r') as arquivo:
        conteudo = arquivo.read()
except FileNotFoundError as e:
    print(f"Arquivo não encontrado: {e}")

Arquivo não encontrado: [Errno 2] No such file or directory: 'arquivo_inexistente.txt'

Estes são apenas alguns exemplos. Em muitos casos, você pode usar a classe base Exception para capturar qualquer exceção, mas é uma prática recomendada ser específico sobre os tipos de exceções que você espera lidar. Isso ajuda a evitar a captura de exceções indesejadas e a tornar seu código mais robusto.

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning