Python
Recuperar Arquivos em um Diretório com Python

Recuperar Arquivos em um Diretório com Python

MoeNagy Dev

Obtendo Todos os Arquivos de um Diretório com Python

O Poder da função os.listdir()

Compreendendo a função os.listdir()

A função os.listdir() é uma ferramenta poderosa na biblioteca padrão do Python que permite recuperar uma lista de todos os arquivos e diretórios dentro de um diretório especificado. Esta função faz parte do módulo os, que fornece uma maneira de interagir com o sistema operacional.

Aqui está um exemplo básico de como usar os.listdir():

import os
 
diretorio_path = '/caminho/para/diretorio'
lista_arquivos = os.listdir(diretorio_path)
print(lista_arquivos)

Este código irá produzir uma lista de todos os arquivos e diretórios dentro do diretorio_path especificado.

Listando todos os arquivos em um diretório

Para obter uma lista apenas dos arquivos (e não dos diretórios) em um diretório, você pode usar a seguinte abordagem:

import os
 
diretorio_path = '/caminho/para/diretorio'
lista_arquivos = [f for f in os.listdir(diretorio_path) if os.path.isfile(os.path.join(diretorio_path, f))]
print(lista_arquivos)

Neste exemplo, usamos uma compreensão de lista para filtrar a lista retornada por os.listdir() e incluir apenas os itens que são arquivos (em oposição a diretórios) usando a função os.path.isfile().

Lidando com subdiretórios e recuperação recursiva de arquivos

Se você quiser recuperar arquivos não apenas do diretório especificado, mas também de seus subdiretórios, você pode usar uma abordagem recursiva. Aqui está um exemplo:

import os
 
def obter_todos_arquivos(diretorio_path):
    lista_arquivos = []
    for raiz, diretorios, arquivos in os.walk(diretorio_path):
        for arquivo in arquivos:
            lista_arquivos.append(os.path.join(raiz, arquivo))
    return lista_arquivos
 
diretorio_path = '/caminho/para/diretorio'
todos_arquivos = obter_todos_arquivos(diretorio_path)
print(todos_arquivos)

Neste exemplo, definimos uma função obter_todos_arquivos() que usa a função os.walk() para percorrer recursivamente a árvore de diretórios. Para cada arquivo encontrado, construímos o caminho completo do arquivo usando os.path.join() e o adicionamos à lista_arquivos.

Filtrando Arquivos por Extensão

Especificando as extensões de arquivo a serem incluídas

Para recuperar apenas os arquivos com extensões de arquivo específicas, você pode usar a seguinte abordagem:

import os
 
diretorio_path = '/caminho/para/diretorio'
extensoes_permitidas = ['.txt', '.py', '.jpg']
 
lista_arquivos = [f for f in os.listdir(diretorio_path) if any(f.endswith(ext) for ext in extensoes_permitidas)]
print(lista_arquivos)

Neste exemplo, definimos uma lista de extensoes_permitidas e, em seguida, usamos uma compreensão de lista para filtrar a lista de arquivos retornada por os.listdir() e incluir apenas os arquivos que têm uma das extensões especificadas.

Excluindo certas extensões de arquivo

Da mesma forma, você pode excluir certas extensões de arquivo modificando a compreensão de lista:

import os
 
diretorio_path = '/caminho/para/diretorio'
extensoes_excluidas = ['.pyc', '.log']
 
lista_arquivos = [f for f in os.listdir(diretorio_path) if not any(f.endswith(ext) for ext in extensoes_excluidas)]
print(lista_arquivos)

Aqui, definimos uma lista de extensoes_excluidas e, em seguida, usamos uma compreensão de lista para filtrar a lista de arquivos, excluindo quaisquer arquivos que tenham uma das extensões especificadas.

Lidando com várias extensões de arquivo

Você também pode lidar com várias extensões de arquivo de forma mais flexível usando um conjunto ou um dicionário:

import os
 
diretorio_path = '/caminho/para/diretorio'
extensoes_permitidas = {'.txt', '.py', '.jpg'}
 
