Python
Obtenha rapidamente uma lista de arquivos no diretório: Um guia Python

Obtenha rapidamente uma lista de arquivos no diretório: Um guia Python

MoeNagy Dev

Explorando os módulos os e os.path

Visão geral dos módulos os e os.path

Os módulos os e os.path em Python oferecem uma maneira independente de plataforma para interagir com o sistema de arquivos do sistema operacional. Esses módulos oferecem uma ampla gama de funcionalidades, desde listar arquivos em um diretório até gerenciar caminhos de arquivo e diretório.

Acessando o diretório de trabalho atual

Você pode usar a função os.getcwd() para obter o diretório de trabalho atual:

import os
 
current_dir = os.getcwd()
print(current_dir)

Isso imprimirá o caminho absoluto do diretório de trabalho atual.

Listando arquivos no diretório atual

A função os.listdir() pode ser usada para listar todos os arquivos e diretórios no diretório de trabalho atual:

import os
 
files_and_dirs = os.listdir()
print(files_and_dirs)

Isso retornará uma lista de todos os itens (arquivos e diretórios) no diretório atual.

Usando a função os.listdir()

Conceitos básicos do os.listdir()

A função os.listdir() recebe um argumento opcional, que é o caminho para o diretório cujo conteúdo você deseja listar. Se nenhum argumento for fornecido, ela listará o conteúdo do diretório de trabalho atual.

import os
 
# Listar arquivos no diretório atual
files_and_dirs = os.listdir()
print(files_and_dirs)
 
# Listar arquivos em um diretório específico
specific_dir = "/caminho/para/o/diretório"
files_and_dirs = os.listdir(specific_dir)
print(files_and_dirs)

Listando arquivos em um diretório específico

Para listar os arquivos em um diretório específico, passe o caminho para o diretório como argumento para os.listdir():

import os
 
specific_dir = "/caminho/para/o/diretório"
files_and_dirs = os.listdir(specific_dir)
print(files_and_dirs)

Isso retornará uma lista de todos os itens (arquivos e diretórios) no diretório especificado.

Manipulação de caminhos relativos e absolutos

Você pode usar tanto caminhos relativos quanto caminhos absolutos com os.listdir(). Caminhos relativos são interpretados em relação ao diretório de trabalho atual, enquanto caminhos absolutos são interpretados como o caminho completo para o diretório.

import os
 
# Usando um caminho relativo
rel_path = "documentos"
files_and_dirs = os.listdir(rel_path)
print(files_and_dirs)
 
# Usando um caminho absoluto
abs_path = "/home/user/documentos"
files_and_dirs = os.listdir(abs_path)
print(files_and_dirs)

Filtrando a lista de arquivos

Excluindo diretórios da lista

Se você deseja listar apenas os arquivos em um diretório, e não os próprios diretórios, você pode usar a função os.path.isfile() para filtrar a lista:

import os
 
diretório = "/caminho/para/o/diretório"
todos_itens = os.listdir(diretório)
arquivos = [item for item in todos_itens if os.path.isfile(os.path.join(diretório, item))]
print(arquivos)

Isso criará uma nova lista arquivos que contém apenas os nomes dos arquivos, excluindo quaisquer diretórios.

Filtrando por extensão de arquivo

Para filtrar a lista de arquivos por extensão de arquivo, você pode usar uma compreensão de lista:

import os
 
diretório = "/caminho/para/o/diretório"
todos_itens = os.listdir(diretório)
arquivos_txt = [item for item in todos_itens if item.endswith(".txt")]
print(arquivos_txt)

Isso criará uma nova lista arquivos_txt que contém apenas os nomes de arquivo com a extensão .txt.

Usando compreensão de listas para filtragens avançadas

Compreensões de lista podem ser usadas para aplicar lógica de filtragem mais complexa. Por exemplo, para obter uma lista de arquivos com uma extensão específica e que sejam maiores que um determinado tamanho:

import os
 
diretório = "/caminho/para/o/diretório"
todos_itens = os.listdir(diretório)
arquivos_csv_grandes = [
    item
    for item in todos_itens
    if item.endswith(".csv") and os.path.getsize(os.path.join(diretório, item)) > 1024 * 1024
]
print(arquivos_csv_grandes)

Isso criará uma nova lista arquivos_csv_grandes que contém apenas os arquivos CSV no diretório que são maiores que 1 MB.

Listando arquivos de forma recursiva em subdiretórios

Explorando subdiretórios com os.walk()

A função os.walk() pode ser usada para percorrer recursivamente uma árvore de diretórios e listar todos os arquivos nos subdiretórios. Ela retorna um gerador que gera uma tupla de 3 elementos para cada diretório visitado: o caminho para o diretório, uma lista dos diretórios naquele diretório e uma lista dos arquivos naquele diretório.

