راهنمای سیستم فایل پایتون: 10 عملیات ضروری با مثال کد [2024]

from pathlib import Path

# Create and manage paths
base_dir = Path('/home/user/documents')
file_path = base_dir / 'data' / 'report.txt'

# File operations
file_path.write_text('Hello World')
content = file_path.read_text()
stats = file_path.stat()

# Directory operations
new_dir = base_dir / 'new_folder'
new_dir.mkdir(parents=True, exist_ok=True)

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import time

class ChangeHandler(FileSystemEventHandler):
    def on_modified(self, event):
        if not event.is_directory:
            print(f"Modified: {event.src_path}")

    def on_created(self, event):
        print(f"Created: {event.src_path}")

observer = Observer()
observer.schedule(ChangeHandler(), ".", recursive=True)
observer.start()

try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    observer.stop()
observer.join()

import mmap
import os

def process_large_file(filename):
    with open(filename, 'r+b') as f:
        mm = mmap.mmap(f.fileno(), 0)
        # Process file in chunks
        chunk_size = 1024 * 1024  # 1MB chunks
        for i in range(0, len(mm), chunk_size):
            chunk = mm[i:i + chunk_size]
            # Process chunk
        mm.close()

import tempfile
import shutil

with tempfile.TemporaryDirectory() as temp_dir:
    temp_path = Path(temp_dir) / 'temp_file.txt'
    temp_path.write_text('Temporary data')
    # Process data
    # Directory and contents automatically cleaned up

with tempfile.NamedTemporaryFile(delete=False) as temp_file:
    temp_file.write(b'Binary data')
    temp_path = temp_file.name

# Manual cleanup when needed
Path(temp_path).unlink()

import shutil

# Copy operations
shutil.copy2('source.txt', 'destination.txt')
shutil.copytree('source_dir', 'backup_dir')

# Move operations
shutil.move('old_location.txt', 'new_location.txt')

# Remove directory tree
shutil.rmtree('temp_directory')

# Disk usage
total, used, free = shutil.disk_usage('/')

import fsspec

# Local filesystem
with fsspec.open('file://path/to/local/file.txt', 'w') as f:
    f.write('Local file content')

# S3 storage
with fsspec.open('s3://bucket/file.txt', 'rb') as f:
    content = f.read()

# HTTP filesystem
with fsspec.open('https://example.com/data.json') as f:
    data = f.read()

from fs import open_fs

# Create filesystem objects
local_fs = open_fs('.')
memory_fs = open_fs('mem://')

# Copy between filesystems
fs.copy.copy_file(
    local_fs, 'source.txt',
    memory_fs, 'destination.txt'
)

# List directory contents
for path in local_fs.walk.files():
    print(path)

from pathlib import Path
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import shutil
import time
import hashlib

class SyncHandler(FileSystemEventHandler):
    def __init__(self, source_dir, backup_dir):
        self.source_dir = Path(source_dir)
        self.backup_dir = Path(backup_dir)

    def get_file_hash(self, path):
        with open(path, 'rb') as f:
            return hashlib.md5(f.read()).hexdigest()

    def sync_file(self, src_path):
        rel_path = Path(src_path).relative_to(self.source_dir)
        dest_path = self.backup_dir / rel_path

        if not dest_path.parent.exists():
            dest_path.parent.mkdir(parents=True)

        if not dest_path.exists() or \
           self.get_file_hash(src_path) != self.get_file_hash(dest_path):
            shutil.copy2(src_path, dest_path)
            print(f"Synced: {rel_path}")

    def on_modified(self, event):
        if not event.is_directory:
            self.sync_file(event.src_path)

def start_sync(source_dir, backup_dir):
    handler = SyncHandler(source_dir, backup_dir)
    observer = Observer()
    observer.schedule(handler, source_dir, recursive=True)
    observer.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

from contextlib import contextmanager
import os
import errno

@contextmanager
def safe_file_operation(path):
    temp_path = path + '.tmp'
    try:
        yield temp_path
        # Atomic operation on most systems
        os.replace(temp_path, path)
    except Exception as e:
        if os.path.exists(temp_path):
            os.unlink(temp_path)
        if isinstance(e, OSError) and e.errno == errno.ENOSPC:
            raise RuntimeError("No space left on device")
        raise

def write_data_safely(path, data):
    with safe_file_operation(path) as temp_path:
        with open(temp_path, 'w') as f:
            f.write(data)

import os
import platform

def get_app_data_dir():
    system = platform.system().lower()
    if system == 'windows':
        base_dir = os.environ.get('APPDATA')
    elif system == 'darwin':
        base_dir = os.path.expanduser('~/Library/Application Support')
    else:
        base_dir = os.path.expanduser('~/.local/share')

    app_dir = os.path.join(base_dir, 'myapp')
    os.makedirs(app_dir, exist_ok=True)
    return app_dir