Saindo da telinha sem cor do terminal: trabalhando com arquivos#

O que você saberá se você ler todo este capítulo?#

  1. Que dá para trabalhar com arquivos em Python ao invés de ficar mexendo só no terminal.

  2. A diferença entre arquivos de texto, JSON e pickle.

  3. Que trabalhar com arquivos é mais fácil do que parece: é só abrir, escrever (ou ler) e fechar novamente.

  4. E que, sob um ponto de vista de trabalho, é muito mais comum usarmos JSON do que outros formatos.

Livro de receitas#

Achou que eu esqueci da receita de bolo? Claro que não, jamais esqueceria de um bolo. Com um café então, nem se fala! Bom, vamos imaginar que você tem uma receita de bolo e você quer dar o seu toque pessoal. Transformar aquela receita de bolo da internet em uma receita de família, sabe? Quem sabe, você se animou bastante e agora quer fazer o seu próprio caderno de receitas usando como base algumas receitas comuns que você já viu por aí. Como você faria isso?

Para isso, você precisa abrir o seu caderno, procurar uma folha em branco, e escrever uma nova receita do seu jeito. Precisou mudar algo? Sem problemas: você vai até a folha em que precisará mudar algo e escreve em cima. Ah, e sabe qual é a vantagem disso? Você pode compartilhar com todo mundo: as pessoas podem tirar fotos ou cópias do seu caderno e, com isso, algum dia você poderá ser reconhecido como o maior boleiro (é esse o nome?) do mundo! Quem diria, né? Por causa desse livro aqui você se tornou o maior mestre dos bolos do mundo e até conseguiu comprar um iate, como esse aqui na imagem abaixo.

Um iate navegando no mar.
Créditos: Robert Linder no Unsplash

Ou, se você quiser continuar estudando desenvolvimento de software, a explicação acima ainda se aplica. Você pode ter percebido que as variáveis que trabalhamos até o momento nunca eram salvas no seu computador, não é? Isto é: você clicava em Run, o seu código aparecia no terminal, você interagia com ele, e acabou. Tirou o computador da tomada, ou acabou a bateria do notebook? Todas as variáveis foram apagadas.

Por outro lado, os arquivos existem para ajudar a salvar e transmitir esta informação para outros lugares. E se nós quiséssemos usar Python para adicionar, modificar ou excluir informações de um arquivo? É possível? Claro que é! É isto que veremos a partir de agora. Vamos lá?

Abrindo e fechando arquivos#

Lembra que no pseudocódigo tínhamos o leia e escreva, né? E que, em Python, eles eram traduzidos como input() e print(). Então, será que o Python teria algo para abrir e fechar arquivos? Mas é claro! E, como você deve adivinhar, os nomes das funções para isso são open() e close(), respectivamente. Vamos começar com um trabalho simples: vamos escrever uma receita de bolo dentro de um arquivo em Python.

Criando coisas#

Rode o código abaixo em um arquivo .py, tal qual você vem fazendo até o momento no PyCharm:

with open("receita.txt", "w") as f:
    f.write("Bolo de chocolate\n")
    f.write("Ingredientes:\n")
    f.write("- 2 xícaras de açúcar\n")
    f.write("- 1 e 3/4 xícaras de farinha de trigo\n")
    f.write("- 3/4 xícara de cacau em pó\n")
    
print("Finalizou!")

Muita coisa nova, né? Agora tem with, tem open, tem aquele "w" também. O que quer dizer tudo isso? Calma! É mais simples do que parece. Este código cria um arquivo chamado "receita.txt" no modo de escrita ("w") usando a função open() na primeira linha. Ou seja, open("receita.txt", "w") é, em bom português, algo como “abra um arquivo chamado “receita.txt” para a gente escrever coisas dentro dele”. A partir de agora, nós chamaremos este arquivo aberto pelo nome de f.

Ah, veja que a primeira linha também possui o with. Essa palavra-chave existe para garantir que o arquivo seja fechado após o uso dele.

Já a função write() é usada para escrever cada linha da receita no arquivo f que acabamos de abrir anteriormente. Perceba que chamamos o write() cinco vezes: estamos escrevendo coisas no arquivo cinco vezes, e uma linha de texto a cada vez. Consegue perceber que isso é bem parecido com o jeito que estamos acostumados a usar o print()?

Ao final da execução do bloco with, o nosso arquivo é automaticamente fechado, e todas as alterações feitas durante a execução do bloco são salvas. No final, temos até uma mensagem na tela mostrando que o código finalizou. Depois de rodar este código, experimente abrir o arquivo receita.txt, que agora existe em seu computador e na mesma pasta em que está o seu arquivo .py. Percebe que contém exatamente as mesmas 5 linhas que pedimos para serem inseridas antes?

Lendo coisas#

Bom, e para lermos o arquivo? Teste o seguinte código:

with open("receita.txt", "r") as f:
    conteudo = f.read()
    print(conteudo)

Percebe que trocamos o open("receita.txt", "w") para open("receita.txt", "r")? O parâmetro "r" indica que agora estamos no modo de leitura: ao invés de escrever, queremos ler o arquivo. Em seguida, usamos o método .read() para ler todo o conteúdo do arquivo e armazená-lo na variável conteudo. Por fim, mostramos o conteúdo na tela utilizando a função print().

Outro jeito de fazermos a mesmíssima coisa, mas sem recorrermos ao with é assim:

f = open("receita.txt", "r")
conteudo = f.read()
print(conteudo)
f.close()

Temos aqui três grandes diferenças. A primeira é que deixamos de usar o with na primeira linha, e o arquivo aberto encontra-se ainda dentro da variável f, mas com o código escrito de uma forma ligeiramente diferente. A segunda diferença fica na segunda e terceira linhas: como não temos mais o with, não temos mais aquela indentação. A terceira diferença está na última linha: sem o with, precisamos dizer explicitamente quando o arquivo deve ser fechado com a função close().

Dito isso, vale reforçar que por uma questão de boa prática é recomendável que você utilize o with para evitar dores de cabeça como, por exemplo, esquecer de fechar o seu arquivo.

Adicionando coisas#

Finalmente, e se quiséssemos só adicionar mais alguma coisinha no arquivo sem apagar o que já temos até o momento? Também tem como. Veja só:

with open("receita.txt", "a") as f:
    f.write("- 1 colher de sopa de fermento em pó\n")
    f.write("- Granulado a gosto\n")

Veja que usamos o f.write() igual como fizemos no primeiro exemplo. A diferença está no parâmetro da primeira linha: agora estamos usando open("receita.txt", "a"). Este "a" indica que queremos adicionar um conteúdo extra no final deste arquivo sem remover nada do que fizemos até o momento. Em resumo, temos o seguinte:

✍ Resumo#

  • open(): serve para abrir um arquivo.

    • Modo r (read): abre o arquivo para leitura. Se o arquivo não existir, ocorrerá um erro.

    • Modo a (append): abre o arquivo para escrita, adicionando conteúdo ao final do arquivo caso ele já exista. Se o arquivo não existir, ele será criado.

    • Modo w (write): abre o arquivo para escrita, apagando todo o conteúdo anterior caso ele já exista. Se o arquivo não existir, ele será criado.

    • Também existem outros modos:

      • Modo x (exclusive): cria um arquivo para escrita, mas retorna um erro se ele já existe.

      • Modo b (binary): cria um arquivo para escrita de dados binários como imagens, vídeos, músicas e demais conteúdos que não são texto puro.

  • close(): serve para fechar um arquivo. Não precisa usar o close() se estiver abrindo um arquivo com o with.

  • with: o uso dele é bem parecido com um if ou for. Ele garante que o arquivo será aberto no início do bloco contendo esta palavra-chave e fechado automaticamente no final do bloco, mesmo que ocorra um erro (exceção).

Escrevendo diferentes tipos de arquivo#

Todos os exemplos acima somente trabalharam com arquivos de texto. Um arquivo de texto (geralmente identificados pela extensão .txt, como o receita.txt que você testou acima) é um arquivo que contém somente caracteres de texto simples. Isto é: só texto puro, e nada de cores, negrito, itálico, ou fontes diferentes. Ele é usado para armazenar informações de texto em formato legível por humanos e é geralmente usado para processamento de texto, editores de código, manuais simples, entre outros. Isto posto, existem jeitos diferentes de armazenarmos os dados. Para isso, vamos usar um código como exemplo:

valor_pi = 3.14159
lista_frutas = ["maçã", "banana", "laranja", "manga"]
dicionario_pessoas = {"João": 25, "Maria": 30, "Pedro": 20, "Marcos": 15}

