Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHESPTRUFRDEEN

Elysia Tools

Navegación

Python

Archivos Python: nombres, protecciones y límites

Examine nombres y control sin leer ni cambiar archivos.

Ejemplos

Entradas de esta colección

CódigopythonSimple

Lectura/Escritura de Archivos de Texto

Leer y escribir archivos de texto con varias opciones de codificación usando Python file I/O

Dificultad

4/10

Tiempo estimado

20 min

Etiquetas

python, web, file operations

Requisitos previos

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 }
CódigopythonIntermedio

Copiar/Mover Archivos

Copiar y mover archivos con seguimiento de progreso y manejo de errores en el navegador

Dificultad

6/10

Tiempo estimado

25 min

Etiquetas

python, web, file operations

Requisitos previos

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 }
CódigopythonComplejo

Recorrido de Directorio

Atravesar directorios usando os.walk, glob patterns y pathlib

Dificultad

7/10

Tiempo estimado

30 min

Etiquetas

python, web, file operations, directory

Requisitos previos

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 }

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Guía de uso de la herramienta

Contexto para entender esta colección de ejemplos

Resumen

Tarjeta de texto para metadatos del nombre, copia/movimiento para guardas o comparación, recorrido para límites. Solo nombres, tamaños y supuestos sintéticos: no se copia, mueve, elimina ni enumera nada.

Elegir la tarjeta según la pregunta

No ejecute demos completas sobre archivos de trabajo. Los helpers pueden crear, sobrescribir o borrar; safe no garantiza atomicidad, permisos ni ausencia de sobrescritura.

Elegir la tarjeta según la pregunta
TarjetaQué examinar
Lectura/Escritura de Archivos de TextoSeparar el último sufijo sin abrir archivos
Copiar/Mover ArchivosLeer la protección del destino existente
Recorrido de DirectorioReconocer un nodo truncado por profundidad

Cómo funciona

  1. 1Lea la función indicada en la página y siga las entradas en papel. Son ejercicios de lectura de código, no resultados de un ejecutor del navegador. Para ejecutarla después, copie solo el helper elegido a un proyecto de prueba separado.

Casos límite y errores frecuentes

  • Alcance de los ejemplos

    Las tarjetas completas pueden necesitar importaciones, dependencias y correcciones de integración. Una traza correcta no valida toda la demostración. No ejecute el programa completo solo para examinar estos valores.

Ejemplos

1. Separar el último sufijo sin abrir archivos

Cómo usarlo

En Lectura/Escritura de Archivos de Texto, siga get_file_extension y get_file_name_without_extension para el nombre sintético archive.tar.gz. Use solo la cadena del nombre.

Resultado

Extensión: ".gz"; nombre restante: "archive.tar". Solo se elimina el último sufijo; no se examinan bytes gzip ni contenido.

2. Leer la protección del destino existente

Cómo usarlo

En Copiar/Mover Archivos, examine safe_copy. Suponga en papel fuente existente y archivo, controles de padres correctos y destino existente. No llame al sistema de archivos.

Resultado

Imprime advertencia y devuelve False. No se alcanza la copia. La comprobación previa no garantiza ausencia de carreras; otro proceso puede cambiar el destino después.

3. Reconocer un nodo truncado por profundidad

Cómo usarlo

En Recorrido de Directorio, examine list_directory_tree / build_tree con depth=2, max_depth=1 y ruta ficticia root/child/grandchild. Deténgase en la guarda inicial.

Resultado

depth > límite devuelve solo name="grandchild" y children vacío. Faltan ruta y tipo: es un nodo truncado, no prueba de directorio vacío.

Tema

Ajuste de codificación de imágenes para peso, carga y entrega

Ajusta la profundidad de bits, la paleta y la transparencia del PNG, elige la carga progresiva o de línea base del JPEG, configura los modos de calidad de WebP y comprime el TIFF de archivo hasta que cada imagen quepa en su destino.

Tema

Simulacro de restauración de archivos de respaldo y evidencias

Define un simulacro acotado, inspecciona una copia ZIP, recupera archivos seleccionados y registra hashes de referencia, uso en aplicaciones, tiempos y fallos pendientes.

Tema

Conversión de formatos para entrega de video: audio, streams, GIF, WebM y MP4

Define el destino de entrega, extrae solo el stream necesario y convierte animaciones breves, dejando constancia de la compatibilidad, la calidad y el tamaño resultantes.

Tema

Verificación de firmas separadas e integridad de archivos

Calcula o reproduce el hash de un archivo conocido, compáralo con un checksum publicado y verifica una firma Ed25519 separada con una clave pública cuya confianza se confirmó por otra vía.

Inicio
Herramientas3216
Ejemplos593
Visualizaciones473
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web194

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Media

Convertidor de MOV a MP4

Convierte archivos de video MOV a formato MP4

Media

Convertidor de MP4 a MOV

Convierte archivos de video MP4 a formato MOV

Media

Remux inteligente

Reenvuelve contenedores con stream copy.

Media

Conversor de Video en Lote

Convierte múltiples archivos de video entre diferentes formatos como MP4, WebM, MKV, AVI, MOV con configuración de calidad y procesamiento por lotes

Media

Video a GIF Optimizado

Convierte videos a formato GIF optimizado con configuración avanzada de compresión

Media

Cortador de Video

Cortar y recortar clips de video con precisión, soportando múltiples formatos y configuraciones de calidad

Media

Volteo Horizontal de Video

Refleja el video de izquierda a derecha, conservando formato contenedor y audio cuando sea posible

Media

Extractor de Streams de Video

Detecta streams primero y extrae audio, video sin audio o ambos sin transcodificar

Go

Ejemplos de Operaciones de Archivo Web Go

Ejemplos de operaciones de archivo Web Go incluyendo lectura/escritura de archivos de texto, copiar/mover, recorrido de directorio y validación de archivos

Rust

Ejemplos de Operaciones de Archivo Web Rust

Ejemplos de operaciones de archivo Web Rust incluyendo lectura/escritura de archivos de texto, copiar/mover, recorrido de directorio y validación de archivos

TypeScript

Ejemplos de Operaciones de Archivo Web TypeScript

Ejemplos de operaciones de archivo Web TypeScript incluyendo lectura/escritura de archivos de texto, copiar/mover, recorrido de directorio y validación de archivos

Java

Ejemplos de Operaciones de Archivos Android Java

Ejemplos de operaciones de archivos Android Java incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos

Kotlin

Ejemplos de Operaciones de Archivos Android Kotlin

Ejemplos de operaciones de archivos Android Kotlin incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos

Objective-C

Ejemplos de Operaciones de Archivos macOS Objective-C

Ejemplos de operaciones de archivos macOS Objective-C incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos