import os

def list_directory_basic(directory_path):
    """
    基礎(chǔ)目錄列表函數(shù)
    """
    try:
        # 獲取目錄內(nèi)容列表
        contents = os.listdir(directory_path)
        print(f"目錄 '{directory_path}' 中的內(nèi)容:")
        
        for item in contents:
            # 獲取完整路徑
            full_path = os.path.join(directory_path, item)
            
            # 判斷是文件還是目錄
            if os.path.isfile(full_path):
                print(f"  文件: {item}")
            elif os.path.isdir(full_path):
                print(f"  目錄: {item}/")
            else:
                print(f"  其他: {item}")
                
        return contents
        
    except FileNotFoundError:
        print(f"錯(cuò)誤: 目錄 '{directory_path}' 不存在")
        return []
    except PermissionError:
        print(f"錯(cuò)誤: 沒有權(quán)限訪問目錄 '{directory_path}'")
        return []
    except NotADirectoryError:
        print(f"錯(cuò)誤: '{directory_path}' 不是目錄")
        return []

# 使用示例
directory_path = "/path/to/directory"
contents = list_directory_basic(directory_path)

import os

def categorize_directory_contents(directory_path):
    """
    分類返回目錄內(nèi)容
    """
    try:
        items = os.listdir(directory_path)
        
        # 使用列表推導(dǎo)式進(jìn)行分類
        files = [item for item in items 
                if os.path.isfile(os.path.join(directory_path, item))]
        
        directories = [item for item in items 
                      if os.path.isdir(os.path.join(directory_path, item))]
        
        other_items = [item for item in items 
                      if not os.path.isfile(os.path.join(directory_path, item)) and 
                         not os.path.isdir(os.path.join(directory_path, item))]
        
        return {
            'files': files,
            'directories': directories,
            'other': other_items
        }
        
    except OSError as e:
        print(f"訪問目錄時(shí)出錯(cuò): {e}")
        return {'files': [], 'directories': [], 'other': []}

# 使用示例
contents = categorize_directory_contents("/tmp")
print("文件:", contents['files'])
print("目錄:", contents['directories'])
print("其他:", contents['other'])

import os

def recursive_directory_walk(root_dir):
    """
    遞歸遍歷目錄樹
    """
    file_count = 0
    dir_count = 0
    
    print(f"開始遍歷: {root_dir}")
    print("-" * 50)
    
    for root, dirs, files in os.walk(root_dir):
        # 當(dāng)前目錄級(jí)別
        level = root.replace(root_dir, '').count(os.sep)
        indent = '  ' * level
        
        print(f"{indent}{os.path.basename(root)}/")
        
        # 處理子目錄
        sub_indent = '  ' * (level + 1)
        for directory in dirs:
            print(f"{sub_indent}{directory}/")
            dir_count += 1
        
        # 處理文件
        for file in files:
            file_path = os.path.join(root, file)
            file_size = os.path.getsize(file_path)
            print(f"{sub_indent}{file} ({file_size} bytes)")
            file_count += 1
    
    print("-" * 50)
    print(f"遍歷完成: 找到 {dir_count} 個(gè)目錄, {file_count} 個(gè)文件")

# 使用示例
recursive_directory_walk("/path/to/directory")

import os
from datetime import datetime

def scan_directory_efficient(directory_path):
    """
    使用os.scandir()高效掃描目錄
    """
    try:
        with os.scandir(directory_path) as entries:
            print(f"目錄 '{directory_path}' 內(nèi)容:")
            print("-" * 60)
            
            for entry in entries:
                # 獲取文件信息
                if entry.is_file():
                    file_type = "文件"
                    size = entry.stat().st_size
                    size_str = f"{size} bytes"
                elif entry.is_dir():
                    file_type = "目錄"
                    size_str = "<DIR>"
                else:
                    file_type = "其他"
                    size_str = "N/A"
                
                # 獲取修改時(shí)間
                mod_time = datetime.fromtimestamp(entry.stat().st_mtime)
                mod_time_str = mod_time.strftime("%Y-%m-%d %H:%M:%S")
                
                print(f"{file_type:8} {entry.name:30} {size_str:12} {mod_time_str}")
                
    except FileNotFoundError:
        print(f"錯(cuò)誤: 目錄不存在")
    except PermissionError:
        print(f"錯(cuò)誤: 沒有訪問權(quán)限")

# 使用示例
scan_directory_efficient("/path/to/directory")

from pathlib import Path

