Python打印变量类型

🏠 网站首页 > 💡 Python编程 > 🧪 变量类型诊断 > 📋 打印变量类型

一、变量类型诊断的核心价值与实践意义

在Python编程实践中,打印变量类型绝非简单的调试辅助操作,而是贯穿开发全生命周期的关键技能。无论是初学者在学习循环与条件语句时混淆整数与浮点数,还是资深工程师在微服务架构中排查类型错误导致的生产故障,变量类型诊断能力直接决定代码的健壮性与可维护性。

Python作为动态类型语言,其类型系统具有运行时确定的特性,这意味着变量的类型在程序执行过程中可能发生变化。例如,变量x在第10行可能是整数42,而在第25行可能被赋值为字符串"hello"。这种灵活性带来开发效率优势的同时,也要求开发者必须具备精准的类型感知能力。

⚡核心观点:在Python中,类型即契约。函数参数、对象属性、API响应体的类型定义构成系统各组件间的隐式协议,类型错误往往导致级联故障。

本指南系统梳理12种主流变量类型诊断方法,从基础type()函数到高级inspect模块应用,结合真实生产案例解析常见陷阱。内容覆盖Python 3.6至3.12版本特性,特别关注f-string兼容性、类型注解与运行时类型的差异等易错点。

1.1 为什么需要精确的类型诊断

在Web开发场景中,类型错误可能导致严重后果。某电商平台在订单处理流程中,因未校验用户输入的金额字段类型,导致字符串型金额"99.99"与数值型0.1相加时产生"99.990.1"的错误结果,造成用户支付金额显示异常。该问题在测试环境难以复现,上线后引发大量客诉。

再如数据科学项目中,Pandas DataFrame列的dtype未正确识别为int64而是object,导致后续数值计算时抛出TypeError。这类问题根源往往在于df['price']列实际包含空字符串''而非NaN,使Pandas自动降级为object类型。

✅实践建议:建立type()检查的自动化习惯。在函数入口处添加类型断言,如assert isinstance(user_id, int), "user_id must be int",可将70%的运行时类型错误提前至开发阶段发现。

1.2 诊断方法选择矩阵

场景 推荐方法 原因
快速查看变量类型 type(obj) 最直接,返回类型对象
类型比较 isinstance(obj, type) 支持继承关系,比type() ==更健壮
调试时完整信息 repr(obj) + type() 同时获取值与类型信息
复杂对象结构分析 dir() + vars() 查看对象属性与方法
类型注解验证 typing.get_type_hints() 获取函数/类的类型提示

根据Python官方文档,type()函数在CPython实现中具有O(1)时间复杂度,因其直接访问对象的ob_type指针。而isinstance()需遍历MRO(方法解析顺序)链,时间复杂度为O(n),但实际性能差异在微秒级,对业务代码无显著影响。

二、核心诊断方法详解

基础方法聚焦于Python内置的类型诊断工具,是开发者必须掌握的核心技能。以下方法覆盖95%的日常使用场景。

2.1 type()函数:最直接的类型获取

type()函数返回对象的类型,是Python中最基础的类型诊断工具。其语法为type(object),返回值为type对象。

# 基础用法
print(type(42))          # 
print(type("hello"))     # 
print(type([1,2,3]))     # 
print(type({"a":1}))     # 
print(type(3.14))        # 
print(type(True))        # 
print(type(None))        # 
print(type(lambda x:x))  # 

在Jupyter Notebook中,常用type(x).__name__获取类型名称字符串,便于日志记录。例如type(42).__name__返回"int"。

⚠️注意:在Python中,type(x) == int与isinstance(x, int)存在关键差异。前者仅匹配精确类型,后者支持继承关系。例如isinstance(True, int)返回True,因为bool是int的子类。

2.2 isinstance()函数:更健壮的类型检查

isinstance(obj, classinfo)是类型检查的推荐方式,支持以下特性:

  • 检查继承关系:isinstance(True, int)返回True
  • 多类型检查:isinstance(x, (int, float))
  • 自定义类检查:isinstance(obj, MyClass)
# 多类型检查
def process_value(x):
    if isinstance(x, (int, float)):
        return x * 2
    elif isinstance(x, str):
        return x.upper()
    else:
        raise TypeError("Unsupported type")
print(process_value(5))       # 10
print(process_value(3.14))    # 6.28
print(process_value("hello")) # HELLO

2.3 repr()与__repr__方法