import os
 
diretório = "/caminho/para/o/diretório"
for root, dirs, files in os.walk(diretório):
    for file in files:
        print(os.path.join(root, file))

Isso imprimirá o caminho completo de cada arquivo na árvore de diretórios, começando pelo diretório especificado.

Manipulação de caminhos de arquivo de maneira recursiva

Ao trabalhar com os.walk(), você precisará manipular corretamente os caminhos de arquivo, especialmente ao lidar com subdiretórios. A função os.path.join() pode ser usada para construir o caminho completo de um arquivo combinando o caminho do diretório e o nome do arquivo.

import os
 
diretório = "/caminho/para/o/diretório"
for root, dirs, files in os.walk(diretório):
    for file in files:
        caminho_completo = os.path.join(root, file)
        print(caminho_completo)

Isso imprimirá o caminho completo de cada arquivo, levando em consideração a estrutura de diretórios.

Personalizando o formato de saída

Você pode personalizar o formato de saída de acordo com suas necessidades. Por exemplo, você pode imprimir o tamanho do arquivo e a data de modificação juntamente com o caminho do arquivo:

import os
from datetime import datetime
 
diretório = "/caminho/para/o/diretório"
for root, dirs, files in os.walk(diretório):
    for file in files:
        caminho_completo = os.path.join(root, file)
file_size = os.path.getsize(caminho_completo)
        mod_time = os.path.getmtime(caminho_completo)
        mod_time_str = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
        print(f"{caminho_completo} - Tamanho: {file_size} bytes - Modificado: {mod_time_str}")

Isso imprimirá o caminho do arquivo, tamanho e horário de modificação para cada arquivo na árvore de diretórios.

Trabalhando com o módulo os.path

Unindo caminhos com os.path.join()

A função os.path.join() é usada para construir caminhos de arquivos juntando um ou mais componentes de caminho de forma inteligente. Ela lida com os separadores de caminho apropriados (por exemplo, barras inclinadas em sistemas semelhantes ao Unix, barras invertidas no Windows) com base no sistema operacional.

import os
 
diretorio = "/caminho/para/diretorio"
nome_arquivo = "exemplo.txt"
caminho_completo = os.path.join(diretorio, nome_arquivo)
print(caminho_completo)

Isso imprimirá o caminho completo do arquivo, com os separadores de caminho apropriados para o sistema operacional atual.

Verificando se um caminho é um arquivo ou diretório

As funções os.path.isfile() e os.path.isdir() podem ser usadas para verificar se um determinado caminho representa um arquivo ou um diretório, respectivamente.

import os
 
caminho = "/caminho/para/arquivo.txt"
if os.path.isfile(caminho):
    print(f"{caminho} é um arquivo.")
else:
    print(f"{caminho} não é um arquivo.")
 
caminho = "/caminho/para/diretorio"
if os.path.isdir(caminho):
    print(f"{caminho} é um diretório.")
else:
    print(f"{caminho} não é um diretório.")

Obtendo tamanho do arquivo e tempo de modificação

As funções os.path.getsize() e os.path.getmtime() podem ser usadas para obter o tamanho de um arquivo e o tempo de sua última modificação, respectivamente.

import os
from datetime import datetime
 
caminho = "/caminho/para/arquivo.txt"
tamanho_arquivo = os.path.getsize(caminho)
tempo_modificacao = os.path.getmtime(caminho)
tempo_modificacao_str = datetime.fromtimestamp(tempo_modificacao).strftime("%Y-%m-%d %H:%M:%S")
print(f"Tamanho do arquivo: {tamanho_arquivo} bytes")
print(f"Última modificação: {tempo_modificacao_str}")

Isso imprimirá o tamanho do arquivo em bytes e o último horário de modificação do arquivo.

Lidando com a Compatibilidade entre Plataformas

Lidando com diferenças entre sistemas operacionais

Os módulos os e os.path foram projetados para fornecer uma interface independente de plataforma, mas ainda existem algumas diferenças na maneira como os caminhos de arquivo são tratados em diferentes sistemas operacionais (por exemplo, o Windows usa barras invertidas, enquanto os sistemas semelhantes ao Unix usam barras inclinadas).

Garantindo um comportamento consistente em todas as plataformas

Para garantir que seu código funcione consistentemente em diferentes plataformas, você deve usar as funções e métodos apropriados do módulo os.path, como os.path.join(), os.path.normpath() e os.path.normcase().

Utilizando os.path.normpath() e os.path.normcase()

A função os.path.normpath() pode ser usada para normalizar um caminho, removendo separadores redundantes e referências a níveis superiores (por exemplo, ../). A função os.path.normcase() pode ser usada para normalizar a caixa de um caminho, o que é importante em sistemas de arquivos que diferenciam maiúsculas de minúsculas.