def list_directory_pathlib(directory_path):
    """
    使用pathlib列出目錄內(nèi)容
    """
    path = Path(directory_path)
    
    if not path.exists():
        print(f"錯(cuò)誤: 路徑 '{directory_path}' 不存在")
        return
    
    if not path.is_dir():
        print(f"錯(cuò)誤: '{directory_path}' 不是目錄")
        return
    
    print(f"目錄 '{directory_path}' 內(nèi)容:")
    print("-" * 50)
    
    # 獲取所有條目
    for item in path.iterdir():
        if item.is_file():
            file_type = "文件"
            size = item.stat().st_size
            info = f"{size} bytes"
        elif item.is_dir():
            file_type = "目錄"
            info = "包含項(xiàng)目"
        else:
            file_type = "其他"
            info = "特殊文件"
        
        print(f"{file_type:6} {item.name:25} {info}")

# 使用示例
list_directory_pathlib("/path/to/directory")

import os
from pathlib import Path
from datetime import datetime, timedelta

class AdvancedDirectoryFilter:
    """
    高級(jí)目錄內(nèi)容過濾器
    """
    
    @staticmethod
    def filter_files(directory, **filters):
        """
        根據(jù)多種條件過濾文件
        """
        path = Path(directory)
        if not path.exists() or not path.is_dir():
            return []
        
        results = []
        for item in path.iterdir():
            if not item.is_file():
                continue
            
            stat = item.stat()
            matches = True
            
            # 應(yīng)用過濾器
            if 'min_size' in filters and stat.st_size < filters['min_size']:
                matches = False
            if 'max_size' in filters and stat.st_size > filters['max_size']:
                matches = False
            if 'extension' in filters and not item.suffix.lower() == filters['extension'].lower():
                matches = False
            if 'min_age_days' in filters:
                file_time = datetime.fromtimestamp(stat.st_mtime)
                if file_time > datetime.now() - timedelta(days=filters['min_age_days']):
                    matches = False
            
            if matches:
                results.append(item)
        
        return results
    
    @staticmethod
    def find_files_by_pattern(directory, pattern, recursive=False):
        """
        使用通配符模式查找文件
        """
        path = Path(directory)
        
        if recursive:
            return list(path.rglob(pattern))
        else:
            return list(path.glob(pattern))

# 使用示例
filterer = AdvancedDirectoryFilter()

# 查找所有.log文件
log_files = filterer.find_files_by_pattern("/var/log", "*.log", recursive=True)

# 查找大于1MB的文件
large_files = filterer.filter_files("/tmp", min_size=1024 * 1024)

# 查找7天前的.txt文件
old_text_files = filterer.filter_files("/backup", extension=".txt", min_age_days=7)

import os
import fnmatch
from pathlib import Path

def find_files_with_pattern(directory, patterns, recursive=False):
    """
    使用fnmatch模式匹配查找文件
    """
    path = Path(directory)
    results = []
    
    if recursive:
        search_method = path.rglob
    else:
        search_method = path.glob
    
    for pattern in patterns:
        # 先使用簡(jiǎn)單的通配符匹配
        for item in search_method('*'):
            if fnmatch.fnmatch(item.name, pattern):
                results.append(item)
    
    return results

# 使用示例
patterns = ['*.log', '*.txt', 'test_*.py']
matching_files = find_files_with_pattern("/var/log", patterns, recursive=True)

print("找到的匹配文件:")
for file in matching_files:
    print(f"  {file}")

from pathlib import Path
import os

class DirectorySizeCalculator:
    """
    目錄大小計(jì)算器，支持多種統(tǒng)計(jì)方式
    """
    
    @staticmethod
    def get_size(path):
        """
        獲取文件或目錄的大小（字節(jié)）
        """
        path = Path(path)
        if path.is_file():
            return path.stat().st_size
        elif path.is_dir():
            total_size = 0
            for item in path.rglob('*'):
                if item.is_file():
                    total_size += item.stat().st_size
            return total_size
        return 0
    
    @staticmethod
    def get_size_readable(path):
        """
        獲取可讀格式的大小
        """
        size_bytes = DirectorySizeCalculator.get_size(path)
        
        for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
            if size_bytes < 1024.0:
                return f"{size_bytes:.2f} {unit}"
            size_bytes /= 1024.0
        
        return f"{size_bytes:.2f} PB"
    
    @staticmethod
    def analyze_directory_structure(directory):
        """
        分析目錄結(jié)構(gòu)，返回大小統(tǒng)計(jì)
        """
        path = Path(directory)
        if not path.exists() or not path.is_dir():
            return {}
        
        size_info = {
            'total_size': 0,
            'file_count': 0,
            'dir_count': 0,
            'by_extension': {},
            'largest_files': []
        }
        
        # 臨時(shí)存儲(chǔ)文件信息用于排序
        file_sizes = []
        
        for item in path.rglob('*'):
            if item.is_file():
                file_size = item.stat().st_size
                size_info['total_size'] += file_size
                size_info['file_count'] += 1
                
                # 按擴(kuò)展名統(tǒng)計(jì)
                ext = item.suffix.lower()
                size_info['by_extension'][ext] = size_info['by_extension'].get(ext, 0) + file_size
                
                # 記錄文件信息用于查找最大文件
                file_sizes.append((item, file_size))
                
            elif item.is_dir():
                size_info['dir_count'] += 1
        
        # 找出最大的10個(gè)文件
        file_sizes.sort(key=lambda x: x[1], reverse=True)
        size_info['largest_files'] = file_sizes[:10]
        
        return size_info

