Elysia Tools

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

Популярные категории

Темы

Язык
ZHESPTRUFRDEEN

Elysia Tools

Навигация

Python

Примеры Файловых Операций Web Python

Примеры файловых операций Web Python включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов

Примеры

Элементы этой коллекции

КодpythonПростой

Чтение/Запись Текстовых Файлов

Чтение и запись текстовых файлов с различными опциями кодирования используя Python файл I/O

Сложность

4/10

Оценка времени

20 min

Теги

python, web, file operations

Предварительные условия

Basic Python, File I/O

python
# Web Python Text File Read/Write Examples
# Using Python file I/O for browser-based file operations (Pyodide)

# 1. Reading Text Files
def read_text_file(file_path):
    """
    Read a text file and return its content

    Args:
        file_path: Path to the text file

    Returns:
        str: Content of the file
    """
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found")
        return None
    except IOError as e:
        print(f"Error reading file: {e}")
        return None

def read_text_file_with_encoding(file_path, encoding='utf-8'):
    """
    Read a text file with specific encoding

    Args:
        file_path: Path to the text file
        encoding: Character encoding (default: utf-8)

    Returns:
        str: Content of the file
    """
    try:
        with open(file_path, 'r', encoding=encoding) as file:
            content = file.read()
        return content
    except UnicodeDecodeError:
        print(f"Error: Cannot decode file with {encoding} encoding")
        return None

def read_text_file_line_by_line(file_path):
    """
    Read a text file line by line

    Args:
        file_path: Path to the text file

    Returns:
        list: List of lines
    """
    lines = []
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            for line in file:
                lines.append(line.rstrip('\n'))
        return lines
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found")
        return None

def read_text_file_in_chunks(file_path, chunk_size=1024):
    """
    Read a text file in chunks (useful for large files)

    Args:
        file_path: Path to the text file
        chunk_size: Size of each chunk in bytes

    Yields:
        str: Chunks of text
    """
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            while True:
                chunk = file.read(chunk_size)
                if not chunk:
                    break
                yield chunk
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found")
        return

# 2. Writing Text Files
def write_text_file(file_path, content):
    """
    Write text content to a file

    Args:
        file_path: Path to the text file
        content: Text content to write

    Returns:
        bool: True if successful
    """
    try:
        with open(file_path, 'w', encoding='utf-8') as file:
            file.write(content)
        return True
    except IOError as e:
        print(f"Error writing file: {e}")
        return False

def write_text_lines(file_path, lines):
    """
    Write a list of lines to a text file

    Args:
        file_path: Path to the text file
        lines: List of strings to write

    Returns:
        bool: True if successful
    """
    try:
        with open(file_path, 'w', encoding='utf-8') as file:
            for line in lines:
                file.write(line + '\n')
        return True
    except IOError as e:
        print(f"Error writing file: {e}")
        return False

def write_text_file_with_encoding(file_path, content, encoding='utf-8'):
    """
    Write text content to a file with specific encoding

    Args:
        file_path: Path to the text file
        content: Text content to write
        encoding: Character encoding

    Returns:
        bool: True if successful
    """
    try:
        with open(file_path, 'w', encoding=encoding) as file:
            file.write(content)
        return True
    except IOError as e:
        print(f"Error writing file: {e}")
        return False

def append_to_text_file(file_path, content):
    """
    Append text content to an existing file

    Args:
        file_path: Path to the text file
        content: Text content to append

    Returns:
        bool: True if successful
    """
    try:
        with open(file_path, 'a', encoding='utf-8') as file:
            file.write(content)
        return True
    except IOError as e:
        print(f"Error appending to file: {e}")
        return False

# 3. File Info Helper
def get_file_size(file_path):
    """
    Get the size of a file in bytes

    Args:
        file_path: Path to the file

    Returns:
        int: File size in bytes
    """
    import os
    try:
        return os.path.getsize(file_path)
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found")
        return None

def get_file_extension(file_path):
    """
    Get the file extension

    Args:
        file_path: Path to the file

    Returns:
        str: File extension
    """
    import os
    return os.path.splitext(file_path)[1]

def get_file_name_without_extension(file_path):
    """
    Get the file name without extension

    Args:
        file_path: Path to the file

    Returns:
        str: File name without extension
    """
    import os
    return os.path.splitext(os.path.basename(file_path))[0]

def format_file_size(bytes_size):
    """
    Format file size in human-readable format

    Args:
        bytes_size: Size in bytes

    Returns:
        str: Formatted size string
    """
    for unit in ['B', 'KB', 'MB', 'GB']:
        if bytes_size < 1024.0:
            return f"{bytes_size:.2f} {unit}"
        bytes_size /= 1024.0
    return f"{bytes_size:.2f} TB"

