Resumo - DESENVOLVIMENTO RÁPIDO DE APLICAÇÕES EM PYTHON - Estácio

Prévia do material em texto

DESENVOLVIMENTO RÁPIDO DE APLICAÇÕES EM PYTHON
Como manipular de dados em Python. 
· MANIPULAÇÃO DE ARQUIVOS-TEXTO
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.
1 def main():
2     print("Digite suas frases. Digite 'sair' para terminar e salvar o arquivo.")
3     frases = []
4     while True:
5         entrada = input("> ")
6         if entrada.lower() == "sair":
7             break
8         frases.append(entrada)
9     
10     with open("meu_arquivo.txt", "w", encoding="utf-8") as arquivo:
11         for frase in frases:
12             arquivo.write(frase + "\n")
13     
14     print("Arquivo original criado. Agora vamos manipular os dados.")
15     dados_modificados = []
16     with open("meu_arquivo.txt", "r",  encoding="utf-8") as arquivo:
17         for linha in arquivo:
18             dados_modificados.append(linha.strip().upper())  # Ex: UPPER: converte para maiúsculas
19     # Ex: STRIP: remove espaços em branco
20     with open("meu_arquivo.txt", "w",  encoding="utf-8") as arquivo:
21         for linha in dados_modificados:
22             arquivo.write(linha + "\n")
23     
24     print("O arquivo foi sobrescrito com os dados modificados.")
25  
26 if __name__ == "__main__":
27     main()
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.
· MANIPULAÇÃO DE DADOS BINÁRIOS
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:
1. Carregar uma imagem simples do sistema de arquivos.
2. Converter a imagem em uma representação binária usando a biblioteca PIL (Python Imaging Library).
3. Exibir os dados binários da imagem.
4. Salvar esses dados em um arquivo binário.
5. Fazer uma cópia desse arquivo binário.
6. Manipular os dados do arquivo binário cópia (por exemplo, inverter os bytes, adicionar ruído etc.).
7. 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: 
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.
1 # Utiliza a biblioteca Python PIL (Pillow) para abrir a imagem “simple_icon.png”.
2 from PIL import Image
3 import numpy as np
4 
5 def main():
6 # Carregar a imagem original
7 img = Image.open("simple_icon.png") # a função “Image.open” carrega a imagem no disco
8 img.show() # exibe a imagem antes da manipulação
9 
10 # Converter a imagem em dados binários
11 img_data = np.array(img) # “np.array(img)” converte em array (contém os valores dos pixels)
12 binary_data = img_data.tobytes() # “img_data.tobytes()” converte os dados do array NumPy 
13 em uma sequência binária. Esse é o formato que permite salvar a imagem em um arquivo binário.
14 
15 # Salvar os dados binários em um arquivo
16 with open("original_img.bin", "wb") as file: # arquivo é criado e aberto para escrita binária.
17 file.write(binary_data) # Os dados binários são escritos no arquivo file.write(binary_data).
18 
19 # Copiar o arquivo binário
20 with open("original_img.bin", "rb") as original_file: # arquivo para leitura.
21 data = original_file.read() # Os dados binários são lidos do arquivo original usando 
22 original_file.read() e armazenados na variável data.
23 
24 with open("copy_img.bin", "wb") as copy_file: 
25 copy_file.write(data) # Um novo arquivo chamado "copy_img.bin" é aberto e os dados 
26 lidos são escritos nele, criando uma cópia do arquivo original.
27 
28 # Manipulação dos dados do arquivo binário cópia
29 # Exemplo: Inverter os bytes
30 with open("copy_img.bin", "rb") as file: # O arquivo é aberto para leitura dos dados binários.
31 data = bytearray(file.read()) # Os dados são convertidos para bytearray, permitindo a modificação 
32 dos bytes.
33 # Inverte todos os bytes
34 data = data[::-1] # Os bytes são invertidos (data[::-1]), que é uma forma simplesde manipulação de 
35 imagem por meio de manipulação de dados binários.
36 with open("copy_img.bin", "wb") as file: 
37 file.write(data) # O arquivo aberto novamente e os bytes modificados são escritos de volta ao arquivo.
38 
39 # Carregar e mostrar a imagem manipulada
40 modified_data = np.frombuffer(data, dtype=np.uint8).reshape(img_data.shape)
41 modified_img = Image.fromarray(modified_data)
42 modified_img.show()
43 # Os dados binários modificados são carregados de volta em um array com o mesmo formato e tipo de dados da 
44 imagem original usando np.frombuffer(data, dtype=np.uint8).reshape(img_data.shape).
45 # A imagem é reconstruída do array modificado usando Image.fromarray(modified_data).
46 # modified_img.show() exibe a imagem resultante, que agora reflete as modificações feitas nos dados binários.
47 if __name__ == "__main__":
48 main()
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.
· MANIPULAÇÃO DE STRINGS
· Codificando mensagens: ZENIT POLAR
1 def zenit_polar_replace(text):
2     # Aplicar a codificação ZENIT POLAR utilizando o método replace
3     replacements = [('z', 'p'), ('e', 'o'), ('n', 'l'), ('i', 'a'), ('t', 'r'),
4                     ('Z', 'P'), ('E', 'O'), ('N', 'L'), ('I', 'A'), ('T', 'R')]
5     for old, new in replacements:
6         text = text.replace(old, new)
7     return text
8  
9 def main():
10     # Entrada da frase e aplicação da codificação
11     phrase = "The quick brown fox jumps over the lazy dog"
12     phrase_title = phrase.title()  # Primeira letra de cada palavra em maiúscula
13     
14     # Dividir a frase em palavras
15     words = phrase.split()
16  
17     # Processar cada palavra na lista usando ZENIT POLAR
18     coded_words = [zenit_polar_replace(word) for word in words]
19  
20     # Juntar todas as palavras codificadas em uma frase
21     coded_phrase = " ".join(coded_words)
22     print("Original:", phrase)
23     print("Frase com cada palavra iniciando em maiusculo: ", phrase_title)
24     print("Coded:", coded_phrase)
25  
26 if __name__ == "__main__":
27     main()
28 
29 # Imprime:
30 # Original: The quick brown fox jumps over the lazy dog
31 
32 # Frase com cada palavra iniciando em maiusculo:  The Quick Brown Fox Jumps Over The Lazy Dog
33 
34 # Coded: Rho quack browl fox jumps ovor rho lapy dog
35 
TRATAMENTO DE EXCEÇÕES 
· Uma exceção ocorre quando uma falha inesperada acontece e o interpretado não consegue resolver o problema, indicando que houve um erro.
· Nesse caso é necessário informar ao interpretador como tratar exceções, para que o programa não seja interrompido.
· O tratamento de exceções é fundamental para lidar com erros em situações inesperadas em programas. 
· Tratar exceções evita a interrupções indesejadas no fluxo do código.
· Implementar estratégias de tratamento de erros eficazes e torna seu código mais robusto e confiável.
· O QUE QUER DIZER “TRATAR EXCEÇÕES”? É dizer ao Python o que fazer, ou quais instruções executar quando ele encontrar um problema
· O QUE ACONTECE QUANDO UMA EXCEÇÃO LANÇADA NÃO É TRATADA? Como não houve tratamento de exceções o Python não sabe como qual caminho tomar ao encontrar esse problema. Dessa forma, o programa interrompe sua execução assim que o problema é encontrado.
· COMO TRATAR EXCEÇÕES: Para tratar exceções precisamos envolver o trecho do código passível de erro com a cláusula try/except ou try/except/finally.
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.
Exceções tratadas por Python:
1. PermissionError (Erro de permissão)
2. FileExistsError (Erro de arquivo existente – arquivo não existe)
3. FileNotFoundError (Erro de arquivo não encontrado)
· PermissionError (Erro de permissão)
· Ocorre quando um programa tenta realizar uma operação em um arquivo ou diretório para o qual não possui permissões;
· O código Python não tem permissão para acessar, ler, escrever ou executar.
· Como evitar: Deve-se ajustar as permissões do arquivo ou diretório para que o código Python possa acessá-lo corretamente.
· FileExistsError (Erro de arquivo existente)
· Ocorre ao tentar criar um arquivo ou diretório com um nome que já existe no sistema de arquivos.
· Como evitar: Deve-se escolher um nome único para o arquivo ou verificar se o arquivo/diretório já existe antes de criar um novo.
· FileExistsError (Erro de arquivo não encontrado - Arquivo não existe)
· Pode ocorrer quando o arquivo ou diretório é solicitado, mas não existe.
· Como evitar: Para tratar essa exceção, poderia ser exibida um pop-up ao usuário informando que o arquivo não existe.
Atividade: 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.
1 try:
2 with open('dados.txt', 'r') as arquivo:
3 conteudo = arquivo.read()
4 except FileNotFoundError:
5 print("Arquivo não encontrado.")
6 except PermissionError:
7 print("Permissão negada.")
8 except Exception as e:
9 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.
Atividade: 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.
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}"
Atividade: 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.
1 import os
2 os.mkdir(“meu_diretório”)
3 try:
4 os.remove('arquivo.txt')
5 except FileNotFoundError:
6 print("Arquivo não encontrado.")
7 except PermissionError:
8 print("Permissão negada.")
9 except IsADirectoryError:
10 print("Não é possível remover, é um diretório.")
11 except Exception as e:
12 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}"
Importância das operações com diretórios 
· Manter a estrutura de arquivos organizada
· Facilitar a navegação e o acesso a arquivos específicos
· Automatizar tarefas de manipulação de arquivos
· Simplificar processos repetitivos
· Criação de diretórios:
· Funcão “mkdir” do módulo “os”:
import os
os.mkdir(“meu_diretorio”)
· Exceções comuns:
· PermissionError - Sem permissão para criar o diretório
· FileExistsError – Diretório já existe
· Remoção de diretórios:
· Funcão “rmdir” do módulo “os”:
import os
os.rmdir(“meu_diretorio”)
· Exceções comuns:
· PermissionError - Sem permissão para remover o diretório
· FileNotFoundError - Diretório não existe
· OsError - Diretório não está vazio (só é possível excluir um diretório que esta vazio)
· Listagem de diretórios:
· Funcão “scandir” do módulo “os”:
import os
with os.scandir(“meu_diretorio”) as entries:
 for entry in entries:
 print(entry.name)· Métodos de “os.DirEntry”:
