callable()：判断对象是否"可调用"
1. 基本用法
callable()函数就像是一个"能力检测器"，它可以判断一个对象是否可以被调用（即是否可以使用括号()来执行）。
# 检测不同类型对象的可调用性
def normal_function():
return "我是一个函数"
class MyClass:
def __init__(self):
self.name = "示例类"
# 测试各种对象
print(callable(normal_function)) # True - 函数是可调用的
print(callable(MyClass)) # True - 类是可调用的（调用类会创建实例）
print(callable(MyClass())) # False - 默认实例不可调用
# 添加__call__方法后，让实例可调用
class CallableClass:
def __call__(self):
return "现在我可以被调用了！"
callable_instance = CallableClass()
print(callable(callable_instance)) # True
print(callable_instance()) # "现在我可以被调用了！"
2. 实际应用场景
# 动态调用验证
def safe_call(func, *args, **kwargs):
"""安全调用函数，避免AttributeError"""
if callable(func):
return func(*args, **kwargs)
else:
raise TypeError(f"对象 {func} 不可调用")
# 插件系统中的应用
class PluginSystem:
def __init__(self):
self.plugins = []
def register_plugin(self, plugin):
"""注册插件，确保插件有call方法"""
if callable(plugin):
self.plugins.append(plugin)
else:
print(f"警告: {plugin} 不是可调用对象，无法注册")
def run_all(self):
"""运行所有插件"""
for plugin in self.plugins:
if callable(plugin):
plugin()
# 使用示例
def simple_plugin():
print("简单插件执行")
system = PluginSystem()
system.register_plugin(simple_plugin) # 成功注册
system.register_plugin("不是函数") # 会发出警告
chr()：数字到字符的"翻译官"
1. 基础字符转换
chr()函数将Unicode码点转换为对应的字符，是ord()函数的逆操作。
# 基本ASCII字符
print(chr(65)) # 'A' - 大写A
print(chr(97)) # 'a' - 小写a
print(chr(48)) # '0' - 数字0
# 特殊符号和表情
print(chr(169)) # '©' - 版权符号
print(chr(8364)) # '€' - 欧元符号
print(chr(128512)) # '😀' - 笑脸表情
# 实用范围示例
for code in range(65, 91): # A-Z
print(chr(code), end=' ')
# 输出: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
2. 实际应用：密码生成器
import random
def generate_password(length=8, use_special_chars=True):
"""生成随机密码"""
password = []
# 数字范围
numbers = [chr(i) for i in range(48, 58)] # 0-9
# 小写字母
lower_case = [chr(i) for i in range(97, 123)] # a-z
# 大写字母
upper_case = [chr(i) for i in range(65, 91)] # A-Z
# 特殊字符
special_chars = [chr(33), chr(35), chr(36), chr(37), chr(38)] # ! # $ % &
# 组合所有字符
all_chars = numbers + lower_case + upper_case
if use_special_chars:
all_chars.extend(special_chars)
# 生成密码
for _ in range(length):
password.append(random.choice(all_chars))
return ''.join(password)
# 生成密码示例
print(f"简单密码: {generate_password(6, use_special_chars=False)}")
print(f"复杂密码: {generate_password(12, use_special_chars=True)}")
@classmethod：面向类的"团队协作"
1. 基本概念和使用
类方法将方法绑定到类而不是实例，第一个参数是类本身（通常命名为cls）。
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
@classmethod
def from_string(cls, date_string):
"""从字符串创建Date实例"""
year, month, day = map(int, date_string.split('-'))
return cls(year, month, day) # 相当于调用Date(year, month, day)
@classmethod
def from_timestamp(cls, timestamp):
"""从时间戳创建Date实例（模拟）"""
# 简化实现，实际中会使用datetime库
return cls(2024, 1, 1) # 返回固定日期
def __str__(self):
return f"{self.year}-{self.month:02d}-{self.day:02d}"
# 使用不同的构造方法
date1 = Date(2024, 1, 15) # 传统构造
date2 = Date.from_string("2024-01-20") # 类方法构造
date3 = Date.from_timestamp(1642204800) # 另一个类方法
print(f"日期1: {date1}")
print(f"日期2: {date2}")
print(f"日期3: {date3}")
2. 实际应用：工厂模式
class Animal:
def __init__(self, name, sound):
self.name = name
self.sound = sound
@classmethod
def create_dog(cls):
"""创建狗实例的工厂方法"""
return cls("狗", "汪汪")
@classmethod
def create_cat(cls):
"""创建猫实例的工厂方法"""
return cls("猫", "喵喵")
@classmethod
def create_animal(cls, animal_type):
"""通用动物工厂"""
animals = {
'dog': ("狗", "汪汪"),
'cat': ("猫", "喵喵"),
'duck': ("鸭子", "嘎嘎")
}
if animal_type in animals:
name, sound = animals[animal_type]
return cls(name, sound)
else:
raise ValueError(f"不支持的动物类型: {animal_type}")
def speak(self):
return f"{self.name}说: {self.sound}"
# 使用工厂方法创建对象
dog = Animal.create_dog()
cat = Animal.create_cat()
duck = Animal.create_animal('duck')
print(dog.speak()) # 狗说: 汪汪
print(cat.speak()) # 猫说: 喵喵
print(duck.speak()) # 鸭子说: 嘎嘎
compile()：代码的"编译器"
1. 基础编译功能
compile()函数将源代码字符串编译为可执行的代码对象或AST对象。
# 编译简单表达式
code_str = "x + y * 2"
compiled_code = compile(code_str, '<string>', 'eval')
# 执行编译后的代码
x, y = 5, 3
result = eval(compiled_code)
print(f"表达式结果: {result}") # 5 + 3 * 2 = 11
# 编译多行代码（语句序列）
multi_line_code = """
for i in range(3):
print(f"数字: {i}")
"""
compiled_exec = compile(multi_line_code, '<string>', 'exec')
exec(compiled_exec)
2. 实际应用：简单公式计算器
def safe_calculator(expression, variables=None):
"""安全的公式计算器"""
if variables is None:
variables = {}
try:
# 编译表达式为eval模式
compiled = compile(expression, '<calculator>', 'eval')
# 安全地执行（限制可用变量）
allowed_vars = {'__builtins__': None} # 限制内置函数
allowed_vars.update(variables)
result = eval(compiled, allowed_vars)
return result
except SyntaxError as e:
return f"公式语法错误: {e}"
except Exception as e:
return f"计算错误: {e}"
# 使用示例
variables = {'a': 10, 'b': 5, 'c': 2}
expressions = [
"a + b * c", # 正常计算
"(a + b) * c", # 带括号
"max(a, b, c)", # 会报错（max被限制）
"invalid syntax" # 语法错误
]
for expr in expressions:
result = safe_calculator(expr, variables)
print(f"{expr} = {result}")
complex()：复数的"创造者"
1. 多种创建方式
complex()函数提供了多种创建复数的方式，非常灵活。
# 方式1：从字符串创建
c1 = complex("3+4j")
print(f"从字符串: {c1}") # (3+4j)
# 方式2：分别指定实部和虚部
c2 = complex(3, 4)
print(f"分别指定: {c2}") # (3+4j)
# 方式3：只指定实部或虚部
c3 = complex(5) # 实部为5，虚部为0
c4 = complex(imag=7) # 实部为0，虚部为7
print(f"只有实部: {c3}") # (5+0j)
print(f"只有虚部: {c4}") # 7j
# 方式4：从其他数字类型转换
c5 = complex(3.14) # 浮点数转复数
print(f"浮点转换: {c5}") # (3.14+0j)
2. 实际应用：复数运算工具
class ComplexCalculator:
"""复数计算工具类"""
@staticmethod
def parse_complex(input_str):
"""解析复数字符串"""
try:
return complex(input_str.replace(' ', '')) # 去除空格
except ValueError:
raise ValueError(f"无法解析复数: {input_str}")
@staticmethod
def add(c1, c2):
"""复数加法"""
return complex(c1.real + c2.real, c1.imag + c2.imag)
@staticmethod
def multiply(c1, c2):
"""复数乘法：(a+bi)(c+di) = (ac-bd) + (ad+bc)i"""
real_part = c1.real * c2.real - c1.imag * c2.imag
imag_part = c1.real * c2.imag + c1.imag * c2.real
return complex(real_part, imag_part)
@staticmethod
def to_polar(complex_num):
"""转换为极坐标形式"""
import math
r = math.sqrt(complex_num.real**2 + complex_num.imag**2)
theta = math.atan2(complex_num.imag, complex_num.real)
return r, math.degrees(theta)
# 使用示例
calc = ComplexCalculator()
# 解析和计算
num1 = calc.parse_complex("3+4j")
num2 = calc.parse_complex("1-2j")
print(f"加法结果: {calc.add(num1, num2)}") # (4+2j)
print(f"乘法结果: {calc.multiply(num1, num2)}") # (11-2j)
# 极坐标表示
magnitude, angle = calc.to_polar(num1)
print(f"极坐标: 模长={magnitude:.2f}, 角度={angle:.1f}°")
总结
通过今天的探索，我们发现这些"熟悉又陌生"的内置函数其实蕴含着强大的功能：
- 1. callable() - 动态调用的安全卫士
- 3. @classmethod - 面向类的团队协作工具