lista_arquivos = [f for f in os.listdir(diretorio_path) if any(f.endswith(ext) for ext in extensoes_permitidas)]
print(lista_arquivos)

Neste exemplo, usamos um conjunto de extensoes_permitidas em vez de uma lista. Isso nos permite adicionar ou remover facilmente extensões sem modificar a compreensão de lista.

Ordenando e Organizando a Lista de Arquivos

Ordenando a lista de arquivos em ordem alfabética

Para ordenar a lista de arquivos em ordem alfabética, você pode usar a função sorted() integrada:

import os
 
diretorio_path = '/caminho/para/diretorio'
lista_arquivos = os.listdir(diretorio_path)
lista_arquivos_ordenada = sorted(lista_arquivos)
print(lista_arquivos_ordenada)

Isso irá ordenar a lista de arquivos em ordem alfabética ascendente.

Ordenando por tamanho de arquivo ou data de modificação

Para ordenar a lista de arquivos por tamanho de arquivo ou data de modificação, você pode usar as funções os.path.getsize() e os.path.getmtime(), respectivamente:

import os
 
diretorio_path = '/caminho/para/diretorio'
lista_arquivos = os.listdir(diretorio_path)
 
# Ordenar por tamanho de arquivo
ordenado_por_tamanho = sorted(lista_arquivos, key=lambda x: os.path.getsize(os.path.join(diretorio_path, x)))
print(ordenado_por_tamanho)
 
# Ordenar por data de modificação
ordenado_por_data = sorted(lista_arquivos, key=lambda x: os.path.getmtime(os.path.join(diretorio_path, x)))
print(ordenado_por_data)

No primeiro exemplo, usamos a função sorted() com uma função de chave personalizada que recupera o tamanho do arquivo usando os.path.getsize(). No segundo exemplo, usamos a data de modificação obtida por os.path.getmtime() como chave de ordenação.

Agrupando arquivos por extensão

Para agrupar os arquivos por suas extensões de arquivo, você pode usar um dicionário para armazenar os arquivos agrupados por suas extensões:

import os
from collections import defaultdict
 
diretorio_path = '/caminho/para/diretorio'
lista_arquivos = os.listdir(diretorio_path)
 
grupos_arquivos = defaultdict(list)
for nome_arquivo in lista_arquivos:
    extensao = os.path.splitext(nome_arquivo)[1].lower()
    grupos_arquivos[extensao].append(nome_arquivo)
 
for extensao, arquivos in grupos_arquivos.items():
    print(f"Arquivos com extensão '{extensao}': {', '.join(arquivos)}")

Neste exemplo, usamos um defaultdict do módulo collections para criar um dicionário que automaticamente inicializa listas vazias para novas extensões de arquivo. Em seguida, iteramos pela lista de arquivos, extraímos a extensão do arquivo usando os.path.splitext() e adicionamos o nome do arquivo à lista correspondente no dicionário file_groups.

Trabalhando com Pathlib

Apresentando o módulo Pathlib

O módulo pathlib em Python fornece uma maneira orientada a objetos de lidar com caminhos de arquivos. Ele oferece uma abordagem mais intuitiva e multiplataforma em comparação com o tradicional módulo os.path.

Listando arquivos usando Pathlib

Aqui está um exemplo de como usar o pathlib para listar arquivos em um diretório:

from pathlib import Path
 
directory_path = '/caminho/para/diretorio'
file_list = [p.name for p in Path(directory_path).glob('*')]
print(file_list)

Neste exemplo, usamos a classe Path do módulo pathlib para representar o caminho do diretório. O método glob() é então usado para recuperar uma lista de todos os arquivos e diretórios dentro do diretório especificado.

Acessando metadados de arquivos com Pathlib

Você também pode usar o pathlib para acessar facilmente metadados de arquivos, como tamanho do arquivo e data de modificação:

from pathlib import Path
 
file_path = '/caminho/para/arquivo.txt'
file_path = Path(file_path)
 
print(f"Nome do arquivo: {file_path.name}")
print(f"Tamanho do arquivo: {file_path.stat().st_size} bytes")
print(f"Tempo de modificação: {file_path.stat().st_mtime}")

