sys 模块

import sys
import os

# ============================================================
# 1. 查看当前模块搜索路径
# ============================================================
print("--- 当前 sys.path ---")
for i, path in enumerate(sys.path):          # enumerate 给每条路径编号
    print(f"  [{i}] {path}")                  # 格式化输出，方便定位

# ============================================================
# 2. sys.path 的构成来源（按优先级从高到低）
# ============================================================
# 来源 1: 脚本所在目录（或交互模式下的当前目录）
# 来源 2: PYTHONPATH 环境变量中的目录
# 来源 3: Python 安装的标准库目录
# 来源 4: 第三方包的 site-packages 目录

# ============================================================
# 3. 临时添加搜索路径（仅当前进程有效）
# ============================================================
# 场景：项目结构如下
#   my_project/
#     main.py          <-- 你在这里
#     libs/
#       my_util.py     <-- 你想导入这个

current_dir = os.path.dirname(__file__)       # 获取当前脚本所在目录
lib_path = os.path.join(current_dir, 'libs')  # 拼接出 libs 目录的绝对路径

if lib_path not in sys.path:                  # 避免重复添加
    sys.path.insert(0, lib_path)              # insert(0, ...) 放到最前面，优先搜索

# 现在 import my_util 就能找到了
# import my_util

# ============================================================
# 4. 检查模块是否已加载
# ============================================================
print(f"\n--- 模块加载状态 ---")
print(f"'os' 已加载?     {'os' in sys.modules}")       # True，os 是常用内置模块
print(f"'json' 已加载?   {'json' in sys.modules}")     # 取决于之前是否 import 过
print(f"'requests' 已加载? {'requests' in sys.modules}") # 通常 False，除非已安装并导入

import sys

# ============================================================
# sys.argv 的结构
# ============================================================
# sys.argv[0]  → 脚本自身的名称（或路径）
# sys.argv[1:] → 传递给脚本的所有命令行参数
# sys.argv     → 完整列表

# 运行示例: python script.py arg1 "hello world" 123
# sys.argv = ['script.py', 'arg1', 'hello world', '123']
#             ^argv[0]    ^argv[1]  ^argv[2]      ^argv[3]

# ============================================================
# 示例 1：基础用法
# ============================================================
print(f"脚本名称: {sys.argv[0]}")
print(f"传递的参数: {sys.argv[1:]}")
print(f"参数数量: {len(sys.argv) - 1}")       # 减 1 是因为 argv[0] 是脚本名

# ============================================================
# 示例 2：带参数验证的脚本
# ============================================================
def main():
    """一个需要名字和年龄两个参数的脚本。"""
    # 检查参数数量是否足够
    if len(sys.argv) < 3:                      # 需要 argv[1] 和 argv[2]
        print(f"用法: {sys.argv[0]} <名字> <年龄>", file=sys.stderr)
        sys.exit(1)                            # 退出码 1 表示错误

    name = sys.argv[1]                         # 第一个参数：名字
    try:
        age = int(sys.argv[2])                 # 第二个参数：年龄（需转为整数）
        print(f"你好, {name}! 你明年将是 {age + 1} 岁。")
    except ValueError:                         # 年龄不是整数
        print(f"错误: 年龄必须是一个整数，收到: '{sys.argv[2]}'", file=sys.stderr)
        sys.exit(1)