· is_dir() – Verifica se é um diretório
· is_file() – Verifica se é um arquivo
· stat() – Retorna atributos do arquivo/diretório
· Módulo “os” do Python
O módulo “os” fornece funções para interagir com o sistema operacional.
os.mkdir(path) – Cria um novo diretório
os.rmdir(path) – Remove um diretório vazio
os.listdir(path) – Lista os arquivos e diretórios no caminho especificado
os.path.join(path, *paths) – Junta componentes de caminhos de forma inteligente.
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
1. Crie um diretório de trabalho e coloque alguns arquivos de texto de exemplo (.txt) nesse diretório.
Passo 2: Estrutura do código
1. Importe o módulo necessário
import os
Passo 3: Função para ler e escrever arquivos
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:
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 inesperado ao 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
1. No script principal, defina os arquivos de origem e destino e chame a função criada:
   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
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: Considere o seguinte código em Python utilizado para abrir um arquivo para leitura utilizando o módulo "os".
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 é .
Situação-problema
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:
1. Verifique se os diretórios de destino (pdf, txt, img) existem; caso contrário, crie-os.
2. Mova os arquivos do diretório de trabalho para os diretórios correspondentes com base em suas extensões.
3. Trate possíveis exceções durante as operações, exibindo mensagens informativas ao usuário.
Resolução
Passo 1: Preparação
1. 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
1. Importe os módulos necessários:
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. Crie uma função para verificar se os diretórios existem e, se não, criá-los:
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
1. Crie uma função para mover os arquivos para os diretórios correspondentes com base em suas extensões:
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
1. No script principal, defina o diretório de trabalho e chame as funções criadas:
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 
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.
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.
TEMA 5: INTERFACE GRÁFICA COM PYTHON
Vamos apresentar exemplos dos componentes:
1. Window
2. Label
3. Button
4. Entry
5. Radiobutton
6. Checkbox
7. Text
8. Message
9. Sliders
10. Dialog
11. Combobox
1. Widget Window (tk.Tk())
O código dessa aplicação é:
import tkinter as tk
janela = tk.Tk()
janela.title(" Aplicação GUI")
janela.mainloop()
Para fixar o tamanho da janela, é necessário determinar essa propriedade conforme o código seguinte:
import tkinter as tk
janela = tk.Tk()
janela.title(" Aplicação GUI NÃO Dimensionável") 
janela.resizable(False, False)
janela.mainloop()
2. Widget Label
O código para gerar uma aplicação com o “Label” é dado por:
import tkinter as tk
from tkinter import ttk
janela = tk.Tk()
janela.title(" Aplicação GUI com o Widget Label") 
ttk.Label(janela, text="Componente Label" ).grid(column=0, row=0)
janela.mainloop()
3. Widget Button
O código para gerar uma aplicação com o componente “Button” é dado por:
import tkinter as tk
contador = 0
def contador_label(lblRotulo):
   def funcao_contar():
      global contador
      contador = contador + 1
      lblRotulo.config(text=str(contador))
      lblRotulo.after(1000, funcao_contar)
      funcao_contar()