Este código demonstra como recuperar o nome do arquivo, o tamanho do arquivo e o horário da modificação usando o objeto pathlib.Path.

Lidando com arquivos e diretórios ocultos

Identificando arquivos e diretórios ocultos

Em muitos sistemas de arquivos, arquivos e diretórios que começam com um ponto (por exemplo, .gitignore) são considerados "ocultos" e geralmente não são exibidos em listagens de diretórios. Para incluir ou excluir esses itens ocultos, você pode usar a seguinte abordagem:

import os
 
directory_path = '/caminho/para/diretorio'
todos_itens = os.listdir(directory_path)
itens_visiveis = [item for item in todos_itens if not item.startswith('.')]
itens_ocultos = [item for item in todos_itens if item.startswith('.')]
 
print("Itens visíveis:", itens_visiveis)
print("Itens ocultos:", itens_ocultos)

Neste exemplo, primeiro recuperamos a lista completa de itens no diretório usando os.listdir(). Em seguida, usamos duas compreensões de lista para separar os itens visíveis e ocultos com base se o nome do item começa com um ponto.

Escolhendo se incluir ou excluir eles

Dependendo do seu caso de uso, você pode querer incluir ou excluir os arquivos e diretórios ocultos. Aqui está um exemplo de como lidar com isso:

import os
 
directory_path = '/caminho/para/diretorio'
incluir_ocultos = False
 
todos_itens = os.listdir(directory_path)
if incluir_ocultos:
    lista_arquivos = todos_itens
else:
    lista_arquivos = [item for item in todos_itens if not item.startswith('.')]
 
print(lista_arquivos)

Neste exemplo, introduzimos uma variável booleana incluir_ocultos que controla se os itens ocultos devem ser incluídos na lista final de arquivos ou não.

Personalizando o comportamento da pesquisa de arquivos

Você pode personalizar ainda mais o comportamento da pesquisa de arquivos criando uma função que permite especificar regras personalizadas para incluir ou excluir arquivos e diretórios:

import os
 
def get_lista_arquivos(directory_path, incluir_ocultos=False, extensoes_permitidas=None, extensoes_excluidas=None):
    todos_itens = os.listdir(directory_path)
    lista_arquivos = []
 
    for item in todos_itens:
        caminho_item = os.path.join(directory_path, item)
        if os.path.isfile(caminho_item):
            if extensoes_permitidas:
                if any(item.endswith(ext) for ext in extensoes_permitidas):
                    lista_arquivos.append(item)
            elif extensoes_excluidas:
                if not any(item.endswith(ext) for ext in extensoes_excluidas):
                    lista_arquivos.append(item)
            else:
                lista_arquivos.append(item)
        elif incluir_ocultos or not item.startswith('.'):
            lista_arquivos.append(item)
 
    return lista_arquivos
 
# Exemplo de uso
directory_path = '/caminho/para/diretorio'
lista_arquivos = get_lista_arquivos(directory_path, incluir_ocultos=False, extensoes_permitidas=['.txt', '.py'])
print(lista_arquivos)

Neste exemplo, a função get_lista_arquivos() permite especificar se deve incluir arquivos e diretórios ocultos, bem como quais extensões de arquivo incluir ou excluir. Isso proporciona uma maneira flexível e personalizável de recuperar a lista de arquivos com base em seus requisitos específicos.

Combinando os.listdir() e os.path.join()

Usando os.path.join() para construir caminhos de arquivo completos

Ao trabalhar com a lista de arquivos recuperada de os.listdir(), você frequentemente precisa construir caminhos de arquivo completos. Você pode usar a função os.path.join() para esse propósito:

import os
 
directory_path = '/caminho/para/diretorio'
lista_arquivos = os.listdir(directory_path)
caminhos_completos_arquivos = [os.path.join(directory_path, nome_arquivo) for nome_arquivo in lista_arquivos]
print(caminhos_completos_arquivos)

Neste exemplo, usamos uma compreensão de lista para iterar pela lista de arquivos e construir os caminhos completos dos arquivos juntando o caminho do diretório e os nomes individuais dos arquivos usando os.path.join().

Iterando pelo diretório e construindo a lista de arquivos

Você pode combinar os.listdir() e os.path.join() para construir a lista de arquivos de uma maneira mais eficiente:

import os
 
def get_lista_arquivos(directory_path):
    lista_arquivos = []
    for nome_arquivo in os.listdir(directory_path):
        caminho_arquivo = os.path.join(directory_path, nome_arquivo)
        if os.path.isfile(caminho_arquivo):
            lista_arquivos.append(caminho_arquivo)
    return lista_arquivos
 
directory_path = '/caminho/para/diretorio'
todos_arquivos = get_lista_arquivos(directory_path)
print(todos_arquivos)
 
## Estruturas de Dados
 
### Listas
As listas são uma das estruturas de dados mais fundamentais em Python. Elas são coleções ordenadas de itens, que podem ter diferentes tipos de dados. Você pode criar uma lista usando colchetes `[]` e separar os itens com vírgulas.
 
```python
fruits = ['apple', 'banana', 'cherry']
print(fruits)  # Saída: ['apple', 'banana', 'cherry']

Você pode acessar elementos individuais em uma lista usando seu índice, que começa em 0.

print(fruits[0])  # Saída: 'apple'
print(fruits[1])  # Saída: 'banana'

Você também pode usar índices negativos para acessar elementos do final da lista.

print(fruits[-1])  # Saída: 'cherry'
print(fruits[-2])  # Saída: 'banana'

As listas suportam uma ampla gama de operações, como fatiamento, concatenação e modificação.

# Fatiamento
print(fruits[1:3])  # Saída: ['banana', 'cherry']
 
# Concatenação
more_fruits = ['orange', 'kiwi']
all_fruits = fruits + more_fruits
print(all_fruits)  # Saída: ['apple', 'banana', 'cherry', 'orange', 'kiwi']
 
# Modificação
fruits[0] = 'pear'
print(fruits)  # Saída: ['pear', 'banana', 'cherry']

Tuplas

As tuplas são semelhantes às listas, mas são imutáveis, ou seja, você não pode modificar seus elementos após a criação. As tuplas são definidas usando parênteses () em vez de colchetes.

point = (3, 4)
print(point)  # Saída: (3, 4)
print(point[0])  # Saída: 3
print(point[1])  # Saída: 4

As tuplas podem ser úteis quando você deseja armazenar um conjunto fixo de valores, como coordenadas ou registros de banco de dados.

Dicionários

Os dicionários são coleções não ordenadas de pares chave-valor. Eles são definidos usando chaves {} e as chaves e valores são separados por dois pontos.

person = {
    'name': 'John Doe',
    'age': 35,
    'occupation': 'Software Engineer'
}
print(person)  # Saída: {'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}

Você pode acessar os valores em um dicionário usando suas chaves.

print(person['name'])  # Saída: 'John Doe'
print(person['age'])  # Saída: 35

Os dicionários são versáteis e podem ser usados para armazenar vários tipos de dados, incluindo listas e outros dicionários.

person = {
    'name': 'John Doe',
    'age': 35,
    'hobbies': ['reading', 'hiking', 'photography'],
    'address': {
        'street': '123 Main St',
        'city': 'Anytown',
        'state': 'CA'
    }
}
 
print(person['hobbies'])  # Saída: ['reading', 'hiking', 'photography']
print(person['address']['city'])  # Saída: 'Anytown'

Conjuntos

Os conjuntos são coleções não ordenadas de elementos únicos. Eles são definidos usando chaves {} e os elementos são separados por vírgulas.

colors = {'red', 'green', 'blue'}
print(colors)  # Saída: {'red', 'green', 'blue'}

Você pode usar conjuntos para realizar várias operações, como união, interseção e diferença.

colors1 = {'red', 'green', 'blue'}
colors2 = {'green', 'yellow', 'orange'}
 
# União
all_colors = colors1 | colors2
print(all_colors)  # Saída: {'red', 'green', 'blue', 'yellow', 'orange'}
 
# Interseção
common_colors = colors1 & colors2
print(common_colors)  # Saída: {'green'}
 
# Diferença
unique_colors1 = colors1 - colors2
print(unique_colors1)  # Saída: {'red', 'blue'}

Fluxo de Controle

Declarações Condicionais

Em Python, você pode usar declarações condicionais para controlar o fluxo do seu programa com base em determinadas condições.

A declaração if-elif-else é a forma mais comum de implementar lógica condicional.

age = 25
if age < 18:
    print("Você é menor de idade.")
elif age < 65:
    print("Você é adulto.")
else:
    print("Você é idoso.")

Você também pode usar o operador ternário, que é uma forma abreviada de escrever declarações simples if-else.

is_student = True
status = "Estudante" if is_student else "Não estudante"
print(status)  # Saída: "Estudante"

Loops

Os loops em Python permitem que você execute repetidamente um bloco de código. Os dois tipos mais comuns de loops são os loops for e while.

Um loop for é usado para iterar sobre uma sequência, como uma lista ou uma string.

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

Um loop while é usado para executar repetidamente um bloco de código enquanto uma determinada condição for verdadeira.

count = 0
while count < 5:
    print(count)
    count += 1

Você também pode usar as instruções break e continue para controlar o fluxo dos seus loops.

for i in range(10):
    if i == 5:
        break
    print(i)  # Saída: 0 1 2 3 4
 
for j in range(10):
    if j % 2 == 0:
        continue
    print(j)  # Saída: 1 3 5 7 9

Funções

Funções em Python são blocos de código reutilizáveis que executam uma tarefa específica. Elas são definidas usando a palavra-chave def.

def greet(name):
    print(f"Olá, {name}!")
 
greet("Alice")  # Saída: "Olá, Alice!"

As funções também podem retornar valores usando a instrução return.

def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)
print(result)  # Saída: 7

Também é possível definir funções com valores padrão de parâmetros e argumentos de comprimento variável.

def print_info(name, age=30, *args):
    print(f"Nome: {name}")
    print(f"Idade: {age}")
    print("Informações adicionais:")
    for arg in args:
        print(arg)
 
print_info("John", 35, "Engenheiro de Software", "Adora fazer caminhadas")

Módulos e Pacotes

Em Python, você pode organizar seu código em módulos e pacotes para torná-lo mais modular e reutilizável.

Um módulo é um único arquivo Python que contém funções, classes e variáveis. Você pode importar módulos usando a instrução import.

import math
print(math.pi)  # Saída: 3.141592653589793

Você também pode importar itens específicos de um módulo usando a palavra-chave from.

from math import sqrt
print(sqrt(16))  # Saída: 4.0

Os pacotes são coleções de módulos relacionados. Eles são organizados em diretórios com um arquivo __init__.py que define o pacote.

meu_pacote/
```pt
    __init__.py
    module1.py
    module2.py