# 使用示例
calculator = DirectorySizeCalculator()
size_info = calculator.analyze_directory_structure("/var/log")

print(f"總大小: {calculator.get_size_readable('/var/log')}")
print(f"文件數(shù): {size_info['file_count']}")
print(f"目錄數(shù): {size_info['dir_count']}")

print("\n按擴(kuò)展名統(tǒng)計(jì):")
for ext, size in size_info['by_extension'].items():
    readable_size = calculator.get_size_readable(Path(f"{ext}_{size}"))
    print(f"  {ext or '無擴(kuò)展名'}: {readable_size}")

print("\n最大的文件:")
for file, size in size_info['largest_files']:
    print(f"  {file}: {calculator.get_size_readable(Path(f'temp_{size}'))}")

from pathlib import Path
import hashlib
import os

class FileSyncUtility:
    """
    文件同步工具基礎(chǔ)類
    """
    
    @staticmethod
    def get_file_hash(file_path, block_size=65536):
        """
        計(jì)算文件的MD5哈希值
        """
        path = Path(file_path)
        if not path.is_file():
            return None
        
        hash_md5 = hashlib.md5()
        with open(file_path, "rb") as f:
            for chunk in iter(lambda: f.read(block_size), b""):
                hash_md5.update(chunk)
        return hash_md5.hexdigest()
    
    @staticmethod
    def compare_directories(source_dir, target_dir):
        """
        比較兩個(gè)目錄的內(nèi)容
        """
        source = Path(source_dir)
        target = Path(target_dir)
        
        if not source.exists() or not source.is_dir():
            raise ValueError("源目錄不存在或不是目錄")
        
        if not target.exists():
            target.mkdir(parents=True)
        
        comparison = {
            'source_only': [],
            'target_only': [],
            'different': [],
            'same': []
        }
        
        # 構(gòu)建源文件索引
        source_files = {}
        for item in source.rglob('*'):
            if item.is_file():
                rel_path = item.relative_to(source)
                source_files[rel_path] = item
        
        # 構(gòu)建目標(biāo)文件索引
        target_files = {}
        for item in target.rglob('*'):
            if item.is_file():
                rel_path = item.relative_to(target)
                target_files[rel_path] = item
        
        # 比較文件
        all_files = set(source_files.keys()) | set(target_files.keys())
        
        for rel_path in all_files:
            source_file = source_files.get(rel_path)
            target_file = target_files.get(rel_path)
            
            if source_file and not target_file:
                comparison['source_only'].append(rel_path)
            elif target_file and not source_file:
                comparison['target_only'].append(rel_path)
            else:
                # 兩個(gè)目錄都有該文件，比較哈希值
                source_hash = FileSyncUtility.get_file_hash(source_file)
                target_hash = FileSyncUtility.get_file_hash(target_file)
                
                if source_hash == target_hash:
                    comparison['same'].append(rel_path)
                else:
                    comparison['different'].append(rel_path)
        
        return comparison

# 使用示例
sync_util = FileSyncUtility()
comparison = sync_util.compare_directories("/path/source", "/path/target")

print("只在源目錄存在的文件:", comparison['source_only'])
print("只在目標(biāo)目錄存在的文件:", comparison['target_only'])
print("內(nèi)容不同的文件:", comparison['different'])
print("內(nèi)容相同的文件:", comparison['same'])

from pathlib import Path
from datetime import datetime
import re