import os
 
# Normalizar um caminho
caminho = "/caminho/para/../arquivo.txt"
caminho_normalizado = os.path.normpath(caminho)
print(caminho_normalizado)  # Saída: "/caminho/arquivo.txt"
 
# Normalizar a caixa de um caminho
caminho = "/CAMINHO/para/ARQUIVO.txt"
caminho_normalizado = os.path.normcase(caminho)
print(caminho_normalizado)  # Saída: "/caminho/para/arquivo.txt" (em sistemas semelhantes ao Unix)

Ao usar essas funções, você pode garantir que seus caminhos de arquivo sejam formatados de maneira consistente em diferentes sistemas operacionais.

Ordenando e Organizando a Lista de Arquivos

Ordenando a lista de arquivos por nome, tamanho ou tempo de modificação

Você pode ordenar a lista de arquivos com base em vários atributos, como o nome do arquivo, tamanho ou tempo de modificação. A função sorted() pode ser usada para esse fim, juntamente com as funções chave apropriadas.

import os
 
diretorio = "/caminho/para/diretorio"
arquivos = os.listdir(diretorio)
 
# Ordenar por nome de arquivo
arquivos_ordenados = sorted(arquivos)
print(arquivos_ordenados)
 
# Ordenar por tamanho de arquivo
tamanhos_arquivos = [(f, os.path.getsize(os.path.join(diretorio, f))) for f in arquivos]
arquivos_ordenados = sorted(tamanhos_arquivos, key=lambda x: x[1])
print(arquivos_ordenados)
 
# Ordenar por tempo de modificação
tempos_modificacao_arquivos = [(f, os.path.getmtime(os.path.join(diretorio, f))) for f in arquivos]
arquivos_ordenados = sorted(tempos_modificacao_arquivos, key=lambda x: x[1])
print(arquivos_ordenados)

Isso imprimirá a lista de arquivos ordenados por nome, tamanho e tempo de modificação, respectivamente.

Agrupando arquivos por extensão ou outros atributos

Você pode agrupar os arquivos por sua extensão de arquivo ou outros atributos usando um dicionário ou um defaultdict:

import os
from collections import defaultdict
 
diretorio = "/caminho/para/diretorio"
arquivos = os.listdir(diretorio)
 
# Agrupar arquivos por extensão
grupos_arquivos = defaultdict(list)
for arquivo in arquivos:
    extensao = os.path.splitext(arquivo)[1][1:]
    grupos_arquivos[extensao].append(arquivo)
 
for extensao, arquivos in grupos_arquivos.items():
    print(f"Arquivos {extensao}: {', '.join(arquivos)}")
 
# Agrupar arquivos por tamanho (em MB)
tamanhos_arquivos = [(f, os.path.getsize(os.path.join(diretorio, f))) for f in arquivos]
grupos_arquivos = defaultdict(list)
for arquivo, tamanho in tamanhos_arquivos:
    tamanho_mb = tamanho / (1024 * 1024)
    grupos_arquivos[f"{tamanho_mb:.2f} MB"].append(arquivo)
 
for tamanho, arquivos in grupos_arquivos.items():
    print(f"Arquivos {tamanho}: {', '.join(arquivos)}")

Isso agrupará os arquivos por

Estruturas de Dados

Listas

Listas são uma das estruturas de dados mais versáteis em Python. Elas são coleções ordenadas de itens, que podem ter diferentes tipos de dados. Aqui está um exemplo:

minha_lista = [1, 'maçã', 3.14, True]

Você pode acessar elementos individuais em uma lista usando seus índices, que começam em 0:

print(minha_lista[0])  # Saída: 1
print(minha_lista[2])  # Saída: 3.14

Você também pode modificar elementos em uma lista:

minha_lista[1] = 'banana'
print(minha_lista)  # Saída: [1, 'banana', 3.14, True]

Listas têm muitos métodos integrados, como append(), insert(), remove() e sort().

Tuplas

As tuplas são semelhantes às listas, mas são imutáveis, o que significa que você não pode modificar seus elementos depois de criados. As tuplas são definidas usando parênteses () em vez de colchetes [].

my_tuple = (1, 'apple', 3.14, True)
print(my_tuple[0])  # Output: 1

As tuplas são úteis quando você deseja garantir que a ordem e o conteúdo de uma coleção de dados permaneçam inalterados.

Dicionários

Dicionários são coleções não ordenadas de pares chave-valor. Eles são definidos usando chaves {} e cada par chave-valor é separado por dois pontos :.

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print(my_dict['name'])  # Output: 'John'

Você pode adicionar, modificar e remover pares chave-valor em um dicionário:

my_dict['email'] = 'john@example.com'
my_dict['age'] = 31
del my_dict['city']

Dicionários são poderosos para armazenar e recuperar dados com base em chaves únicas.

Conjuntos

Conjuntos são coleções não ordenadas de elementos únicos. Eles são definidos usando chaves {} ou a função set().

my_set = {1, 2, 3, 4, 5}
print(2 in my_set)  # Output: True
print(6 in my_set)  # Output: False

Conjuntos são úteis para realizar operações como união, interseção e diferença entre coleções de dados.

Fluxo de Controle

Declarações Condicionais

As declarações condicionais em Python usam as palavras-chave if, elif e else para executar diferentes blocos de código com base em determinadas condições.

x = 10
if x > 0:
    print("x é positivo")
elif x < 0:
    print("x é negativo")
else:
    print("x é zero")

Laços

Python possui duas estruturas principais de laços: for e while. O laço for é usado para iterar sobre sequências (como listas, tuplas ou strings), enquanto o laço while é usado para executar um bloco de código enquanto uma certa condição for verdadeira.

# Laço for
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)
 
# Laço while
count = 0
while count < 5:
    print(count)
    count += 1

Você também pode usar as declarações break e continue para controlar o fluxo de um laço.

Compreensões de Listas

As compreensões de lista fornecem uma maneira concisa de criar novas listas com base em listas existentes. Elas são particularmente úteis para transformar ou filtrar dados.

# Criar uma nova lista com os quadrados de números de 1 a 10
squares = [x**2 for x in range(1, 11)]
print(squares)  # Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
# Criar uma nova lista com os números pares de 1 a 10
even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers)  # Output: [2, 4, 6, 8, 10]

Funções

Funções em Python são definidas usando a palavra-chave def. Elas podem aceitar parâmetros e retornar valores.

def greet(name):
    """Sauda a pessoa com o nome fornecido."""
    print(f"Olá, {name}!")
 
greet("Alice")  # Output: Olá, Alice!

Você também pode definir funções com valores padrão para parâmetros e argumentos de comprimento variável.

def calculate_area(length, width=1):
    """Calcula a área de um retângulo."""
    return length * width
 
print(calculate_area(5, 3))  # Output: 15
print(calculate_area(4))  # Output: 4 (a largura padrão é 1)
 
def sum_numbers(*args):
    """Calcula a soma de qualquer número de argumentos."""
    return sum(args)
 
print(sum_numbers(1, 2, 3))  # Output: 6
print(sum_numbers(4, 5, 6, 7, 8))  # Output: 30

As funções também podem ser definidas como funções lambda (funções anônimas) para operações simples em uma única linha.

square = lambda x: x**2
print(square(5))  # Output: 25

Módulos e Pacotes

A biblioteca padrão do Python fornece uma ampla variedade de módulos integrados que você pode usar em seus programas. Você também pode criar seus próprios módulos e pacotes para organizar seu código.

# Usando um módulo integrado
import math
print(math.pi)  # Output: 3.141592653589793
 
# Criando um módulo personalizado
# my_module.py
def greet(name):
    print(f"Olá, {name}!")
 
# Usando o módulo personalizado
import my_module
my_module.greet("Alice")  # Output: Olá, Alice!

Pacotes são coleções de módulos e ajudam a estruturar seu código e a gerenciar dependências.

Tratamento de Exceções

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

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Erro: Divisão por zero")
else:
    print(f"Resultado: {result}")
finally:
    print("Este bloco será executado sempre.")

Você também pode definir suas próprias exceções personalizadas e lançá-las quando necessário.

class InvalidInputError(Exception):
    pass
 
def divide(a, b):
    if b == 0:
        raise InvalidInputError("Erro: Divisão por zero")
    return a / b
 
try:
    print(divide(10, 0))
except InvalidInputError as e:
    print(e)

E/S de Arquivos

O Python fornece funções integradas para ler de e escrever em arquivos.

# Escrevendo em um arquivo
with open("output.txt", "w") as file:
    file.write("Olá, Mundo!")
 
# Lendo de um arquivo
with open("input.txt", "r") as file:
    content = file.read()
    print(content)

A declaração with garante que o arquivo seja fechado corretamente após a conclusão da operação.

Conclusão

Neste tutorial de Python, abordamos uma ampla variedade de tópicos, incluindo estruturas de dados, fluxo de controle, funções, módulos e pacotes, tratamento de exceções e E/S de arquivos. Ao entender esses conceitos, você estará bem encaminhado para se tornar um programador Python proficiente. Lembre-se de praticar regularmente e explorar o vasto ecossistema de bibliotecas e frameworks do Python para expandir suas habilidades e criar aplicativos poderosos.

MoeNagy Dev