Python Typer 命令行工具开发实战：5 分钟打造专业级 CLI

1
import argparse
2
import os
3

4
def main():
5
    parser = argparse.ArgumentParser(description="文件搜索工具")
6
    parser.add_argument("pattern", help="搜索模式")
7
    parser.add_argument("--directory", "-d", default=".", help="搜索目录")
8
    parser.add_argument("--recursive", "-r", action="store_true", help="递归搜索")
9
    parser.add_argument("--ignore-case", "-i", action="store_true", help="忽略大小写")
10

11
    args = parser.parse_args()
12

13
    for root, dirs, files in os.walk(args.directory):
14
        for f in files:
15
            name = f.lower() if args.ignore_case else f
16
            pat = args.pattern.lower() if args.ignore_case else args.pattern
17
            if pat in name:
18
                print(os.path.join(root, f))
19
        if not args.recursive:
20
            break
21

22
if __name__ == "__main__":
23
    main()

1
import os
2
import typer
3
from typing import Annotated
4

5
app = typer.Typer(help="文件搜索工具")
6

7
@app.command()
8
def search(
9
    pattern: str,
10
    directory: Annotated[str, typer.Option("--directory", "-d", help="搜索目录")] = ".",
11
    recursive: Annotated[bool, typer.Option("--recursive", "-r", help="递归搜索")] = False,
12
    ignore_case: Annotated[bool, typer.Option("--ignore-case", "-i", help="忽略大小写")] = False,
13
):
14
    """搜索匹配模式的文件"""
15
    for root, dirs, files in os.walk(directory):
16
        for f in files:
17
            name = f.lower() if ignore_case else f
18
            pat = pattern.lower() if ignore_case else pattern
19
            if pat in name:
20
                typer.echo(os.path.join(root, f))
21
        if not recursive:
22
            break
23

24
if __name__ == "__main__":
25
    app()

1
import typer
2
from typing import Annotated, Optional
3
from pathlib import Path
4

5
app = typer.Typer()
6

7
@app.command()
8
def convert(
9
    # Argument：位置参数，必填
10
    source: Annotated[Path, typer.Argument(help="源文件路径")],
11

12
    # Option：选项参数，有默认值
13
    output: Annotated[Optional[Path], typer.Option("--output", "-o", help="输出路径")] = None,
14

15
    # Option：布尔开关
16
    verbose: Annotated[bool, typer.Option("--verbose", "-v", help="详细输出")] = False,
17

18
    # Option：枚举选择
19
    format: Annotated[str, typer.Option("--format", "-f", help="输出格式")] = "json",
20
):
21
    """转换文件格式"""
22
    if not source.exists():
23
        typer.echo(f"错误：文件 {source} 不存在", err=True)
24
        raise typer.Exit(code=1)
25

26
    out = output or source.with_suffix(f".{format}")
27

28
    if verbose:
29
        typer.echo(f"源文件: {source}")
30
        typer.echo(f"输出到: {out}")
31
        typer.echo(f"格式: {format}")
32

33
    # 转换逻辑...
34
    typer.echo(f"✅ 转换完成: {out}")

1
import typer
2
from typing import Annotated, Optional
3
from pathlib import Path
4
import json
5
import time
6

7
app = typer.Typer(help="📦 项目管理工具")
8

9
# ============ 子命令组：项目操作 ============
10

11
@app.command()
12
def init(
13
    name: Annotated[str, typer.Argument(help="项目名称")],
14
    template: Annotated[str, typer.Option("--template", "-t")] = "default",
15
):
16
    """初始化新项目"""
17
    project_dir = Path(name)
18
    project_dir.mkdir(exist_ok=True)
19

20
    config = {
21
        "name": name,
22
        "version": "0.1.0",
23
        "template": template,
24
        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
25
    }
26

27
    config_file = project_dir / "project.json"
28
    config_file.write_text(json.dumps(config, indent=2, ensure_ascii=False))
29

30
    typer.echo(f"✅ 项目 {name} 已创建（模板: {template}）")
31

