Python para Intermediário

Aprofunde seus conhecimentos em Python e torne-se um

desenvolvedor mais habilidoso.

Iniciar

Visão geral
O curso de Python para Intermediário é projetado para alunos que já possuem uma
base sólida em Python e desejam aprimorar suas habilidades na linguagem. O curso
abrange tópicos avançados, como manipulação de arquivos, programação orientada a
objetos e tratamento de exceções. Os alunos também aprenderão sobre bibliotecas
populares em Python, como numpy, pandas e matplotlib, que são amplamente
utilizadas para análise de dados e visualização. Ao final do curso, os alunos estarão
aptos a criar programas mais complexos e eficientes com Python.

01 Arquivos

Manipulação Avançada de
Arquivos

01 Manipulação Avançada de Arquivos

Neste tópico, veremos técnicas avançadas de manipulação de arquivos utilizando

Python. Através dessas técnicas, você poderá realizar tarefas complexas, como ler e
escrever em arquivos de diferentes formatos, manipular dados estruturados e
comprimir arquivos.
Leitura e Escrita em Formatos de Arquivo
Específicos

Ao trabalhar com arquivos em Python, é importante conhecer as diferentes bibliotecas

disponíveis para ler e escrever em formatos específicos. Algumas das bibliotecas mais
comuns são:

csv: Utilizada para leitura e escrita de arquivos CSV (Comma Separated Values), que são
amplamente utilizados para armazenar dados tabulares.

json: Ideal para trabalhar com arquivos JSON (JavaScript Object Notation), que são
amplamente utilizados para representar dados estruturados.

xlsxwriter e openpyxl: Essas bibliotecas permitem a leitura e escrita em arquivos Excel

(XLSX), um formato popular para armazenar dados em planilhas.

pdfminer e PyPDF2: Utilizadas para extrair informações de arquivos PDF, como texto e
metadados.

PIL (Python Imaging Library) e opencv: Essas bibliotecas são ideais para manipular imagens,
permitindo a leitura, redimensionamento, conversão de formato, entre outras operações.

Manipulação Estruturada de Arquivos

Além de ler e escrever em diferentes formatos de arquivo, em Python é possível

manipular dados estruturados armazenados em arquivos. Para isso, podemos utilizar
bibliotecas como:

pandas: Facilita a leitura, escrita e manipulação de dados tabulares de forma eficiente. Com
pandas, você poderá filtrar, ordenar, agregar e transformar dados em arquivos CSV, Excel,
JSON, entre outros formatos.

sqlite3: Permite interagir com bancos de dados SQLite, que são armazenados em um único
arquivo. Com essa biblioteca, você poderá executar consultas SQL, criar tabelas, inserir,
 atualizar e excluir registros.

lxml e BeautifulSoup: Essas bibliotecas são amplamente utilizadas para analisar e extrair
informações de arquivos HTML e XML. Com elas, é possível fazer scraping de páginas web,
buscar elementos específicos e extrair dados estruturados.

Compressão de Arquivos

Python também possui bibliotecas que permitem compactar e descompactar arquivos,

o que é especialmente útil quando se lida com grande volume de dados. Algumas
dessas bibliotecas são:

zipfile: Utilizada para compactar e descompactar arquivos ZIP. Com ela, você poderá criar e
extrair arquivos ZIP, bem como adicionar, atualizar e excluir arquivos dentro de um arquivo
compactado.

gz, bz2 e lzma: Essas bibliotecas lidam com a compressão e descompressão de arquivos
nos formatos GZIP, BZIP2 e LZMA, respectivamente. Elas são ideais para a manipulação de
arquivos individuais que precisam ser compactados.

tarfile: Permite criar, abrir e manipular arquivos TAR, que são arquivos de arquivamento que
podem conter múltiplos arquivos e diretórios.

Conclusão - Manipulação Avançada de Arquivos

A manipulação avançada de arquivos é uma habilidade essencial