def get_file_details(file_path):
    """
    Get detailed information about a file

    Args:
        file_path: Path to the file

    Returns:
        dict: File details
    """
    import os
    from datetime import datetime

    try:
        stat_info = os.stat(file_path)
        return {
            'name': os.path.basename(file_path),
            'size': stat_info.st_size,
            'readable_size': format_file_size(stat_info.st_size),
            'extension': get_file_extension(file_path),
            'modified_time': datetime.fromtimestamp(stat_info.st_mtime),
            'created_time': datetime.fromtimestamp(stat_info.st_ctime),
            'is_file': os.path.isfile(file_path),
            'is_dir': os.path.isdir(file_path)
        }
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found")
        return None

# 4. File Validation
def file_exists(file_path):
    """
    Check if a file exists

    Args:
        file_path: Path to the file

    Returns:
        bool: True if file exists
    """
    import os
    return os.path.exists(file_path)

def is_file(file_path):
    """
    Check if path is a file

    Args:
        file_path: Path to check

    Returns:
        bool: True if it's a file
    """
    import os
    return os.path.isfile(file_path)

def is_directory(dir_path):
    """
    Check if path is a directory

    Args:
        dir_path: Path to check

    Returns:
        bool: True if it's a directory
    """
    import os
    return os.path.isdir(dir_path)

def validate_file(file_path, max_size_mb=None):
    """
    Validate file properties

    Args:
        file_path: Path to the file
        max_size_mb: Maximum file size in MB

    Returns:
        dict: Validation result
    """
    import os
    result = {'valid': True, 'errors': []}

    if not os.path.exists(file_path):
        result['valid'] = False
        result['errors'].append('File does not exist')
        return result

    if not os.path.isfile(file_path):
        result['valid'] = False
        result['errors'].append('Path is not a file')
        return result

    if max_size_mb:
        size_mb = os.path.getsize(file_path) / (1024 * 1024)
        if size_mb > max_size_mb:
            result['valid'] = False
            result['errors'].append(f'File size ({size_mb:.2f}MB) exceeds limit ({max_size_mb}MB)')

    return result

# 5. Batch File Operations
def read_multiple_files(file_paths):
    """
    Read multiple text files

    Args:
        file_paths: List of file paths

    Returns:
        dict: Map of file paths to their contents
    """
    results = {}
    for file_path in file_paths:
        content = read_text_file(file_path)
        if content is not None:
            results[file_path] = content
    return results

def batch_write_files(file_data_map):
    """
    Write to multiple files

    Args:
        file_data_map: Dictionary mapping file paths to content

    Returns:
        tuple: (successful_files, failed_files)
    """
    import os
    successful = []
    failed = []

    for file_path, content in file_data_map.items():
        if write_text_file(file_path, content):
            successful.append(file_path)
        else:
            failed.append(file_path)

    return successful, failed

def search_in_files(file_paths, search_text, case_sensitive=False):
    """
    Search for text in multiple files

    Args:
        file_paths: List of file paths
        search_text: Text to search for
        case_sensitive: Whether search is case sensitive

    Returns:
        dict: Files with their matching lines
    """
    results = {}

    for file_path in file_paths:
        lines = read_text_file_line_by_line(file_path)
        if lines:
            matching_lines = []
            for i, line in enumerate(lines, 1):
                search_line = line if case_sensitive else line.lower()
                search_term = search_text if case_sensitive else search_text.lower()

                if search_term in search_line:
                    matching_lines.append({'line_number': i, 'content': line})

            if matching_lines:
                results[file_path] = matching_lines

    return results

# 6. File Encoding Utilities
def detect_file_encoding(file_path, encodings=['utf-8', 'latin-1', 'cp1252']):
    """
    Detect file encoding by trying different encodings

    Args:
        file_path: Path to the file
        encodings: List of encodings to try

    Returns:
        str: Detected encoding or None
    """
    for encoding in encodings:
        try:
            with open(file_path, 'r', encoding=encoding) as file:
                file.read(1024)  # Try reading first 1KB
            return encoding
        except (UnicodeDecodeError, IOError):
            continue
    return None

def convert_file_encoding(input_path, output_path, from_encoding, to_encoding='utf-8'):
    """
    Convert file from one encoding to another

    Args:
        input_path: Input file path
        output_path: Output file path
        from_encoding: Source encoding
        to_encoding: Target encoding

    Returns:
        bool: True if successful
    """
    try:
        with open(input_path, 'r', encoding=from_encoding) as input_file:
            content = input_file.read()

        with open(output_path, 'w', encoding=to_encoding) as output_file:
            output_file.write(content)

        return True
    except Exception as e:
        print(f"Error converting file: {e}")
        return False

# Usage Examples
def demonstrate_text_file_operations():
    print("=== Web Python Text File Read/Write Examples ===\n")

    # 1. Read text file
    print("--- 1. Read Text File ---")
    content = read_text_file("example.txt")
    if content:
        print(f"Content length: {len(content)} characters")

    # 2. Read line by line
    print("\n--- 2. Read Line by Line ---")
    lines = read_text_file_line_by_line("example.txt")
    if lines:
        print(f"Number of lines: {len(lines)}")
        print("First 3 lines:", lines[:3])

    # 3. Write text file
    print("\n--- 3. Write Text File ---")
    if write_text_file("output.txt", "Hello, World!\nThis is a new file."):
        print("File written successfully")

    # 4. Write lines
    print("\n--- 4. Write Lines ---")
    lines_to_write = ["Line 1", "Line 2", "Line 3"]
    if write_text_lines("lines.txt", lines_to_write):
        print("Lines file written successfully")

    # 5. Get file details
    print("\n--- 5. File Details ---")
    details = get_file_details("example.txt")
    if details:
        print(f"Name: {details['name']}")
        print(f"Size: {details['readable_size']}")
        print(f"Extension: {details['extension']}")

    # 6. File validation
    print("\n--- 6. File Validation ---")
    validation = validate_file("example.txt", max_size_mb=1)
    print(f"Valid: {validation['valid']}")

    print("\n=== All Text File Operations Completed ===")

# Export functions
# export { read_text_file, read_text_file_with_encoding, read_text_file_line_by_line, read_text_file_in_chunks }
# export { write_text_file, write_text_lines, write_text_file_with_encoding, append_to_text_file }
# export { get_file_size, get_file_extension, get_file_name_without_extension, format_file_size, get_file_details }
# export { file_exists, is_file, is_directory, validate_file }
# export { read_multiple_files, batch_write_files, search_in_files }
# export { detect_file_encoding, convert_file_encoding }
# export { demonstrate_text_file_operations }
КодpythonСредний

Копирование/Перемещение Файлов

Копирование и перемещение файлов с отслеживанием прогресса и обработкой ошибок в браузере

Сложность

6/10

Оценка времени

25 min

Теги

python, web, file operations

Предварительные условия

Intermediate Python, shutil module

python
# Web Python File Copy/Move Examples
# Browser-based file operations using Python

# 1. File Copy Operations
import shutil
import os

def copy_file(source_path, destination_path):
    """
    Copy a file from source to destination

    Args:
        source_path: Path to source file
        destination_path: Path to destination

    Returns:
        bool: True if successful
    """
    try:
        shutil.copy2(source_path, destination_path)
        return True
    except FileNotFoundError:
        print(f"Error: Source file '{source_path}' not found")
        return False
    except PermissionError:
        print(f"Error: Permission denied")
        return False
    except IOError as e:
        print(f"Error copying file: {e}")
        return False

def copy_file_with_metadata(source_path, destination_path):
    """
    Copy file preserving metadata

    Args:
        source_path: Path to source file
        destination_path: Path to destination

    Returns:
        bool: True if successful
    """
    try:
        shutil.copy2(source_path, destination_path)

        # Preserve timestamps
        stat_info = os.stat(source_path)
        os.utime(destination_path, (stat_info.st_atime, stat_info.st_mtime))

        return True
    except Exception as e:
        print(f"Error copying file with metadata: {e}")
        return False

def copy_directory(source_dir, destination_dir):
    """
    Copy entire directory recursively

    Args:
        source_dir: Source directory path
        destination_dir: Destination directory path

    Returns:
        bool: True if successful
    """
    try:
        shutil.copytree(source_dir, destination_dir)
        return True
    except FileNotFoundError:
        print(f"Error: Source directory '{source_dir}' not found")
        return False
    except FileExistsError:
        print(f"Error: Destination directory '{destination_dir}' already exists")
        return False
    except Exception as e:
        print(f"Error copying directory: {e}")
        return False

def copy_directory_with_progress(source_dir, destination_dir, callback=None):
    """
    Copy directory with progress callback

    Args:
        source_dir: Source directory path
        destination_dir: Destination directory path
        callback: Progress callback function

    Returns:
        bool: True if successful
    """
    try:
        # Count total files first
        total_files = sum(len(files) for _, _, files in os.walk(source_dir))
        copied_files = 0

        for root, dirs, files in os.walk(source_dir):
            # Create corresponding directory structure
            rel_path = os.path.relpath(root, source_dir)
            dest_dir = os.path.join(destination_dir, rel_path)

            os.makedirs(dest_dir, exist_ok=True)

            # Copy files
            for file in files:
                source_file = os.path.join(root, file)
                dest_file = os.path.join(dest_dir, file)

                shutil.copy2(source_file, dest_file)
                copied_files += 1

                if callback:
                    callback(copied_files, total_files, file)

        return True
    except Exception as e:
        print(f"Error copying directory with progress: {e}")
        return False

# 2. File Move Operations
def move_file(source_path, destination_path):
    """
    Move a file from source to destination

    Args:
        source_path: Path to source file
        destination_path: Path to destination

    Returns:
        bool: True if successful
    """
    try:
        shutil.move(source_path, destination_path)
        return True
    except FileNotFoundError:
        print(f"Error: Source file '{source_path}' not found")
        return False
    except PermissionError:
        print(f"Error: Permission denied")
        return False
    except Exception as e:
        print(f"Error moving file: {e}")
        return False

def move_directory(source_dir, destination_dir):
    """
    Move directory from source to destination

    Args:
        source_dir: Source directory path
        destination_dir: Destination directory path

    Returns:
        bool: True if successful
    """
    try:
        shutil.move(source_dir, destination_dir)
        return True
    except Exception as e:
        print(f"Error moving directory: {e}")
        return False