janela = tk.Tk()
janela.title("Contagem dos Segundos")
lblRotulo = tk.Label(janela, fg="green")
lblRotulo.pack()
contador_label(lblRotulo)
btnAcao = tk.Button(janela, text='Clique aqui para Interromper a contagem', width=50, command=janela.destroy)
btnAcao.pack()
janela.mainloop()
4. Widget Entry
O componente “entry é uma das principais formas de o usuário entrar com dados no sistema.
O código para gerar uma aplicação com o componente “entry” é dado por:
import tkinter as tk
def mostrar_nomes():
   print("Nome: %s\nSobrenome: %s" % (e1.get(), e2.get()))
janela = tk.Tk()
janela.title("Aplicação GUI com o Widget Entry")
tk.Label(janela,text="Nome").grid(row=0)
tk.Label(janela,text="Sobrenome").grid(row=1)
e1 = tk.Entry(janela)
e2 = tk.Entry(janela)
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
tk.Button(janela, text='Sair',command=janela.quit).grid(row=3,column=0,sticky=tk.W,pady=4)
tk.Button(janela, text='Exibir Dados', command=mostrar_nomes).grid(row=3,column=1,sticky=tk.W,pady=4)
tk.mainloop()
5. Widget Radiobutton
O código para gerar uma aplicação com o componente “Radiobutton” é dado por:
import tkinter as tk
janela = tk.Tk()
v = tk.IntVar()
tk.Label(janela,text="""Escolha uma linguagem de programação:""",justify = tk.LEFT, padx = 20).pack()
tk.Radiobutton(janela,text="python",padx = 25,variable=v,value=1).pack(anchor=tk.W)
tk.Radiobutton(janela,text="C++",padx = 25,variable=v,value=2).pack(anchor=tk.W)
janela.mainloop()
6. Widget Checkbox
O código para gerar uma aplicação com o componente “checkbox” é dado por:
import tkinter as tk
from tkinter import ttk
janela = tk.Tk()
def escolha_carreira():
   print("Gerencial: %d,\nTécnica : %d" % (var1.get(), var2.get()))