para lidar com operações mais complexas de leitura e escrita
em Python. Ao dominar as técnicas apresentadas neste módulo,
você estará apto a realizar tarefas como contagem de palavras,
mesclagem de arquivos e muito mais. Continue praticando e
 explorando as possibilidades que a manipulação avançada de
arquivos oferece.

Programação Orientada a
Objetos

02 Programação Orientada a Objetos

A Programação Orientada a Objetos (POO) é um paradigma de programação que

busca organizar e estruturar o código de forma mais intuitiva, permitindo a criação de
programas mais modulares, flexíveis e reutilizáveis. A POO é amplamente utilizada
atualmente e é suportada por várias linguagens de programação, incluindo Python.

Conceitos Básicos
A POO se baseia em conceitos fundamentais que são essenciais para compreender
e utilizar corretamente essa abordagem. Os principais conceitos são:

Classe

Uma classe é uma estrutura que define um novo tipo de dado, especificando quais
atributos e métodos esse tipo de dado possui. A classe é a representação abstrata de
um objeto, descrevendo suas características e comportamentos. Para criar uma
classe em Python, utilizamos a palavra reservada class , seguida pelo nome da
classe e dois pontos (:).

class Carro:
pass

Nesse exemplo, criamos uma classe chamada Carro que ainda não possui nenhum
atributo ou método definido.

Objeto

Um objeto é uma instância de uma classe, ou seja, é uma representação concreta de

um tipo de dado definido pela classe. Para criar um objeto, utilizamos a sintaxe
nome_da_classe() , adicionando parênteses após o nome da classe. Podemos atribuir
esse objeto a uma variável para manipulá-lo posteriormente.

meu_carro = Carro()

Neste caso, criamos um objeto meu_carro que é uma instância da classe Carro .

Atributos
Atributos são características ou propriedades de um objeto que o definem. Podemos
pensar em um objeto do mundo real, como um carro, que possui atributos como cor,
modelo, ano, etc. Em Python, podemos adicionar atributos às nossas classes
definindo-os dentro de métodos chamados de construtores. O construtor padrão é o
método __init__() .

class Carro:
def __init__(self, cor, modelo, ano):
self.cor = cor
self.modelo = modelo
self.ano = ano

Neste exemplo, definimos três atributos ( cor , modelo e ano ) para a classe
Carro . Esses atributos são inicializados quando um novo objeto é criado.

Métodos

Métodos são funções que definem o comportamento de um objeto. Eles permitem

que os objetos executem ações ou realizem operações específicas. Em Python, os
métodos são definidos dentro de uma classe, assim como os atributos.

class Carro:
def __init__(self, cor, modelo, ano):
self.cor = cor
self.modelo = modelo
self.ano = ano

def acelerar(self):
print("O carro está acelerando...")

def frear(self):
print("O carro está freando...")
Neste exemplo, adicionamos dois métodos à classe Carro : acelerar() e frear() .
Esses métodos definem o comportamento de um objeto da classe Carro .

Encapsulamento

Uma das principais vantagens da POO é o conceito de encapsulamento, que consiste

em esconder a implementação interna dos objetos e fornecer uma interface para
interagir com eles. Isso permite que os objetos sejam usados de maneira mais
intuitiva e segura, sem a necessidade de conhecer detalhes internos complicados.

Em Python, utilizamos métodos especiais chamados de getters e setters para acessar

e definir os atributos de um objeto de forma controlada.

class Carro:
def __init__(self, cor, modelo, ano):
self.cor = cor
self.modelo = modelo
self.ano = ano

def get_cor(self):
return self.cor

def set_cor(self, nova_cor):

self.cor = nova_cor

Neste exemplo, definimos um método getter get_cor() e um método setter

set_cor() para o atributo cor da classe Carro . Assim, podemos acessar e
modificar esse atributo de forma segura.

Herança
A herança é um conceito importante na programação orientada a objetos, que
permite que uma classe herde atributos e métodos de outra classe. A classe que
herda é chamada de classe filha ou subclasse, e a classe da qual ela herda é
chamada de classe pai ou superclasse.

class Veiculo:
def __init__(self, cor, modelo, ano):
self.cor = cor
self.modelo = modelo
self.ano = ano

def acelerar(self):
print("O veículo está acelerando...")

def frear(self):
print("O veículo está freando...")

class Carro(Veiculo):
def __init__(self, cor, modelo, ano, num_portas):
super().__init__(cor, modelo, ano)
self.num_portas = num_portas

def abrir_porta(self):
print("A porta do carro está aberta.")

Neste exemplo, a classe Carro herda os atributos e métodos da classe Veiculo .

Além disso, a classe Carro também possui um novo atributo num_portas eo
método abrir_porta() .

Polimorfismo

O polimorfismo é outro conceito importante na POO, que permite que um objeto seja
tratado de várias formas diferentes ou possa assumir diferentes comportamentos
dependendo do contexto.

class Animal:
def fazer_som(self):
pass

class Cachorro(Animal):
def fazer_som(self):
print("Au Au!")

class Gato(Animal):
def fazer_som(self):
print("Miau!")

def fazer_barulho(animal):
animal.fazer_som()

cachorro = Cachorro()
gato = Gato()

fazer_barulho(cachorro) # Output: Au Au!

fazer_barulho(gato) # Output: Miau!

Neste exemplo, temos as classes Animal , Cachorro e Gato . Cada uma dessas
classes possui um método fazer_som() . O polimorfismo é aplicado quando
chamamos a função fazer_barulho() , passando um objeto Cachorro e um objeto
Gato . O comportamento específico de cada objeto é invocado dependendo do tipo
do objeto em tempo de execução.

Conclusão - Programação Orientada a Objetos

 A programação orientada a objetos é um paradigma
fundamental no desenvolvimento de software em Python. Neste
módulo, você aprendeu sobre classes, objetos, herança e outros
conceitos que permitem a criação de estruturas de código mais
organizadas, flexíveis e reutilizáveis. Ao aplicar os princípios da
programação orientada a objetos, você estará preparado para
desenvolver soluções mais robustas e escaláveis em Python.

Tratamento de Exceções

03 Tratamento de Exceções

O tratamento de exceções é uma técnica essencial na programação em Python, que

permite lidar com erros e exceções que podem ocorrer durante a execução de um
programa. É importante entender como tratar adequadamente essas exceções, a fim
de melhorar a robustez e a manutenibilidade do código.
O que são exceções?

Uma exceção é um evento que ocorre durante a execução de um programa e que

interrompe o fluxo normal de execução. Em Python, as exceções são representadas
por objetos que fornecem informações sobre o erro que ocorreu. Existem vários tipos
de exceções pré-definidos em Python, como SyntaxError , TypeError ,
ZeroDivisionError , entre outros. Além disso, é possível criar exceções
personalizadas para casos específicos.

Bloco try-except

O tratamento de exceções é realizado por meio do uso dos blocos try e except .
O bloco try é utilizado para definir o código que pode gerar uma exceção. Se
ocorrer uma exceção durante a execução desse bloco, o controle é transferido para o
bloco except , onde o código para tratar a exceção é especificado.

A estrutura básica de um bloco try-except é a seguinte:

try:
# Código que pode gerar uma exceção
except ExcecaoTipo:
# Código para tratar a exceção

Tratando exceções específicas

É possível tratar diferentes tipos de exceções de forma específica, para lidar com
cada situação de erro de maneira adequada. Para isso, basta especificar o tipo de
exceção após a palavra-chave except . Por exemplo, para tratar uma exceção do
tipo ZeroDivisionError , utilizamos o seguinte código:

try:
# Código que pode gerar uma exceção
except ZeroDivisionError:
# Código para tratar a exceção do tipo ZeroDivisionError

Caso uma exceção ocorra durante a execução do bloco try e não seja tratada por
nenhum bloco except específico, ela será propagada para blocos except de níveis
superiores.

Bloco finally

O bloco finally é opcional e pode ser utilizado em conjunto com o bloco try-

except . O código especificado no bloco finally será sempre executado,

independentemente de ocorrer uma exceção ou não. Geralmente, esse bloco é
utilizado para a execução de ações de limpeza ou liberação de recursos, garantindo
que eles sejam realizados mesmo em caso de erro.

A estrutura básica de um bloco try-except-finally é a seguinte:

try:
# Código que pode gerar uma exceção
except ExcecaoTipo:
# Código para tratar a exceção
finally:
# Código que será sempre executado

Exceções personalizadas
Além das exceções pré-definidas em Python, é possível criar exceções
personalizadas para casos específicos. Isso é especialmente útil quando queremos
lançar uma exceção com uma mensagem personalizada ou estender o
comportamento de uma exceção existente. Para criar uma exceção personalizada,
basta criar uma classe que herde da classe Exception (ou de uma de suas
subclasses) e adicionar o comportamento desejado.

Por exemplo, podemos criar uma exceção personalizada chamada

SaldoInsuficienteError para ser utilizada em um sistema de controle de finanças:

class SaldoInsuficienteError(Exception):
def __init__(self, saldo_atual, quantidade):
self.saldo_atual = saldo_atual
self.quantidade = quantidade

def __str__(self):
return f"Saldo insuficiente. Saldo atual: {self.saldo_atual}, Quantida

Dessa forma, podemos lançar a exceção SaldoInsuficienteError quando uma

determinada transação exigir um saldo maior do que o disponível.

Conclusão

O tratamento de exceções é uma técnica fundamental para lidar com erros e

exceções em Python. O uso adequado dos blocos try-except e a criação de
exceções personalizadas permitem que o código seja mais robusto e tolerante a
erros, melhorando a experiência do usuário e facilitando a manutenção do sistema. É
importante familiarizar-se com os diferentes tipos de exceções e saber como tratá-las
corretamente, a fim de garantir que o código funcione corretamente em diferentes
situações.
 Conclusão - Tratamento de Exceções

O tratamento de exceções é uma habilidade essencial para lidar

com erros e situações inesperadas em programas Python.
Neste módulo, você aprendeu como utilizar blocos `try-except`
para capturar e tratar exceções, evitando que seu programa
seja interrompido abruptamente. Além disso, você explorou a
importância do bloco `finally` e como ele permite executar
código independente de ocorrer ou não uma exceção. Com o
conhecimento adquirido sobre tratamento de exceções, você
estará preparado para escrever códigos mais robustos e lidar
com cenários imprevistos de forma elegante.

Exercícios Práticos
Vamos colocar seus conhecimentos em prática
 04 Exercícios Práticos

Nesta lição, colocaremos a teoria em prática por meio de atividades práticas. Clique
nos itens abaixo para conferir cada exercício e desenvolver habilidades práticas que o
ajudarão a ter sucesso na disciplina.

Exercício 1: Contagem de Palavras

Escreva um programa em Python que leia um arquivo de texto e conte

quantas vezes cada palavra aparece. Em seguida, imprima no console o
resultado mostrando cada palavra e sua respectiva contagem.

Exercício 2: Mesclar Arquivos

Crie um programa em Python que receba como entrada dois arquivos de

texto e gere um terceiro arquivo contendo a mescla dos conteúdos dos dois
primeiros. O programa deve combinar as linhas alternadamente, começando
com a primeira linha do primeiro arquivo.
Exercício 3: Classe Banco

Crie uma classe chamada `Banco` que represente um banco. A classe deve
ter os atributos `nome` (string) e `saldo` (float). Além disso, implemente os
métodos `depositar(valor)` e `sacar(valor)` que atualizam o saldo conforme as
operações são realizadas. Teste a classe criando uma instância e realizando
algumas operações de depósito e saque.

Exercício 4: Herança