São três variáveis, e cada um possui um tipo diferente, certo? Uma delas é uma variável do tipo float, outra é uma lista e, a outra, um dicionário. Agora, como guardaríamos estas informações em arquivos? Vamos testar de quatro jeitos diferentes: com arquivos de texto (que acabei de explicar o que são), CSVs, JSON e, finalmente, Pickle. Também vamos falar para que servem cada um desses tipos, beleza? Ah, para cada um desses jeitos, salvaremos essas três variáveis em arquivos separados e, depois, abriremos elas para ver como ficaram.

Salvando em texto#

Vamos começar escrevendo aquela variável valor_pi em um arquivo de texto, o que acha? Usando as mesmas funções que vimos até agora, teríamos:

# salvar valor_pi em um arquivo txt
with open("valor_pi.txt", "w") as f:
    f.write(str(valor_pi))

# ler valor_pi de um arquivo txt   
with open("valor_pi.txt", "r") as f:
    valor_pi_lido = f.read()
    print(f'{valor_pi_lido}, tipo {type(valor_pi_lido)}')

Percebe a linha f.write(str(valor_pi))? Para salvarmos texto precisaremos, obrigatoriamente, converter as variáveis para texto. É por isso que o valor da variável é convertido em uma string usando a função str() antes de o gravarmos no arquivo.

Quanto à leitura, veja que na penúltima linha estamos lendo o conteúdo do arquivo valor_pi.txt usando o modo de leitura "r" do método open(). O conteúdo do arquivo é armazenado na variável valor_pi_lido como uma string. Para comprovar isso, veja que na última linha eu mostro na tela o valor de valor_pi_lido e o tipo de dado da variável usando a função print(). No caso, aquele type(valor_pi_lido) mostra na tela o tipo daquela variável que, no caso, é uma string.

O resultado, portanto, seria:

3.14159, tipo <class 'str'>

Quer converter aquele valor lido do arquivo de volta para um número? Então você precisaria fazer um float(valor_pi_lido) para isso. Agora, e se quiséssemos salvar a lista em arquivo? Veja só (e teste, se possível):

# salvar lista_frutas em um arquivo txt
with open("lista_frutas.txt", "w") as f:
    f.write(str(lista_frutas))

# ler lista_frutas de um arquivo txt
with open("lista_frutas.txt", "r") as f:
    lista_frutas_lida = f.read()
    print(f'{lista_frutas_lida}, tipo {type(lista_frutas_lida)}')

A mesma coisa: convertemos primeiro a lista para string para poder salvar (por isso o str() em f.write(str(lista_frutas))). E, para ler, também teremos o resultado em string, igualzinho como no exemplo anterior. Aqui, a saída será:

['maçã', 'banana', 'laranja', 'manga'], tipo <class 'str'>

Também existe outra forma de salvar os dados dessa lista em arquivo. Poderíamos, por exemplo, salvar cada fruta em uma linha separada. Assim, teríamos o seguinte:

# salvar lista_frutas em um arquivo txt
with open("lista_frutas_split.txt", "w") as f:
    for fruta in lista_frutas:
        f.write(fruta + "\n")

# ler lista_frutas de um arquivo txt
with open("lista_frutas_split.txt", "r") as f:
    lista_frutas_lida = f.readlines()
    print(f'{lista_frutas_lida}, tipo {type(lista_frutas_lida)}')

O primeiro for irá percorrer cada elemento da lista_frutas e escreverá cada elemento em uma linha separada no arquivo de texto. Já a linha f.write(fruta + "\n") adiciona uma quebra de linha depois de cada fruta, para que cada uma fique em uma linha separada no arquivo.

Outra mudança: viu a função readlines()? Ela lerá o arquivo linha por linha e retornará uma lista contendo cada linha como um elemento separado. Interessante, não é? Agora, e para salvarmos o dicionário? Poderíamos fazer o seguinte:

# salvar dicionario_pessoas em um arquivo txt
with open("dicionario_pessoas.txt", "w") as f:
    f.write(str(dicionario_pessoas))

# ler dicionario_pessoas de um arquivo txt
with open("dicionario_pessoas.txt", "r") as f:
    dicionario_pessoas_lido = f.read()
    print(f'{dicionario_pessoas_lido}, tipo {type(dicionario_pessoas_lido)}')

