Python
Легко получить файлы в каталоге с помощью Python

Легко получить файлы в каталоге с помощью Python

MoeNagy Dev

Получение всех файлов в каталоге с помощью Python

Мощь функции os.listdir()

Понимание функции os.listdir()

Функция os.listdir() - это мощный инструмент в стандартной библиотеке Python, который позволяет получить список всех файлов и каталогов в указанном каталоге. Эта функция является частью модуля os, который предоставляет способ взаимодействия с операционной системой.

Вот простой пример использования os.listdir():

import os
 
directory_path = '/path/to/directory'
file_list = os.listdir(directory_path)
print(file_list)

Этот код выведет список всех файлов и каталогов в указанном directory_path.

Перечисление всех файлов в каталоге

Чтобы получить список только файлов (а не каталогов) в каталоге, можно использовать следующий подход:

import os
 
directory_path = '/path/to/directory'
file_list = [f for f in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, f))]
print(file_list)

В этом примере мы используем список составления (list comprehension), чтобы отфильтровать список, возвращаемый os.listdir(), и включить только те элементы, которые являются файлами (а не каталогами), используя функцию os.path.isfile().

Обработка подкаталогов и рекурсивное получение файлов

Если вы хотите получить файлы не только из указанного каталога, но и из его подкаталогов, вы можете использовать рекурсивный подход. Вот пример:

import os
 
def get_all_files(directory_path):
    file_list = []
    for root, dirs, files in os.walk(directory_path):
        for file in files:
            file_list.append(os.path.join(root, file))
    return file_list
 
directory_path = '/path/to/directory'
all_files = get_all_files(directory_path)
print(all_files)

В этом примере мы определяем функцию get_all_files(), которая использует функцию os.walk() для рекурсивного обхода дерева каталогов. При обнаружении каждого файла мы конструируем полный путь к файлу с помощью os.path.join() и добавляем его в file_list.

Фильтрация файлов по расширению

Указание включаемых расширений файлов

Чтобы получить только файлы с определенными расширениями файлов, можно использовать следующий подход:

import os
 
directory_path = '/path/to/directory'
allowed_extensions = ['.txt', '.py', '.jpg']
 
file_list = [f for f in os.listdir(directory_path) if any(f.endswith(ext) for ext in allowed_extensions)]
print(file_list)

В этом примере мы определяем список allowed_extensions, а затем с помощью списка составления фильтруем список файлов, возвращаемых os.listdir(), чтобы включить только файлы с одним из указанных расширений.

Исключение определенных расширений файлов

Аналогично, вы можете исключить определенные расширения файлов, изменяя список составления:

import os
 
directory_path = '/path/to/directory'
excluded_extensions = ['.pyc', '.log']
 
file_list = [f for f in os.listdir(directory_path) if not any(f.endswith(ext) for ext in excluded_extensions)]
print(file_list)

Здесь мы определяем список excluded_extensions, а затем с помощью списка составления фильтруем список файлов, исключая файлы с одним из указанных расширений.

Обработка нескольких расширений файлов

Вы также можете обрабатывать несколько расширений файлов более гибким способом, используя множество (set) или словарь (dictionary):

import os
 
directory_path = '/path/to/directory'
allowed_extensions = {'.txt', '.py', '.jpg'}
 
file_list = [f for f in os.listdir(directory_path) if any(f.endswith(ext) for ext in allowed_extensions)]
print(file_list)

В этом примере мы используем множество allowed_extensions вместо списка. Это позволяет нам легко добавлять или удалять расширения без изменения списка составления.

Сортировка и организация списка файлов

Сортировка списка файлов в алфавитном порядке

Чтобы отсортировать список файлов в алфавитном порядке, можно использовать встроенную функцию sorted():

import os
 
directory_path = '/path/to/directory'
file_list = os.listdir(directory_path)
sorted_file_list = sorted(file_list)
print(sorted_file_list)

Это сортирует список файлов в алфавитном порядке по возрастанию.

Сортировка по размеру файла или дате модификации

Чтобы отсортировать список файлов по размеру файла или дате модификации, можно использовать функции os.path.getsize() и os.path.getmtime(), соответственно:

import os
 
directory_path = '/path/to/directory'
file_list = os.listdir(directory_path)
 
# Сортировка по размеру файла
sorted_by_size = sorted(file_list, key=lambda x: os.path.getsize(os.path.join(directory_path, x)))
print(sorted_by_size)
 
# Сортировка по дате модификации
sorted_by_date = sorted(file_list, key=lambda x: os.path.getmtime(os.path.join(directory_path, x)))
print(sorted_by_date)