Defina uma classe `Veiculo` com os atributos `marca` e `modelo`. Em

seguida, crie as classes `Carro` e `Moto` que herdam da classe `Veiculo` e
adicionam o atributo `ano`. Implemente os métodos `mostrar_informacoes()`
nas classes filhas para exibir as informações do veículo.

Exercício 5: Divisão Segura

Escreva uma função em Python chamada `divisao_segura` que recebe dois

números como parâmetros e realiza a divisão do primeiro pelo segundo. No
entanto, trate a exceção caso ocorra uma divisão por zero, exibindo uma
mensagem de erro adequada. Teste a função chamando-a com diferentes
valores.
 Exercício 6: Leitura de Arquivo

Crie uma função chamada `ler_arquivo` em Python que recebe o nome de

um arquivo como parâmetro e tenta ler o conteúdo do arquivo. Caso o
arquivo não exista, capture a exceção e exiba uma mensagem informando
que o arquivo não foi encontrado. Teste a função passando-o o nome de um
arquivo inexistente.

Resumo
Vamos revisar o que acabamos de ver até agora

05 Resumo

A manipulação avançada de arquivos é uma habilidade essencial para lidar com

operações mais complexas de leitura e escrita em Python. Ao dominar as
técnicas apresentadas neste módulo, você estará apto a realizar tarefas como
contagem de palavras, mesclagem de arquivos e muito mais. Continue
praticando e explorando as possibilidades que a manipulação avançada de
arquivos oferece.

A programação orientada a objetos é um paradigma fundamental no

desenvolvimento de software em Python. Neste módulo, você aprendeu sobre
classes, objetos, herança e outros conceitos que permitem a criação de
estruturas de código mais organizadas, flexíveis e reutilizáveis. Ao aplicar os
princípios da programação orientada a objetos, você estará preparado para
desenvolver soluções mais robustas e escaláveis em Python.

O tratamento de exceções é uma habilidade essencial para lidar com erros e

situações inesperadas em programas Python. Neste módulo, você aprendeu
como utilizar blocos `try-except` para capturar e tratar exceções, evitando que
seu programa seja interrompido abruptamente. Além disso, você explorou a
importância do bloco `finally` e como ele permite executar código independente
de ocorrer ou não uma exceção. Com o conhecimento adquirido sobre
tratamento de exceções, você estará preparado para escrever códigos mais
robustos e lidar com cenários imprevistos de forma elegante.
Questionário
Verifique seu conhecimento respondendo a algumas perguntas

06 Questionário

1. Qual método em Python é usado para abrir um arquivo em modo de leitura?

open('arquivo.txt', 'r')

open('arquivo.txt', 'a')

open('arquivo.txt', 'w')

2. O que é herança na Programação Orientada a Objetos?

Uma técnica para criar novos objetos a partir de uma classe existente.

Um recurso que permite que uma classe herde os atributos e métodos de outra classe.

A capacidade de alterar o comportamento de um objeto em tempo de execução.

3. Qual das seguintes opções representa corretamente a sintaxe do bloco `try-except` em
Python?

try-catch { ... }

try: ... except Exception: ...

try { ... } except { ... }

4. Qual método é utilizado para escrever conteúdo em um arquivo em Python?

file.write()

file.close()

file.read()

5. O que acontece se uma exceção não for tratada em Python?

O programa gera um traceback e pode ser interrompido.

O programa continua a execução normalmente.

O programa exibe uma mensagem de erro e é encerrado.

6. Qual é o bloco final em um bloco `try-except` que permite executar código

independentemente de ocorrer ou não uma exceção?

finally

else

catch
 Enviar

Conclusão

Parabéns!
Parabéns por concluir este curso! Você deu um passo importante para liberar todo o
seu potencial. Concluir este curso não é apenas adquirir conhecimento; trata-se de
colocar esse conhecimento em prática e causar um impacto positivo no mundo ao
seu redor.

Compartilhar este curso

Created with LearningStudioAI

v0.3.16