ttk.Label(janela, text="Escolha sua vocação:").grid(row=0, sticky=tk.W)
var1 = tk.IntVar()
ttk.Checkbutton(janela, text="Gerencial", variable=var1).grid(row=1, sticky=tk.W)
var2 = tk.IntVar()
ttk.Checkbutton(janela, text="Técnica", variable=var2).grid(row=2, sticky=tk.W)
ttk.Button(janela, text='Sair', command=janela.quit).grid(row=3, sticky=tk.W, pady=4)
ttk.Button(janela, text='Mostrar', command=escolha_carreira).grid(row=4, sticky=tk.W, pady=4)
janela.mainloop()
7. Text
O código para gerar uma aplicação com o componente “text” é dado por:
import tkinter as tk
janela = tk.Tk()
T = tk.Text(janela, height=2, width=30)
T.pack()
T.insert(tk.END, "Este é um texto\ncom duas linhas\n")
tk.mainloop()
8. Message
O código para gerar uma aplicação com o componente “message” é dado por:
import tkinter as tk
janela = tk.Tk()
mensagem_para_usuario = "Esta é uma mensagem.\n(Pode ser bastante útil para o usuário)"
msg = tk.Message(janela, text = mensagem_para_usuario)
msg.config(bg='lightgreen', font=('times', 24, 'italic'))
msg.pack()
janela.mainloop()
9. Sliders
O código para gerar uma aplicação com o componente “sliders” é dado por:
import tkinter as tk
from tkinter import ttk
def mostrar_valores():
   print (w1.get(), w2.get())
janela = tk.Tk()
w1 = ttk.Scale(janela, from_=0, to=50)
w1.pack()
w2 = ttk.Scale(janela, from_=0, to=100, orient=tk.HORIZONTAL)
w2.pack()
ttk.Button(janela, text='Mostrar a Escala', command=mostrar_valores).pack()
janela.mainloop()
10. Dialog
O código para gerar uma aplicação com o componente “dialog” é dado por:
import tkinter as tk
from tkinter import messagebox as mb
def resposta():
   mb.showerror("Resposta", "Desculpe, nenhuma resposta disponível!")
def verificacao():
   if mb.askyesno('Verificar', 'Realmente quer sair?'):
      mb.showwarning('Yes', 'Ainda não foi implementado')
   else:
      mb.showinfo('No', 'A opção de Sair foi cancelada')
tk.Button(text='Sair', command=verificacao).pack(fill=tk.X)
tk.Button(text='Resposta', command=resposta).pack(fill=tk.X)
tk.mainloop()
11. Combobox
12. O código para gerar uma aplicação com o componente “combobox” é dado por:
import tkinter as tk
from tkinter import ttk
# Criação de uma janela tkinter
janela = tk.Tk()
janela.title('Combobox')
janela.geometry('500x250')
# Componente Label
ttk.Label(janela, text = "Combobox Widget",background = 'green', foreground ="white",font = ("Times New Roman", 15)).grid(row = 0, column = 1)
# Componente Label
ttk.Label(janela, text = "Selecione um mês :",font = ("Times New Roman", 10)).grid(column = 0,row = 5, padx = 10, pady = 25)
# Componente Combobox
n = tk.StringVar()
escolha = ttk.Combobox(janela, width = 27, textvariable = n)
# Adição de itens no Combobox
escolha['values'] = (' Janeiro',' Fevereiro',' Março',' Abril',' Maio',' Junho',' Julho',' Agosto',' Setembro',' Outubro',' Novembro',' Dezembro')
escolha.grid(column = 1, row = 5)
escolha.current()
janela.mainloop()