3 - Mnipulação de Arquivos de Dados

Prévia do material em texto

Manipulação de dados em arquivos
A partir da linguagem de programação Python, vamos compreender as formas de armazenamento e
recuperação de dados em arquivos e diretórios, os passos necessários para manipulação de arquivos e
strings, utilizando as boas práticas de programação e o tratamento de exceção, para garantir o correto
funcionamento do programa.
Prof. Frederico Tosta de Oliveira / Colaboração: Prof. Kleber de Aguiar
1. Itens iniciais
Objetivos
Identificar as funções de manipulação de arquivos.
Reconhecer as funções de manipulação de strings.
Descrever as exceções na manipulação de arquivos e outras operações.
Introdução
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
• 
• 
• 
1. Funções de manipulação de arquivos
Operações básicas
A habilidade de manipular arquivos é fundamental para qualquer desenvolvedor, uma vez que quase todas as
aplicações modernas necessitam interagir com arquivos de algum tipo. 
Conhecer as operações básicas de manipulação de arquivos, como abrir, fechar, ler e escrever,
permite a implementação eficiente de recursos, como armazenamento de dados, configurações de
usuário, e processamento de entrada/saída. 
Dominar essas operações é essencial para garantir a integridade e a segurança dos dados manipulados e a
eficiência e eficácia dos sistemas de informação.
Neste vídeo, você vai entender como manipular arquivos com eficiência em Python. Vamos abordar as
operações básicas, ou seja, abrir, ler, escrever e fechar arquivos, usando exemplos práticos.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Conceitos
Abrindo um arquivo
Veja as operações básicas de manipulação de arquivos:
 
Abrir
Fechar
Ler 
Escrever
A primeira operação que precisamos realizar, independentemente se vamos ler o conteúdo de um arquivo ou
adicionar um conteúdo, é abrir o arquivo. 
Para abrir um arquivo, o Python disponibiliza a função interna chamada open. Essa função está disponível
globalmente, ou seja, não é preciso importá-la. 
A função open retorna um objeto do tipo arquivo. Sua forma mais simples de utilização tem a seguinte sintaxe:
python
arquivo = open (caminho) 
Utilizamos a função open com o parâmetro caminho. Esse parâmetro é uma string que representa a
localização do arquivo no sistema de arquivos. 
Veja como é fácil abrir um arquivo:
• 
• 
• 
• 
Imagem 1
Temos, inicialmente, o script inicial e sua saída. 
Imagem 2
Temos, à esquerda da imagem, a árvore de diretório, onde verificamos a
existência dos arquivos script_inicial.py e teste.txt, ambos no mesmo
diretório EAD. 
Imagem 3
Temos, ao centro, o código do nosso script e, à direita, a saída do
console. 
Imagem 4
Utilizamos, na linha 1 do script, a função open para abrir o arquivo
teste.txt. Isso já é suficiente para termos um objeto do tipo arquivo e
começar a manipulá-lo. 
Imagem 5
Imprimimos, na linha 3, a frase “Arquivo aberto com sucesso!” apenas
para verificar se o programa foi executado sem problemas. 
Nesse exemplo, o caminho utilizado para abrir o arquivo foi “teste.txt”, pois o script e o arquivo que abrimos
estão no mesmo diretório. Porém, não precisamos nos limitar a manter os arquivos e scripts no mesmo
diretório. 
Veja como o Python trata o acesso aos arquivos a seguir. O caminho de um arquivo pode ser classificado em
dois tipos: 
Absoluto
É a referência completa para se encontrar um arquivo ou diretório. Ele deve começar com uma barra (
/ ) ou o rótulo do drive ( C:, D: ...).
Exemplo:
open(“C:\Downloads\arquivo.txt”) – utilizado em ambientes MS Windows.
open(“/home/usuario/arquivo.txt”) – utilizado em ambientes Linux.
Relativo
É a referência para se encontrar um arquivo ou diretório a partir de outro diretório. Normalmente, a
partir do diretório de onde o script está.
Exemplo:
open(“arquivo.txt”), para os casos em que o arquivo está no mesmo diretório do script.
open(“../arquivo.txt”), para os casos em que o arquivo está no diretório acima do script.
Vamos criar um script que ilustra as diferentes formas de referenciar um arquivo com caminhos absolutos e
relativos. 
No exemplo, a seguir, alteramos um pouco a forma de exibir o conteúdo: 
Imagem 1
Temos, inicialmente, o script1, sua saída e arquivo dados1.txt. 
Imagem 2
Temos, à esquerda, nossa árvore de diretórios. 
Imagem 3
Temos, ao centro, o script1.py. 
Imagem 4
Temos, à direita, o arquivo dados.txt, e, abaixo, a saída do console do
Python. Na linha 1 do script1.py, importamos o módulo os do Python. 
Imagem 5
Utilizamos, na linha 4, a função open para abrir o arquivo “dados1.txt”,
que se encontra no mesmo diretório do nosso script. Nessa linha,
utilizamos o caminho relativo. Observe que, como o arquivo dados1.txt
está na mesma pasta EAD que o script1.py, basta escrever o nome do
arquivo como argumento. 
Imagem 6
Abrimos, na linha 5, o mesmo arquivo dados1.txt, utilizando o caminho
absoluto (completo), que, no nosso exemplo, é: "C:/EAD/dados1.txt". 
Imagem 7
Abrimos, nas linhas 8 e 9, o arquivo dados2.txt, que se encontra na pasta
documentos. Na linha 8, utilizamos o caminho relativo desse arquivo para
abri-lo: "documentos/dados2.txt", enquanto, na linha 9, utilizamos o
caminho absoluto: "C:/EAD/documentos/dados2.txt". 
O Python também disponibiliza algumas funções para exibir os caminhos absolutos e relativos de um arquivo
ou diretório, que são:
Na linha 11, utilizamos a função path.relpath para imprimir o caminho relativo do arquivo1, a partir do
nome do arquivo passado como parâmetro.
 
Na linha 12, utilizamos a função path.abspath para exibir o caminho absoluto do mesmo arquivo.
Observe que, mesmo utilizando o caminho relativo para abrir o arquivo (linha 4), é possível obter o
caminho absoluto utilizando essa função. Isso pode ser verificado na saída do console.
 
Na linha 14, utilizamos a função interna print para imprimir a variável arquivo1.
Verifique, na saída do console, onde foi impressa a representação do objeto arquivo1:
python
 
Desmembrando essa saída, temos:
O tipo do objeto, TextIOWrapper, que trata de arquivos de texto.
O nome do arquivo, name='dados.txt'.
O modo de acesso ao arquivo, mode='r'.
A codificação do arquivo, encoding='cp1252'.].
Neste módulo, vamos tratar apenas de arquivos do tipo texto, ou seja, objetos TextIOWrapper. A seguir, vamos
apresentar os diferentes modos de acesso aos arquivos. 
• 
• 
• 
• 
• 
• 
• 
Modos de acesso a um arquivo
Quando abrimos um arquivo, precisamos informar ao Python o que desejamos fazer, ou seja, qual será o modo
(mode) de acesso ao arquivo. O modo é um dos parâmetros da função open, e cada modo é representado por
uma string. 
Os principais modos são: 
python
r: leitura (read) 
python
w: escrita (write) 
python
a: acrescentar (append) 
O modo padrão da função open é o modo leitura (“r”). 
Esses modos podem ser combinados e para informar que desejamos ler e escrever em um arquivo, utilizamos
a string “r+”, por exemplo. 
O Python também nos permite diferenciar arquivos texto de arquivos binários, como uma imagem, por
exemplo. Para informar que desejamos abrir um arquivo binário, adicionamos a string “b” ao modo, ficando
“rb”, “wb” e “ab”. 
A tabela abaixo resume os modos de acesso a arquivos:
Caractere Significado
'r' Abre o arquivo para leitura (default).
'w' Abre o arquivo para escrita, truncando o arquivo primeiro.
'x' Cria um arquivo para escrita e falha, caso ele exista.
'a'
Abre o arquivo para escrita, acrescentando conteúdo ao final do arquivo, caso
ele exista.
'b' Modo binário.
't' Modo texto (default).
'+' Abre o arquivo para atualização (leitura ou escrita).
Tabela: Modos de abertura de arquivos em Python.
Adaptada de Python (2020).
Atividade 1
Questão 
Na programação com Python, é comum utilizar funções específicas para manipular arquivos de dados.
Quando precisamos manipular arquivos em Python, qual função é usada para abrir um arquivo para leitura?
Considere a localizaçãoo fluxo de execução para o trecho onde é realizado o tratamento da exceção
lançada.
Vamos explorar mais operações referentes a arquivos e diretórios e mostrar novas exceções que podem ser
lançadas quando utilizamos tais operações. Fique atento!
Atividade 1
Questão
Em Python, a manipulação de arquivos pode resultar em diversos tipos de exceções, que devem ser tratadas
para evitar a interrupção do programa de forma inesperada. Analise o código a seguir e responda à questão.
python
 try:
 with open('dados.txt', 'r') as arquivo:
 conteudo = arquivo.read()
except FileNotFoundError:
 print("Arquivo não encontrado.")
except PermissionError:
 print("Permissão negada.")
except Exception as e:
 print(f"Erro inesperado: {e}") 
O que será exibido na tela se o arquivo dados.txt não existir no diretório?
A
Nenhuma mensagem será exibida.
B
"Arquivo não encontrado."
C
"Permissão negada."
D
"Erro inesperado: {e}"
E
O programa será encerrado sem exibir nenhuma mensagem.
A alternativa B está correta.
Se o arquivo dados.txt não existir, o Python lançará uma exceção do tipo FileNotFoundError. Como essa
exceção está mapeada no except correspondente, a mensagem "Arquivo não encontrado." será exibida na
tela.
Operações adicionais em arquivos
Conhecer as operações com arquivos em Python é fundamental para qualquer desenvolvedor que lide com
manipulação de dados. As operações de remoção e renomeação são essenciais para automatizar tarefas,
organizar informações e manter a integridade dos dados. 
Além disso, compreender como realizar essas operações de forma eficiente e segura permite desenvolver
aplicações mais robustas e confiáveis, evitando problemas comuns como perda de dados e interrupções
inesperadas do programa.
Neste vídeo, veremos as operações de arquivos em Python, com foco na remoção e renomeação.
Aprenderemos a utilizar métodos específicos para remover arquivos de forma segura e a renomear com
eficácia. Exploraremos cenários em que essas operações são úteis e discutiremos boas práticas para lidar
com manipulação de arquivos em Python.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Além das opções para leitura e escrita em arquivos, o Python disponibiliza um conjunto de operações
adicionais, como renomear e apagar arquivo, além de operações em diretórios, como listar arquivos de
diretórios, criar diretórios etc. 
A partir de agora, apresentaremos algumas dessas operações. 
Vamos iniciar pela operação de remover um arquivo, que está disponível por meio da função remove do
módulo os do Python. 
A função remove tem a seguinte sintaxe: 
python
>>> os.remove(caminho) 
Nesse exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função remove. Como
parâmetro, a função espera o caminho para um arquivo. Para remover diretório, devemos utilizar outra função,
rmdir. 
Veja a função remove na imagem abaixo. Iniciamos o script com a importação do módulo os, na linha 1. Aqui
vamos remover o arquivo teste.txt, que se encontra no mesmo diretório do nosso script. Observe a arvore de
diretórios à esquerda:
Script 25 e sua saída.
Na linha 2, utilizamos a função remove, passando como argumento o caminho do arquivo que desejamos
remover. Como estamos no mesmo diretório, utilizamos apenas o nome do arquivo. Pronto! Isso é suficiente
para remover um arquivo. 
Dentre as exceções lançadas ao usar a função remove, destacamos as seguintes: 
FileNotFoundError
Ocorre quando o arquivo não existe.
PermissionError
Ocorre quando não temos permissão para
alterar o arquivo.
IsADirectoryError
Ocorre quando tentamos remover um diretório
usando a função remove, em vez de rmdir.
Observe a saída do console, onde tudo ocorreu conforme esperado e nenhuma exceção foi lançada. 
A segunda operação, também muito comum, é a de renomear um arquivo. Essa operação também está
disponível no módulo os, mas por meio da função rename. 
A função rename tem a seguinte sintaxe:
python
>>> os.rename(origem, destino) 
Nesse exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função rename. Como
parâmetro, a função espera o caminho para o arquivo que desejamos renomear, origem, e o novo nome do
arquivo, destino. 
Veja agora o exemplo em que descrevemos o uso dessa função:
Script 26 e sua saída.
Na linha 1, importamos o módulo os, no qual será utilizada a função rename. 
Na linha 4, chamamos a função rename com os parâmetros teste_alfa.txt (origem) e teste_beta.txt (destino).
Caso tudo ocorra bem, ao final da operação, teremos apenas o arquivo destino. 
Veja agora algumas exceções que podem ser lançadas quando utilizamos a função rename. Não estamos
tratando todas as opções possíveis, mas apenas as mais comuns: 
FileNotFoundError
Ocorre quando a origem não existe.
FileExistsError
Ocorre quando o arquivo de destino já existe.
PermissionError
Ocorre quando não temos permissão para
alterar o arquivo de origem ou para escrita do
destino.
Na imagem Script 26 e sua saída, veja a árvore de diretórios à esquerda. Temos tanto o arquivo teste_alfa.txt
quanto o arquivo teste_beta.txt. 
Observe a execução do script pelo console e veja que ele saltou da linha 4 para a linha 13. Isso ocorreu
porque, como o arquivo teste_beta.txt já existia, a exceção FileExistsError foi lançada.
Dica
Para os casos em que desejamos renomear sobrescrevendo o arquivo destino, caso ele exista, podemos
utilizar a função replace, também do módulo os. 
Atividade 2
Questão
As operações de arquivos em Python, como renomear e remover, são cruciais para a gestão eficiente de
dados. Analise o código a seguir e responda à questão.
python
import os
try:
 os.remove('arquivo.txt')