В первом примере мы используем функцию sorted() с пользовательской функцией ключа, которая извлекает размер файла с помощью os.path.getsize(). Во втором примере мы используем дату модификации, полученную функцией os.path.getmtime(), в качестве ключа сортировки.

Группировка файлов по расширению

Чтобы сгруппировать файлы по их расширениям файлов, вы можете использовать словарь для хранения файлов, сгруппированных по их расширениям:

import os
from collections import defaultdict
 
directory_path = '/path/to/directory'
file_list = os.listdir(directory_path)
 
file_groups = defaultdict(list)
for filename in file_list:
    extension = os.path.splitext(filename)[1].lower()
    file_groups[extension].append(filename)
 
for extension, files in file_groups.items():
    print(f"Файлы с расширением '{extension}': {', '.join(files)}")

В этом примере мы используем defaultdict из модуля collections, чтобы создать словарь, который автоматически инициализирует пустые списки для новых расширений файлов. Затем мы перебираем список файлов, извлекаем расширение файла с помощью os.path.splitext() и добавляем имя файла в соответствующий список в словаре file_groups.

Работа с Pathlib

Представление модуля Pathlib

Модуль pathlib в Python предоставляет объектно-ориентированный способ работы с путями к файлам. Он предлагает более интуитивный и межплатформенный подход по сравнению с традиционным модулем os.path.

Перечисление файлов с использованием Pathlib

Вот пример использования pathlib для перечисления файлов в каталоге:

from pathlib import Path
 
directory_path = '/path/to/directory'
file_list = [p.name for p in Path(directory_path).glob('*')]
print(file_list)

В этом примере мы используем класс Path из модуля pathlib для представления пути каталога. Затем используется метод glob(), чтобы получить список всех файлов и каталогов в указанном каталоге.

Доступ к метаданным файла с помощью Pathlib

Также вы можете использовать pathlib для удобного доступа к метаданным файла, таким как размер файла и дата изменения:

from pathlib import Path
 
file_path = '/path/to/file.txt'
file_path = Path(file_path)
 
print(f"Имя файла: {file_path.name}")
print(f"Размер файла: {file_path.stat().st_size} байт")
print(f"Время изменения: {file_path.stat().st_mtime}")

Этот код показывает, как получить имя файла, размер файла и время его изменения с использованием объекта pathlib.Path.

Работа с скрытыми файлами и каталогами

Определение скрытых файлов и каталогов

Во многих файловых системах файлы и каталоги, которые начинаются с точки (например, .gitignore), считаются "скрытыми" и обычно не отображаются в списках каталогов. Чтобы включить или исключить эти скрытые элементы, можно использовать следующий подход:

import os
 
directory_path = '/path/to/directory'
all_items = os.listdir(directory_path)
visible_items = [item for item in all_items if not item.startswith('.')]
hidden_items = [item for item in all_items if item.startswith('.')]
 
print("Видимые элементы:", visible_items)
print("Скрытые элементы:", hidden_items)

В этом примере мы сначала получаем полный список элементов в каталоге с помощью os.listdir(). Затем мы используем два списковых выражения для разделения видимых и скрытых элементов на основе того, начинается ли имя элемента с точки.

Выбор включения или исключения скрытых элементов

В зависимости от вашего конкретного случая использования вы можете захотеть включить или исключить скрытые файлы и каталоги. Вот пример обработки этой ситуации:

import os
 
directory_path = '/path/to/directory'
include_hidden = False
 
all_items = os.listdir(directory_path)
if include_hidden:
    file_list = all_items
else:
    file_list = [item for item in all_items if not item.startswith('.')]
 
print(file_list)

В этом примере мы вводим логическую переменную include_hidden, которая управляет тем, следует ли включать скрытые элементы в конечный список файлов или нет.

Настройка поведения поиска файлов

Вы также можете настроить поведение поиска файлов путем создания функции, которая позволяет задать пользовательские правила включения или исключения файлов и каталогов:

import os
 
def get_file_list(directory_path, include_hidden=False, allowed_extensions=None, excluded_extensions=None):
    all_items = os.listdir(directory_path)
    file_list = []
 
    for item in all_items:
        item_path = os.path.join(directory_path, item)
        if os.path.isfile(item_path):
            if allowed_extensions:
                if any(item.endswith(ext) for ext in allowed_extensions):
                    file_list.append(item)
            elif excluded_extensions:
                if not any(item.endswith(ext) for ext in excluded_extensions):
                    file_list.append(item)
            else:
                file_list.append(item)
        elif include_hidden or not item.startswith('.'):
            file_list.append(item)
 
    return file_list
 
