Python實現(xiàn)目錄遍歷和內(nèi)容獲取的完整指南
更新時間：2025年09月22日 09:15:11 作者：Python×CATIA工業(yè)智造
在軟件開發(fā)中,目錄遍歷和文件系統(tǒng)操作是極其常見且重要的任務(wù),本文將深入探討Python中獲取目錄內(nèi)容的各種方法,展示如何在不同場景下選擇和使用最合適的工具,希望對大家有所幫助
引言
在軟件開發(fā)中，目錄遍歷和文件系統(tǒng)操作是極其常見且重要的任務(wù)。無論是構(gòu)建文件管理器、實現(xiàn)數(shù)據(jù)備份工具、開發(fā)日志分析系統(tǒng)，還是簡單地處理用戶上傳的文件，我們都需要高效、可靠地獲取目錄內(nèi)容列表。Python作為一門功能強大的編程語言，提供了多種方法來實現(xiàn)目錄遍歷，每種方法都有其獨特的優(yōu)勢和適用場景。
從簡單的文件列表獲取到復(fù)雜的遞歸目錄遍歷，從基本的文件名檢索到詳細的文件元數(shù)據(jù)提取，Python的標(biāo)準(zhǔn)庫和第三方庫提供了豐富的工具集。然而，選擇不當(dāng)?shù)姆椒赡軐?dǎo)致性能問題、資源浪費甚至安全漏洞。特別是在處理大型目錄結(jié)構(gòu)或需要高性能的場景中，選擇合適的目錄遍歷方法顯得尤為重要。
本文將深入探討Python中獲取目錄內(nèi)容的各種方法，從基礎(chǔ)的os.listdir()到現(xiàn)代的pathlib模塊，從簡單的文件列表到高級的元數(shù)據(jù)檢索。我們將通過大量實際示例，展示如何在不同場景下選擇和使用最合適的工具，幫助讀者掌握高效、安全處理目錄內(nèi)容的技巧。
一、基礎(chǔ)目錄遍歷方法
1.1 使用os模塊的基礎(chǔ)方法
Python的os模塊提供了最基礎(chǔ)的目錄遍歷功能，適用于簡單的文件列表獲取需求。
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"錯誤: 目錄 '{directory_path}' 不存在")
return []
except PermissionError:
print(f"錯誤: 沒有權(quán)限訪問目錄 '{directory_path}'")
return []
except NotADirectoryError:
print(f"錯誤: '{directory_path}' 不是目錄")
return []
# 使用示例
directory_path = "/path/to/directory"
contents = list_directory_basic(directory_path)1.2 區(qū)分文件和目錄
在實際應(yīng)用中，我們經(jīng)常需要分別處理文件和目錄。
import os
def categorize_directory_contents(directory_path):
"""
分類返回目錄內(nèi)容
"""
try:
items = os.listdir(directory_path)
# 使用列表推導(dǎo)式進行分類
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"訪問目錄時出錯: {e}")
return {'files': [], 'directories': [], 'other': []}
# 使用示例
contents = categorize_directory_contents("/tmp")
print("文件:", contents['files'])
print("目錄:", contents['directories'])
print("其他:", contents['other'])二、高級目錄遍歷技術(shù)
2.1 使用os.walk()進行遞歸遍歷
os.walk()是Python中最強大的目錄遍歷工具之一，可以遞歸遍歷整個目錄樹。
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)前目錄級別
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} 個目錄, {file_count} 個文件")
# 使用示例
recursive_directory_walk("/path/to/directory")2.2 使用os.scandir()提高性能
os.scandir()（Python 3.5+）提供了比os.listdir()更好的性能，特別是在需要文件元數(shù)據(jù)的場景中。
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"
# 獲取修改時間
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"錯誤: 目錄不存在")
except PermissionError:
print(f"錯誤: 沒有訪問權(quán)限")
# 使用示例
scan_directory_efficient("/path/to/directory")2.3 使用pathlib模塊（現(xiàn)代方法）
Python 3.4引入的pathlib模塊提供了面向?qū)ο蟮穆窂讲僮鞣绞健?/p>
from pathlib import Path
def list_directory_pathlib(directory_path):
"""
使用pathlib列出目錄內(nèi)容
"""
path = Path(directory_path)
if not path.exists():
print(f"錯誤: 路徑 '{directory_path}' 不存在")
return
if not path.is_dir():
print(f"錯誤: '{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 = "包含項目"
else:
file_type = "其他"
info = "特殊文件"
print(f"{file_type:6} {item.name:25} {info}")
# 使用示例
list_directory_pathlib("/path/to/directory")三、過濾和搜索目錄內(nèi)容
3.1 基于條件的文件過濾
import os
from pathlib import Path
from datetime import datetime, timedelta
class AdvancedDirectoryFilter:
"""
高級目錄內(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)3.2 使用fnmatch進行模式匹配
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:
# 先使用簡單的通配符匹配
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}")四、高級應(yīng)用場景
4.1 目錄大小計算器
from pathlib import Path
import os
class DirectorySizeCalculator:
"""
目錄大小計算器，支持多種統(tǒng)計方式
"""
@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)計
"""
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': []
}
# 臨時存儲文件信息用于排序
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
# 按擴展名統(tǒng)計
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個文件
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按擴展名統(tǒng)計:")
for ext, size in size_info['by_extension'].items():
readable_size = calculator.get_size_readable(Path(f"{ext}_{size}"))
print(f" {ext or '無擴展名'}: {readable_size}")
print("\n最大的文件:")
for file, size in size_info['largest_files']:
print(f" {file}: {calculator.get_size_readable(Path(f'temp_{size}'))}")4.2 文件同步工具基礎(chǔ)
from pathlib import Path
import hashlib
import os
class FileSyncUtility:
"""
文件同步工具基礎(chǔ)類
"""
@staticmethod
def get_file_hash(file_path, block_size=65536):
"""
計算文件的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):
"""
比較兩個目錄的內(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:
# 兩個目錄都有該文件，比較哈希值
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'])4.3 日志文件分析器
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
# 按修改時間排序
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"讀取日志文件時出錯: {e}")
return None
return analysis
def generate_log_report(self):
"""
生成日志分析報告
"""
latest_log = self.find_latest_log_file()
if not latest_log:
return "沒有找到日志文件"
analysis = self.analyze_log_file(latest_log)
if not analysis:
return "分析日志文件時出錯"
report = [
f"日志文件分析報告",
f"生成時間: {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)計信息:",
f"錯誤數(shù)量: {analysis['error_count']}",
f"警告數(shù)量: {analysis['warning_count']}",
f"信息數(shù)量: {analysis['info_count']}",
""
]
if analysis['errors']:
report.extend(["最近錯誤:", ""] + 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)五、性能優(yōu)化與最佳實踐
5.1 高效目錄遍歷技巧
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)
# 達到批次大小時處理
if len(all_items) >= batch_size:
if processor_func:
processor_func(all_items, batch_count)
all_items = []
batch_count += 1
# 處理剩余項目
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):
"""處理單個子目錄"""
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)} 個項目")
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)5.2 內(nèi)存友好的大型目錄處理
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)計信息"""
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)} 個子目錄)")
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")六、錯誤處理與安全考慮
6.1 健壯的目錄遍歷框架
from pathlib import Path
import os
import logging
import stat
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class RobustDirectoryLister:
"""
健壯的目錄遍歷框架，包含完整的錯誤處理
"""
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)限錯誤 (嘗試 {attempts + 1}): {e}")
attempts += 1
if attempts >= self.max_retries:
logger.error("達到最大重試次數(shù)")
return []
except OSError as e:
logger.error(f"系統(tǒng)錯誤: {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
# 檢查是否符號鏈接（可能需要特殊處理）
if path.is_symlink():
logger.warning("路徑是符號鏈接，正在解析真實路徑")
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']}")總結(jié)
獲取目錄內(nèi)容列表是Python編程中的基礎(chǔ)操作，但真正掌握這一技能需要理解其背后的復(fù)雜性和各種優(yōu)化技巧。本文從基礎(chǔ)方法到高級應(yīng)用，全面探討了Python中目錄遍歷的各個方面。
??關(guān)鍵要點總結(jié)：??
- ??方法選擇??：根據(jù)需求選擇合適的工具，簡單列表用
os.listdir()，需要元數(shù)據(jù)用os.scandir()，遞歸遍歷用os.walk()，現(xiàn)代代碼用pathlib - ??性能優(yōu)化??：處理大型目錄時使用批量處理、并行掃描和內(nèi)存友好的方法
- ??錯誤處理??：完整的錯誤處理機制是生產(chǎn)環(huán)境代碼的必要條件
- ??安全考慮??：特別是在處理用戶輸入或敏感目錄時，需要嚴格的安全檢查
- ??資源管理??：使用上下文管理器(
with語句)確保資源正確釋放
??最佳實踐建議：??
- 使用
pathlib進行現(xiàn)代Python路徑操作 - 對于需要文件元數(shù)據(jù)的場景，優(yōu)先使用
os.scandir() - 處理大型目錄時實現(xiàn)適當(dāng)?shù)呐亢筒⑿刑幚?/li>
- 始終包含完整的錯誤處理和日志記錄
- 對用戶提供的路徑進行嚴格的安全驗證
通過掌握這些技術(shù)和最佳實踐，開發(fā)者可以編寫出高效、可靠且安全的目錄遍歷代碼，能夠處理從簡單文件列表到復(fù)雜目錄分析的各種場景。無論是開發(fā)文件管理工具、實現(xiàn)數(shù)據(jù)同步系統(tǒng)，還是進行日志分析，良好的目錄遍歷能力都是成功的基礎(chǔ)。
到此這篇關(guān)于Python實現(xiàn)目錄遍歷和內(nèi)容獲取的完整指南的文章就介紹到這了,更多相關(guān)Python目錄遍歷與內(nèi)容獲取內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
pyCharm 設(shè)置調(diào)試輸出窗口中文顯示方式(字符碼轉(zhuǎn)換)
這篇文章主要介紹了pyCharm 設(shè)置調(diào)試輸出窗口中文顯示方式(字符碼轉(zhuǎn)換)，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-06-06
無監(jiān)督生成模型在機器學(xué)習(xí)中扮演著重要角色,特別是當(dāng)我們在沒有標(biāo)簽數(shù)據(jù)的情況下想要生成新的樣本或理解數(shù)據(jù)的內(nèi)在結(jié)構(gòu)時,這篇文章主要介紹了python 無監(jiān)督生成模型的示例,需要的朋友可以參考下2024-07-07
這篇文章主要為大家介紹了Pyinstaller加密打包成可執(zhí)行文件方法示例。有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
在日常工作中會需要安裝或者卸載Python模塊.于是我整理了一下,下面這篇文章主要給大家介紹了關(guān)于python安裝/卸載模塊的相關(guān)資料,文中通過圖文介紹的非常詳細,需要的朋友可以參考下2023-01-01
這篇文章主要為大家詳細介紹了使用TensorFlow實現(xiàn)SVM的相關(guān)資料，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-09-09
這篇文章主要介紹了Python實現(xiàn)檢測文件MD5值的方法,涉及Python針對大文件的讀取、判斷、運算、加密等相關(guān)操作技巧,需要的朋友可以參考下2018-04-04
這篇文章主要給大家介紹了關(guān)于利用Python實現(xiàn)Json序列化庫的方法步驟，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-09-09
python實現(xiàn)定時任務(wù)的八種方式總結(jié)
在日常工作中,我們常常會用到需要周期性執(zhí)行的任務(wù),下面這篇文章主要給大家介紹了關(guān)于python實現(xiàn)定時任務(wù)的八種方式,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下2023-01-01
python實現(xiàn)html轉(zhuǎn)ubb代碼(html2ubb)
這篇文章主要介紹了python實現(xiàn)html轉(zhuǎn)ubb代碼(html2ubb),使用正則表達式寫的一個函數(shù),需要的朋友可以參考下2014-07-07
django之導(dǎo)入并執(zhí)行自定義的函數(shù)模塊圖解
這篇文章主要介紹了django之導(dǎo)入并執(zhí)行自定義的函數(shù)模塊圖解，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-04-04