def rename_file(old_path, new_path):
    """
    Rename a file

    Args:
        old_path: Current file path
        new_path: New file path

    Returns:
        bool: True if successful
    """
    return move_file(old_path, new_path)

def rename_directory(old_path, new_path):
    """
    Rename a directory

    Args:
        old_path: Current directory path
        new_path: New directory path

    Returns:
        bool: True if successful
    """
    return move_directory(old_path, new_path)

# 3. Batch File Operations
def batch_rename_files(directory, pattern, replacement):
    """
    Batch rename files in a directory

    Args:
        directory: Directory path
        pattern: Pattern to replace (supports regex)
        replacement: Replacement string

    Returns:
        tuple: (renamed_files, failed_files)
    """
    import re
    renamed = []
    failed = []

    try:
        files = os.listdir(directory)

        for file in files:
            old_path = os.path.join(directory, file)

            # Skip directories
            if os.path.isdir(old_path):
                continue

            # Apply regex replacement
            new_name = re.sub(pattern, replacement, file)
            new_path = os.path.join(directory, new_name)

            # Rename file
            try:
                os.rename(old_path, new_path)
                renamed.append((file, new_name))
            except Exception as e:
                print(f"Error renaming {file}: {e}")
                failed.append(file)

        return renamed, failed

    except Exception as e:
        print(f"Error in batch rename: {e}")
        return [], failed

def batch_convert_files(source_files, target_directory, conversion_func):
    """
    Batch convert files (read, process, write)

    Args:
        source_files: List of source file paths
        target_directory: Target directory path
        conversion_func: Function to convert content

    Returns:
        tuple: (converted_files, failed_files)
    """
    import os

    os.makedirs(target_directory, exist_ok=True)

    converted = []
    failed = []

    for source_file in source_files:
        try:
            # Read source file
            with open(source_file, 'r', encoding='utf-8') as f:
                content = f.read()

            # Apply conversion
            converted_content = conversion_func(content)

            # Write to target
            file_name = os.path.basename(source_file)
            target_file = os.path.join(target_directory, file_name)

            with open(target_file, 'w', encoding='utf-8') as f:
                f.write(converted_content)

            converted.append((source_file, target_file))

        except Exception as e:
            print(f"Error converting {source_file}: {e}")
            failed.append(source_file)

    return converted, failed

# 4. File Synchronization
def sync_directories(source_dir, target_dir):
    """
    Synchronize two directories (copy newer files from source to target)

    Args:
        source_dir: Source directory path
        target_dir: Target directory path

    Returns:
        dict: Sync statistics
    """
    stats = {
        'copied': 0,
        'skipped': 0,
        'failed': 0
    }

    try:
        for root, dirs, files in os.walk(source_dir):
            rel_path = os.path.relpath(root, source_dir)
            dest_dir = os.path.join(target_dir, rel_path)

            os.makedirs(dest_dir, exist_ok=True)

            for file in files:
                source_file = os.path.join(root, file)
                dest_file = os.path.join(dest_dir, file)

                # Check if file exists in target
                if os.path.exists(dest_file):
                    source_mtime = os.path.getmtime(source_file)
                    dest_mtime = os.path.getmtime(dest_file)

                    if source_mtime <= dest_mtime:
                        stats['skipped'] += 1
                        continue

                # Copy newer file
                try:
                    shutil.copy2(source_file, dest_file)
                    stats['copied'] += 1
                except Exception as e:
                    print(f"Error syncing {file}: {e}")
                    stats['failed'] += 1

        return stats

    except Exception as e:
        print(f"Error syncing directories: {e}")
        return stats

# 5. Backup and Restore
def create_backup(source_paths, backup_dir, timestamp=True):
    """
    Create backup of files/directories

    Args:
        source_paths: List of source paths to backup
        backup_dir: Backup directory path
        timestamp: Whether to add timestamp to backup name

    Returns:
        str: Path to backup directory
    """
    from datetime import datetime

    try:
        # Create backup directory name
        if timestamp:
            backup_name = datetime.now().strftime('%Y%m%d_%H%M%S')
            backup_path = os.path.join(backup_dir, f'backup_{backup_name}')
        else:
            backup_path = os.path.join(backup_dir, 'backup')

        os.makedirs(backup_path, exist_ok=True)

        # Copy each source to backup
        for source in source_paths:
            dest = os.path.join(backup_path, os.path.basename(source))

            if os.path.isdir(source):
                shutil.copytree(source, dest, dirs_exist_ok=True)
            else:
                shutil.copy2(source, dest)

        return backup_path

    except Exception as e:
        print(f"Error creating backup: {e}")
        return None

def restore_from_backup(backup_dir, target_dir):
    """
    Restore files from backup directory

    Args:
        backup_dir: Backup directory path
        target_dir: Target directory to restore to

    Returns:
        bool: True if successful
    """
    try:
        if os.path.isdir(backup_dir):
            shutil.copytree(backup_dir, target_dir, dirs_exist_ok=True)
        else:
            shutil.copy2(backup_dir, target_dir)

        return True

    except Exception as e:
        print(f"Error restoring from backup: {e}")
        return False