Aqui, a mesma coisa dos outros exemplos anteriores também acontece: convertemos o dicionário para texto, e lemos de volta um texto. É por isso que para guardarmos estruturas de dados um pouco mais complexas como um dicionário ou uma lista não seria muito interessante trabalhar com esse read() ou readlines() do jeito que são. Afinal, teríamos uma certa dor de cabeça para convertermos o resultado do arquivo lido (que é sempre em string) de volta para uma lista, um dicionário ou qualquer outra estrutura.

Salvando em JSON#

O JSON é outra maneira bem comum para salvarmos arquivos. Ele é usado para transmitir informações entre diferentes aplicações, permitindo que dados sejam facilmente compartilhados e manipulados. Geralmente sites, aplicativos e outros serviços que se comunicam com um usuário também trocam informações com servidores e bancos de dados usando JSON.

Um arquivo JSON é composto por pares chave-valor, onde a chave é uma string que identifica o valor correspondente, que pode ser um número, string, objeto ou lista. Os objetos e listas podem ser aninhados, o que permite a criação de estruturas complexas de dados. Aqui, uma analogia para entender um arquivo JSON seria pensar em um mapa de cidade. Cada chave seria como uma rua, e seu valor correspondente seria como as casas ou prédios nessa rua. Assim como um mapa, um arquivo JSON fornece um meio organizado de acessar informações e entender a estrutura de um conjunto de dados.

Sabe o dicionário em Python que você está acostumado (eu espero) a trabalhar? Então, está praticamente (senão totalmente) em formato JSON, já. Bom, vamos para os exemplos? Experimente rodar o código abaixo em Python:

import json

# INÍCIO DO BLOCO 1
# salvar valor_pi em um arquivo json
with open("valor_pi.json", "w") as f:
    json.dump(valor_pi, f)

# ler valor_pi de um arquivo json
with open("valor_pi.json", "r") as f:
    valor_pi_lido = json.load(f)
    print(f'{valor_pi_lido}, tipo {type(valor_pi_lido)}')
# FIM DO BLOCO 1

# INÍCIO DO BLOCO 2
# salvar lista_frutas em um arquivo json
with open("lista_frutas.json", "w") as f:
    json.dump(lista_frutas, f)

# ler lista_frutas de um arquivo json
with open("lista_frutas.json", "r") as f:
    lista_frutas_lido = json.load(f)
    print(f'{lista_frutas_lido}, tipo {type(lista_frutas_lido)}')
# FIM DO BLOCO 2

# INÍCIO DO BLOCO 3
# salvar dicionario_pessoas em um arquivo json
with open("dicionario_pessoas.json", "w") as f:
    json.dump(dicionario_pessoas, f)

# ler dicionario_pessoas de um arquivo json
with open("dicionario_pessoas.json", "r") as f:
    dicionario_pessoas_lido = json.load(f)
    print(f'{dicionario_pessoas_lido}, tipo {type(dicionario_pessoas_lido)}')
    for nome, idade in dicionario_pessoas_lido.items():
        print(nome, idade)
# FIM DO BLOCO 3

Muito código? Calma, vou explicar. Tá vendo aquele import json na primeira linha? Este código é uma importação do módulo json em Python. O módulo json é utilizado para codificar e decodificar dados em formato JSON. Imagine estes módulos como se fossem itens adicionais de uma comida de um fast-food ou os itens opcionais de um carro: eles não vem “de fábrica”, e você precisa “pedir” por este item. Existem vários módulos já integrados ao Python que fornecem funções úteis para lidar com tarefas comuns, como manipulação de arquivos, processamento de dados, matemática, networking, entre outras. Como nem sempre precisamos desses módulos em todo código, só os importamos quando realmente é necessário. Como somente agora estamos precisando trabalhar com o JSON, nós chamamos agora por esta importação.

Percebe que temos ao longo do código o json.dump() e json.load() no lugar do f.write() e f.read()? Então: estas funções são específicas para salvarmos os dados em formato JSON e lermos de volta os dados que estão em JSON, respectivamente. A função json.dump() sempre recebe dois parâmetros: primeiro, o objeto a ser salvo. Depois, o arquivo onde ele deve ser salvo.

Em seguida, o código lê cada um dos arquivos utilizando a função json.load(), que recebe como parâmetro o arquivo de onde os dados devem ser lidos. O bloco 1 salva e lê o valor da variável valor_pi em um arquivo JSON (experimente abrir o arquivo valor_pi.json no bloco de notas depois de rodar este código). O bloco 2 salva e lê a lista de frutas lista_frutas. Por fim, o bloco 3 salva e lê o dicionário dicionario_pessoas, que é impresso na tela utilizando um for.