Você pode importar itens de um pacote usando a notação de ponto.

import meu_pacote.module1
resultado = meu_pacote.module1.minha_funcao()

Tratamento de Exceções

O mecanismo de tratamento de exceções do Python permite lidar com erros em tempo de execução e situações inesperadas no seu código.

Você pode usar a instrução try-except para capturar e tratar exceções.

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Erro: Divisão por zero")

Você também pode lidar com várias exceções e fornecer um bloco except default.

try:
    num = int(input("Digite um número: "))
    print(10 / num)
except ValueError:
    print("Erro: Entrada inválida")
except ZeroDivisionError:
    print("Erro: Divisão por zero")
except:
    print("Ocorreu um erro desconhecido")

Você também pode lançar suas próprias exceções usando a instrução raise.

def sacar(saldo, valor):
    if valor > saldo:
        raise ValueError("Fundos insuficientes")
    return saldo - valor
 
try:
    novo_saldo = sacar(100, 150)
except ValueError as e:
    print(e)

Conclusão

Neste tutorial, você aprendeu sobre várias estruturas de dados, declarações de fluxo de controle, funções, módulos e tratamento de exceções em Python. Esses conceitos são essenciais para construir aplicativos Python mais complexos e robustos. Lembre-se de praticar e experimentar com os exemplos fornecidos para solidificar seu entendimento desses tópicos.

MoeNagy Dev