except FileNotFoundError:
 print("Arquivo não encontrado.")
except PermissionError:
 print("Permissão negada.")
except IsADirectoryError:
 print("Não é possível remover, é um diretório.")
except Exception as e:
 print(f"Erro inesperado: {e}") 
O que será exibido na tela se o arquivo.txt for, na verdade, um diretório?
A
Nenhuma mensagem será exibida.
B
"Arquivo não encontrado."
C
"Permissão negada."
D
"Não é possível remover, é um diretório."
E
"Erro inesperado: {e}"
A alternativa D está correta.
Se arquivo.txt for um diretório, o Python lançará a exceção IsADirectoryError. Como essa exceção está
mapeada no except correspondente, a mensagem "Não é possível remover, é um diretório" será exibida na
tela.
Manipulação de diretórios
Conhecer operações com diretórios em Python é essencial para a organização e a gestão eficaz de dados em
diversos projetos. Essas operações incluem a criação, a remoção e a listagem de diretórios, permitindo a
estruturação adequada dos arquivos. 
Além disso, o domínio dessas técnicas facilita a automação de tarefas, melhora a manutenção do sistema e
garante um ambiente de trabalho mais organizado e eficiente, fundamental para o sucesso de qualquer
aplicação. 
Neste vídeo, aprenderemos a criar, remover e listar diretórios, além de tratar exceções comuns nessas
operações. Além disso, veremos como a manipulação de diretórios contribui para a organização e a robustez
do seu código, aplicando boas práticas para automatizar a gestão de arquivos e diretórios em seus projetos.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Criando e removendo diretórios
Trabalhar com arquivos significa trabalhar com diretórios. Vejamos as principais funcionalidades relacionadas
à manipulação de diretórios em Python começando pela criação e remoção de um diretório. 
Para criar um diretório, utilizamos a função mkdir do módulo os, enquanto, para remover um diretório,
utilizamos a função rmdir, também do módulo os. 
A sintaxe dessas duas funções são as seguintes: 
python
>>> os.mkdir(caminho) 
python
>>> os.rmdir(caminho) 
Nesse exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função mkdir ou rmdir. Como
parâmetro, a função espera o caminho para o diretório. 
Veja agora como utilizamos essas duas funções:Scripts 28 e 29 e suas respectivas saídas.
No script 28, importamos o módulo os na linha 1 e, na linha 4, utilizamos a função mkdir(“meu_diretorio”). O
diretório meu_diretorio foi criado na mesma pasta onde o script28 se encontra. Considere as seguintes
condições:
Caso não tenhamos permissão para criar o diretório, será lançada a exceção PermissionError.
 
Caso o diretório já exista, a exceção FileExistsError é lançada.
No script29, na linha 4, utilizamos a função rmdir para remover o diretório meu_diretorio. Considere as
seguintes condições:
Caso não tenhamos permissão para remover o diretório, será lançada a exceção PermissionError.
 
Caso o diretório não exista, a exceção FileNotFoundError é lançada.
Para os casos em que o diretório a ser removido não esteja vazio, será lançada a exceção OSError. Essa
exceção é mais abrangente. 
Não temos como garantir, a princípio, que a exceção lançada ocorre especificamente pelo fato de o
diretório não estar vazio.
Nessas situações, precisamos analisar mais o erro, principalmente o seu número, para verificar o que
realmente aconteceu.
O número do erro está disponível no atributo errno do objeto erro. 
Os códigos dos possíveis erros estão no módulo errno do Python e podem ser utilizados no tratamento das
exceções para descobrir o que realmente deu errado. 
Veja esse problema mais de perto:
Imagem 1
Temos o script 30, sua saída e modulo errno.py. 
Imagem 2
Importamos, à esquerda, no script30, os módulos os e errno nas linhas 1
e 2. 
• 
• 
• 
• 
Imagem 3
Tentamos remover, na linha 5, o diretório meu_diretorio utilizando a
função rmdir. Como o diretório não está vazio, a exceção OSError é
lançada, e a execução do programa salta para a linha 8. 
Imagem 4
Imprimimos, na linha 8, o número do erro por meio do atributo errno da
variável erro. Observe que o valor impresso foi 41. O erro 41 faz parte da
numeração interna de erros do Python, que pode ser verificado no
modulo errno à direita da imagem, mapeado como ENOTEMPTY (não
vazio). 
Imagem 5
Comparamos, na linha 9, o erro gerado pelo programa com o código do
erro ENOTEMPTY (erro 41). Caso o resultado da comparação seja
verdadeiro, teremos certeza de que o erro ocorreu, pois o diretório não
está vazio. Caso contrário, precisaremos analisá-lo novamente. O
WinError 145 é o erro nativo que o Windows retornou. Esse erro foi
mapeado pelo Python para o erro 41. 
Como a exceção OSError é mais abrangente que as outras exceções que estudamos, ela deve ficar por último.
Caso contrário, nunca alcançaremos as exceções mais específicas. 
Listando conteúdo de diretórios
Outra tarefa muito comum quando estamos tratando com arquivos é listar os arquivos presentes em um
diretório. 
Para isso, podemos utilizar a função scandir do módulo os. Sua sintaxe é a seguinte: 
python
>>> os.scandir(caminho) 
Nesse exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função scandir. Como
parâmetro, a função espera o caminho para o diretório. 
Como resultado, teremos um iterável (iterator) que retorna objetos do tipo os.DirEntry, que podem ser
arquivos ou diretórios. Dentre os atributos e métodos desse tipo de objetos, destacamos:
Name
Nome do diretório ou arquivo.
Path
Caminho completo do diretório ou arquivo.
is_dir()
Retorna verdadeiro se o objeto é um diretório.
is_file()
Retorna verdadeiro se o objeto é um arquivo.
stat()
Retorna alguns atributos do arquivo ou diretório, como tamanho.
Agora veja como utilizar essa função:
Imagem 1
Temos o script 31 e sua saída. Vamos percorrer os arquivos e diretórios
da pasta meu_diretorio. A árvore de diretórios pode ser verificada à
esquerda da imagem. 
Imagem 2
Importamos, na linha 1, o módulo os, onde se encontra a função scandir. 
Imagem 3
Utilizamos, na linha 4, a função scandir utilizando o diretório
“meu_diretorio” como argumento. Armazenamos o retorno dessa função
na variável entradas. 
Imagem 4
Iteramos, na linha 6, cada entrada e, da linha 7 a 13, imprimimos algumas
de suas propriedades. 
Imagem 5
Observe a saída no console à direita. 
Atividade 3
Questão 
Em Python, as operações com diretórios são fundamentais para a organização e manipulação de arquivos.
Analise as afirmações sobre operações com diretórios e marque a alternativa correta.
A
Para criar um novo diretório, utilizamos a função os.makedir(caminho), e para removê-lo, usamos a função
os.removedir(caminho).
B
A função os.listdir(caminho) é usada para criar uma lista de todos os arquivos e subdiretórios em um diretório
especificado.
C
A função os.remove(caminho) é usada para remover diretórios e a função os.rmdir(caminho) é usada para
remover arquivos.
D
A função os.mkdir(caminho) cria um novo diretório e a função os.rmdir(caminho) remove um diretório vazio.
E
A função os.rename(caminho_antigo, caminho_novo) só pode ser usada para renomear arquivos, não
diretórios.
A alternativa D está correta.
A função os.mkdir(caminho) é usada para criar um novo diretório, enquanto a função os.rmdir(caminho) é
utilizada para remover um diretório vazio. É importante entender essas operações para gerenciar a
estrutura de diretórios corretamente. As outras opções apresentam funções ou usos incorretos.
Exceções e o módulo "os"
A capacidade de ler, processar e escrever dados de maneira eficiente é importante para inúmeras aplicações,
como processamento de dados, geração de relatórios e automação de tarefas. 
Além disso, o tratamento de exceções garante que seu código seja robusto e capaz de lidar com situações
inesperadas, como arquivos inexistentes ou falta de permissões, aumentando a confiabilidade e a resiliência
de suas aplicações. 
A prática de ler um arquivo de texto, adicionar um cabeçalho e escrever o conteúdo em um novo arquivo
permite aos desenvolvedores entenderem a importância de manipular arquivos de forma segura.
Compreender como tratar exceções específicas, como FileNotFoundError e PermissionError, ajuda a criar
scripts que não falhem inesperadamente, proporcionando uma experiência de usuário mais estável e
profissional. 
Ao dominar essas técnicas, você poderá criar soluções automatizadas que requerem manipulação de
arquivos, essenciais em diversos campos da tecnologia.
Neste vídeo, veremos uma situação prática para tratamento de exceções em leitura e escrita de arquivos.
Adicionalmente, empregaremos o módulo "os", presente na biblioteca padrão do Python e amplamente
utilizado para referenciar caminhos no sistema operacional.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Situação-problema
Você foi contratado por uma empresa para desenvolver um script em Python que automatize a organização de
arquivos de texto. A tarefa envolve ler o conteúdo de arquivos, processar essas informações, escrever em
novos arquivos e tratar exceções que possam surgir, como arquivos inexistentes ou falta de permissões.
Tarefa
Implemente um script em Python que realize as seguintes operações:
1. Leia o conteúdo de um arquivo de texto.
 
2. Escreva o conteúdo lido em um novo arquivo, adicionando uma linha de cabeçalho.
 
3. Trate possíveis exceções durante as operações, exibindo mensagens informativas ao usuário.
Resolução
Passo 1: Preparação
Crie um diretório de trabalho e coloque alguns arquivos de texto de exemplo (.txt) nesse diretório.
Passo 2: Estrutura do código
Importe o módulo necessário
python
import os 
Passo 3: Função para ler e escrever arquivos
1. 
1. 
Crie uma função para ler o conteúdo de um arquivo e escrever em um novo arquivo com uma linha de
cabeçalho:
python
def processar_arquivo(arquivo_origem, arquivo_destino):
 try:
 with open(arquivo_origem, 'r') as f_origem:
 conteudo = f_origem.read()
 except FileNotFoundError:
 print(f"Arquivo {arquivo_origem} não encontrado.")
 return
 except PermissionError:
 print(f"Sem permissão para ler {arquivo_origem}.")
 return
 except Exception as e:
 print(f"Erro inesperadoao ler {arquivo_origem}: {e}")
 return
 try:
 with open(arquivo_destino, 'w') as f_destino:
 f_destino.write("Cabeçalho: Conteúdo do Arquivo\n")
 f_destino.write(conteudo)
 print(f"Conteúdo escrito em {arquivo_destino}.")
 except PermissionError:
 print(f"Sem permissão para escrever em {arquivo_destino}.")
 except Exception as e:
 print(f"Erro inesperado ao escrever em {arquivo_destino}: {e}") 
Passo 4: Script principal
No script principal, defina os arquivos de origem e destino e chame a função criada:
python
 def main():
 diretorio_trabalho = "diretorio_trabalho"
 arquivo_origem = os.path.join(diretorio_trabalho, "arquivo_origem.txt")
 arquivo_destino = os.path.join(diretorio_trabalho, "arquivo_destino.txt")
 processar_arquivo(arquivo_origem, arquivo_destino)
 if __name__ == "__main__":
 main() 
Passo 5: Teste e validação
1. Crie um arquivo de texto chamado arquivo_origem.txt no diretório de trabalho e insira algum conteúdo.
 
2. Execute o script e verifique se o conteúdo do arquivo_origem.txt foi escrito no arquivo_destino.txt com a
linha de cabeçalho adicionada.
 