# 6. Safe File Operations
def safe_copy(source_path, destination_path):
    """
    Copy file with safety checks

    Args:
        source_path: Source file path
        destination_path: Destination file path

    Returns:
        bool: True if successful
    """
    # Validate source
    if not os.path.exists(source_path):
        print(f"Error: Source file '{source_path}' does not exist")
        return False

    if not os.path.isfile(source_path):
        print(f"Error: Source path is not a file")
        return False

    # Check if destination directory exists
    dest_dir = os.path.dirname(destination_path)
    if dest_dir and not os.path.exists(dest_dir):
        try:
            os.makedirs(dest_dir, exist_ok=True)
        except Exception as e:
            print(f"Error creating destination directory: {e}")
            return False

    # Check if destination already exists
    if os.path.exists(destination_path):
        print(f"Warning: Destination file '{destination_path}' already exists")
        return False

    # Perform copy
    return copy_file(source_path, destination_path)

def safe_move(source_path, destination_path):
    """
    Move file with safety checks

    Args:
        source_path: Source file path
        destination_path: Destination file path

    Returns:
        bool: True if successful
    """
    # Validate source
    if not os.path.exists(source_path):
        print(f"Error: Source file '{source_path}' does not exist")
        return False

    if not os.path.isfile(source_path):
        print(f"Error: Source path is not a file")
        return False

    # Check if destination directory exists
    dest_dir = os.path.dirname(destination_path)
    if dest_dir and not os.path.exists(dest_dir):
        try:
            os.makedirs(dest_dir, exist_ok=True)
        except Exception as e:
            print(f"Error creating destination directory: {e}")
            return False

    # Perform move
    return move_file(source_path, destination_path)

# Usage Examples
def demonstrate_file_copy_move():
    print("=== Web Python File Copy/Move Examples ===\n")

    # 1. Copy file
    print("--- 1. Copy File ---")
    if safe_copy("source.txt", "copy.txt"):
        print("File copied successfully")

    # 2. Copy directory
    print("\n--- 2. Copy Directory ---")
    if copy_directory_with_progress(
        "source_dir",
        "backup_dir",
        lambda current, total, file: print(f"Copying {file}: {current}/{total}")
    ):
        print("Directory copied successfully")

    # 3. Move file
    print("\n--- 3. Move File ---")
    if safe_move("old_name.txt", "new_name.txt"):
        print("File moved successfully")

    # 4. Batch rename
    print("\n--- 4. Batch Rename ---")
    renamed, failed = batch_rename_files(".", r"\.(txt)$", ".bak")
    print(f"Renamed {len(renamed)} files")
    print(f"Failed {len(failed)} files")

    # 5. Sync directories
    print("\n--- 5. Sync Directories ---")
    stats = sync_directories("source_dir", "target_dir")
    print(f"Copied: {stats['copied']}, Skipped: {stats['skipped']}, Failed: {stats['failed']}")

    # 6. Backup
    print("\n--- 6. Backup ---")
    backup_path = create_backup(["important_file.txt", "important_dir"], "backups")
    if backup_path:
        print(f"Backup created at: {backup_path}")

    print("\n=== All File Copy/Move Examples Completed ===")

# Export functions
# export { copy_file, copy_file_with_metadata, copy_directory, copy_directory_with_progress }
# export { move_file, move_directory, rename_file, rename_directory }
# export { batch_rename_files, batch_convert_files }
# export { sync_directories }
# export { create_backup, restore_from_backup }
# export { safe_copy, safe_move }
# export { demonstrate_file_copy_move }
КодpythonСложный

Обход Директорий

Обход директорий используя os.walk, glob patterns и pathlib

Сложность

7/10

Оценка времени

30 min

Теги

python, web, file operations, directory

Предварительные условия

Advanced Python, os module, glob

python
# Web Python Directory Traversal Examples
# Using os.walk, glob, and pathlib for directory operations

# 1. Directory Listing with os.walk
def list_directory_contents(directory, recursive=False):
    """
    List contents of a directory

    Args:
        directory: Directory path
        recursive: Whether to list recursively

    Returns:
        dict: Directory contents with files and subdirectories
    """
    import os

    if not os.path.exists(directory):
        print(f"Error: Directory '{directory}' does not exist")
        return None

    result = {
        'directory': directory,
        'files': [],
        'directories': []
    }

    if recursive:
        for root, dirs, files in os.walk(directory):
            for dir_name in dirs:
                full_path = os.path.join(root, dir_name)
                result['directories'].append(full_path)

            for file_name in files:
                full_path = os.path.join(root, file_name)
                result['files'].append(full_path)
    else:
        try:
            with os.scandir(directory) as entries:
                for entry in entries:
                    if entry.is_file():
                        result['files'].append(os.path.join(directory, entry.name))
                    elif entry.is_dir():
                        result['directories'].append(os.path.join(directory, entry.name))
        except Exception as e:
            print(f"Error listing directory: {e}")

    return result