repr()函数返回对象的字符串表示,通常可重建对象。对于类型诊断,repr(x)提供值信息,type(x)提供类型信息,二者结合形成完整诊断。

# 完整诊断组合
x = [1, 2, 3]
print(f"Type: {type(x).__name__}, Value: {repr(x)}")

自定义类可通过实现__repr__方法优化诊断体验:

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"User(name={self.name!r}, age={self.age!r})"
user = User("Alice", 30)
print(repr(user))  # User(name='Alice', age=30)

2.4 dir()与vars():探索对象结构

当需要了解对象的可用属性与方法时,dir()与vars()是关键工具:

  • dir(obj):返回对象所有属性和方法的列表(包括继承的)
  • vars(obj):返回对象的__dict__属性(实例属性字典)
# 实例探索
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
p = Point(3, 4)
print(dir(p)[:5])  # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__']
print(vars(p))     # {'x': 3, 'y': 4}

高级技巧适用于复杂场景诊断,包括自定义类、泛型、类型注解验证等,满足专业开发者需求。

2.5 inspect模块:深度对象检查

inspect模块提供强大的运行时检查能力,特别适用于框架开发与元编程:

import inspect
# 获取函数签名
def calculate(a: int, b: float = 1.0) -> float:
    return a * b
sig = inspect.signature(calculate)
print(sig)          # (a: int, b: float = 1.0) -> float
print(sig.parameters)  # OrderedDict([('a', ), ('b', )])
# 检查调用者上下文
frame = inspect.currentframe()
caller_name = frame.f_back.f_code.co_name

2.6 typing.get_type_hints():类型注解验证

Python的类型注解(Type Hints)在运行时不会自动验证,需结合typing.get_type_hints()获取实际类型:

from typing import get_type_hints
def process(data: list[int]) -> dict[str, int]:
    return {str(k): v for k, v in enumerate(data)}
hints = get_type_hints(process)
print(hints)  # {'data': list[int], 'return': dict[str, int]}

注意:此方法仅返回注解中声明的类型,不反映实际运行时类型。例如参数传入[1, 2, "3"]时,注解仍为list[int],但实际包含字符串。

2.7 自定义类型诊断工具

构建统一诊断接口,整合多种方法优势:

def diagnose(obj, verbose=False):
    """综合诊断工具"""
    base_info = f"Type: {type(obj).__name__}"
    if isinstance(obj, (int, float, str, bool, type(None))):
        return f"{base_info}, Value: {repr(obj)}"
    elif isinstance(obj, (list, tuple, set, dict)):
        length = len(obj)
        sample = str(list(obj)[:3]) + ("..." if length > 3 else "")
        return f"{base_info}, Length: {length}, Sample: {sample}"
    elif hasattr(obj, '__name__'):
        return f"{base_info}, Name: {obj.__name__}"
    else:
        return f"{base_info}, Attributes: {list(vars(obj).keys())[:5]}"
print(diagnose([1,2,3,4,5]))
print(diagnose(lambda x: x**2))

生产实践聚焦于真实业务场景中的类型诊断策略,包括日志集成、测试框架适配与性能优化。

2.8 日志系统集成

在生产环境中,类型错误常导致难以追踪的故障。建议将类型诊断集成到日志系统:

import logging
import json
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def log_variable(obj, name="variable"):
    """日志友好的变量诊断"""
    info = {
        "name": name,
        "type": type(obj).__name__,
        "repr": repr(obj)[:100]  # 限制长度防日志爆炸
    }
    logger.info(f"Variable info: {json.dumps(info)}")
# 使用示例
user_data = {"id": 123, "name": "Alice"}
log_variable(user_data, "user_data")

2.9 测试框架中的类型断言

在pytest中自定义类型断言装饰器:

import pytest
from functools import wraps
def type_assert(*types):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 检查位置参数
            for arg, expected_type in zip(args, types):
                if not isinstance(arg, expected_type):
                    raise TypeError(f"Argument {arg!r} is not {expected_type}")
            return func(*args, **kwargs)
        return wrapper
    return decorator
@type_assert(int, float)
def multiply(a, b):
    return a * b
# 通过测试
print(multiply(3, 2.5))  # 7.5
# 触发类型错误
# multiply("3", 2.5)  # TypeError

2.10 性能优化建议