32
@app.command()
33
def info(
34
    path: Annotated[Path, typer.Argument(help="项目路径")] = Path("."),
35
):
36
    """查看项目信息"""
37
    config_file = path / "project.json"
38
    if not config_file.exists():
39
        typer.echo("❌ 当前目录不是有效项目", err=True)
40
        raise typer.Exit(1)
41

42
    config = json.loads(config_file.read_text())
43
    typer.echo(f"📦 项目: {config['name']}")
44
    typer.echo(f"📌 版本: {config['version']}")
45
    typer.echo(f"📅 创建: {config['created_at']}")
46

47
@app.command()
48
def build(
49
    path: Annotated[Path, typer.Argument(help="项目路径")] = Path("."),
50
    production: Annotated[bool, typer.Option("--prod", help="生产模式")] = False,
51
):
52
    """构建项目"""
53
    mode = "生产" if production else "开发"
54
    typer.echo(f"🔨 构建中（{mode}模式）...")
55

56
    # 模拟构建过程
57
    with typer.progressbar(range(100), label="编译") as progress:
58
        for _ in progress:
59
            time.sleep(0.02)
60

61
    typer.echo("✅ 构建完成！")
62

63
if __name__ == "__main__":
64
    app()

1
#!/usr/bin/env python3
2
"""batch-file — 批量文件处理工具"""
3

4
import os
5
import re
6
import shutil
7
import hashlib
8
from pathlib import Path
9
from typing import Annotated, Optional
10
from datetime import datetime
11

12
import typer
13
from rich.console import Console
14
from rich.table import Table
15
from rich.progress import track
16

17
app = typer.Typer(help="🗂️ 批量文件处理工具", no_args_is_help=True)
18
console = Console()
19

20
@app.command()
21
def rename(
22
    directory: Annotated[Path, typer.Argument(help="目标目录")],
23
    pattern: Annotated[str, typer.Option("--pattern", "-p", help="匹配模式(glob)")] = "*",
24
    prefix: Annotated[Optional[str], typer.Option(help="添加前缀")] = None,
25
    suffix: Annotated[Optional[str], typer.Option(help="添加后缀（扩展名前）")] = None,
26
    replace: Annotated[Optional[str], typer.Option(help="替换规则，格式: old=new")] = None,
27
    dry_run: Annotated[bool, typer.Option("--dry-run", "-n", help="预览模式，不实际执行")] = False,
28
):
29
    """批量重命名文件"""
30
    files = sorted(directory.glob(pattern))
31

32
    if not files:
33
        console.print(f"[yellow]⚠️ 没有找到匹配 '{pattern}' 的文件[/yellow]")
34
        raise typer.Exit()
35

36
    table = Table(title="重命名预览")
37
    table.add_column("原文件名", style="red")
38
    table.add_column("新文件名", style="green")
39

40
    renames = []
41
    for f in files:
42
        if f.is_dir():
43
            continue
44

45
        new_name = f.stem
46
        ext = f.suffix
47

48
        if replace:
49
            old, new = replace.split("=", 1)
50
            new_name = new_name.replace(old, new)
51
        if prefix:
52
            new_name = prefix + new_name
53
        if suffix:
54
            new_name = new_name + suffix
55

56
        new_path = f.parent / (new_name + ext)
57

58
        if new_path != f:
59
            renames.append((f, new_path))
60
            table.add_row(f.name, new_path.name)
61

62
    if not renames:
63
        console.print("[green]✅ 无需重命名[/green]")
64
        return
65

66
    console.print(table)
67

68
    if dry_run:
69
        console.print(f"\n[yellow]预览模式：{len(renames)} 个文件将被重命名[/yellow]")
70
        return
71

72
    if not typer.confirm(f"确认重命名 {len(renames)} 个文件？"):
73
        raise typer.Abort()
74

75
    for old, new in track(renames, description="重命名中..."):
76
        old.rename(new)
77

78
    console.print(f"[green]✅ 完成！{len(renames)} 个文件已重命名[/green]")
79

80