def list_directory_tree(directory, max_depth=None):
    """
    List directory as a tree structure

    Args:
        directory: Root directory path
        max_depth: Maximum depth to traverse (None = unlimited)

    Returns:
        dict: Tree structure
    """
    import os

    def build_tree(path, depth=0):
        if max_depth is not None and depth > max_depth:
            return {'name': os.path.basename(path), 'children': []}

        node = {
            'name': os.path.basename(path),
            'path': path,
            'is_dir': os.path.isdir(path),
            'children': []
        }

        if os.path.isdir(path):
            try:
                entries = sorted(os.listdir(path))
                for entry in entries:
                    child_path = os.path.join(path, entry)
                    child_node = build_tree(child_path, depth + 1)
                    node['children'].append(child_node)
            except PermissionError:
                pass  # Skip directories we can't access

        return node

    return build_tree(directory)

def print_directory_tree(tree, indent=0):
    """
    Print directory tree structure

    Args:
        tree: Tree structure from list_directory_tree
        indent: Indentation level
    """
    prefix = '  ' * indent
    icon = '📁' if tree['is_dir'] else '📄'
    print(f"{prefix}{icon} {tree['name']}")

    for child in tree.get('children', []):
        print_directory_tree(child, indent + 1)

# 2. File Pattern Matching with glob
import glob

def find_files_by_pattern(directory, pattern):
    """
    Find files matching a pattern

    Args:
        directory: Directory to search
        pattern: Glob pattern (e.g., '*.txt', '**/*.py')

    Returns:
        list: List of matching file paths
    """
    search_pattern = os.path.join(directory, pattern)
    return glob.glob(search_pattern, recursive=True)

def find_files_by_extension(directory, extension):
    """
    Find files with specific extension

    Args:
        directory: Directory to search
        extension: File extension (e.g., 'txt', 'py')

    Returns:
        list: List of matching file paths
    """
    pattern = f"*.{extension}"
    return find_files_by_pattern(directory, pattern)

def find_files_by_name(directory, name_pattern):
    """
    Find files by name pattern

    Args:
        directory: Directory to search
        name_pattern: Name pattern (supports wildcards)

    Returns:
        list: List of matching file paths
    """
    import os

    matching_files = []

    for root, dirs, files in os.walk(directory):
        for file in files:
            if fnmatch.fnmatch(file, name_pattern):
                matching_files.append(os.path.join(root, file))

    return matching_files

# 3. Directory Statistics
def get_directory_statistics(directory):
    """
    Get statistics about a directory

    Args:
        directory: Directory path

    Returns:
        dict: Directory statistics
    """
    import os

    stats = {
        'total_files': 0,
        'total_directories': 0,
        'total_size': 0,
        'extension_counts': {},
        'largest_files': []
    }

    try:
        for root, dirs, files in os.walk(directory):
            stats['total_directories'] += len(dirs)

            for file in files:
                file_path = os.path.join(root, file)
                stats['total_files'] += 1

                try:
                    file_size = os.path.getsize(file_path)
                    stats['total_size'] += file_size

                    # Track extensions
                    ext = os.path.splitext(file)[1].lower()
                    stats['extension_counts'][ext] = stats['extension_counts'].get(ext, 0) + 1

                    # Track largest files
                    stats['largest_files'].append((file_path, file_size))

                except OSError:
                    pass

        # Sort largest files
        stats['largest_files'] = sorted(
            stats['largest_files'],
            key=lambda x: x[1],
            reverse=True
        )[:10]

        # Format size
        stats['formatted_size'] = format_file_size(stats['total_size'])

        return stats

    except Exception as e:
        print(f"Error getting directory statistics: {e}")
        return None

def format_file_size(bytes_size):
    """Format file size in human-readable format"""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if bytes_size < 1024.0:
            return f"{bytes_size:.2f} {unit}"
        bytes_size /= 1024.0
    return f"{bytes_size:.2f} TB"

# 4. File Search in Directory
def search_in_directory(directory, search_text, file_pattern='*'):
    """
    Search for text in files within a directory

    Args:
        directory: Directory to search
        search_text: Text to search for
        file_pattern: Pattern to filter files

    Returns:
        dict: Files containing the search text
    """
    import os

    results = {}

    for root, dirs, files in os.walk(directory):
        for file in files:
            if fnmatch.fnmatch(file, file_pattern):
                file_path = os.path.join(root, file)

                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        content = f.read()

                    if search_text in content:
                        # Find line numbers
                        lines = content.split('\n')
                        matches = []
                        for i, line in enumerate(lines, 1):
                            if search_text in line:
                                matches.append(i)

                        results[file_path] = matches

                except (UnicodeDecodeError, IOError):
                    pass  # Skip files that can't be read as text

    return results