O resultado desse código será isto:

3.14159, tipo <class 'float'>
['maçã', 'banana', 'laranja', 'manga'], tipo <class 'list'>
{'João': 25, 'Maria': 30, 'Pedro': 20, 'Marcos': 15}, tipo <class 'dict'>
João 25
Maria 30
Pedro 20
Marcos 15

Percebeu que os tipos estão corretos? Temos float, list e dict. Legal, né? Isto acontece porque a função json.load() já converte automaticamente os dados lidos para o formato Python correspondente.

Salvando em Pickle#

Beleza, mas e se quiséssemos salvar as variáveis do Python direto em um arquivo? Isto é: sem ser salvo em texto ou algo assim? E se quiséssemos salvar um dicionário como tal, ou uma lista do jeito que está, sem termos que nos preocupar em converter nada? É para resolver isso que temos em Python os arquivos pickle. Imagine que este pickle é como se fosse um pote de vidro onde podemos guardar alimentos na geladeira. Quando colocamos alimentos no pote, eles são armazenados em um formato que pode ser facilmente recuperado posteriormente, quando quisermos consumi-los. Assim como podemos armazenar diferentes tipos de alimentos em potes de vidro, podemos armazenar diferentes tipos de objetos Python em arquivos pickle.

Arquivos pickle em Python são arquivos binários usados para serializar e desserializar objetos Python. Isso significa que podemos usar o formato pickle para converter objetos Python em uma sequência de bytes, que pode ser gravada em um arquivo, transmitida pela rede ou armazenada em um banco de dados, por exemplo. Posteriormente, podemos recuperar o objeto Python original a partir dos bytes usando a desserialização.

Mas, e aí? Vamos testar?

import pickle

# INÍCIO DO BLOCO 1
# salvar valor_pi em um arquivo pickle
with open("valor_pi.pickle", "wb") as f:
    pickle.dump(valor_pi, f)

# ler valor_pi de um arquivo pickle   
with open("valor_pi.pickle", "rb") as f:
    valor_pi_lido = pickle.load(f)
    print(f'{valor_pi_lido}, tipo {type(valor_pi_lido)}')
# FIM DO BLOCO 1

# INÍCIO DO BLOCO 2
# salvar lista_frutas em um arquivo pickle
with open("lista_frutas.pickle", "wb") as f:
    pickle.dump(lista_frutas, f)

# ler lista_frutas de um arquivo pickle
with open("lista_frutas.pickle", "rb") as f:
    lista_frutas_lida = pickle.load(f)
    print(f'{lista_frutas_lida}, tipo {type(lista_frutas_lida)}')
# FIM DO BLOCO 2

# INÍCIO DO BLOCO 3
# salvar dicionario_pessoas em um arquivo pickle
with open("dicionario_pessoas.pickle", "wb") as f:
    pickle.dump(dicionario_pessoas, f)

# ler dicionario_pessoas de um arquivo pickle
with open("dicionario_pessoas.pickle", "rb") as f:
    dicionario_pessoas_lido = pickle.load(f)
    print(f'{dicionario_pessoas_lido}, tipo {type(dicionario_pessoas_lido)}')
    for nome, idade in dicionario_pessoas_lido.items():
        print(nome, idade)
# FIM DO BLOCO 3

O código acima terá o mesmo resultado do que fizemos com o exemplo do JSON, mas a diferença é que agora estamos trabalhando com pickle. Agora, importamos o módulo pickle na primeira linha porque, afinal de contas, estaremos trabalhando com arquivos pickle. O que temos também de diferenças são:

  • A abertura e escrita de arquivos com o open() deixou de usar os modos "w" e "r" para usar "wb" e "rb". A letra b indica que estamos trabalhando com arquivos binários (ou seja: não é mais um arquivo de texto. Se você tentar abrir este arquivo pickle com o bloco de notas verá que não conseguirá entender nada).

  • Para salvar um arquivo pickle passamos a usar o pickle.dump().

  • Para ler o conteúdo de um arquivo pickle passamos a usar o pickle.load().