81
@app.command()
82
def dedup(
83
    directory: Annotated[Path, typer.Argument(help="目标目录")],
84
    recursive: Annotated[bool, typer.Option("-r", help="递归搜索")] = False,
85
    dry_run: Annotated[bool, typer.Option("--dry-run", "-n", help="预览模式")] = False,
86
):
87
    """查找并删除重复文件（基于 MD5）"""
88
    glob_pattern = "**/*" if recursive else "*"
89

90
    hash_map: dict[str, Path] = {}
91
    duplicates: list[tuple[Path, Path]] = []
92

93
    files = [f for f in directory.glob(glob_pattern) if f.is_file()]
94

95
    for f in track(files, description="计算哈希..."):
96
        file_hash = hashlib.md5(f.read_bytes()).hexdigest()
97
        if file_hash in hash_map:
98
            duplicates.append((f, hash_map[file_hash]))
99
        else:
100
            hash_map[file_hash] = f
101

102
    if not duplicates:
103
        console.print("[green]✅ 没有发现重复文件[/green]")
104
        return
105

106
    table = Table(title=f"发现 {len(duplicates)} 个重复文件")
107
    table.add_column("重复文件", style="red")
108
    table.add_column("原始文件", style="green")
109

110
    total_size = 0
111
    for dup, orig in duplicates:
112
        size = dup.stat().st_size
113
        total_size += size
114
        table.add_row(str(dup), str(orig))
115

116
    console.print(table)
117
    console.print(f"\n可释放空间: [bold]{total_size / 1024 / 1024:.2f} MB[/bold]")
118

119
    if dry_run:
120
        return
121

122
    if not typer.confirm("确认删除重复文件？"):
123
        raise typer.Abort()
124

125
    for dup, _ in track(duplicates, description="删除中..."):
126
        dup.unlink()
127

128
    console.print(f"[green]✅ 已删除 {len(duplicates)} 个重复文件[/green]")
129

130

131
@app.command()
132
def stats(
133
    directory: Annotated[Path, typer.Argument(help="目标目录")] = Path("."),
134
    top: Annotated[int, typer.Option(help="显示 Top N 大文件")] = 10,
135
):
136
    """统计目录文件信息"""
137
    ext_stats: dict[str, dict] = {}
138
    all_files: list[tuple[Path, int]] = []
139

140
    for f in directory.rglob("*"):
141
        if not f.is_file():
142
            continue
143
        size = f.stat().st_size
144
        ext = f.suffix.lower() or "(无扩展名)"
145
        all_files.append((f, size))
146

147
        if ext not in ext_stats:
148
            ext_stats[ext] = {"count": 0, "size": 0}
149
        ext_stats[ext]["count"] += 1
150
        ext_stats[ext]["size"] += size
151

152
    # 按扩展名统计
153
    table = Table(title="📊 文件类型统计")
154
    table.add_column("扩展名", style="cyan")
155
    table.add_column("数量", justify="right")
156
    table.add_column("总大小", justify="right")
157

158
    for ext, info in sorted(ext_stats.items(), key=lambda x: x[1]["size"], reverse=True):
159
        size_mb = info["size"] / 1024 / 1024
160
        table.add_row(ext, str(info["count"]), f"{size_mb:.2f} MB")
161

162
    console.print(table)
163

164
    # Top N 大文件
165
    all_files.sort(key=lambda x: x[1], reverse=True)
166

167
    big_table = Table(title=f"📁 Top {top} 大文件")
168
    big_table.add_column("文件", style="yellow")
169
    big_table.add_column("大小", justify="right", style="red")
170

171
    for f, size in all_files[:top]:
172
        size_mb = size / 1024 / 1024
173
        big_table.add_row(str(f.relative_to(directory)), f"{size_mb:.2f} MB")
174

175
    console.print(big_table)
176
    console.print(f"\n总计: {len(all_files)} 个文件, {sum(s for _, s in all_files) / 1024 / 1024:.2f} MB")
177

178

179
if __name__ == "__main__":
180
    app()