# Пример использования
directory_path = '/path/to/directory'
file_list = get_file_list(directory_path, include_hidden=False, allowed_extensions=['.txt', '.py'])
print(file_list)

В этом примере функция get_file_list() позволяет вам указать, нужно ли включать скрытые файлы и каталоги, а также какие расширения файлов нужно включить или исключить. Это обеспечивает гибкий и настраиваемый способ получения списка файлов в соответствии с ваши масимальными требованиями.

Комбинирование os.listdir() и os.path.join()

Использование os.path.join() для построения полного пути к файлам

При работе со списком файлов, полученных из os.listdir(), вам часто необходимо построить полные пути к этим файлам. Для этой цели вы можете использовать функцию os.path.join():

import os
 
directory_path = '/path/to/directory'
file_list = os.listdir(directory_path)
full_file_paths = [os.path.join(directory_path, filename) for filename in file_list]
print(full_file_paths)

В этом примере мы используем списковое включение для перебора списка файлов и построения полных путей к файлам с помощью объединения пути каталога и отдельных имен файлов с помощью os.path.join().

Итерирование по каталогу и построение списка файлов

Вы можете объединить os.listdir() и os.path.join() для более эффективного построения списка файлов:

import os
 
def get_file_list(directory_path):
    file_list = []
    for filename in os.listdir(directory_path):
        file_path = os.path.join(directory_path, filename)
        if os.path.isfile(file_path):
            file_list.append(file_path)
    return file_list
 
directory_path = '/path/to/directory'
all_files = get_file_list(directory_path)
print(all_files)
 
## Структуры данных
 
### Списки

Списки - это одна из наиболее базовых структур данных в Python. Они являются упорядоченными наборами элементов, которые могут быть разных типов данных. Список можно создать с использованием квадратных скобок [] и разделить элементы запятыми.

fruits = ['apple', 'banana', 'cherry']
print(fruits)  # Вывод: ['apple', 'banana', 'cherry']

Вы можете получить доступ к отдельным элементам в списке, используя их индексы, которые начинаются с 0.

print(fruits[0])  # Вывод: 'apple'
print(fruits[1])  # Вывод: 'banana'

Вы также можете использовать отрицательные индексы для доступа к элементам с конца списка.

print(fruits[-1])  # Вывод: 'cherry'
print(fruits[-2])  # Вывод: 'banana'

Списки поддерживают широкий набор операций, таких как срезы, конкатенация и модификация.

# Срезы
print(fruits[1:3])  # Вывод: ['banana', 'cherry']
 
# Конкатенация
more_fruits = ['orange', 'kiwi']
all_fruits = fruits + more_fruits
print(all_fruits)  # Вывод: ['apple', 'banana', 'cherry', 'orange', 'kiwi']
 
# Модификация
fruits[0] = 'pear'
print(fruits)  # Вывод: ['pear', 'banana', 'cherry']

Кортежи

Кортежи похожи на списки, но они являются неизменяемыми, что означает, что вы не можете изменять их элементы после их создания. Кортежи определяются с помощью круглых скобок () вместо квадратных скобок.

point = (3, 4)
print(point)  # Вывод: (3, 4)
print(point[0])  # Вывод: 3
print(point[1])  # Вывод: 4

Кортежи могут быть полезны, когда вы хотите хранить фиксированный набор значений, таких как координаты или записи из базы данных.

Словари

Словари - это неупорядоченные наборы пар ключ-значение. Они определяются с помощью фигурных скобок {} , а ключи и значения разделяются двоеточием.

person = {
    'name': 'John Doe',
    'age': 35,
    'occupation': 'Software Engineer'
}
print(person)  # Вывод: {'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}

Вы можете получить доступ к значениям в словаре, используя их ключи.

print(person['name'])  # Вывод: 'John Doe'
print(person['age'])  # Вывод: 35

Словари являются гибкими и могут использоваться для хранения различных типов данных, включая списки и другие словари.

person = {
    'name': 'John Doe',
    'age': 35,
    'hobbies': ['reading', 'hiking', 'photography'],
    'address': {
        'street': '123 Main St',
        'city': 'Anytown',
        'state': 'CA'
    }
}
 
print(person['hobbies'])  # Вывод: ['reading', 'hiking', 'photography']
print(person['address']['city'])  # Вывод: 'Anytown'

Множества

Множества - это неупорядоченные наборы уникальных элементов. Они определяются с помощью фигурных скобок {} и элементы разделяются запятыми.