class LogFileAnalyzer:
    """
    日志文件分析器
    """
    
    def __init__(self, log_directory):
        self.log_dir = Path(log_directory)
        self.log_patterns = {
            'error': re.compile(r'ERROR|CRITICAL|FAILED', re.IGNORECASE),
            'warning': re.compile(r'WARNING|ALERT', re.IGNORECASE),
            'info': re.compile(r'INFO|DEBUG', re.IGNORECASE)
        }
    
    def find_latest_log_file(self):
        """
        查找最新的日志文件
        """
        log_files = list(self.log_dir.glob('*.log'))
        if not log_files:
            return None
        
        # 按修改時(shí)間排序
        log_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
        return log_files[0]
    
    def analyze_log_file(self, log_file_path, max_entries=100):
        """
        分析日志文件內(nèi)容
        """
        path = Path(log_file_path)
        if not path.exists() or not path.is_file():
            return None
        
        analysis = {
            'error_count': 0,
            'warning_count': 0,
            'info_count': 0,
            'errors': [],
            'warnings': [],
            'file_size': path.stat().st_size,
            'last_modified': datetime.fromtimestamp(path.stat().st_mtime)
        }
        
        try:
            with open(log_file_path, 'r', encoding='utf-8', errors='ignore') as f:
                for line in f:
                    if self.log_patterns['error'].search(line):
                        analysis['error_count'] += 1
                        if len(analysis['errors']) < max_entries:
                            analysis['errors'].append(line.strip())
                    elif self.log_patterns['warning'].search(line):
                        analysis['warning_count'] += 1
                        if len(analysis['warnings']) < max_entries:
                            analysis['warnings'].append(line.strip())
                    elif self.log_patterns['info'].search(line):
                        analysis['info_count'] += 1
        
        except IOError as e:
            print(f"讀取日志文件時(shí)出錯(cuò): {e}")
            return None
        
        return analysis
    
    def generate_log_report(self):
        """
        生成日志分析報(bào)告
        """
        latest_log = self.find_latest_log_file()
        if not latest_log:
            return "沒有找到日志文件"
        
        analysis = self.analyze_log_file(latest_log)
        if not analysis:
            return "分析日志文件時(shí)出錯(cuò)"
        
        report = [
            f"日志文件分析報(bào)告",
            f"生成時(shí)間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
            f"分析文件: {latest_log.name}",
            f"文件大小: {analysis['file_size']} bytes",
            f"最后修改: {analysis['last_modified'].strftime('%Y-%m-%d %H:%M:%S')}",
            "",
            "統(tǒng)計(jì)信息:",
            f"錯(cuò)誤數(shù)量: {analysis['error_count']}",
            f"警告數(shù)量: {analysis['warning_count']}",
            f"信息數(shù)量: {analysis['info_count']}",
            ""
        ]
        
        if analysis['errors']:
            report.extend(["最近錯(cuò)誤:", ""] + analysis['errors'][:10])
        
        if analysis['warnings']:
            report.extend(["", "最近警告:", ""] + analysis['warnings'][:10])
        
        return "\n".join(report)

# 使用示例
analyzer = LogFileAnalyzer("/var/log")
report = analyzer.generate_log_report()
print(report)

from pathlib import Path
import os
import time

class EfficientDirectoryLister:
    """
    高效目錄列表工具
    """
    
    @staticmethod
    def batch_process_directory(directory_path, batch_size=1000, processor_func=None):
        """
        批量處理大型目錄
        """
        path = Path(directory_path)
        if not path.exists() or not path.is_dir():
            return
        
        all_items = []
        batch_count = 0
        
        with os.scandir(directory_path) as entries:
            for entry in entries:
                all_items.append(entry)
                
                # 達(dá)到批次大小時(shí)處理
                if len(all_items) >= batch_size:
                    if processor_func:
                        processor_func(all_items, batch_count)
                    all_items = []
                    batch_count += 1
        
        # 處理剩余項(xiàng)目
        if all_items and processor_func:
            processor_func(all_items, batch_count)
    
    @staticmethod
    def parallel_directory_scan(directory_path, max_workers=None):
        """
        并行目錄掃描（適用于超大目錄）
        """
        import concurrent.futures
        
        path = Path(directory_path)
        if not path.exists() or not path.is_dir():
            return []
        
        def process_subdirectory(subdir_path):
            """處理單個(gè)子目錄"""
            subdir_items = []
            try:
                with os.scandir(subdir_path) as entries:
                    for entry in entries:
                        subdir_items.append(entry)
            except OSError:
                pass
            return subdir_items
        
        # 獲取所有子目錄
        subdirectories = [str(item.path) for item in os.scandir(directory_path) 
                         if item.is_dir()]
        
        # 并行處理
        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
            results = list(executor.map(process_subdirectory, subdirectories))
        
        # 合并結(jié)果
        all_items = []
        for result in results:
            all_items.extend(result)
        
        return all_items

# 使用示例
def example_processor(items, batch_number):
    """示例處理函數(shù)"""
    print(f"處理批次 {batch_number}: {len(items)} 個(gè)項(xiàng)目")
    for item in items:
        if item.is_file():
            print(f"  文件: {item.name}")

efficient_lister = EfficientDirectoryLister()
efficient_lister.batch_process_directory("/large/directory", processor_func=example_processor)

from pathlib import Path
import os

class MemoryEfficientDirectoryWalker:
    """
    內(nèi)存友好的大型目錄遍歷器
    """
    
    def __init__(self):
        self.file_count = 0
        self.dir_count = 0
        self.total_size = 0
    
    def walk_with_callback(self, root_dir, file_callback=None, dir_callback=None):
        """
        使用回調(diào)函數(shù)遍歷目錄，減少內(nèi)存使用
        """
        path = Path(root_dir)
        
        for root, dirs, files in os.walk(root_dir):
            self.dir_count += 1
            
            if dir_callback:
                dir_callback(root, dirs)
            
            for file in files:
                self.file_count += 1
                file_path = os.path.join(root, file)
                
                try:
                    file_size = os.path.getsize(file_path)
                    self.total_size += file_size
                    
                    if file_callback:
                        file_callback(file_path, file_size)
                        
                except OSError:
                    continue
    
    def get_stats(self):
        """獲取統(tǒng)計(jì)信息"""
        return {
            'directories': self.dir_count,
            'files': self.file_count,
            'total_size': self.total_size
        }

# 使用示例
def file_callback(file_path, file_size):
    """文件處理回調(diào)"""
    if file_size > 1024 * 1024:  # 大于1MB的文件
        print(f"大文件: {file_path} ({file_size} bytes)")

def dir_callback(dir_path, subdirs):
    """目錄處理回調(diào)"""
    if len(subdirs) > 10:  # 子目錄很多的目錄
        print(f"多子目錄: {dir_path} ({len(subdirs)} 個(gè)子目錄)")

walker = MemoryEfficientDirectoryWalker()
walker.walk_with_callback("/large/directory", file_callback, dir_callback)

stats = walker.get_stats()
print(f"遍歷完成: {stats['directories']} 目錄, {stats['files']} 文件, 總大小: {stats['total_size']} bytes")

from pathlib import Path
import os
import logging
import stat

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class RobustDirectoryLister:
    """
    健壯的目錄遍歷框架，包含完整的錯(cuò)誤處理
    """
    
    def __init__(self, max_retries=3, timeout=30):
        self.max_retries = max_retries
        self.timeout = timeout
    
    def safe_list_directory(self, directory_path):
        """
        安全地列出目錄內(nèi)容
        """
        path = Path(directory_path)
        
        # 前置檢查
        if not self._pre_check(path):
            return []
        
        attempts = 0
        while attempts < self.max_retries:
            try:
                contents = []
                with os.scandir(directory_path) as entries:
                    for entry in entries:
                        contents.append({
                            'name': entry.name,
                            'is_file': entry.is_file(),
                            'is_dir': entry.is_dir(),
                            'path': entry.path
                        })
                return contents
                
            except PermissionError as e:
                logger.warning(f"權(quán)限錯(cuò)誤 (嘗試 {attempts + 1}): {e}")
                attempts += 1
                if attempts >= self.max_retries:
                    logger.error("達(dá)到最大重試次數(shù)")
                    return []
                
            except OSError as e:
                logger.error(f"系統(tǒng)錯(cuò)誤: {e}")
                return []
        
        return []
    
    def _pre_check(self, path):
        """
        前置安全檢查
        """
        try:
            # 檢查路徑是否存在
            if not path.exists():
                logger.error("路徑不存在")
                return False
            
            # 檢查是否是目錄
            if not path.is_dir():
                logger.error("路徑不是目錄")
                return False
            
            # 檢查讀取權(quán)限
            if not os.access(str(path), os.R_OK):
                logger.error("沒有讀取權(quán)限")
                return False
            
            # 檢查是否符號(hào)鏈接（可能需要特殊處理）
            if path.is_symlink():
                logger.warning("路徑是符號(hào)鏈接，正在解析真實(shí)路徑")
                real_path = path.resolve()
                return self._pre_check(real_path)
            
            return True
            
        except Exception as e:
            logger.error(f"前置檢查失敗: {e}")
            return False

# 使用示例
robust_lister = RobustDirectoryLister()
contents = robust_lister.safe_list_directory("/secure/directory")

for item in contents:
    print(f"{'文件' if item['is_file'] else '目錄'}: {item['name']}")