def search_in_directory_regex(directory, pattern, file_pattern='*'):
    """
    Search for regex pattern in files within a directory

    Args:
        directory: Directory to search
        pattern: Regular expression pattern
        file_pattern: Pattern to filter files

    Returns:
        dict: Files containing matches
    """
    import os
    import re

    results = {}
    compiled_pattern = re.compile(pattern)

    for root, dirs, files in os.walk(directory):
        for file in files:
            if fnmatch.fnmatch(file, file_pattern):
                file_path = os.path.join(root, file)

                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        content = f.read()

                    matches = []
                    for match in compiled_pattern.finditer(content):
                        matches.append({
                            'start': match.start(),
                            'end': match.end(),
                            'text': match.group()
                        })

                    if matches:
                        results[file_path] = matches

                except (UnicodeDecodeError, IOError):
                    pass

    return results

# 5. Directory Comparison
def compare_directories(dir1, dir2):
    """
    Compare two directories and find differences

    Args:
        dir1: First directory path
        dir2: Second directory path

    Returns:
        dict: Comparison results
    """
    import os
    import filecmp

    result = {
        'only_in_dir1': [],
        'only_in_dir2': [],
        'different': [],
        'same': []
    }

    # Get all files in both directories
    files1 = set()
    files2 = set()

    for root, dirs, files in os.walk(dir1):
        for file in files:
            rel_path = os.path.relpath(os.path.join(root, file), dir1)
            files1.add(rel_path)

    for root, dirs, files in os.walk(dir2):
        for file in files:
            rel_path = os.path.relpath(os.path.join(root, file), dir2)
            files2.add(rel_path)

    # Find files only in dir1
    result['only_in_dir1'] = list(files1 - files2)

    # Find files only in dir2
    result['only_in_dir2'] = list(files2 - files1)

    # Compare common files
    common_files = files1 & files2
    for rel_path in common_files:
        file1 = os.path.join(dir1, rel_path)
        file2 = os.path.join(dir2, rel_path)

        if os.path.isfile(file1) and os.path.isfile(file2):
            if filecmp.cmp(file1, file2, shallow=False):
                result['same'].append(rel_path)
            else:
                result['different'].append(rel_path)

    return result

# 6. Directory Cleanup
def cleanup_directory(directory, dry_run=True, patterns=None):
    """
    Clean up directory by removing files matching patterns

    Args:
        directory: Directory path
        dry_run: If True, only print what would be deleted
        patterns: List of glob patterns to delete

    Returns:
        dict: Cleanup results
    """
    import os

    if patterns is None:
        patterns = ['*.tmp', '*.log', '*.bak', '*~']

    results = {
        'deleted': [],
        'failed': []
    }

    for pattern in patterns:
        search_pattern = os.path.join(directory, pattern)
        files = glob.glob(search_pattern, recursive=True)

        for file in files:
            try:
                if dry_run:
                    print(f"Would delete: {file}")
                    results['deleted'].append(file)
                else:
                    if os.path.isfile(file):
                        os.remove(file)
                    elif os.path.isdir(file):
                        os.rmdir(file)
                    results['deleted'].append(file)
            except Exception as e:
                print(f"Error deleting {file}: {e}")
                results['failed'].append(file)

    return results

def remove_empty_directories(directory, recursive=False):
    """
    Remove empty directories

    Args:
        directory: Directory path
        recursive: Whether to recursively remove empty subdirectories

    Returns:
        int: Number of directories removed
    """
    import os

    removed_count = 0

    if recursive:
        # Process subdirectories first (bottom-up)
        for root, dirs, files in os.walk(directory, topdown=False):
            for dir_name in dirs:
                dir_path = os.path.join(root, dir_name)
                try:
                    os.rmdir(dir_path)
                    removed_count += 1
                    print(f"Removed empty directory: {dir_path}")
                except OSError:
                    pass  # Directory not empty

    # Remove the root directory if it's empty
    try:
        if not os.listdir(directory):
            os.rmdir(directory)
            removed_count += 1
            print(f"Removed empty directory: {directory}")
    except OSError:
        pass

    return removed_count

# Usage Examples
def demonstrate_directory_traversal():
    print("=== Web Python Directory Traversal Examples ===\n")

    # 1. List directory contents
    print("--- 1. List Directory Contents ---")
    contents = list_directory_contents('.')
    if contents:
        print(f"Files: {len(contents['files'])}")
        print(f"Directories: {len(contents['directories'])}")

    # 2. Directory tree
    print("\n--- 2. Directory Tree ---")
    tree = list_directory_tree('.')
    print_directory_tree(tree)

    # 3. Find files by pattern
    print("\n--- 3. Find Files by Pattern ---")
    txt_files = find_files_by_extension('.', 'txt')
    print(f"Text files: {len(txt_files)}")

    # 4. Directory statistics
    print("\n--- 4. Directory Statistics ---")
    stats = get_directory_statistics('.')
    if stats:
        print(f"Total files: {stats['total_files']}")
        print(f"Total size: {stats['formatted_size']}")
        print(f"Extensions: {stats['extension_counts']}")

    # 5. Search in directory
    print("\n--- 5. Search in Directory ---")
    search_results = search_in_directory('.', 'TODO', '*.txt')
    print(f"Files containing 'TODO': {len(search_results)}")

    # 6. Compare directories
    print("\n--- 6. Compare Directories ---")
    comparison = compare_directories('dir1', 'dir2')
    print(f"Only in dir1: {len(comparison['only_in_dir1'])}")
    print(f"Only in dir2: {len(comparison['only_in_dir2'])}")
    print(f"Different: {len(comparison['different'])}")

    # 7. Cleanup
    print("\n--- 7. Cleanup ---")
    cleanup_results = cleanup_directory('.', dry_run=True)
    print(f"Would delete {len(cleanup_results['deleted'])} files")

    print("\n=== All Directory Traversal Examples Completed ===")