3. Simule diferentes exceções (como renomear o arquivo para que não seja encontrado ou remover
permissões) para verificar se o tratamento de exceções está funcionando corretamente.
Resultado esperado
1. 
1. 
O script deve ler o conteúdo do arquivo arquivo_origem.txt, escrever esse conteúdo em arquivo_destino.txt
com uma linha de cabeçalho, e exibir mensagens informativas para qualquer exceção encontrada durante o
processo.
Atividade 4
Questão
Considere o seguinte código em Python utilizado para abrir um arquivo para leitura utilizando o módulo "os".
python
import os 
 caminho_origem = os.path.join("diretorio_trabalho", "arquivo_origem.txt") 
 arquivo = open(caminho_origem, "r") 
O que aconteceria se o aluno substituísse a utilização do os.path.join por open("diretorio_trabalho/
arquivo_origem.txt", "r") para definir o caminho do arquivo?
A
O código sempre funcionaria corretamente, sem nenhuma diferença observável.
B
O código geraria um erro de sintaxe, pois open não pode ser usado para concatenar strings.
C
O código tentaria abrir um arquivo chamado "diretorio/arquivo" e falharia porque o arquivo não existe.
D
O código não funcionaria em sistemas Unix, em que o separador de diretórios é /.
E
O código funcionaria apenas em sistemas Windows, em que o separador de diretórios é \.
A alternativa D está correta.
Se substituir os.path.join por open("diretorio/arquivo"), o código funcionaria apenas em sistemas Unix, onde
o separador de diretórios é /. Em sistemas Unix, a barra (/) é usada para definir caminhos de diretórios. A
abordagem multiplataforma é usar os.path.join para garantir a compatibilidade com diferentes sistemas
operacionais.
Organizando arquivos de acordo com suas extensões
Ao mover arquivos para diretórios específicos com base em suas extensões, você está aplicando conceitos de
organização e automação, essenciais para a gestão eficiente de dados em projetos reais. 
Além disso, o uso do módulo shutil para operações de movimentação e o módulo os para verificação e criação
de diretórios são práticas comuns em tarefas de administração de sistemas e desenvolvimento de software. 
Ao mover arquivos, independentemente da biblioteca ou do módulo utilizados, devemos dar atenção ao
tratamento de exceções, garantindo que seu código seja capaz de lidar com situações inesperadas, como
diretórios inexistentes ou falta de permissões. 
Essa prática prepara você para enfrentar desafios mais complexos em ambientes de Front, onde a integridade
e a organização dos dados são prioritárias. Ao compreender e implementar essas operações, você melhora a
eficiência e a confiabilidade dos seus scripts, facilitando a manutenção e a escalabilidade de suas aplicações.
Neste vídeo, será demonstrada uma situação prática na qual é necessário mover arquivos para diretórios
específicos com base em suas extensões, utilizando os módulos os e shutil. Além disso, reforçaremos os
conceitos de criação de diretórios, movimentação de arquivos e tratamento de exceções.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Uma biblioteca pública digitaliza seus documentos e salva os arquivos em um diretório de trabalho. Para
facilitar a organização, você foi contratado para desenvolver um script em Python capaz de mover
automaticamente esses arquivos para subdiretórios específicos com base em suas extensões. O objetivo é
garantir que arquivos PDF sejam movidos para uma pasta pdf, documentos de texto para uma pasta txt e
imagens para uma pasta img.
Tarefa
Implemente um script em Python que realize as seguintes operações:
Verifique se os diretórios de destino (pdf, txt, img) existem; caso contrário, crie-os.
Mova os arquivos do diretório de trabalho para os diretórios correspondentes com base em suas
extensões.
Trate possíveis exceções durante as operações, exibindo mensagens informativas ao usuário.
Roteiro de prática
Passo 1: Preparação
Crie um diretório de trabalho e adicione alguns arquivos de exemplo com diferentes extensões (.pdf,
.txt, .jpg) nesse diretório.
Passo 2: Estrutura do código
Importe os módulos necessários:
python
import os
import shutil 
O módulo shutil
Este módulo em Python oferece várias operações de alto nível em arquivos e coleções de arquivos. Ele é
especialmente útil para copiar, mover, renomear e remover arquivos e diretórios. A função shutil.move é
utilizada para mover um arquivo ou diretório de um local para outro, sendo uma ferramenta essencial para a
organização de arquivos.
Passo 3: Função para criar diretórios
1. 
2. 
3. 
1. 
1. 
Crie uma função para verificar se os diretórios existem e, se não, criá-los:
python
def criar_diretorios(diretorios):
 for diretorio in diretorios:
 if not os.path.exists(diretorio):
 try:
 os.makedirs(diretorio)
 print(f"Diretório {diretorio} criado.")
 except PermissionError:
 print(f"Sem permissão para criar o diretório {diretorio}.")
 except Exception as e:
 print(f"Erro inesperado ao criar {diretorio}: {e}") 
Passo 4: Função para mover arquivos
Crie uma função para mover os arquivos para os diretórios correspondentes com base em suas
extensões:
python
 def mover_arquivos(diretorio_origem):
 for arquivo in os.listdir(diretorio_origem):
 caminho_arquivo = os.path.join(diretorio_origem, arquivo)
 if os.path.isfile(caminho_arquivo):
 extensao = arquivo.split('.')[-1].lower()
 if extensao in ['pdf', 'txt', 'jpg']:
 diretorio_destino = os.path.join(diretorio_origem, extensao)
 try:
 shutil.move(caminho_arquivo, diretorio_destino)
 print(f"{arquivo} movido para {diretorio_destino}.")
 except PermissionError:
 print(f"Sem permissão para mover {arquivo}.")
 except Exception as e:
 print(f"Erro inesperado ao mover {arquivo}: {e}")
 else:
 print(f"Extensão {extensao} de {arquivo} não é suportada.") 
Passo 5: Script principal
No script principal, defina o diretório de trabalho e chame as funções criadas:
1. 
1. 
1. 
python
def main():
 diretorio_trabalho = "diretorio_trabalho"
 diretorios = [os.path.join(diretorio_trabalho, 'pdf'),
 os.path.join(diretorio_trabalho, 'txt'),
 os.path.join(diretorio_trabalho, 'jpg')]
 # Criar diretórios se não existirem
 criar_diretorios(diretorios)
 # Mover arquivos para os diretórios correspondentes
 mover_arquivos(diretorio_trabalho)
 if __name__ =="__main__":
 main() 
Passo 6: Teste e validação
1. Execute o script e verifique se os arquivos foram movidos para os diretórios corretos (pdf, txt, jpg).
 
2. Simule diferentes exceções (como alterar permissões ou usar arquivos inexistentes) para verificar se o
tratamento de exceções está funcionando corretamente.
Resultado esperado
O script deve criar os diretórios pdf, txt, e jpg se não existirem, mover os arquivos para os diretórios
correspondentes com base em suas extensões e exibir mensagens informativas para qualquer exceção
encontrada durante o processo.
Atividade 5
Questão
O módulo shutil em Python é amplamente utilizado para operações de manipulação de arquivos, como mover
e copiar. Considere o seguinte código que tenta mover arquivos para diretórios específicos com base em suas
extensões.
python
import os
import shutil
def mover_arquivos(diretorio_origem):
 for arquivo in os.listdir(diretorio_origem):
 caminho_arquivo = os.path.join(diretorio_origem, arquivo)
 if os.path.isfile(caminho_arquivo):
 extensao = arquivo.split('.')[-1].lower()
 if extensao in ['pdf', 'txt', 'jpg']:
 diretorio_destino = os.path.join(diretorio_origem, extensao)
 if not os.path.exists(diretorio_destino):
 os.makedirs(diretorio_destino)
 shutil.move(caminho_arquivo, diretorio_destino)
 print(f"{arquivo} movido para {diretorio_destino}.") 
Qual das opções a seguir é necessária para que o código funcione corretamente se os diretórios de destino
não existirem inicialmente?
A
Alterar shutil.move para shutil.copy.
B
Remover a linha os.path.isfile(caminho_arquivo).
C
Adicionar uma verificação de permissões antes de shutil.move.
D
Garantir que os.makedirs(diretorio_destino) seja chamado antes de shutil.move.
E
Remover a verificação de extensão dos arquivos.
A alternativa D está correta.
Para que o código funcione corretamente, é necessário criar os diretórios de destino com
os.makedirs(diretorio_destino) antes de tentar mover os arquivos, garantindo que o diretório exista. Sem
essa criação, shutil.move falhará se o diretório de destino não existir.
4. Conclusão
Considerações finais
O que você aprendeu neste conteúdo?
Operações para abrir e fechar arquivos.
Operações de leitura e escrita em arquivos.
Operações para renomear e remover arquivos.
Manipulação e formatação de strings.
Tratamento de exceções.
Criação e remoção de diretórios.
 Explore +
Confira agora o que separamos especialmente para você!
 
Além de manipular arquivos de texto, o Python permite a leitura e escrita de arquivos binários. O tratamento
de arquivos compirmidos é um exemplo disso. O Python possui um módulo interno chamado gzip que permite
a leitura e escrita desse tipo de arquivo. Pesquise sobre o módulo gzip e verifique os comandos de
manipulação existentes.
 
Outro tipo de arquivo binário é a imagem. Apesar de o Python não ter um módulo interno que suporte
manipulação de imagens, existem bibliotecas gratuitas que dão esse suporte, como Pillow e OpenCV.
Pesquise sobre essas bibliotecas e verifique os recursos disponíveis para a manipulação de imagens.
Referências
Python. Python Software Foundation. Consultado em meio eletrônico em: 10 ago. 2020. 
• 
• 
• 
• 
• 
• 
	Manipulação de dados em arquivos
	1. Itens iniciais
	Objetivos
	Introdução
	Conteúdo interativo
	1. Funções de manipulação de arquivos
	Operações básicas
	Conteúdo interativo
	Conceitos
	Abrindo um arquivo
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Absoluto
	Relativo
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Imagem 6
	Imagem 7
	Modos de acesso a um arquivo
	Atividade 1
	Atributos do objeto tipo arquivo
	Conteúdo interativo
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Fechando um arquivo
	Lendo o conteúdo de um arquivo
	Read()
	Readline()
	Readlines()
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Na linha 1
	Na linha 3
	Na linha 7
	Atenção
	Escrevendo conteúdo em um arquivo
	Write (texto)
	Writelines (iterável)
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Imagem 6
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Boas práticas
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Atividade 2
	Manipulando arquivo-texto em Python
	Conteúdo interativo
	Situação-problema
	Objetivo
	Captura dados
	Cria e armazena o arquivo
	Lê e manipula o arquivo
	Sobrescreve o arquivo original
	Confirma a conclusão
	Atividade 3
	Lidando com dados binários em arquivo com Python
	Conteúdo interativo
	Situação-problema
	Objetivos do programa
	Carregar a imagem original
	Converter a imagem em dados binários
	Salvar os dados binários em um arquivo
	Copiar o arquivo binário
	Manipular os dados do arquivo binário cópia
	Carregar e mostrar a imagem modificada
	Atividade 4
	2. Funções de manipulação de strings
	Manipulação de strings
	Conteúdo interativo
	Método strip
	Conteúdo interativo
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Imagem 6
	Imagem 7
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Métodos count e split
	Imagem 1
	Imagem 2
	Imagem 3
	Exemplo
	Dica
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Conteúdo interativo
	Conteúdo interativo
	Método join
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Atividade 1
	Formatação de strings
	Conteúdo interativo
	F-strings
	Imagem 1
	Imgem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Imagem 6
	Imagem 7
	Linhas 3 até 6
	Linhas 10 até 16
	Linhas 20 até 24
	Atividade 2
	Codificando mensagens com Python
	Conteúdo interativo
	Função zenit_polar_replace
	Definição da função e substituições
	Aplicação das substituições
	Função main
	Entrada de texto
	Divisão do texto em palavras
	Codificação de cada palavra
	Junção das palavras codificadas em uma frase
	Exibição dos resultados
	Atividade 3
	3. Tratamento de exceções e outras operações
	Tratamento de exceções na manipulação de arquivos
	Conteúdo interativo
	Tratamento de exceções
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Atenção
	PermissionError
	FileExistsError
	FileNotFoundError
	Imagem 1
	Imagem 2
	Imagem 3
	Atividade 1
	Questão
	Operações adicionais em arquivos
	Conteúdo interativo
	FileNotFoundError
	PermissionError
	IsADirectoryError
	FileNotFoundError
	FileExistsError
	PermissionError
	Dica
	Atividade 2
	Questão
	Manipulação de diretórios
	Conteúdo interativo
	Criando e removendo diretórios
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Listando conteúdo de diretórios
	Name
	Path
	is_dir()
	is_file()
	stat()
	Imagem 1
	Imagem 2
	Imagem 3
	Imagem 4
	Imagem 5
	Atividade 3
	Exceções e o módulo "os"
	Conteúdo interativo
	Situação-problema
	Tarefa
	Resolução
	Resultado esperado
	Atividade 4
	Questão
	Organizando arquivos de acordo com suas extensões
	Conteúdo interativo
	Tarefa
	Roteiro de prática
	Resultado esperado
	Atividade 5
	Questão
	4. Conclusão
	Considerações finais
	O que você aprendeu neste conteúdo?
	Explore +
	Referênciaspadrão do arquivo como sendo o mesmo diretório do script.
A
file.open("dados.txt")
B
open("dados.txt", "r")
C
read("dados.txt")
D
openFile("dados.txt", "read")
E
getFile("dados.txt")
A alternativa B está correta.
A função correta para abrir um arquivo para leitura em Python é open(), com o modo "r" especificado como
segundo argumento para indicar que o arquivo é aberto em modo de leitura. As outras alternativas ou não
usam a função correta ou utilizam argumentos incorretos.
Atributos do objeto tipo arquivo
Compreender os atributos de um objeto do tipo arquivo em Python é imprescindível para o desenvolvimento
de software eficiente e seguro. Esses atributos, como name, mode e closed, fornecem informações essenciais
sobre o estado atual do arquivo, permitindo que os desenvolvedores gerenciem melhor os recursos do
sistema. 
Saber quando um arquivo está aberto ou fechado, por exemplo, ajuda a prevenir erros comuns, como
tentativas de acesso a um arquivo já fechado, garantindo a integridade dos dados e a estabilidade do
aplicativo.
Neste vídeo, você vai explorar os atributos essenciais de objetos do tipo arquivo em Python, como name,
mode e closed. Será demonstrado como esses atributos influenciam a manipulação de arquivos, evitando
erros comuns e otimizando o gerenciamento de recursos.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
O objeto do tipo arquivo contém alguns atributos importantes, como name, mode e closed, veja:
Imagem 1
Temos o script2, sua saída e arquivo dados.txt. 
Imagem 2
Abrimos, na linha 1, o arquivo utilizando a função open. Como não
explicitamos o parâmetro mode, o arquivo será aberto no modo leitura
(“r”). 
Imagem 3
Imprimimos, na linha 3, o atributo name do objeto arquivo. Esse atributo
contém o nome do arquivo. 
Imagem 4
Imprimimos, na linha 4, o atributo mode do objeto arquivo. Esse atributo
contém o modo de acesso do arquivo (r, w, a, rb ...). 
Imagem 5
Imprimimos, na linha 5, o atributo closed do objeto arquivo. Essa atributo
serve para verificar se um arquivo está ou não fechado. 
Os valores de cada atributo podem ser verificados no console abaixo da
imagem. 
Fechando um arquivo
Após realizar a operação desejada no arquivo, precisamos liberá-lo. Para isso, utilizamos o método close(),
que libera a memória alocada pelo interpretador e o uso do arquivo por outros programas, por exemplo. 
Agora, vamos utilizar o script do exemplo anterior como base e adicionar uma chamada ao método close() e
verificar o atributo closed novamente:
Script3, sua saída e seu arquivo dados.txt.
Em relação ao script do exemplo anterior, adicionamos, na linha 7, uma chamada ao método close() do objeto
arquivo. 
Na linha 9, imprimimos novamente a propriedade closed, onde podemos observar que seu valor agora é True.
Lendo o conteúdo de um arquivo
Agora que já sabemos abrir e fechar um arquivo, vamos ver as formas de ler seu conteúdo. 
O Python disponibiliza os seguintes métodos para leitura do conteúdo de um arquivo-texto:
Read()
Retorna todo o conteúdo de um arquivo como
uma única string.
Readline()
Retorna uma linha de arquivo, incluindo
caracteres de final (\n ou \r\n), e avança o
cursor para a próxima.
Readlines()
Retorna uma lista em que cada item da lista é
uma linha do arquivo.
Abaixo, temos três scripts, em que cada um utiliza um dos métodos descritos anteriormente para leitura do
arquivo. Observe que explicitamos o modo de operação como leitura (“r”):
Três scripts
Em cada um dos scripts, vamos abrir o mesmo arquivo dados.txt dos exemplos anteriores, ler o
conteúdo, verificar o tipo de conteúdo retornado por cada método de leitura e imprimir o valor canônico
(real) do conteúdo lido.
Imagem 1
Temos os scripts 4, 5 e 6 e suas respectivas saídas. 
Imagem 2
Abrimos, no script4.py, mais à esquerda, abrimos o arquivo na linha 1 e,
na linha 3, utilizamos o método read() do objeto arquivo para ler o
conteúdo de dados.txt e armazená-lo na variável conteúdo. 
Imagem 3
Verificamos, na linha 5, o tipo do conteúdo retornado pelo método read(),
utilizando a função interna type. Conforme exibido no console, a variável 
conteúdo é um objeto do tipo str (string). 
Imagem 4
Imprimimos, na linha 8, o conteúdo em si, porém utilizamos a função
interna repr para mostrar o conteúdo real contido da variável conteúdo.
Observe que foi retornado todo o texto existente no arquivo dados.txt,
que também pode ser verificado no console. 
No script5.py, seguimos os mesmos passos do script anterior, porém, na linha 3, utilizamos o método
readline(). 
Na linha 5, verificamos que o tipo do conteúdo retornado pelo método readline() também é um objeto do tipo
str (string). 
Na linha 8, imprimimos a representação do conteúdo que contém apenas a primeira linha do arquivo dados.txt
(incluindo o caractere de final de linha \n). Isso aconteceu porque, quando abrimos o arquivo utilizando o
modo leitura (‘r’), o cursor interno de leitura fica posicionado no início do arquivo. 
Se chamarmos novamente o método readline(), linha 10, será retornado à próxima linha do arquivo, que foi
impressa na linha 13. Confira a saída do script 5 no console abaixo dele; seguimos os mesmos passos do
script anterior, porém, na linha 3, utilizamos o método readline(). 
Veja tudo isso na imagem a seguir: 
Script5 e sua saída.
No script6.py, seguimos novamente os mesmos passos, mas, desta vez, utilizamos o método readlines(). 
Na linha 5, verificamos que o tipo do conteúdo retornado pelo método readlines() é um objeto do tipo list
(lista). 
Na linha 8, imprimimos o conteúdo retornado, que é uma lista na qual cada item é uma linha do arquivo. Veja a
saída desse script no console abaixo dele. 
Além dos três métodos já apresentados, os objetos do tipo arquivo são iteráveis. Com isso, podemos utilizar o
laço for diretamente sobre os objetos desse tipo. Veja tudo isso na imagem a seguir: 
Script6 e sua saída.
Veja agora como iterar diretamente sobre um arquivo: 
Na linha 1, abrimos o arquivo da mesma maneira que fizemos nos exemplos anteriores. 
Na linha 4, utilizamos o laço for para iterar diretamente sobre a variável arquivo. Para cada iteração,
recebemos uma nova linha do arquivo, disponibilizada na variável linha, impressa na linha 5. Observe a saída
do console abaixo da imagem:
Script7 e sua saída.
Quando precisamos abrir um arquivo muito grande, é inviável utilizar os métodos read e readlines, pois eles
retornam todo o conteúdo do arquivo de uma só vez, seja na forma de string, seja na forma de lista. Isso pode
consumir todos os recursos do computador, travando seu programa. 
Nesses casos, precisamos chamar o método readline inúmeras vezes até o final do arquivo ou iterar
diretamente sobre o objeto do tipo arquivo. 
Após utilizar qualquer um dos métodos para leitura do arquivo apresentado, não podemos utilizá-los
novamente. Isso acontece porque o cursor estará posicionado ao final do arquivo, e as chamadas aos
métodos read, readline ou readlines retornarão vazias.
Depois de conhecer a resposta correta, confira o exemplo do script8, onde exploramos na prática essa
situação:
Script8 e sua saída.
Vejamos agora o que se sucedeu em cada linha a seguir:
Na linha 1
Abrimos o arquivo em modo leitura.
Na linha 3
Lemos todo seu conteúdo utilizando o método read, que é impresso na linha 5. Veja no console à
direita da imagem.
Na linha 7
Utilizamos o método read para ler novamente o conteúdo do arquivo e atribuímos o valor retornado à
variável conteudo_releitura. Na linha 9, imprimimos o conteúdo dessa variável, que, conforme exibido
no console, é uma string vazia ('').
Para contornar esse problema, fechamos e abrimos o arquivo novamente, linhas 11 e 14, respectivamente. Na
linha 16, utilizamos novamente o método read e imprimimos o conteúdo retornado na linha 18. Observe que,
mais uma vez, conseguimos acessar todo o conteúdo do arquivo. 
Para demonstrar a utilização do método seek, no mesmo arquivo que já estava aberto, arquivo_reaberto,
utilizamos o método seek(0),linha 20. Imprimimos mais uma vez o conteúdo correto do arquivo na linha 23. 
Toda a sequência pode ser acompanhada pelo console.
Atenção
Todos os três métodos apresentados aceitam como parâmetro a quantidade de bytes que desejamos
ler. O valor padrão para esse parâmetro é -1, o que corresponde a todo o arquivo. 
Escrevendo conteúdo em um arquivo
Confira agora como escrever conteúdo em um arquivo a partir da função open. Vamos lá! 
A primeira modificação é alterar o modo de acesso ao arquivo. Para escrita de texto, podemos utilizar o modo
w (write) ou o modo a (append), a seguir:
O modo w abre o arquivo para escrita, truncando o arquivo em primeiro lugar. Caso ele não exista, será
criado um.
 
O modo a abre o arquivo para escrita, acrescentando conteúdo ao final dele, caso ele exista; do
contrário, será criado um arquivo.
O Python disponibiliza dois métodos para escrita de conteúdo em um arquivo texto, para o modo w e para o
modo a. Os métodos write e writelines são descritos abaixo: 
Write (texto)
Escreve todo o conteúdo passado como
parâmetro no arquivo.
Writelines (iterável)
Escreve cada item do iterável (exemplo: lista) no
arquivo.
No exemplo a seguir, vamos criar dois scripts para mostrar o uso do modo w. No primeiro, script9, vamos
utilizar o método write. No segundo, script10, vamos utilizar o método writelines. 
Imagem 1
Temos os scripts 9 e 10 e suas respectivas saídas.
Imagem 2
Abrimos, no script9, o arquivo dados_write.txt para escrita utilizando o
modo w na linha 1.
• 
• 
Imagem 3
Escrevemos os conteúdos utilizando o método write, conforme linhas 2 e
3, e fechamos o arquivo, como exposto na linha 4. 
Imagem 4
Observe como ficou o arquivo dados_write.txt, abaixo do script9, após a
execução desse script. 
Imagem 5
Criamos, no script10, uma lista chamada linhas na linha 1. Abrimos o
arquivo dados_write.txt para escrita na linha 4, utilizando o mesmo modo
de acesso ao arquivo, modo w. Para escrever o conteúdo da lista linhas
no arquivo, utilizamos o método writelines, linha 5. 
Imagem 6
Verifique também o conteúdo do arquivo dados_writelines.txt após a
execução do script, abaixo do script10 na imagem. 
Fique atento às seguintes orientações:
O Python não insere quebra de linha ('\n') entre os elementos da lista. Precisamos fazer isso 
manualmente!
 
Como o modo w trunca o arquivo, ou seja, remove todo o conteúdo do arquivo, caso ele exista,
podemos executar esses scripts repetidas vezes e, ainda assim, o resultado será sempre o mesmo.
No próximo exemplo, vamos mostrar como utilizar o modo append (a) para adicionar conteúdo a um arquivo já
existente. 
Para isso, vamos abrir o arquivo dados_write.txt, criado pelo script9, utilizando o modo a. Utilizamos esse
modo para acrescentar conteúdo a um arquivo. Confira o próximo script:
Imagem 1
Temos o script11 e sua saída. 
Imagem 2
Abrimos, em primeiro lugar, na linha 1, o arquivo dados_write.txt utilizando
o modo escrita a (append). 
• 
• 
Imagem 3 
Utilizamos, na linha 3, o método write para acrescentar o texto
"\nConteúdo adicional." ao final do arquivo dados_write.txt. 
Imagem 4
Fechamos, na linha 5, o arquivo. 
Imagem 5
Observe como ficou o conteúdo final do arquivo à direita da imagem,
onde a nova frase foi posicionada corretamente ao final do arquivo. 
Boas práticas
Ao lidar com arquivos, devemos utilizar a palavra reservada with, disponibilizada pelo Python. Ela garante que
o arquivo será fechado adequadamente após utilizarmos o arquivo, não sendo necessário chamar o método
close explicitamente. A sintaxe de utilização do with é: 
python
with open(caminho, modo) as nome: (seu código indentado) 
Iniciamos com a palavra reservada with, seguida da função open, a palavra reservada as, um nome de variável
que receberá o objeto do tipo arquivo e dois pontos. Todo o código indentado posteriormente está dentro do
contexto do with, no qual o arquivo referenciado pela variável nome estará disponível. 
Veja como utilizar o with no exemplo a seguir. Clique nas setas e acompanhe: 
Imagem 1
Temos o script12 e sua saída.
Imagem 2 
Utilizamos a sintaxe do with, na linha 3, e o arquivo dados.txt é aberto no
modo leitura, atribuído à variável arquivo. Esta variável está disponível em
todo o escopo do with, linhas 4, 5 e 6. 
Imagem 3
Iteramos, nas linhas 4 e 5, sobre o conteúdo do arquivo e imprimimos
linha por linha.
Imagem 4
Imprimimos, na linha 6, o nome do arquivo.
Imagem 5
Verifique as saídas no console à direita.
Atividade 2
Questão 
Ao trabalhar com arquivos em Python, é importante entender os atributos de um objeto de arquivo para evitar
erros comuns e gerenciar recursos adequadamente. Qual dos seguintes é um atributo válido de um objeto do
tipo arquivo que indica se o arquivo está aberto ou fechado?
A
opened
B
is_open
C
close_status
D
closed
E
is_closed
A alternativa D está correta.
O atributo closed é um atributo padrão de um objeto do tipo arquivo em Python, que retorna True se o
arquivo estiver fechado e False se estiver aberto. As demais alternativas não correspondem a atributos
reais de objetos de arquivo em Python.
Manipulando arquivo-texto em Python
Manipular arquivos de texto em Python permite a automação de tarefas rotineiras, como leitura, escrita e
processamento de dados. Essa prática é importante para o desenvolvimento de scripts que gerenciam logs,
processam grandes volumes de dados ou geram relatórios. 
Além disso, compreender como manipular esses arquivos eficientemente contribui para a criação de
aplicações mais robustas e escaláveis, garantindo melhor gestão e organização das informações.
Neste vídeo, você verá o processo de captura, armazenamento e manipulação de texto através de Python. A
partir de exemplos, abordaremos a leitura e a escrita de arquivos de texto, mostrando como alterações
simples nos dados podem impactar o conteúdo final.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Situação-problema
Você foi contratado por uma editora para desenvolver um programa que ajude na revisão de textos. A editora
recebe frequentemente textos de autores que contêm inconsistências no uso de maiúsculas e minúsculas, o
que dificulta o processo de edição e publicação.
Objetivo
A ideia é desenvolver um programa em Python que permita a captura de texto via console, no qual um editor
pode inserir trechos de textos recebidos dos autores. O programa deve salvar esses trechos em um arquivo
de texto, ler o arquivo, converter todo o texto para letras maiúsculas para padronizar a formatação e
finalmente sobrescrever o arquivo original com o texto formatado. Esse processo facilitará a revisão preliminar
antes da edição final.
Acompanhe os passos esperados no programa!
Captura de dados: o programa deve solicitar ao usuário que insira várias frases ou parágrafos pelo
console. A entrada de dados deve continuar até o usuário digitar "sair", indicando que deseja encerrar a
inserção e salvar o arquivo.
 
Criação e armazenamento: o texto inserido deve ser salvo em um arquivo chamado meu_arquivo.txt.
 
Manipulação do arquivo: o programa deve abrir o arquivo salvo, ler o conteúdo e converter todas as
letras para maiúsculas.
 
Sobrescrever o arquivo original: após a manipulação, o texto alterado deve ser usado para
sobrescrever o arquivo original, garantindo que o arquivo contenha apenas o texto formatado.
Veja o código a seguir.
• 
• 
• 
• 
python
def main():
 print("Digite suas frases. Digite 'sair' para terminar e salvar o arquivo.")
 frases = []
 while True:
 entrada = input("> ")
 if entrada.lower() == "sair":
 break
 frases.append(entrada)
 
 with open("meu_arquivo.txt", "w") as arquivo:
 for frase in frases:
 arquivo.write(frase + "\n")
 
 print("Arquivo original criado. Agora vamos manipular os dados.")
 dados_modificados = []
 with open("meu_arquivo.txt", "r") as arquivo:
 for linha in arquivo:
 dados_modificados.append(linha.strip().upper())# Exemplo de manipulação: 
converter para maiúsculas
 
 with open("meu_arquivo.txt", "w") as arquivo:
 for linha in dados_modificados:
 arquivo.write(linha + "\n")
 
 print("O arquivo foi sobrescrito com os dados modificados.")
if __name__ == "__main__":
 main() 
O código apresentado é um exemplo de script para capturar, manipular e armazenar texto digitado pelo
usuário. Acompanhe suas operações principais!
Captura dados
Acontece da seguinte maneira:
O script inicia com uma mensagem para o usuário, solicitando que ele digite frases e termine digitando
sair quando quiser finalizar.
 
Um loop while True é usado para receber continuamente as entradas do usuário através da função
input(). Cada entrada é adicionada a uma lista chamada frases.
 
O loop é interrompido (break) quando o usuário digita sair, verificado após cada entrada com o método
.lower() para garantir que a comparação seja insensível a maiúsculas e minúsculas.
Cria e armazena o arquivo
Acontece da seguinte maneira:
Após o término da entrada de dados, o script abre (ou cria, se não existir) um arquivo chamado
meu_arquivo.txt no modo de escrita (w) usando a instrução with open(...) as arquivo:
• 
• 
• 
• 
 
Dentro desse bloco, o script escreve cada frase armazenada na lista frases no arquivo. Cada frase é
seguida por uma quebra de linha \n.
Lê e manipula o arquivo
Acontece da seguinte maneira:
Uma vez que o arquivo é criado, o script procede para abrir o mesmo arquivo, agora no modo de leitura
(r).
 
O conteúdo do arquivo é lido linha por linha. Cada linha é despojada de espaços extras e quebras de
linha com .strip() e convertida para letras maiúsculas com .upper().
 
As linhas modificadas são armazenadas em uma nova lista chamada dados_modificados.
Sobrescreve o arquivo original
Acontece da seguinte maneira:
O arquivo meu_arquivo.txt é novamente aberto, dessa vez, no modo de escrita (w), o que trunca o
arquivo a zero antes de começar a escrever.
 
O script então escreve cada linha da lista dados_modificados de volta ao arquivo, cada uma
terminando com uma quebra de linha \n.
Confirma a conclusão
Acontece da seguinte maneira:
Após a reescrita, uma mensagem é impressa para informar que o arquivo foi sobrescrito com os dados
modificados.
É importante considerar o seguinte:
O uso do contexto with para manipulação de arquivos é uma prática recomendada porque garante que
o arquivo seja fechado corretamente após as operações, mesmo se uma exceção ocorrer durante o
processo.
 
A conversão de todas as entradas para maiúsculas é um exemplo de normalização de dados, útil em
muitos contextos de processamento de texto para garantir consistência.
Esse script é uma excelente maneira de entender a manipulação básica de arquivos em Python, incluindo
leitura, escrita e aplicação de transformações simples aos dados de texto.
Atividade 3
Questão 
• 
• 
• 
• 
• 
• 
• 
• 
• 
Considere o script Python apresentado anteriormente, na demonstração prática, que lê, modifica e
sobrescreve um arquivo de texto. Se, em vez de abrir o arquivo no modo "w" (write) para sobrescrevê-lo, o
arquivo fosse aberto no modo "a" (append) após ser lido e modificado, qual seria o resultado?
A
O arquivo original seria duplicado, contendo primeiro o texto original seguido pelo texto modificado.
B
Apenas o texto modificado seria salvo no arquivo, substituindo o texto original.
C
O texto modificado seria adicionado ao final do arquivo, após o texto original.
D
Um novo arquivo seria criado e o original permaneceria inalterado.
E
O programa retornaria um erro, pois o modo "a" não permite leitura.
A alternativa C está correta.
Abrir o arquivo no modo "a" (append) faz com que os dados sejam escritos ao final do arquivo existente,
sem excluir o conteúdo anterior. Assim, o texto original permaneceria, e o texto modificado seria adicionado
ao final, resultando em uma duplicação parcial do conteúdo.
Lidando com dados binários em arquivo com Python
Lidar com arquivos binários em Python é uma habilidade prática essencial para trabalhar com dados
complexos e formatos de arquivo personalizados. 
Arquivos binários são usados para armazenar dados de forma compacta e eficiente, incluindo imagens,
vídeos, áudios, e arquivos executáveis. Ao manipular arquivos binários, você pode realizar operações de
leitura e escrita de dados em baixo nível, possibilitando a criação de aplicações que interagem diretamente
com hardware ou sistemas legados. 
Essa habilidade é imprescindível em áreas como processamento de imagem, engenharia de software
embarcado, e desenvolvimento de jogos. Além disso, entender como manipular arquivos binários permite
otimizar o desempenho de suas aplicações, pois a manipulação direta de bytes pode ser significativamente
mais rápida do que o processamento de dados em formato texto. 
Compreender a leitura, a escrita e a interpretação de arquivos binários também é fundamental para garantir a
integridade e a segurança dos dados, uma vez que qualquer corrupção pode levar a falhas no sistema. 
Neste vídeo, será abordada a manipulação direta de dados de imagens com Python. Demonstraremos como
abrir, exibir e alterar imagens usando a biblioteca PIL e como salvar esses dados em arquivos binários.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Situação-problema
Em uma pequena empresa de design gráfico, surgiu a necessidade de implementar um sistema capaz de
manipular imagens para uso em diferentes campanhas publicitárias. O gerente do projeto solicitou uma
ferramenta que permita aos designers visualizarem, manipularem e criarem cópias de imagens no formato
binário para entender melhor a estrutura de dados de imagens e explorar efeitos criativos através da
manipulação direta desses dados.
Objetivos do programa
Desenvolver um programa em Python que execute as seguintes operações:
Carregar uma imagem simples do sistema de arquivos.
Converter a imagem em uma representação binária usando a biblioteca PIL (Python Imaging Library).
Exibir os dados binários da imagem.
Salvar esses dados em um arquivo binário.
Fazer uma cópia desse arquivo binário.
Manipular os dados do arquivo binário cópia (por exemplo, inverter os bytes, adicionar ruído etc.).
Carregar a imagem modificada a partir do arquivo binário e exibi-la para ver o efeito das manipulações.
O Código Python fica da seguinte maneira:
1. 
2. 
3. 
4. 
5. 
6. 
7. 
python
from PIL import Image
import numpy as np
def main():
 # Carregar a imagem original
 img = Image.open("simple_icon.png")
 img.show()
 # Converter a imagem em dados binários
 img_data = np.array(img)
 binary_data = img_data.tobytes()
 # Salvar os dados binários em um arquivo
 with open("original_img.bin", "wb") as file:
 file.write(binary_data)
 # Copiar o arquivo binário
 with open("original_img.bin", "rb") as original_file:
 data = original_file.read()
 
 with open("copy_img.bin", "wb") as copy_file:
 copy_file.write(data)
 # Manipulação dos dados do arquivo binário cópia
 # Exemplo: Inverter os bytes
 with open("copy_img.bin", "rb") as file:
 data = bytearray(file.read())
 
 # Inverte todos os bytes
 data = data[::-1]
 with open("copy_img.bin", "wb") as file:
 file.write(data)
 # Carregar e mostrar a imagem manipulada
 modified_data = np.frombuffer(data, dtype=np.uint8).reshape(img_data.shape)
 modified_img = Image.fromarray(modified_data)
 modified_img.show()
if __name__ == "__main__":
 main() 
O código Python descrito realiza uma série de operações envolvendo a manipulação de uma imagem usando a
biblioteca PIL (Python Imaging Library) e manipulação de dados binários. A seguir, apresentamos uma
explicação passo a passo de cada etapa do código.
Carregar a imagem original
A função Image.open("simple_icon.png") da biblioteca PIL é usada para carregar uma imagem
do disco. O arquivo "simple_icon.png"deve estar no mesmo diretório do script ou o caminho
até ele deve ser especificado corretamente.
img.show() exibe a imagem original. Isso permite que o usuário visualize a imagem antes das
manipulações.
Converter a imagem em dados binários
np.array(img) converte a imagem carregada em um array do NumPy. Esse array contém os
valores dos pixels da imagem.
img_data.tobytes() converte os dados do array NumPy em uma sequência binária. Esse é o
formato que permite salvar a imagem em um arquivo binário diretamente.
Salvar os dados binários em um arquivo
Um arquivo chamado "original_img.bin" é criado e aberto no modo "wb" (write binary) para
escrita binária.
Os dados binários são escritos no arquivo usando file.write(binary_data).
Copiar o arquivo binário
O arquivo "original_img.bin" é aberto no modo "rb" (read binary) para leitura.
Os dados binários são lidos do arquivo original usando original_file.read() e armazenados na
variável data.
Um novo arquivo chamado "copy_img.bin" é então aberto no modo "wb" e os dados lidos são
escritos nele, efetivamente criando uma cópia do arquivo original.
• 
• 
• 
• 
• 
• 
• 
• 
• 
Manipular os dados do arquivo binário cópia
O arquivo "copy_img.bin" é novamente aberto no modo "rb" para leitura dos dados binários.
Os dados são lidos e convertidos para bytearray, permitindo a modificação dos bytes.
Os bytes são invertidos (data[::-1]), uma forma simples de manipulação. Isso inverte a ordem
dos bytes em todo o arquivo, o que provavelmente corromperá a imagem de uma maneira
visualmente distinta.
O arquivo é então aberto novamente no modo "wb" e os bytes modificados são escritos de
volta ao arquivo.
Carregar e mostrar a imagem modificada
Os dados binários modificados são carregados de volta em um array NumPy com o mesmo
formato e tipo de dados da imagem original usando np.frombuffer(data,
dtype=np.uint8).reshape(img_data.shape).
A imagem é reconstruída do array NumPy modificado usando Image.fromarray(modified_data).
modified_img.show() exibe a imagem resultante, que agora reflete as modificações feitas nos
dados binários.
Esse script é um exemplo prático de como as operações de baixo nível em arquivos binários podem afetar o
conteúdo dos arquivos (neste caso, uma imagem). Ele serve como um exercício educativo para entender a
estrutura de dados de imagens e o impacto de manipulações diretas dos dados binários.
Atividade 4
Questão 
No script de manipulação de imagem utilizando a biblioteca PIL para manipular arquivos binários, o que
aconteceria se os arquivos fossem abertos no modo "w" (write) e "r" (read) em vez de "wb" (write binary) e
"rb" (read binary) ao tentar escrever os dados binários?
A
Os dados seriam escritos corretamente sem nenhum erro.
B
A imagem resultante seria exatamente invertida, conforme pretendido na manipulação.
• 
• 
• 
• 
• 
• 
• 
C
Seria retornado um erro, pois o método write requer um argumento do tipo string em vez de bytes.
D
Os dados binários seriam convertidos automaticamente para string antes de serem escritos.
E
O arquivo final seria maior devido à conversão incorreta de bytes para strings.
A alternativa C está correta.
Quando arquivos são abertos no modo "w" em vez de "wb", o Python espera que os dados escritos sejam
do tipo string e não bytes. Ao tentar escrever dados binários diretamente em um arquivo aberto no modo
"w", ocorrerá um erro, pois o método write não aceita bytes sem uma conversão explícita para string.
2. Funções de manipulação de strings
Manipulação de strings
A habilidade de manipular strings em Python é essencial na programação moderna, pois textos são
frequentemente o meio de comunicação entre o usuário e a máquina, assim como entre sistemas. 
Seja para ajustar dados extraídos de arquivos, formatar mensagens para exibição, ou processar entradas do
usuário, as operações sobre strings — como remoção de espaços, alteração de maiúsculas e minúsculas, e
substituição de caracteres — são ferramentas poderosas. 
Dominar essas funções permite um tratamento eficiente e preciso dos dados, fundamental para a integridade
e usabilidade das aplicações.
Neste vídeo, exploramos as funções essenciais de manipulação de strings em Python, incluindo strip, split,
join e count. Demonstraremos como esses métodos podem ser aplicados para limpar dados, contar palavras,
dividir e unir strings, facilitando o processamento de texto em aplicações.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Durante a vida de programador, é muito comum nos
depararmos com situações em que precisamos realizar
alguns ajustes e operações sobre os textos lidos de
arquivos, como remover espaço em branco, colocar todas
as letras maiúsculas, substituir e contar palavras. 
Neste módulo, veremos alguns métodos presentes nos
objetos do tipo str (string), que são muito utilizados em
conjunto com a manipulação de arquivos. 
Método strip
Como mostrado nos scripts da imagem abaxio (script5), ao
ler o conteúdo do arquivo, o Python retorna os caracteres
de final de linha (\r e \n). Muitas vezes, essa informação não é necessária, principalmente se estivermos
tratando uma linha de cada vez. Veja:
Conteúdo interativo
Acesse a versão digital para ver mais detalhes da imagem
abaixo.
Leitura do arquivo script5.
Dependendo do objetivo, esses caracteres são considerados lixo e podem atrapalhar o processamento que
desejamos realizar. Para remover esses caracteres e também espaços em branco adicionais, o tipo str
disponibiliza o método strip(). O método strip remove os caracteres do início e do final da linha. Observe o uso
deste método no exemplo a seguir. Clique nas setas para acompanhar cada ação:
Imagem 1
Temos os scripts 13a e 13b, suas respectivas saídas e seu arquivo
dados13.txt. 
Imagem 2
Abrimos o arquivo dados13.txt, exibido à direita da figura, e imprimimos o
conteúdo de cada linha desse arquivo. Vamos utilizar o método repr para
verificar o real conteúdo da string. 
Imagem 3
Separamos o script em duas partes, a e b, de forma a se perceber melhor
o resultado da utilização do método strip(). 
Imagem 4
Abrimos o arquivo em modo leitura, na primeira parte, script13a,
utilizando o with na linha 1, iteramos sobre o objeto arquivo na linha 3 e
imprimimos o conteúdo de cada linha na linha 4. 
Imagem 5
Observe, no console abaixo do script13a, que os espaços em branco no
início de cada linha e os caracteres de nova linha (\n) estão presentes na
string. 
Imagem 6
Abrimos, na segunda parte, script13b, o mesmo arquivo e iteramos da
mesma forma. Porém, desta vez, “limpamos” a linha utilizando o método
strip, na linha 4. Esse método retorna uma nova string, que é armazenada
na variável linha_limpa. Em seguida, na linha 5, imprimimos a
representação dessa variável. 
Imagem 7
Observe a saída do console e verifique que os caracteres em branco do
início da linha e os caracteres de nova linha foram removidos. 
Um exemplo real de utilização do strip é quando desejamos contar a quantidade de linhas com algum
conteúdo em um arquivo. Dependendo do tamanho do arquivo, é inviável remover manualmente as linhas em
branco. Para resolver esses problemas, podemos utilizar o método strip da seguinte forma: 
Vamos abrir o mesmo arquivo do exemplo anterior, dados13.txt, e iterar sobre cada linha, incrementando um
contador, que será impresso no final. Para melhor ilustrar, vamos mostrar como contar as linhas sem usar o
método strip, script14a, com o strip script14b, veja:
Imagem 1
Temos os scripts 14a e 14b e suas respectivas saídas.
Imagem 2
Abrimos, no primeiro script, o arquivo em modo leitura na linha 1, criamos
e inicializamos uma variável inteira contador, linha 3, e iteramos seu
conteúdo linha a linha, utilizando o loop for, linha 4. 
Imagem 3
Verificamos, na linha 5, se a variável linha, do tipo str, contém algum
conteúdo. Lembrando que uma variável do tipo string testa para falso
apenas se seu conteúdo for vazio ('' ou ""); caso a string contenha, pelo
menos, um espaço, ela testará verdadeiro. Continuando,na linha 6, caso
exista algum conteúdo, incrementamos o contador. 
Imagem 4
O contador, para o primeiro script, obteve valor 7, indicando que o arquivo
contém 7 linhas, conforme console abaixo do script14a. 
Imagem 5
Escrevemos, no segundo script, praticamente o mesmo código, iniciando
pela abertura do arquivo na linha 1, e assim por diante. A exceção é a
linha 5, que testa o conteúdo da variável linha após utilização do método 
strip(). Observe que, agora, contamos corretamente o número de linhas
com algum conteúdo, 3. 
Métodos count e split
Outra atividade muito comum na manipulação de arquivos é a contagem do número de vezes que determinada
palavra aparece. O Python disponibiliza o método count para strings, que recebe como parâmetro a palavra
que desejamos contar e retorna o total de ocorrências dela. Sua sintaxe é a seguinte: 
python
contagem = variavel_string.count(palavra) 
Nela, a variavel_string é uma variável do tipo str e palavra é a string que desejamos contar. 
Veja a seguir como utilizamos o método count para contar a quantidade de vezes em que aparece a palavra
“Olá”, no arquivo dados13.txt: 
Imagem 1
Temos os scripts 15, sua saída e arquivo dados13.txt.
Imagem 2
Utilizamos, após abrir o arquivo na linha 1, o método read, linha 2, para
retornar todo o conteúdo do arquivo como uma única string e armazená-
lo na variável texto. Na linha 3 utilizamos o método count da variável
texto, passando como argumento à string “Olá”. 
Imagem 3
O total de ocorrências da palavra “Olá” foi armazenado na variável 
contador, que foi impressa na linha 4. Observe que o total de ocorrência
está correto: 3. 
Apesar de ser muito simples a utilização do método count do tipo str, pode gerar alguns efeitos indesejáveis,
pois esse método também conta as palavras que contêm parte da string passada como argumento. 
Exemplo
Considere a frase: “Eu amo comer amoras no café da manhã”. Se utilizarmos o método count, com a
string “amo” como argumento, o retorno será 2, pois o método irá considerar tanto a palavra amo quanto
a palavra amoras. 
Para contornar esse problema, podemos “quebrar” uma frase em palavras e depois verificar se cada palavra é
igual à string que buscamos. 
Isso nos leva a outro método muito utilizado em processamento de textos, o método split(), que é usado para
quebrar uma string em partes menores, retornando uma lista com essas partes. Sua sintaxe é a seguinte:
python
lista_termos = variavel_string.split(separador) 
No exemplo, a variavel_string é uma variável do tipo str, e separador é uma string que desejamos utilizar como
ponto de quebra do texto. O retorno desse método é uma lista de strings. 
Digamos que desejamos usar o método split com separador ‘–‘ na frase: “Amo futebol – Gosto de basquete”. O
resultado seria uma lista em que o primeiro elemento é a string “Amo futebol ” e o segundo elemento é string “
Gosto de basquete”. Caso nenhum separador seja passado como argumento, o Python irá utilizar um ou mais
espaços como separador padrão.
Dica
A string utilizada como separador não aparecerá em nenhum elemento da lista retornada. 
No exemplo a seguir o método split é utilizado em três frases diferentes para mostrar o comportamento dele.
Confira:
Imagem 1
Temos o script 16 e sua saída.
Imagem 2
Utilizamos o método split sem argumentos, linha 2, e imprimimos a lista
retornada na linha 3. Observe pelo console que cada item da lista é uma
palavra da frase.
Imagem 3
Utilizamos o método split, também, sem argumentos, linha 6, e
imprimimos a lista retornada na linha 7. Observe pelo console que,
mesmo havendo muitos espaços em branco entre as palavras da frase, a
lista contém apenas as palavras, sem nenhum espaço adicional. O Python
é esperto o suficiente para detectar vários espaços contínuos e tratá-los
como um único separador. 
Imagem 4
Temos, na linha 9, a última frase: "Carro,moto,avião". Desta vez,
utilizamos o método split passando uma vírgula ( , ) como argumento, na
linha 10. O resultado é uma lista contendo apenas as palavras, sem o
separador, conforme podemos ver pelo console. 
Agora que sabemos como funciona o método split, no próximo exemplo, vamos utilizar esse método para
realizar a contagem da palavra “amo” na frase do exemplo anterior: “Eu amo comer amoras no café da
manhã.”. Vamos aproveitar para comparar os resultados obtidos pelos métodos count e split. 
Imagem 1
Temos o script 17 e sua saída.
Imagem 2
Definimos, na linha 1, nossa variável frase com o conteúdo descrito
anteriormente.
Imagem 3
Utilizamos, na linha 4, o método count do tipo str para contar diretamente
o número de ocorrências da string “amo” na frase. Pelo console, vemos
que o resultado da contagem foi 2. Uma ocorrência pela palavra amo e
outra pela palavra amora. 
Imagem 4
Criamos, para realizar a contagem da mesma frase usando o split, um
contador, linha 7, e quebramos a frase em palavras utilizando o método
split, linha 8. 
Imagem 5
Iteramos, na linha 9, sobre cada palavra utilizando a variável termo. Para
cada termo, comparamos se seu valor é igual a string “amo”, linha 10.
Caso seja igual, incrementamos o contador, linha 11. Observe que desta
vez alcançamos o resultado correto para a contagem, 1. 
No script17.py, para realizar a contagem da palavra “amo” na frase “Eu amo comer amoras no café da manhã”,
foi criada uma lista chamada lista_termos, através do uso do método split sobre a variável que continha a frase
mencionada. Também foi criado um contador e houve uma iteração sobre lista_termos, realizando
comparações entre os elementos desta e a palavra “amo”. 
Será que não haveria uma maneira de realizar essa contagem de outra maneira, fazendo uso dos
métodos de manipulação de strings apresentados até aqui?
Utilize o emulador de códigos abaixo para desenvolver outra solução para o problema da contagem da palavra
“amo” na frase “Eu amo comer amoras no café da manhã.”:
Conteúdo interativo
esse a versão digital para executar o código.
A resolução está contida a seguir:
Conteúdo interativo
esse a versão digital para executar o código.
No código acima, na linha 2, temos a separação das palavras da frase por meio do uso do método split na
variável frase (tipo string). A seguir, na linha 3, utilizamos o método count com o argumento “amo”, para
obtermos a quantidade de ocorrências dessa string (“amo”) em lista_termos. Por fim, na linha 4, imprimimos o
resultado no console do emulador. 
Vamos avançar para mais um método!
Método join
Assim como há a necessidade de quebrar uma frase em uma lista de palavras, podem existir situações em que
ocorra o inverso, ou seja, temos uma lista de palavras ou frases e desejamos concatená-las em uma única
string. 
Para essa operação, utilizamos o método join do tipo str, que retorna uma única string com todos os
elementos da lista concatenados, utilizando determinado conector. Sua sintaxe é a seguinte: 
python
string_final = “conector”.join(iteravel) 
Em que “conector” é a string que será utilizada entre os elementos da lista que serão concatenados (ex. ', ') e
iteravel é um iterável, como uma lista ou tupla. 
No exemplo a seguir, vamos unir os elementos de uma lista utilizando dois conectores diferentes: o conector
vírgula (', ') e o conector de nova linha ('\n'). Após a união, vamos gravar o conteúdo em um arquivo para
mostrar o resultado: 
Imagem 1
Temos o script 19, arquivos texto1.txt e texto2.txt.
Imagem 2
Criamos, na linha 1, a lista minha_lista, que será utilizada nos dois
exemplos.
Imagem 3
Utilizamos, na linha 3, o método join com o conector ', ' e atribuímos o
resultado à variável texto1. O resultado dessa variável foi gravado no
arquivo texto1.txt, que pode ser visto na imagem. 
Imagem 4
Fazemos, na linha 7, a junção dos elementos da mesma lista utilizando o
conector '\n'. O resultado da junção foi gravado no arquivo texto2.txt, que
pode ser visto à direita da imagem. Com isso, fomos capazes de colocar
cada elemento da lista em uma linha do arquivo. 
Atividade 1
Questão 
Ao trabalhar com manipulação destrings em Python, é comum a necessidade de remover espaços em branco
e caracteres de nova linha ao final de strings, especialmente ao ler linhas de um arquivo. Qual método é
utilizado para essa finalidade?
A
remove()
B
delete()
C
strip()
D
cut()
E
clean()
A alternativa C está correta.
O método strip() é usado para remover espaços em branco, incluindo novas linhas e tabulações, do início e
do fim de uma string. As demais alternativas não são métodos válidos para manipulação de strings em
Python.
Formatação de strings
Saber formatar strings em Python é uma competência importantíssima para qualquer profissional da
tecnologia, pois permite a personalização e a apresentação adequada de dados em diversas aplicações. 
Desde a inclusão de variáveis em mensagens até a especificação de formatos numéricos e datas, a
formatação de strings viabiliza a criação de saídas legíveis e profissionais. As chamadas "f-strings" do Python
simplificam significativamente a inserção de expressões dentro de strings, facilitando a leitura e a manutenção
do código. 
Dominar essas técnicas de formatação, além de melhorar a interface do usuário, também é crucial para o
processamento eficiente de dados e geração de relatórios. 
Neste vídeo, exploraremos as técnicas de formatação de strings em Python, incluindo o poderoso recurso das
f-strings. Veremos como incorporar variáveis, definir precisão numérica e formatar datas diretamente em
strings para gerar saídas claras e profissionais.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Até o momento, realizamos operações sobre strings pré-existentes. No entanto, é muito comum precisarmos
juntar valores de variáveis com strings. 
Agora, veremos algumas funções relacionadas às strings, começando pela formatação de strings (string
formatting). 
A formatação de strings permite ajustar como uma string será exibida ou gravada em um arquivo, por
exemplo. Ajustes como: número de casas decimais em float, exibição de datas, inclusão de variáveis e
espaçamento são alguns dos exemplos.
Existem basicamente três formas de realizar a formatação de strings. São elas:
Utilizando f-strings (formatted string literals).
Utilizando o método format() das strings.
Fazendo manualmente.
f strings
São tipos especiais de strings que aceitam uma notação especial para permitir a inclusão de expressões
diretamente na string.
Veremos como utilizar f-strings, recurso adicionado na versão 3.6 do Python.
F-strings
• 
• 
• 
O objetivo principal da criação das f-strings foi facilitar a formatação de strings. 
Para definimos uma variável f-string, precisamos incluir, antes das aspas que definem uma string, a letra f (ou
F), por exemplo:
python
minha_string = f”Olá Mundo {expr}” 
Dentro das f-string, podemos utilizar expressões em Python entre as chaves, delimitadas pelos caracteres {
e }. 
Essas expressões incluem variáveis ou literais. Inclusive, podemos fazer chamada para funções ou utilizar
métodos de variáveis dentro desses delimitadores.
Literais
É algo que o interpretador reconhece como uma sintaxe válida (exemplo: 2 > 3 retorna False, [1, 2])
retorna uma lista.
Todo o conteúdo entre os caracteres { e } é substituído pelo resultado da expressão e interpolado à string. 
Compare a seguir a manipulação manual de strings com a utilização de f-string e veja alguns exemplos de uso
de literais mais sofisticados dentro de f-strings: 
Imagem 1
Temos o script 20 e sua saída.
Imgem 2
Definimos, na linha 1, a variável nome, do tipo string, que será utilizada ao
longo do script. 
Mostramos, na linha 3, como incluir o valor da variável nome no meio de
outra string, utilizando o processo manual de concatenação de strings
por meio do operador '+'. 
Imagem 3
Utilizamos, na linha 4, a sintaxe da f-string para incluir o valor da variável
nome também no meio de outra string. Observe que a IDE PyCharm já
detectou que temos uma expressão entre as chaves e alterou a cor para
destacar esse elemento. No console, o resultado das variáveis
minha_string e minha_fstring1 foi o mesmo, porém a sintaxe da f-string é
muito mais clara e simples de ser utilizada e entendida. 
Imagem 4
Temos, na linha 5, o mesmo exemplo da linha anterior, porém chamamos
o método upper do tipo str para colocar todas as letras em maiúsculo.
Isso foi feito diretamente na expressão! 
Imagem 5
Utilizamos, na linha 6, uma soma na expressão entre chaves, que foi
calculada corretamente, conforme console. 
Imagem 6
Utilizamos, na linha 7, o comparador booleano >, que também foi avaliado
corretamente. 
Imagem 7
Utilizamos, na linha 8, o operador IN para verificar a pertinência de um
número em uma lista, que, mais uma vez, foi avaliado corretamente.
Observe como é fácil e intuitiva a utilização de f-string! 
Veja agora algumas funcionalidades adicionais de formatação de string utilizando f-string, como a definição
de largura de uma string, formatação de float e de datas:
Script 21 e sua saída.
Para facilitar o entendimento, o script21 foi dividido em três trechos. O primeiro trecho, entre as linhas 3 e 6,
trata da formatação de largura do conteúdo de expressões, que serve, principalmente, para alinhar conteúdo
de texto. No segundo trecho, das linhas 10 a 16, mostramos como formatar floats. No terceiro trecho, das
linhas 20 a 24, mostramos como formatar datas. Confira cada trecho citado: 
Linhas 3 até 6
No primeiro trecho, definimos uma lista chamada frutas na linha 3 e, na linha 4, percorremos cada item dessa
lista.
 
Para cada item, montamos a f-string minha_fruta, que contém o nome da fruta e o número de letras que a
fruta tem. Destacamos essa linha a seguir:
Destaque f-string.
Para indicar a largura, ou melhor, o número de espaços que o conteúdo de uma variável deve ocupar, devemos
utilizar a sintaxe {variavel:n}, onde temos o nome da variável, seguida de dois pontos (:) e o número de
espaços (n) que se deve ocupar.
 
Caso o tamanho do conteúdo da variável seja menor que o número n, serão incluídos espaços em branco até
completar esse tamanho. A posição dos espaços adicionados depende do tipo da variável. Para variáveis do
tipo string, os espaços são adicionados à direita, enquanto para variáveis do tipo inteiro, os espaços são
adicionados à esquerda.
 
Caso o tamanho do conteúdo da variável seja maior que o número n, a formatação será ignorada.
 
Retornando ao exemplo, desejamos imprimir o nome da fruta de forma que ela ocupe 12 espaços ({fruta:12}), e
o número de letras da fruta deve ocupar apenas três espaços ({len(fruta):3}). Observe o resultado obtido no
console à direita.
Linhas 10 até 16
No segundo trecho, definimos uma variável float na linha 10 e criamos três f-strings para exibir esse conteúdo.
 
A formatação com f-string nos permite um controle maior de como será exibido um número do tipo float, no
qual podemos definir a largura e o número de casas decimais que devem ser exibidos. A sintaxe para formatar
um float é a seguinte:
python
{variavel_float:largura.precisao f} 
Pelo exemplo, temos o nome da variável do tipo float seguida de dois pontos (:), a largura total que o número
deve ocupar, incluindo as casas decimais, e o ponto (separador de decimal), seguido de um ponto (.), o
número de casas decimais (precisao) e a letra “f”, que deve estar junto à precisão. A largura é opcional.
 
Na primeira f-string, na linha 11, utilizamos a expressão {pi:.1f}, ou seja, queremos que seja exibido o valor da
variável pi com uma casa decimal apenas. Como não especificamos a largura, ela será calculada de forma a
acomodar toda a parte inteira do float.
 
Na f-string da linha 12, utilizamos a expressão {pi:6.1f}, que indica que o número deve ocupar seis espaços,
sendo que, necessariamente, deve ter uma casa decimal.
 
Na última f-string, linha 13, utilizamos a expressão {pi:.4f}, para que seja exibido o número com quatro casas
decimais. Observe, no console, como ficaram os resultados.
Linhas 20 até 24
No terceiro e último trecho, vamos mostrar como formatar datas em expressõesf-string.
 
Na linha 20, definimos a variável data com a data atual, utilizando o método datetime.now().
 
Na linha 21, criamos uma f-string para exibir o valor da variável data sem informar ao Python qual formatação
ele deve utilizar ({data}). Com isso, a data foi impressa no formato padrão: 2020-08-13 10:50:32.262037.
 
Na linha 22, utilizamos a expressão {data:%d/%m/%Y}, que indica que desejamos exibir a data no formato “dia/
mês/ano” (13/08/2020). Veja o resultado no console à direta.
Pesquise mais sobre o módulo datetime na documentação oficial para descobrir outras maneiras de formatar
datas. 
Vamos avançar! 
Atividade 2
Questão 
Na programação Python, uma compreensão adequada da formatação de strings é fundamental para a
apresentação clara de informações. Qual método permite uma manipulação detalhada da apresentação de
variáveis dentro de strings, incluindo a definição de largura e precisão?
A
String concatenation
B
Método join()
C
f-strings
D
Método replace()
E
Método strip()
A alternativa C está correta.
As f-strings, introduzidas no Python 3.6, oferecem uma maneira prática e eficiente de formatar strings. Elas
permitem a inclusão direta de expressões Python dentro de chaves {}, possibilitando ajustes finos de
largura, precisão e outros formatos diretamente na string, tornando o código mais legível e conciso.
Codificando mensagens com Python
Transformar e codificar strings em Python é uma habilidade prática de grande relevância para
desenvolvedores e analistas de dados. A manipulação de strings é uma tarefa comum em diversas aplicações,
desde a preparação de dados para análise até a criação de interfaces de usuário. 
Codificar strings, por outro lado, é importante para garantir a segurança e a integridade das informações
transmitidas e armazenadas. Por exemplo, ao enviar dados através da internet, é essencial codificar strings
para prevenir ataques de injeção SQL e proteger informações sensíveis. 
Além disso, compreender e aplicar técnicas de transformação e codificação de strings é fundamental para a
internacionalização de software, na qual caracteres especiais e diferentes codificações de texto são comuns.
Isso permite que as aplicações sejam mais inclusivas e utilizáveis por um público global. 
A prática de transformar e codificar strings também é importante na manipulação de arquivos, na formatação
de dados para APIs e na integração de sistemas diversos.
Neste vídeo, exploraremos como codificar uma mensagem usando a cifra ZENIT POLAR em Python.
Demonstraremos o uso de métodos simples de substituição de strings, como o replace, e técnicas para
manipular e formatar textos, incluindo o uso de split e join.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Um desenvolvedor em uma empresa de segurança é encarregado de criar uma ferramenta simples para
codificar mensagens de texto confidenciais antes de enviá-las. Para garantir uma codificação básica, ele
decide usar a cifra de substituição "ZENIT POLAR". 
A codificação ZENIT POLAR é um tipo de cifra de substituição simples na qual as letras de duas palavras ou
grupos de letras são usadas para substituir uma pela outra. No caso específico de "ZENIT POLAR", cada letra
em "ZENIT" é substituída pela letra correspondente em "POLAR" e vice-versa. Esse tipo de cifra é bidirecional
e simétrica, significando que a mesma substituição é usada para codificar e decodificar mensagens.
Observe como a substituição funciona para cada letra.
**Z** é substituída por **P** e **P** por **Z**.
**E** é substituída por **O** e **O** por **E**.
**N** é substituída por **L** e **L** por **N**.
**I** é substituída por **A** e **A** por **I**.
**T** é substituída por **R** e **R** por **T**.
Todas as outras letras que não estão incluídas na cifra são deixadas inalteradas. A cifra ZENIT POLAR é
relativamente simples e não oferece uma segurança robusta para padrões modernos, mas é um exemplo
interessante de manipulação básica de texto e pode ser usada para ilustrar conceitos de criptografia em
contextos educacionais ou para diversão.
• 
• 
• 
• 
• 
Observe o código Python!
python
def zenit_polar_replace(text):
 # Aplicar a codificação ZENIT POLAR utilizando o método replace
 replacements = [('z', 'p'), ('e', 'o'), ('n', 'l'), ('i', 'a'), ('t', 'r'),
 ('Z', 'P'), ('E', 'O'), ('N', 'L'), ('I', 'A'), ('T', 'R')]
 for old, new in replacements:
 text = text.replace(old, new)
 return text
def main():
 # Entrada da frase e aplicação da codificação
 phrase = "The quick brown fox jumps over the lazy dog"
 phrase = phrase.title() # Primeira letra de cada palavra em maiúscula
 # Dividir a frase em palavras
 words = phrase.split()
 # Processar cada palavra na lista usando ZENIT POLAR
 coded_words = [zenit_polar_replace(word) for word in words]
 # Juntar todas as palavras codificadas em uma frase
 coded_phrase = " ".join(coded_words)
 print("Original:", phrase)
 print("Coded:", coded_phrase)
if __name__ == "__main__":
 main()
``` 
O código demonstrado realiza a codificação de uma mensagem usando uma cifra de substituição simples
chamada ZENIT POLAR e demonstra manipulações básicas de strings em Python. A seguir, apresentamos o
funcionamento detalhado de cada parte do script.
Função zenit_polar_replace
Definição da função e substituições
A função zenit_polar_replace aceita um argumento text, que é a string a ser codificada.
Dentro da função, uma lista de tuplas chamada replacements é definida, em que cada tupla contém um
par de caracteres. O primeiro elemento de cada tupla é a letra original e o segundo é a letra substituta,
conforme a cifra ZENIT POLAR (ex: ('z', 'p') substitui 'z' por 'p').
Aplicação das substituições
Um loop for itera sobre cada tupla na lista replacements.
Para cada tupla, o método replace é chamado no text atual. O método replace(old, new) substitui todas
as ocorrências do caractere old pelo caractere new no texto.
O texto modificado é então retornado ao final da função.
• 
• 
• 
• 
• 
Função main
1
Entrada de texto
A frase "The quick brown fox jumps over the lazy dog" é armazenada na variável phrase e é
convertida para ter a primeira letra de cada palavra em maiúscula usando o método title(). Isso é
feito para simular um cenário no qual todas as palavras começam com maiúsculas antes de serem
codificadas.
2
Divisão do texto em palavras
O método split() é utilizado para dividir phrase em uma lista de palavras, armazenada na variável
words. O método split() por padrão divide uma string em cada espaço em branco, retornando uma
lista das substrings.
3
Codificação de cada palavra
Uma compreensão de lista ([zenit_polar_replace(word) for word in words]) é usada para aplicar a
função zenit_polar_replace a cada palavra na lista words. O resultado é uma lista de palavras
codificadas, armazenada em coded_words.
4
Junção das palavras codificadas em uma frase
O método join() é usado para concatenar todas as palavras na lista coded_words em uma única
string, separadas por espaços. Essa nova string é armazenada em coded_phrase.
5
Exibição dos resultados
O script imprime a phrase original e a coded_phrase para que o usuário possa comparar a entrada
original com a saída codificada.
Esse script é um exemplo prático para demonstrar como realizar substituições simples em strings e como
manipular e transformar strings em Python para fins de codificação básica.
Atividade 3
Questão 
No contexto do script Python utilizando a cifra ZENIT POLAR para codificar mensagens, o que aconteceria se
o desenvolvedor passasse toda a frase como argumento para o método zenit_polar_replace sem primeiro usar
o método split para criar uma lista de palavras?
A
A codificação não seria aplicada, pois o método requer divisão em palavras.
B
Apenas as letras no início de cada palavra seriam codificadas.
C
A codificação seria aplicada da mesma maneira, alterando todas as letras elegíveis na frase completa.D
Seria gerado um erro, pois o método replace não pode ser aplicado a strings não segmentadas.
E
Nenhuma letra seria codificada, mantendo a frase original intacta.
A alternativa C está correta.
A codificação ocorreria exatamente da mesma maneira, pois o método zenit_polar_replace aplica as
substituições de letras definidas na cifra ZENIT POLAR diretamente sobre qualquer string que receba como
entrada, independentemente de ser uma única palavra ou uma frase completa. Assim, todas as letras
correspondentes na frase seriam substituídas conforme a configuração da cifra.
3. Tratamento de exceções e outras operações
Tratamento de exceções na manipulação de arquivos
Durante a manipulação de arquivos, problemas como arquivos inexistentes ou falta de permissões são comuns
e só podem ser detectados em tempo de execução. Sem um tratamento adequado, essas exceções podem
interromper o programa, comprometendo a experiência do usuário e a integridade dos dados. 
Utilizar técnicas de tratamento de exceções, como as cláusulas try/except, permite gerenciar esses problemas
de maneira eficiente, garantindo que o programa continue executando de forma controlada e segura.
Neste vídeo, vamos explorar o tratamento de exceções em Python, uma prática fundamental para lidar com
erros e situações inesperadas em programas. Aprenderemos a utilizar blocos try-except para capturar e tratar
exceções, evitando interrupções indesejadas no fluxo do código. Descubra como implementar estratégias de
tratamento de erros eficazes e tornar seu código mais robusto e confiável.
Conteúdo interativo
Acesse a versão digital para assistir ao vídeo.
Tratamento de exceções
Quando trabalhamos com arquivos, é comum encontrarmos
alguns problemas, como arquivo inexistente e falta de
permissão para escrever em um. A maioria desses
problemas só pode ser detectada durante a execução do
programa. 
Quando uma falha inesperada ocorre e o interpretador não
consegue resolver o problema, dizemos que houve uma
exceção. 
Nesses casos, precisamos informar ao interpretador como
tratar a exceção, para que o programa não seja
interrompido.
Se a exceção é um problema inesperado, como tratá-la? 
Ao desenvolver um programa, precisamos
procurar na documentação da biblioteca, do
módulo ou da própria linguagem de
programação se as funcionalidades que vamos
utilizar têm exceções mapeadas. Essas
exceções são problemas que podem ocorrer, e
é nossa tarefa tratá-las. 
Você deve estar se perguntando: “O que seria
‘tratar uma exceção?”. Isso nada mais é do que
dizer ao Python o que fazer, ou quais instruções
executar, quando ele encontrar um problema.
Para ilustrar, observe os seguintes passos:
 
1. Quando abrimos um arquivo em modo leitura e esse arquivo não existe, o Python lança uma exceção do tipo
FileNotFoundError.
 
2. Se não avisarmos ao Python o que fazer quando isso ocorrer, o programa será interrompido.
 
3. Nesse caso, um tratamento para essa exceção poderia ser: exibir um pop-up ao usuário informando que o
arquivo não existe.
Veja o que acontece quando uma exceção lançada não é tratada:
Imagem 1
Temos o script 22 e sua saída. 
Imagem 2
Imprimimos, na linha 1, a string “Abrindo um arquivo”. Essa impressão
serve para acompanhar a execução do programa no console. 
Imagem 3
Abrimos, na linha 3, o arquivo teste.txt no modo leitura. Esse arquivo não
existe no diretório modulo3 no qual estamos trabalhando, como podemos
observar pela árvore de diretórios à esquerda da figura. 
Imagem 4
Recebemos um erro, ao executarmos o programa, destacado em
vermelho no console. O nome do erro é FileNotFoundError, e a sua
descrição é No such file or directory (em tradução literal, não existe tal
arquivo ou diretório), seguido do nome do arquivo que apresentou o erro,
teste.txt. 
Imagem 5
Essa exceção foi gerada, ou lançada, de acordo com o linguajar da
computação, pois o Python não sabia qual caminho tomar ao encontrar
esse problema. Observe que a linha 5 não foi executada, pois o programa
parou sua execução assim que o problema foi encontrado. 
Para resolver isso, precisamos tratar a exceção, ou melhor, uma possível exceção. Esse tratamento informa ao
Python uma rota alternativa, caso ele encontre um problema. 
Para tratar exceções, precisamos “envolver” o trecho de código passível de erro com a cláusula try/
except ou try/except/finally. Veremos apenas a cláusula try/except. 
Veja a sintaxe a seguir:
Sintaxe try/except.
O código crítico que desejamos executar deve estar no escopo do try, enquanto o código alternativo, que será
executado em caso de erro, deve estar no escopo do except. 
Uma mesma operação pode lançar mais de um tipo diferente de exceção, em que, para cada tipo, Erro1 e
Erro2, devemos ter uma cláusula except específica. 
No exemplo da imagem, a exceção está disponível por meio da variável erro, de onde podemos extrair mais
informações, como veremos a seguir. 
Praticamente todas as exceções em Python são herdadas da classe Exception, ou seja, ela é uma exceção
muito genérica, lançada por diversos tipos de erros diferentes. Quanto mais genérica, mais abrangente é a
exceção. 
Atenção
Não é uma boa prática utilizar exceções abrangentes, pois elas podem silenciar erros que não
esperamos. O ideal é tratar as exceções utilizando a forma mais específica possível. 
Confira algumas exceções específicas relacionadas à manipulação de arquivos e alguns motivos que podem
gerar essas exceções:
PermissionError
Lançada quando não temos permissão para
realizar uma operação.
FileExistsError
Lançada quando tentamos criar um arquivo ou
diretório já existentes.
FileNotFoundError
Lançada quando tentamos abrir um arquivo ou
diretório que não existem.
Todas essas exceções herdam da exceção mais abrangente OSError, que, por sua vez, herda de Exception. 
Observe o exemplo a seguir, onde vamos tratar a exceção do exemplo anterior, utilizando a exceção
específica mais indicada: FileNotFoundError:
Imagem 1
Temos o script 23 e sua saída.
Imagem 2
“Envolvemos” o código que pode gerar problema com o try. Para isso,
indentamos as linhas 4 e 5. 
Imagem 3
Precisamos, para tratar o erro, explicitar qual o tipo que vamos tratar.
Nesse caso, FileNotFoundError, como descrito na linha 6. Indentamos as
linhas 7 e 8 para indicar que elas fazem parte do escopo da exceção
explicitada na linha 6. 
Durante a execução do programa, ao executar a linha 4, o Python encontra um erro, pois tentamos abrir o
arquivo teste.txt para leitura, mas ele não existe. Como este código está dentro do escopo do try, o
interpretador interrompe imediatamente a execução do código contido nesse escopo e inicia a execução do
código do except correspondente ao erro FileNotFoundError. Ou seja, a execução salta da linha 4 para a linha
7. 
Na linha 7, imprimimos a mensagem "Arquivo inexistente" e, na linha 8, imprimimos o problema encontrado,
disponível na variável erro. 
Observe a sequência de execução pelas saídas no console:
Início da execução do código do except.
Saiba que o Python só consegue tratar a exceção caso o erro esteja mapeado em algum except. Se o
interpretador não encontrar o except adequado, será gerado um erro, e o programa será interrompido. 
Um problema clássico que ocorre quando lidamos com arquivos é tentar alterar o conteúdo de um arquivo
quando ele está aberto em outro programa. No caso do sistema operacional Windows 10, é lançada uma
exceção sobre permissão de acesso. 
A seguir, vamos criar mais um except para tratar o caso de não termos permissão para abrir um arquivo,
mostrando o tratamento do problema levantado no parágrafo anterior. 
Neste exemplo, tentamos abrir o arquivo teste.pdf para escrita, linha 4, porém ele já está aberto em outro
programa: 
Script 24 e sua saída.
Observe que o fluxo de execução do programa saltou da linha 4 para a linha 10. Na linha 10, temos o início do
tratamento da exceção PermissionError, que foi justamente a exceção lançada pelo Python, impressa pela
linha 11, e que pode ser verificada no console.
O Python direciona