colors = {'red', 'green', 'blue'}
print(colors)  # Вывод: {'red', 'green', 'blue'}

Вы можете использовать множества для выполнения различных операций, таких как объединение, пересечение и разность.

colors1 = {'red', 'green', 'blue'}
colors2 = {'green', 'yellow', 'orange'}
 
# Объединение
all_colors = colors1 | colors2
print(all_colors)  # Вывод: {'red', 'green', 'blue', 'yellow', 'orange'}
 
# Пересечение
common_colors = colors1 & colors2
print(common_colors)  # Вывод: {'green'}
 
# Разность
unique_colors1 = colors1 - colors2
print(unique_colors1)  # Вывод: {'red', 'blue'}

Управляющие структуры

Условные операторы

В Python вы можете использовать условные операторы для управления ходом программы на основе определенных условий.

Оператор if-elif-else - это наиболее распространенный способ реализации условной логики.

age = 25
if age < 18:
    print("Вы несовершеннолетний.")
elif age < 65:
    print("Вы взрослый.")
else:
    print("Вы пенсионер.")

Вы также можете использовать тернарный оператор, который является кратким способом записи простых условных операторов if-else.

is_student = True
status = "Студент" if is_student else "Не студент"
print(status)  # Вывод: "Студент"

Циклы

Циклы в Python позволяют вам повторно выполнять блок кода. Два самых распространенных типа циклов - это циклы for и while.

Цикл for используется для итерации по последовательности, такой как список или строка.

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

Цикл while используется для повторного выполнения блока кода до тех пор, пока определенное условие истинно.

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

Вы также можете использовать операторы break и continue, чтобы управлять ходом ваших циклов.

for i in range(10):
    if i == 5:
        break
    print(i)  # Вывод: 0 1 2 3 4
 
for j in range(10):
    if j % 2 == 0:
        continue
    print(j)  # Вывод: 1 3 5 7 9

Функции

Функции в Python - это блоки повторно используемого кода, выполняющие определенную задачу. Они определяются с помощью ключевого слова def.

def greet(name):
    print(f"Привет, {name}!")
 
greet("Alice")  # Вывод: "Привет, Alice!"

Функции также могут возвращать значения с помощью оператора return.

def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)
print(result)  # Вывод: 7

Вы также можете определить функции со значениями параметров по умолчанию и аргументами переменной длины.

def print_info(name, age=30, *args):
    print(f"Имя: {name}")
    print(f"Возраст: {age}")
    print("Дополнительная информация:")
    for arg in args:
        print(arg)
 
print_info("John", 35, "Инженер-программист", "Любит пешие прогулки")

Модули и пакеты

В Python вы можете организовать свой код в модули и пакеты, чтобы сделать его более модульным и повторно используемым.

Модуль - это один файл Python, содержащий функции, классы и переменные. Вы можете импортировать модули с помощью оператора import.

import math
print(math.pi)  # Вывод: 3.141592653589793

Вы также можете импортировать конкретные элементы из модуля с помощью оператора from.

from math import sqrt
print(sqrt(16))  # Вывод: 4.0

Пакеты - это совокупности связанных модулей. Они организованы в каталоги с файлом __init__.py, который определяет пакет.

my_package/

Затем вы можете импортировать элементы из пакета, используя точечную нотацию.

import my_package.module1
result = my_package.module1.my_function()

Обработка исключений

Механизм обработки исключений Python позволяет обрабатывать ошибки времени выполнения и непредвиденные ситуации в вашем коде.

Вы можете использовать оператор try-except для перехвата и обработки исключений.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Ошибка: деление на ноль")

Также вы можете обрабатывать несколько исключений и предоставить блок except по умолчанию.

try:
    num = int(input("Введите число: "))
    print(10 / num)
except ValueError:
    print("Ошибка: неверный ввод")
except ZeroDivisionError:
    print("Ошибка: деление на ноль")
except:
    print("Произошла неизвестная ошибка")

Также вы можете вызывать свои собственные исключения с помощью оператора raise.

def withdraw(balance, amount):
    if amount > balance:
        raise ValueError("Недостаточно средств")
    return balance - amount
 
try:
    new_balance = withdraw(100, 150)
except ValueError as e:
    print(e)

Заключение

В этом руководстве вы узнали о различных структурах данных, операторах управления потоком, функциях, модулях и обработке исключений в Python. Эти концепции являются важными для создания более сложных и надежных приложений на Python. Помните, что важно практиковаться и экспериментировать с предоставленными примерами, чтобы укрепить свое понимание этих тем.

MoeNagy Dev```