Agora, quando preferimos usar JSON e quando pickle é melhor? A resposta é: depende. Se estivermos trabalhando com diferentes softwares, plataformas e linguagens de programação a resposta é clara: JSON. Se precisar abrir no bloco de notas/Visual Studio Code/similares, também seria o JSON. Agora, se a ideia é salvar uma variável dentro do seu computador para você continuar trabalhando depois em Python, aí seria pickle. Dito isso, não recomendo muito que você use pickle para transferir variáveis de lugares desconhecidos para você ou vice-versa: você pode estar carregando uma variável contendo algo que pode causar danos para o seu código ou para outros computadores sem querer.

Exercícios#

Vamos colocar em prática os conhecimentos de manipulação de arquivos? Iremos também combinar com o conhecimento de listas e dicionários do último capítulo. Vamos lá?

  1. Crie um dicionário com o nome e a profissão de duas pessoas e adicione uma terceira pessoa com nome e profissão. Salve o resultado em um arquivo JSON.

  2. Crie um código que peça para o usuário digitar uma frase. Salve o resultado em uma arquivo de texto. Depois, abra este arquivo de texto que salvou e mostre o resultado na tela.

  3. A partir do exercício 2 e após mostrar o resultado na tela, peça novamente para que o usuário digite uma nova frase. Adicione esta nova frase no mesmo arquivo de texto sem apagar o conteúdo que já estava lá, e mostre o resultado na tela.

  4. Crie uma lista com números de 1 a 10 e, em seguida, crie uma segunda lista contendo somente os números pares. Salve somente a lista dos números pares em um arquivo pickle. Depois, abra novamente o arquivo pickle que salvou e mostre na tela o seu conteúdo.

  5. Modifique o código do exercício 4 para que salve, dentro de um único arquivo, as duas listas. Depois, abra novamente o arquivo pickle que salvou e mostre na tela o seu conteúdo.

Respostas#

1. Crie um dicionário com o nome e a profissão de duas pessoas e adicione uma terceira pessoa com nome e profissão. Salve o resultado em um arquivo JSON.

Você deve ter percebido que é praticamente o mesmo exercício do capítulo anterior, mas com um passo final para salvar o resultado em JSON, não é? Veja só como ficaria um exemplo de resposta:

import json

pessoas = {}

# adiciona as duas primeiras pessoas
for i in range(2):
    nome = input("Digite o nome da pessoa: ")
    profissao = input("Digite a profissão da pessoa: ")
    pessoas[nome] = profissao

# adiciona a terceira pessoa
nome = input("Digite o nome da terceira pessoa: ")
profissao = input("Digite a profissão da terceira pessoa: ")
pessoas[nome] = profissao

# salva o resultado em um arquivo JSON
with open("pessoas.json", "w") as arquivo:
    json.dump(pessoas, arquivo)

O que temos de diferente neste código? Veja que, primeiramente, importamos a biblioteca json na primeira linha do Python para salvar o dicionário pessoas em um arquivo JSON. A função json.dump() é usada para escrever o dicionário no arquivo JSON. E, ainda, a opção "w" é passada para o open() para indicar que queremos escrever no arquivo.

Experimente testar o código e abrir o arquivo pessoas.json logo em seguida para ver o que houve. No meu caso, o meu arquivo ficou assim:

{"João": "Engenheiro", "Maria": "Advogada", "Pedro": "Médico"}

2. Crie um código que peça para o usuário digitar uma frase. Salve o resultado em uma arquivo de texto. Depois, abra este arquivo de texto que salvou e mostre o resultado na tela.

# pede para o usuário digitar uma frase
frase = input("Digite uma frase: ")

# salva a frase em um arquivo de texto
with open("frase.txt", "w") as arquivo:
    arquivo.write(frase)

# abre o arquivo de texto e exibe o conteúdo na tela
with open("frase.txt", "r") as arquivo:
    conteudo = arquivo.read()
    print("Conteúdo do arquivo:")
    print(conteudo)

Veja que a função input() para solicitar que o usuário digite uma frase. Em seguida, a salvamos em um arquivo de texto chamado frase.txt usando a abertura do arquivo em modo de escrita ("w") e a função write().

Depois, abrimos o arquivo em modo de leitura ("r") e o conteúdo é lido usando o método read() e salvo na variável conteudo, que é mostrada na tela com o print(conteudo).

3. A partir do exercício 2 e após mostrar o resultado na tela, peça novamente para que o usuário digite uma nova frase. Adicione esta nova frase no mesmo arquivo de texto sem apagar o conteúdo que já estava lá, e mostre o resultado na tela.