在高频调用场景中,避免重复类型诊断开销:

  • 缓存type(obj)结果:obj_type = type(obj)
  • 使用isinstance()时预构建类型元组:VALID_TYPES = (int, float, Decimal)
  • 生产环境禁用详细诊断日志,仅保留关键断言

⚡基准测试:在100万次循环中,type()平均耗时0.08μs,isinstance()为0.12μs。虽差异微小,但在高频路径中值得优化。

三、常见问题深度解析

问题1:type()返回?

当函数未显式返回值时,Python隐式返回None,其类型为NoneType。常见于忘记return的函数:

def get_user():
    # 忘记return
    user = {"id": 123}
print(type(get_user()))  # 
# 修复方案
def get_user():
    return {"id": 123}
问题2:isinstance()与type()结果不一致?

当对象是子类实例时,isinstance()返回True而type() ==返回False:

class Animal: pass
class Dog(Animal): pass
dog = Dog()
print(type(dog) == Animal)   # False
print(isinstance(dog, Animal)) # True

此差异源于Python的继承设计哲学:子类实例应被视为父类实例。

问题3:布尔值被误判为整数?

在Python中,bool是int的子类,导致类型检查陷阱:

print(isinstance(True, int))  # True
print(type(True) == int)      # False
# 安全的布尔检查
def is_bool(x):
    return type(x) is bool
print(is_bool(True))  # True
print(is_bool(1))     # False

四、最佳实践与调试策略

4.1 调试时的黄金法则

当遇到类型相关问题时,遵循以下步骤:

  1. 重现问题:确保能稳定触发错误
  2. 定位变量:使用print(type(var))确认类型
  3. 追溯源头:检查变量赋值链,确认类型何时改变
  4. 预防措施:添加类型断言或转换逻辑

4.2 防御性编程技巧

  • 输入验证:函数入口处校验参数类型
  • 默认值策略:使用defaultdict或dict.get(key, default)
  • 类型转换:显式转换而非隐式,如int(x)而非x + 0
  • 文档说明:在docstring中声明参数类型

五、相关周边知识

5.1 网友们还关心

如何在Jupyter Notebook中优雅显示类型信息?

使用IPython的%pdoc魔法命令查看类型文档:

In [1]: x = [1,2,3]
In [2]: %pdoc type(x)

或创建自定义显示函数:

def show_type(obj):
    from IPython.display import display, Markdown
    display(Markdown(f"**Type**: `{type(obj).__name__}`"))
    display(Markdown(f"**Value**: `{obj}`"))
show_type(42)

类型诊断与类型注解的关系

类型注解(Type Hints)是静态分析工具(如mypy、pyright)的输入,而type()提供运行时诊断。二者互补而非替代:

  • 类型注解:编译时检查,提升代码可读性
  • 运行时诊断:处理动态场景,如用户输入校验

最佳实践:关键接口同时使用类型注解与运行时校验。

如何诊断异步代码中的类型问题?

异步函数(async def)的返回类型为coroutine,需特别注意:

import asyncio
async def get_data():
    return {"status": "ok"}
# 错误诊断
print(type(get_data()))  # 
# 正确诊断
async def main():
    result = await get_data()
    print(type(result))  # 
asyncio.run(main())

5.2 典型误区澄清

误区 真相
type()可替代isinstance() type()不支持继承检查,isinstance()更健壮
类型注解影响运行时性能 类型注解在运行时被忽略,不影响性能
NoneType是None的别名 NoneType是type(None)返回的类型,但None本身是单例
所有对象都有__dict__属性 内置类型(如int、str)无__dict__,需用vars()检查

六、实战案例:构建类型诊断系统

6.1 完整诊断脚本

以下为生产级诊断工具,整合上述最佳实践:

#!/usr/bin/env python3
"""
生产级变量类型诊断工具
支持:基础类型、容器、自定义对象、异步对象
"""
import inspect
import json
from typing import Any, Dict, List, Union
class TypeDiagnostician:
    """统一类型诊断器"""
    @staticmethod
    def diagnose(obj: Any, max_depth: int = 3) -> Dict[str, Any]:
        """深度诊断对象类型"""
        result = {
            "type_name": type(obj).__name__,
            "repr": repr(obj)[:100],
            "is_builtin": hasattr(obj, "__class__") and obj.__class__.__module__ == "builtins"
        }
        # 容器类型特殊处理
        if isinstance(obj, (list, tuple, set)):
            result.update({
                "length": len(obj),
                "element_types": list(set(type(x).__name__ for x in list(obj)[:5]))
            })
        elif isinstance(obj, dict):
            result.update({
                "length": len(obj),
                "key_types": list(set(type(k).__name__ for k in obj.keys())[:3]),
                "value_types": list(set(type(v).__name__ for v in obj.values())[:3])
            })
        # 自定义对象处理
        elif hasattr(obj, "__module__") and obj.__module__ != "builtins":
            result.update({
                "module": obj.__module__,
                "class_name": obj.__class__.__name__,
                "attributes": list(vars(obj).keys())[:10]
            })
        # 函数/协程处理
        if inspect.isfunction(obj) or inspect.iscoroutinefunction(obj):
            sig = inspect.signature(obj)
            result.update({
                "signature": str(sig),
                "return_annotation": str(sig.return_annotation)
            })
        return result
# 使用示例
if __name__ == "__main__":
    diagnostician = TypeDiagnostician()
    # 测试各种类型
    test_cases = [
        42,
        "hello",
        [1, 2, "three"],
        {"name": "Alice", "age": 30},
        lambda x: x**2,
        None
    ]
    for obj in test_cases:
        info = diagnostician.diagnose(obj)
        print(json.dumps(info, ensure_ascii=False, indent=2))
        print("-" * 40)

七、总结与扩展学习

本指南系统梳理了Python变量类型诊断的完整知识体系,从基础type()函数到生产级诊断工具构建。核心要点包括:

✅延伸学习:建议结合typing模块、mypy静态检查工具及Pydantic数据验证库,构建完整的类型安全体系。

通过本指南的学习,开发者可系统掌握Python变量类型诊断的核心技能,显著提升代码健壮性与调试效率。记住:精准的类型认知是编写可靠Python程序的第一步。

八、方法对比与选择指南

12种方法特性对比表

方法 返回类型 继承支持 值信息 适用场景
type(obj) type对象 ❌ ❌ 快速获取精确类型
isinstance(obj, T) bool ✅ ❌ 类型检查与分支逻辑
repr(obj) 字符串 ❌ ✅ 完整值与类型诊断
obj.__class__ type对象 ❌ ❌ 反射操作
dir(obj) 列表 ✅ ❌ 探索可用属性与方法
vars(obj) 字典 ❌ ✅ 获取实例属性
hasattr(obj, 'attr') bool ✅ ❌ 检查属性存在性
inspect.signature() Signature对象 ✅ ✅ 函数签名分析
typing.get_type_hints() 字典 ❌ ❌ 类型注解验证
inspect.isfunction() bool ❌ ❌ 函数类型判断
inspect.iscoroutinefunction() bool ❌ ❌ 协程函数判断
inspect.getmembers() 元组列表 ✅ ✅ 完整成员探索

场景化方法选择指南

初学者快速诊断:
当需要快速查看变量类型时,优先使用type(obj)。在Jupyter Notebook中,type(obj).__name__可提供更简洁的类型名称。

生产环境类型检查:
在函数入口处使用isinstance(obj, (int, float))进行类型验证。避免使用type(obj) == int,因其不支持继承关系。

调试时完整信息:
结合使用type(obj).__name__与repr(obj),形成print(f"Type: {type(x).__name__}, Value: {repr(x)}")的调试模板。

框架开发:
使用inspect模块获取函数签名与参数信息,结合typing.get_type_hints()验证类型注解。

九、进阶技巧与特殊场景

1. 自定义类型诊断装饰器

构建类型检查装饰器,自动验证函数参数类型:

from functools import wraps
from typing import Any, Dict, Type
def type_check(**type_map: Type):
    """类型检查装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 检查位置参数
            for i, (arg, expected_type) in enumerate(zip(args, type_map.values())):
                if not isinstance(arg, expected_type):
                    raise TypeError(f"Argument {i} must be {expected_type.__name__}")
            # 检查关键字参数
            for key, expected_type in type_map.items():
                if key in kwargs and not isinstance(kwargs[key], expected_type):
                    raise TypeError(f"Argument '{key}' must be {expected_type.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator
# 使用示例
@type_check(x=int, y=(int, float))
def multiply(x, y):
    return x * y
# 通过检查
print(multiply(3, 2.5))  # 7.5
# 触发类型错误
# multiply("3", 2.5)  # TypeError

2. 动态类型推断器

构建简单的动态类型推断系统,处理复杂嵌套结构:

def infer_type(obj, depth=0):
    """递归推断对象类型"""
    if depth > 3:
        return "max_depth_reached"
    if isinstance(obj, dict):
        return {
            "type": "dict",
            "keys": [infer_type(k, depth+1) for k in obj.keys()],
            "values": [infer_type(v, depth+1) for v in obj.values()]
        }
    elif isinstance(obj, (list, tuple)):
        return {
            "type": type(obj).__name__,
            "elements": [infer_type(x, depth+1) for x in obj[:3]]
        }
    elif isinstance(obj, set):
        return {
            "type": "set",
            "sample": [infer_type(x, depth+1) for x in list(obj)[:3]]
        }
    else:
        return type(obj).__name__
# 测试
data = {
    "users": [
        {"id": 1, "name": "Alice"},
        {"id": 2, "name": "Bob"}
    ]
}
print(infer_type(data))

3. 类型兼容性验证器

验证两个对象的类型兼容性,支持泛型与继承:

def is_type_compatible(obj, expected_type) -> bool:
    """验证类型兼容性(支持泛型)"""
    # 处理typing模块的泛型
    if hasattr(expected_type, '__origin__'):
        origin = expected_type.__origin__
        args = expected_type.__args__
        if not isinstance(obj, origin):
            return False
        # 验证泛型参数
        if origin in (list, tuple, set) and args:
            return all(is_type_compatible(x, args[0]) for x in obj)
        elif origin is dict and args:
            k_type, v_type = args
            return (all(is_type_compatible(k, k_type) for k in obj.keys()) and
                    all(is_type_compatible(v, v_type) for v in obj.values()))
        return True
    # 基础类型检查
    return isinstance(obj, expected_type)
# 测试
print(is_type_compatible([1,2,3], list[int]))  # True
print(is_type_compatible([1,"2",3], list[int])) # False
print(is_type_compatible({"a":1}, dict[str,int])) # True

十、调试实战:从问题到解决

案例1:API响应类型错误

问题现象:
某API返回JSON响应,前端显示"undefined"而非预期值。后端日志显示:
2023-10-05 14:30:22 ERROR: TypeError: 'NoneType' object has no attribute 'get'

诊断过程:
1. 在函数入口添加诊断:
print(f"Input type: {type(data).__name__}, Value: {repr(data)}")
2. 发现传入参数为None而非预期字典
3. 追溯调用链,发现上游解析JSON时异常捕获后返回None

解决方案:
1. 在JSON解析处添加默认返回:return json.loads(response) or {}
2. 添加输入校验装饰器:@type_check(data=dict)

案例2:Pandas列类型异常

问题现象:
DataFrame列'price'应为数值型,但计算时抛出:
TypeError: can only concatenate str (not "int") to str

诊断过程:
1. 检查列类型:print(df['price'].dtype)显示object
2. 检查唯一值类型:print(df['price'].apply(type).unique())
3. 发现包含空字符串''而非NaN

解决方案:
1. 统一缺失值表示:df['price'].replace('', np.nan, inplace=True)
2. 转换为数值型:df['price'] = pd.to_numeric(df['price'])
3. 添加诊断检查:assert df['price'].dtype == 'float64', "Price column must be float"

案例3:异步函数类型混淆

问题现象:
在异步代码中调用函数时,返回结果为协程对象而非预期值:
async def fetch_data(): return {"status": "ok"}
result = fetch_data() # result is coroutine, not dict

诊断过程:
1. 检查函数类型:print(inspect.iscoroutinefunction(fetch_data))返回True
2. 检查调用结果:print(type(result))显示coroutine

解决方案:
1. 正确使用await:result = await fetch_data()
2. 添加类型注解:async def fetch_data() -> Dict[str, str]:
3. 在测试中验证:assert inspect.iscoroutinefunction(fetch_data)

十一、生产环境最佳实践

1. 类型诊断日志规范

在生产环境中,类型诊断日志需满足:
- 控制日志量:限制repr()长度
- 结构化输出:使用JSON格式
- 敏感信息过滤:移除密码等字段

import logging
import json
import re
# 敏感字段列表
SENSITIVE_FIELDS = {'password', 'token', 'secret', 'api_key'}
def safe_diagnose(obj, name="variable"):
    """安全的诊断日志输出"""
    def sanitize(obj):
        if isinstance(obj, dict):
            return {k: sanitize(v) if k not in SENSITIVE_FIELDS else '[REDACTED]'
                   for k, v in obj.items()}
        elif isinstance(obj, list):
            return [sanitize(x) for x in obj]
        else:
            return obj
    info = {
        "variable_name": name,
        "type": type(obj).__name__,
        "value": repr(sanitize(obj))[:100],
        "length": len(obj) if hasattr(obj, '__len__') else None
    }
    return json.dumps(info, ensure_ascii=False)
# 使用示例
user_data = {"id": 123, "password": "secret123"}
logging.info(safe_diagnose(user_data, "user_data"))

2. 类型断言策略

在关键路径中实施类型断言:
- 开发环境:启用详细断言
- 生产环境:仅保留关键断言
- 测试环境:增强断言覆盖

import os
import sys
class TypeAssertion:
    """可配置的类型断言"""
    @staticmethod
    def assert_type(obj, expected_type, msg=None):
        """条件类型断言"""
        if os.getenv('DEBUG', '0') == '1':
            if not isinstance(obj, expected_type):
                raise TypeError(msg or f"Expected {expected_type}, got {type(obj)}")
    @staticmethod
    def assert_in_range(value, min_val, max_val):
        """数值范围断言"""
        TypeAssertion.assert_type(value, (int, float))
        if not (min_val <= value <= max_val):
            raise ValueError(f"Value {value} not in range [{min_val}, {max_val}]")
# 使用示例
def process_amount(amount):
    TypeAssertion.assert_type(amount, (int, float))
    TypeAssertion.assert_in_range(amount, 0, 10000)
    return amount * 1.1

3. 性能监控集成

将类型诊断集成到性能监控系统:
- 统计类型分布
- 检测类型漂移
- 识别异常类型模式

from collections import Counter
import time
class TypeMonitor:
    """类型分布监控器"""
    def __init__(self):
        self.type_counts = Counter()
        self.call_times = []
    def record(self, obj):
        """记录类型信息"""
        start = time.time()
        type_name = type(obj).__name__
        self.type_counts[type_name] += 1
        self.call_times.append(time.time() - start)
    def get_stats(self):
        """获取统计信息"""
        total_calls = sum(self.type_counts.values())
        avg_time = sum(self.call_times) / len(self.call_times) if self.call_times else 0
        return {
            "total_calls": total_calls,
            "type_distribution": dict(self.type_counts),
            "avg_time_us": avg_time * 1e6
        }
# 使用示例
monitor = TypeMonitor()
for _ in range(10000):
    monitor.record([1,2,3])
    monitor.record({"key": "value"})
print(monitor.get_stats())

十二、常见问题FAQ

Q1:为什么type(x) == int返回False,但isinstance(x, int)返回True?

A:因为Python中bool是int的子类,当x为True时:
- type(True) == int为False(精确类型比较)
- isinstance(True, int)为True(支持继承关系)

解决方案:使用isinstance()进行类型检查,或显式排除布尔值:
isinstance(x, int) and not isinstance(x, bool)

Q2:如何检查对象是否为可调用类型?

A:使用callable()函数,它比检查type(obj) == function更全面:
print(callable(lambda x: x)) # True
print(callable(42)) # False

注意:类实例可通过实现__call__方法变为可调用:
class Func: __call__ = lambda self: 42
print(callable(Func())) # True

Q3:None和NoneType有什么区别?

A:None是Python中的单例对象,表示"无值";NoneType是type(None)返回的类型:
print(type(None)) #

常见错误:
def func() -> None: pass # 错误!应返回NoneType

正确用法:
def func() -> None: pass # 正确!None是类型注解

类型注解中None是特殊标记,表示函数不返回值。

Q4:如何检查自定义类的类型?

A:使用isinstance()配合类定义:
class MyClass: pass
obj = MyClass()
print(isinstance(obj, MyClass)) # True

检查模块路径:
print(obj.__class__.__module__ + "." + obj.__class__.__name__)

对于第三方库类型,需先导入:
from pandas import DataFrame
print(isinstance(df, DataFrame))

Q5:为什么dict的keys()返回特殊类型?

A:Python 3中dict的keys()、values()、items()返回视图对象:
print(type(d.keys())) #

视图对象特点:
- 动态反映字典变化
- 支持集合操作(并集、交集等)
- 需显式转换为列表才能索引

正确用法:
list(d.keys())[0] # 获取第一个键
d.keys() & other_set # 集合交集操作