# ============================================================
# 示例 3：简单的命令行工具框架
# ============================================================
def cli_tool():
    """一个支持子命令的简单 CLI 框架。"""
    if len(sys.argv) < 2:
        print("用法: tool.py <command> [args]")
        print("可用命令: greet, calc, info")
        sys.exit(1)

    command = sys.argv[1]                      # 子命令

    if command == "greet":
        name = sys.argv[2] if len(sys.argv) > 2 else "世界"
        print(f"你好, {name}!")
    elif command == "calc":
        if len(sys.argv) < 4:
            print("用法: tool.py calc <a> <b>", file=sys.stderr)
            sys.exit(1)
        a, b = int(sys.argv[2]), int(sys.argv[3])
        print(f"{a} + {b} = {a + b}")
    elif command == "info":
        print(f"Python: {sys.version}")
        print(f"平台: {sys.platform}")
    else:
        print(f"未知命令: {command}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

import sys
import io
import contextlib

# ============================================================
# 示例 1：处理管道输入（stdin）
# ============================================================
def process_pipe_input():
    """从 stdin 逐行读取并处理，适合管道操作。"""
    # 常见用法: echo -e "hello\nworld" | python script.py
    # 或者: cat data.txt | python script.py
    for line in sys.stdin:                     # sys.stdin 是可迭代的，逐行读取
        processed = line.strip().upper()       # 去除首尾空白并转大写
        print(f"处理后: {processed}")           # 输出到 stdout

# ============================================================
# 示例 2：手动重定向 stdout（捕获 print 输出）
# ============================================================
def capture_stdout_manual():
    """手动重定向 sys.stdout 来捕获输出。"""
    def greet():
        print("Hello, World!")                 # 这个输出将被捕获

    string_io = io.StringIO()                  # 创建内存中的文本流
    original_stdout = sys.stdout               # 保存原始 stdout，必须恢复！

    try:
        sys.stdout = string_io                 # 重定向：stdout 指向内存流
        greet()                                # 调用函数，输出进入内存
    finally:
        sys.stdout = original_stdout           # 无论是否异常，都要恢复

    captured = string_io.getvalue()            # 获取捕获的内容
    print(f"捕获到的输出: '{captured.strip()}'")

# ============================================================
# 示例 3：使用 contextlib 更优雅地重定向（推荐）
# ============================================================
def capture_stdout_context():
    """使用 contextlib.redirect_stdout 上下文管理器。"""
    def greet():
        print("Hello from context!")

    f = io.StringIO()
    with contextlib.redirect_stdout(f):        # 上下文管理器自动保存和恢复
        greet()                                # 输出被重定向到 f

    captured = f.getvalue()
    print(f"捕获到的输出: '{captured.strip()}'")

# ============================================================
# 示例 4：同时重定向 stdout 和 stderr
# ============================================================
def capture_both():
    """同时捕获正常输出和错误输出。"""
    out_buffer = io.StringIO()
    err_buffer = io.StringIO()

    with contextlib.redirect_stdout(out_buffer), \
         contextlib.redirect_stderr(err_buffer):
        print("这是正常输出")                    # 进入 out_buffer
        print("这是错误信息", file=sys.stderr)   # 进入 err_buffer

    print(f"stdout: {out_buffer.getvalue().strip()}")
    print(f"stderr: {err_buffer.getvalue().strip()}")

# ============================================================
# 示例 5：stderr 的正确使用方式
# ============================================================
def proper_stderr_usage():
    """错误信息应该写到 stderr，而不是 stdout。"""
    # 错误做法：print("Error: file not found")
    #   → 错误信息混在正常输出中，管道处理时会污染数据

    # 正确做法：
    print("Error: file not found", file=sys.stderr)
    #   → 错误信息走 stderr，不影响 stdout 的管道处理

    # 这样做的好处：
    #   python script.py > result.txt 2> error.log
    #   → 正常结果和错误信息分别保存到不同文件

# ============================================================
# 示例 6：二进制数据的 I/O
# ============================================================
def binary_io():
    """处理二进制数据时使用 .buffer 属性。"""
    # sys.stdout 是文本流（TextIOWrapper），会自动编码
    # sys.stdout.buffer 是底层的二进制流（BufferedWriter），跳过编码
    import struct

    # 写入二进制数据到 stdout（适合管道传输）
    data = struct.pack('>I', 42)               # 打包为 4 字节大端整数
    sys.stdout.buffer.write(data)              # 直接写二进制，不经编码
    sys.stdout.buffer.flush()                  # 刷新缓冲区

import sys

# ============================================================
# 1. 查看已加载的模块
# ============================================================
print(f"当前已加载模块数量: {len(sys.modules)}")

# 查看所有已加载模块的名称（按字母排序）
loaded = sorted(sys.modules.keys()
print(f"前 10 个模块: {loaded[:10]}")

# 检查特定模块是否已加载
print(f"'os' 已加载? {'os' in sys.modules}")         # True
print(f"'numpy' 已加载? {'numpy' in sys.modules}")   # 取决于是否 import 过

# ============================================================
# 2. 模块缓存的工作原理
# ============================================================
import json                                    # 首次导入 json
json_module_1 = sys.modules['json']           # 从缓存获取

import json                                    # 第二次导入——直接从缓存取
json_module_2 = sys.modules['json']

print(f"两次导入获取的是同一个对象? {json_module_1 is json_module_2}")
# True！这就是缓存的作用

# ============================================================
# 3. 强制重新导入模块（高级用法，慎用！）
# ============================================================
# 删除缓存条目后，下次 import 会重新执行模块代码
# del sys.modules['some_module']
# import some_module  # 会重新加载

# ⚠️ 警告：这可能导致难以调试的问题，因为其他已加载的模块
# 可能还持有旧模块对象的引用。生产代码请使用 importlib.reload()

# ============================================================
# 4. 使用 importlib.reload() 安全地重新加载（推荐）
# ============================================================
# import importlib
# importlib.reload(some_module)  # 安全地重新加载已导入的模块

# ============================================================
# 5. 统计已加载模块的分类
# ============================================================
def categorize_modules():
    """将已加载模块按来源分类。"""
    builtin_count = 0
    third_party_count = 0
    local_count = 0

    for name, mod in sys.modules.items():
        if mod is None:                         # 延迟导入的占位符
            continue
        if name in sys.builtin_module_names:
            builtin_count += 1
        elif 'site-packages' in getattr(mod, '__file__', '') or \
             'dist-packages' in getattr(mod, '__file__', ''):
            third_party_count += 1
        else:
            local_count += 1

    print(f"内置模块: {builtin_count}")
    print(f"第三方模块: {third_party_count}")
    print(f"其他模块: {local_count}")

categorize_modules()

import sys

# ============================================================
# 1. sys.getrefcount：引用计数
# ============================================================
a = [1, 2, 3]                                  # 创建列表，引用计数 = 1
b = a                                          # b 也指向同一列表，引用计数 = 2
c = a                                          # c 也指向同一列表，引用计数 = 3

# 调用 getrefcount(a) 时，参数传递本身创建了一个临时引用
# 所以返回值 = 实际引用数 + 1（临时引用）+ 1（可能还有其他内部引用）
result = sys.getrefcount(a)
print(f"引用计数: {result}")
# 预期约为 4~5（3个变量 + 1个临时参数 + 可能的内部引用）

del b                                          # 删除 b，引用计数 -1
print(f"删除 b 后的引用计数: {sys.getrefcount(a)}")

del c                                          # 删除 c，引用计数 -1
print(f"删除 c 后的引用计数: {sys.getrefcount(a)}")

# ============================================================
# 2. sys.getsizeof：内存大小（浅测量）
# ============================================================
my_list = list(range(100))                     # 包含 100 个整数的列表
my_dict = {f"key_{i}": i for i in range(100)}  # 包含 100 个键值对的字典
my_set = set(range(100))                       # 包含 100 个整数的集合
my_tuple = tuple(range(100))                   # 包含 100 个整数的元组

print("--- 浅大小（仅容器本身）---")
print(f"list:   {sys.getsizeof(my_list)} 字节")
print(f"dict:   {sys.getsizeof(my_dict)} 字节")
print(f"set:    {sys.getsizeof(my_set)} 字节")
print(f"tuple:  {sys.getsizeof(my_tuple)} 字节")

# ============================================================
# 3. 深大小估算：容器 + 所有元素
# ============================================================
# getsizeof 只算"外壳"，不算"内容"
# 要估算总大小，需要递归计算所有元素

def deep_size(obj, seen=None):
    """递归估算对象的完整内存占用（字节）。"""
    if seen is None:
        seen = set()                            # 防止循环引用导致无限递归

    obj_id = id(obj)
    if obj_id in seen:                          # 已计算过的对象不再重复计算
        return 0
    seen.add(obj_id)

    size = sys.getsizeof(obj)                   # 对象自身的大小

    if isinstance(obj, dict):                   # 字典：递归计算所有键和值
        for k, v in obj.items():
            size += deep_size(k, seen)
            size += deep_size(v, seen)
    elif isinstance(obj, (list, tuple, set, frozenset)):
        # 列表/元组/集合：递归计算所有元素
        for item in obj:
            size += deep_size(item, seen)

    return size

print("\n--- 深大小（容器 + 所有元素）---")
print(f"list:   {deep_size(my_list)} 字节")
print(f"dict:   {deep_size(my_dict)} 字节")
print(f"set:    {deep_size(my_set)} 字节")
print(f"tuple:  {deep_size(my_tuple)} 字节")

# ============================================================
# 4. 不同数据结构的内存效率对比
# ============================================================
print("\n--- 存储 100 个整数，各容器内存对比 ---")
print(f"{'容器类型':<10} {'浅大小':>10} {'深大小':>10} {'每元素':>10}")
print("-" * 45)
for name, obj in [("list", my_list), ("tuple", my_tuple),
                   ("set", my_set), ("dict", my_dict)]:
    shallow = sys.getsizeof(obj)
    deep = deep_size(obj)
    per_elem = deep / 100
    print(f"{name:<10} {shallow:>10} {deep:>10} {per_elem:>10.1f}")

import sys

# ============================================================
# 1. 查看和修改递归限制
# ============================================================
print(f"当前递归限制: {sys.getrecursionlimit()}")  # 通常为 1000

# 谨慎地临时修改递归限制
original_limit = sys.getrecursionlimit()
try:
    sys.setrecursionlimit(2000)                # 提高到 2000
    print(f"修改后的递归限制: {sys.getrecursionlimit()}")
    # ... 执行需要更深递归的代码 ...
finally:
    sys.setrecursionlimit(original_limit)      # 恢复原始限制

# ============================================================
# 2. 递归深度超限的演示
# ============================================================
def recursive_func(depth=0):
    """一个会递归到超限的函数。"""
    print(f"递归深度: {depth}", end="\r")       # \r 让输出在同一行刷新
    return recursive_func(depth + 1)           # 无限递归

# 取消下面的注释会触发 RecursionError
# try:
#     recursive_func()
# except RecursionError as e:
#     print(f"\n递归超限! 错误: {e}")

# ============================================================
# 3. 递归 vs 迭代的对比（推荐重构为迭代）
# ============================================================
# 递归版本：受递归深度限制
def factorial_recursive(n):
    """递归计算阶乘。"""
    if n <= 1:
        return 1
    return n * factorial_recursive(n - 1)      # 每次调用增加一层栈帧

# 迭代版本：不受递归深度限制（推荐）
def factorial_iterative(n):
    """迭代计算阶乘。"""
    result = 1
    for i in range(2, n + 1):                  # 只用一个栈帧
        result *= i
    return result

print(f"\n递归版 10! = {factorial_recursive(10)}")
print(f"迭代版 10! = {factorial_iterative(10)}")

# ============================================================
# 4. 获取当前实际递归深度
# ============================================================
import inspect

def show_call_depth(depth=0):
    """显示当前函数调用的实际栈深度。"""
    current_depth = len(inspect.stack())        # 获取当前调用栈的深度
    print(f"inspect 栈深度: {current_depth}, 参数 depth: {depth}")
    if depth < 5:                               # 只递归 5 层做演示
        show_call_depth(depth + 1)

show_call_depth()

import sys
import traceback

# ============================================================
# 1. sys.exc_info 的基本用法
# ============================================================
try:
    result = 1 / 0                             # 故意触发 ZeroDivisionError
except ZeroDivisionError:
    exc_type, exc_value, exc_tb = sys.exc_info()
    # exc_type  → 异常类型：<class 'ZeroDivisionError'>
    # exc_value → 异常实例：division by zero
    # exc_tb    → 回溯对象：包含完整的调用栈信息

    print(f"异常类型: {exc_type.__name__}")
    print(f"异常信息: {exc_value}")
    print(f"回溯对象: {exc_tb}")

    # 使用 traceback 模块格式化完整的回溯信息
    tb_lines = traceback.format_exception(exc_type, exc_value, exc_tb)
    print("完整回溯:")
    print("".join(tb_lines)

# ============================================================
# 2. 在 except 块外部，sys.exc_info() 返回 (None, None, None)
# ============================================================
print(f"\n在 except 块外: {sys.exc_info()}")    # (None, None, None)

# ============================================================
# 3. 自定义 excepthook 中使用 exc_info
# ============================================================
import logging

logging.basicConfig(
    filename='error.log',
    level=logging.ERROR,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def custom_excepthook(exc_type, exc_value, exc_tb):
    """自定义全局异常钩子：记录日志 + 友好提示。"""
    # 格式化异常信息
    error_msg = "".join(traceback.format_exception(exc_type, exc_value, exc_tb)
    logging.error("未捕获的异常:\n%s", error_msg)  # 写入日志文件

    # 向用户显示友好的错误提示（不暴露技术细节）
    print(f"程序遇到错误，详情已记录到 error.log", file=sys.stderr)
    print(f"错误类型: {exc_type.__name__}", file=sys.stderr)

# 设置自定义钩子
sys.excepthook = custom_excepthook

# 以下未捕获的异常将触发 custom_excepthook
# result = 1 / 0

# ============================================================
# 4. exc_info 与 logging 模块配合
# ============================================================
# logging 模块内置支持 exc_info 参数
try:
    risky_operation = 1 / 0
except Exception:
    logging.error("操作失败", exc_info=True)   # exc_info=True 自动附加异常信息
    # 等价于:
    # logging.error("操作失败", exc_info=sys.exc_info()

import sys
import os

# ============================================================
# 1. sys.version / sys.version_info：Python 版本
# ============================================================
print("--- Python 版本信息 ---")
print(f"版本字符串: {sys.version}")
# 示例输出: 3.12.4 (main, Jun  6 2024, 18:26:44) [Clang 15.0.0 ...]

print(f"版本元组: {sys.version_info}")
# 示例输出: sys.version_info(major=3, minor=12, micro=4, releaselevel='final', serial=0)

# version_info 支持命名属性和索引访问
major = sys.version_info.major                  # 主版本号，如 3
minor = sys.version_info.minor                  # 次版本号，如 12
print(f"主版本: {major}, 次版本: {minor}")

# 版本检查的推荐方式（使用元组比较）
if sys.version_info < (3, 10):
    print("需要 Python 3.10+")
    sys.exit(1)

# ============================================================
# 2. sys.platform：操作系统平台
# ============================================================
print("\n--- 平台信息 ---")
print(f"平台标识: {sys.platform}")
# 'linux'   → Linux
# 'win32'   → Windows（包括 64 位）
# 'darwin'  → macOS

# 跨平台代码示例
def clear_screen():
    """根据平台执行不同的清屏命令。"""
    if sys.platform == "win32":
        os.system("cls")                        # Windows 清屏
    else:
        os.system("clear")                      # Linux/macOS 清屏

# 路径分隔符适配
def get_path_separator():
    """获取当前平台的路径分隔符。"""
    # 注意：推荐使用 os.path 或 pathlib，而不是手动拼接
    return "\\" if sys.platform == "win32" else "/"

# ============================================================
# 3. sys.executable：解释器路径
# ============================================================
print(f"\n解释器路径: {sys.executable}")
# 示例: /usr/bin/python3 或 C:\Python312\python.exe

# 用途：在脚本中启动子进程时，确保使用同一个 Python
# subprocess.run([sys.executable, 'other_script.py'])

# ============================================================
# 4. sys.flags：解释器启动标志
# ============================================================
print("\n--- 解释器启动标志 ---")
print(f"优化级别 (-O): {sys.flags.optimize}")       # 0=正常, 1=-O, 2=-OO
print(f"调试模式 (-d): {sys.flags.debug}")           # 0 或 1
print(f"交互模式: {sys.flags.interactive}")          # 是否在交互模式下运行
print(f"哈希随机化: {sys.flags.hash_randomization}") # 安全特性
print(f"隔离模式 (-I): {sys.flags.isolated}")        # 隔离模式
print(f"开发模式 (-X dev): {sys.flags.dev_mode}")    # 开发模式（3.7+）

# 优化模式的影响：
# -O: 移除 assert 语句和 __debug__ 条件代码
# -OO: 在 -O 基础上还移除 docstring

# ============================================================
# 5. sys.implementation：Python 实现信息
# ============================================================
print(f"\nPython 实现: {sys.implementation.name}")
# CPython → 'cpython'（最常见）
# PyPy   → 'pypy'
# Jython → 'jython'
# IronPython → 'ironpython'

# ============================================================
# 6. 生成环境诊断报告
# ============================================================
def diagnostic_report():
    """生成完整的环境诊断报告，适合在 bug report 中附带。"""
    print("=" * 60)
    print("Python 环境诊断报告")
    print("=" * 60)
    print(f"Python 版本:  {sys.version}")
    print(f"版本元组:     {sys.version_info}")
    print(f"实现:         {sys.implementation.name}")
    print(f"平台:         {sys.platform}")
    print(f"解释器路径:   {sys.executable}")
    print(f"递归限制:     {sys.getrecursionlimit()}")
    print(f"编码:         {sys.getdefaultencoding()}")
    print(f"文件系统编码: {sys.getfilesystemencoding()}")
    print(f"优化级别:     {sys.flags.optimize}")
    print(f"字节序:       {sys.byteorder}")           # 'little' 或 'big'
    print(f"已加载模块数: {len(sys.modules)}")
    print("=" * 60)

diagnostic_report()

import sys
import atexit

# ============================================================
# 1. sys.exit()：正常退出
# ============================================================
# sys.exit(code) 会抛出 SystemExit 异常
# code=0 表示成功，非零表示错误
# 关键特性：try...finally 和 with 语句的清理代码**会**执行

def process_file(filename):
    """处理文件，失败时以错误码退出。"""
    try:
        with open(filename, 'r') as f:         # with 块确保文件关闭
            content = f.read()
            print(f"成功读取 {len(content)} 个字符")
    except FileNotFoundError:
        print(f"错误: 文件 '{filename}' 不存在", file=sys.stderr)
        sys.exit(1)                            # 退出码 1 = 错误
        # 注意：上面的 with 块和 try...finally 都会正常清理

# ============================================================
# 2. sys.exit() vs os._exit() 对比
# ============================================================
# sys.exit()      → 抛出 SystemExit，执行 finally 和 atexit
# os._exit()      → 立即终止进程，不执行任何清理
# os._exit() 只应在 fork() 后的子进程中使用

# ============================================================
# 3. atexit：注册退出时的清理函数
# ============================================================
def cleanup_database():
    """程序退出时关闭数据库连接。"""
    print("正在关闭数据库连接...")

def cleanup_temp_files():
    """程序退出时清理临时文件。"""
    print("正在清理临时文件...")

# 注册清理函数（按注册的逆序执行）
atexit.register(cleanup_temp_files)
atexit.register(cleanup_database)

# 使用装饰器语法注册
@atexit.register
def final_log():
    print("程序即将退出，记录最终日志。")

# ============================================================
# 4. sys.excepthook：全局异常钩子
# ============================================================
# 当异常未被捕获时，解释器调用 sys.excepthook
# 默认行为：打印回溯信息到 stderr
# 可以自定义，实现日志记录、错误报告等功能

import logging
import traceback

logging.basicConfig(
    filename='error.log',
    level=logging.ERROR,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def custom_excepthook(exc_type, exc_value, exc_tb):
    """自定义全局异常钩子。"""
    # 1. 记录到日志
    error_msg = "".join(traceback.format_exception(exc_type, exc_value, exc_tb)
    logging.error("未捕获的异常:\n%s", error_msg)

    # 2. 向用户显示友好提示
    print(f"\n程序遇到错误: {exc_type.__name__}: {exc_value}", file=sys.stderr)
    print("详情已记录到 error.log", file=sys.stderr)

    # 3. 确保钩子本身不会抛出异常
    # 如果钩子抛出异常，解释器会打印 "Error in sys.excepthook" 并使用默认钩子

sys.excepthook = custom_excepthook

# 正确的临时添加方式
import os, sys
lib_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'libs')
if lib_path not in sys.path:
    sys.path.insert(0, lib_path)              # insert(0, ...) 而非 append()

# 错误做法：没有 finally 保护
sys.stdout = io.StringIO()
do_something()                                 # 如果这里抛异常，stdout 永远回不来
sys.stdout = original_stdout                   # 这行不会执行！

# 正确做法：使用 try...finally 或 contextlib
original_stdout = sys.stdout
try:
    sys.stdout = io.StringIO()
    do_something()
finally:
    sys.stdout = original_stdout               # 无论如何都会恢复

# 更好的做法：使用上下文管理器
with contextlib.redirect_stdout(io.StringIO()):
    do_something()                             # 自动恢复

a = "hello"                                    # 引用计数 = 1 (变量 a)
# 调用 getrefcount(a) 时：
#   - 参数传递创建临时引用 → 引用计数 = 2
#   - 函数内部可能还有其他引用 → 可能更多
print(sys.getrefcount(a))                      # 输出通常 > 2
# 对于短字符串，CPython 有内部缓存（intern），引用计数可能更高