# Export functions
# export { list_directory_contents, list_directory_tree, print_directory_tree }
# export { find_files_by_pattern, find_files_by_extension, find_files_by_name }
# export { get_directory_statistics, format_file_size }
# export { search_in_directory, search_in_directory_regex }
# export { compare_directories }
# export { cleanup_directory, remove_empty_directories }
# export { demonstrate_directory_traversal }

Инструменты

Инструменты, которые часто используются с этим примером

Связано

Похожие коллекции примеров

Связано

Похожие темы

Тема

Разрешенный захват webhook и проверка доверия к endpoint

Захватывайте и повторяйте контролируемые webhook-запросы, проверяйте свидетельства доставки и отдельно анализируйте HTTPS-сертификат получателя, не выдавая его валидность за доверие к бизнес-сервису.

Тема

Отладка наблюдаемости по логам, трейсам, webhook и JSON payload

Разберите логи, декодируйте трейсы, проверьте доказательства webhook/API, исследуйте JSON payload и извлеките повторяющиеся паттерны перед заметкой об инциденте.

Тема

Форматы для передачи видео: аудио, потоки, GIF, WebM и MP4

Определите формат по назначению файла, извлеките только нужный аудио- или видеопоток и преобразуйте короткую анимацию, зафиксировав компромиссы по качеству, совместимости и размеру.

Тема

Настройка кодирования изображений под вес, загрузку и доставку

Настройте глубину цвета, палитру и прозрачность PNG, выберите прогрессивную или базовую загрузку JPEG, задайте режимы качества WebP и сожмите архивный TIFF, пока каждое изображение не уложится в бюджет своего назначения.

Главная
Инструменты3206
Примеры593
Визуализации468
Средства просмотра файлов103
Темы236
Теги333
Изображения, аудио и видео657

Инструменты для обработки, конвертации и оптимизации изображений, аудио и видео

Математика, даты и финансы645

Калькуляторы, числовые инструменты, логика дат, статистика и финансы

Дизайн и цвет298

Инструменты для цвета, макетов, графики, визуального стиля и дизайна

Текст и письмо209

Инструменты для письма, очистки, форматирования, извлечения и анализа текста

Разработка и Web193

Инструменты разработчика, сетевые утилиты, веб-отладка и автоматизация

Преобразование и кодирование175

Инструменты для преобразования форматов, файлов, архивов, единиц и кодировок

Из статьи в черновики X и LinkedIn: проверка фактов и передача
Проверка интерактивного Markdown-урока и автономная передача
Проверка расстановки мебели в маленькой комнате и план переезда
Проверка источников FLAC/WAV и передача доказательств
Проверка и передача виджета розыгрыша для собственного хостинга

© 2026 Elysia Tools. Все права защищены.

ДокументацияТарифыО насУсловия использованияПолитика конфиденциальностиCookieКонтакты

Media

Конвертер MOV в MP4

Конвертирует видеофайлы MOV в формат MP4

Media

Конвертер MP4 в MOV

Конвертирует видеофайлы MP4 в формат MOV

Media

Умный remux

Перепаковывает контейнеры через stream copy.

Media

Пакетный Конвертер Видео

Конвертируйте несколько видеофайлов между различными форматами, такими как MP4, WebM, MKV, AVI, MOV с настройками качества и пакетной обработкой

Media

Видео в GIF Оптимизированный

Конвертирует видео в оптимизированный формат GIF с расширенными настройками сжатия

Media

Редактор Видео

Точная нарезка и обрезка видеоклипов с поддержкой различных форматов и настроек качества

Media

Горизонтальный Флип Видео

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

Media

Извлечение Потоков Видео

Сначала проверяет потоки, затем извлекает аудио, видео без аудио или оба без перекодирования

Go

Примеры Файловых Операций Web Go

Примеры файловых операций Web Go включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов

Rust

Примеры Файловых Операций Web Rust

Примеры файловых операций Web Rust включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов

TypeScript

Примеры Файловых Операций Web TypeScript

Примеры файловых операций Web TypeScript включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов

Java

Примеры Файловых Операций Android Java

Примеры файловых операций Android Java включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов

Kotlin

Примеры Файловых Операций Android Kotlin

Примеры файловых операций Android Kotlin включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов

Objective-C

Примеры Файловых Операций macOS Objective-C

Примеры файловых операций macOS Objective-C включая чтение/запись текстовых файлов, копирование/перемещение, обход директорий и валидацию файлов