# pede para o usuário digitar uma frase
frase = input("Digite uma frase: ")

# salva a frase em um arquivo de texto
with open("frase.txt", "w") as arquivo:
    arquivo.write(frase)

# abre o arquivo de texto e exibe o conteúdo na tela
with open("frase.txt", "r") as arquivo:
    conteudo = arquivo.read()
    print("Conteúdo do arquivo:")
    print(conteudo)

# Pede ao usuário para digitar uma outra frase
frase = input("Digite uma frase: ")

# Abre o arquivo em modo "a" para adicionar a nova frase
with open("frases.txt", "a") as arquivo:
    # Adiciona a nova frase ao arquivo
    arquivo.write(frase + "\n")

# Abre o arquivo novamente em modo "r" (leitura)
with open("frases.txt", "r") as arquivo:
    # Lê o conteúdo do arquivo e mostra na tela
    conteudo = arquivo.read()
    print(conteudo)

Perceba principalmente o que vem depois do comentário “Pede ao usuário para digitar uma outra frase”. Para adicionar a nova frase ao arquivo de texto sem apagar o conteúdo já existente, usamos o modo "a" (append) na abertura do arquivo. Se usássemos o "w" de volta iríamos sobrescrever o que já havia sido salvo anteriormente.

4. Crie uma lista com números de 1 a 10 e, em seguida, crie uma segunda lista contendo somente os números pares. Salve somente a lista dos números pares em um arquivo pickle. Depois, abra novamente o arquivo pickle que salvou e mostre na tela o seu conteúdo.

import pickle

# cria a lista de números de 1 a 10
numeros = list(range(1, 11))

# filtra os números pares
numeros_pares = []
for num in numeros:
    if num % 2 == 0:
        numeros_pares.append(num)

# salva a lista de números pares em um arquivo pickle
with open("numeros_pares.pickle", "wb") as f:
    pickle.dump(numeros_pares, f)

# abre o arquivo pickle e mostra o conteúdo na tela
with open("numeros_pares.pickle", "rb") as f:
    numeros_pares_lidos = pickle.load(f)
    print(numeros_pares_lidos)

Veja que salvamos a lista numeros_pares em um arquivo pickle chamado numeros_pares.pickle. Como é um arquivo binário (isto é: não é legível por humanos ao abrir no bloco de notas), salvamos este arquivo usando "wb" e lemos usando "rb" (perceba a letra b presente em ambos os casos). Por fim, o código abre novamente o arquivo pickle com o uso do pickle.load() e mostra o conteúdo na tela. O resultado esperado é a exibição na tela da lista [2, 4, 6, 8, 10].

5. Modifique o código do exercício 4 para que salve, dentro de um único arquivo, as duas listas. Depois, abra novamente o arquivo pickle que salvou e mostre na tela o seu conteúdo.

import pickle

# cria a lista de números de 1 a 10
numeros = list(range(1, 11))

# filtra os números pares
numeros_pares = []
for num in numeros:
    if num % 2 == 0:
        numeros_pares.append(num)

# salva a lista de números pares em um arquivo pickle
with open("numeros_pares.pickle", "wb") as f:
    pickle.dump([numeros, numeros_pares], f)

# abre o arquivo pickle e mostra o conteúdo na tela
with open("numeros_pares.pickle", "rb") as f:
    numeros_lidos, numeros_pares_lidos = pickle.load(f)
    print(numeros_lidos)
    print(numeros_pares_lidos)

É muito provável que você tenha dificuldades para fazer este aqui. Afinal, em nenhum momento lhe disse como salvaríamos mais de uma variável em um arquivo pickle. Sem problemas - a ideia aqui é a de demonstrar, mesmo. Perceba duas grandes modificações em relação ao código anterior:

  • O pickle.dump([numeros, numeros_pares], f): veja o [numeros, numeros_pares]. Para salvar mais de uma variável em um mesmo arquivo pickle basta informar todas as variáveis em uma lista.

  • Para ler estas variáveis, basta informar a mesma quantidade na hora de chamar o pickle.load(). Como salvamos duas variáveis, teremos que armazenar o resultado do pickle.load() em duas variáveisl. É por isso que temos o numeros_lidos, numeros_pares_lidos na antepenúltima linha.

Referências bibliográficas#