PY基础函数、自定义函数与高级函数

PY基础函数、自定义函数与高级函数

以下是函数主题的详细代码实例，涵盖基础到高级应用，帮助大家深入理

解Python函数的核心机制和编程技巧：

一. 函数的定义与基础知识

示例1：基本函数定义

# python

def greet(name):

"""返回问候语"""

return f"Hello, {name}!"

print(greet("Alice")) # Hello, Alice!

示例2：位置参数与默认参数

# python

def power(base, exponent=2):

return base ** exponent

print(power(3)) # 9 (32)

print(power(3, 3)) # 27 (33)

示例3：强制关键字参数（Python 3+）

# python

def register(name, *, email, age):

print(f"Name: {name}, Email: {email}, Age: {age}")

register("Bob", email="bob@example.com", age=25) # 正确

# register("Bob", "bob@example.com", 25) # 报错

示例4：可变参数`*args`和`**kwargs`

# python

def sum_all(*numbers): # 接收任意数量位置参数

return sum(numbers)

print(sum_all(1, 2, 3)) # 6

def print_profile(**details): # 接收任意数量关键字参数

for key, value in details.items():

print(f"{key}: {value}")

print_profile(name="Alice", age=30)

示例5：参数解包

# python

def connect(host, port):

print(f"Connecting to {host}:{port}")

params = ("localhost", 8080)

connect(*params) # 解包元组 -> Connecting to localhost:8080

options = {"host": "127.0.0.1", "port": 80}

connect(**options) # 解包字典 -> Connecting to 127.0.0.1:80

示例6：函数注解（Type Hints）

# python

def multiply(a: int, b: int) -> int:

return a * b

print(multiply(4, 5)) # 20

示例7：空函数与占位符

# python

def todo():

pass # 函数体待实现

todo()

示例8：返回多个值

# python

def analyze_numbers(numbers):

return min(numbers), max(numbers), sum(numbers)/len(numbers)

min_val, max_val, avg = analyze_numbers([2, 4, 6, 8])

print(f"Min: {min_val}, Max: {max_val}, Avg: {avg}") # Min:2,

Max:8, Avg:5.0

示例9：动态默认参数处理

# python

def add_item(item, items=None): # 避免默认参数陷阱

if items is None:

items = []

items.append(item)

return items

print(add_item(1)) # [1]

print(add_item(2)) # [2] item 默认None

示例10：函数属性赋值

# python

def func():

print("Function executed")

func.description = "This is a demo function"

print(func.description) # This is a demo function

---

二. 函数的调用与作用域

示例1：全局变量修改

# python

count = 0

def increment():

global count

count += 1 # 修改外层变量

increment()

print(count) # 1

示例2：嵌套函数与闭包

# python

def outer():

message = "Hello"

def inner():

print(message) # 捕获外层变量

return inner

closure = outer()

closure() # Hello

示例3：nonlocal关键字

# python

def counter():

num = 0

def increment():

nonlocal num

num += 1

return num

return increment

c = counter()

print(c(), c(), c()) # 1 2 3

示例4：局部变量覆盖

# python

x = 10

def test_scope():

x = 20 # 创建新的局部变量

print(x) # 20

test_scope()

print(x) # 10（全局变量不变）

示例5：函数生命周期

# python

def create_adder(n):

def adder(x):

return x + n

return adder

add5 = create_adder(5)

print(add5(3)) # 8（adder函数持续持有n=5的引用）

示例6：作用域链查找

# python

def level1():

x = 1

def level2():

def level3():

print(x) # 向上查找找到level1的x=1

level3()

level2()

level1() # 1

示例7：变量隐藏

# python

value = "global"

def outer():

value = "outer"

def inner():

value = "inner" # 隐藏外层变量

print(value)

inner()

print(value)

outer() # inner -> outer

print(value) # global

示例8：动态作用域模拟

# python

import inspect

def dynamic_scope():

frame = inspect.currentframe().f_back

print(frame.f_locals.get('x')) # 访问调用者的局部变量

def caller():

x = 10

dynamic_scope()

caller() # 10

示例9：函数作为命名空间

# python

def config():

host = "localhost"

port = 8080

return host, port

print(config()) # ('localhost', 8080)

示例10：del删除引用

# python

def demo():

x = 10

print(x)

del x # 删除局部变量

# print(x) # 报错：x未定义

demo()

三. 高阶函数

示例1：自定义高阶函数

# python

def apply_operation(func, a, b):

return func(a, b)

result = apply_operation(lambda x, y: x**y, 2, 3)

print(result) # 8

示例2：函数工厂

# python

def power_factory(exponent):

def power(base):

return base ** exponent

return power

square = power_factory(2)

cube = power_factory(3)

print(square(4), cube(3)) # 16 27

示例3：map应用

# python

numbers = [1, 2, 3, 4]

squared = list(map(lambda x: x**2, numbers))

print(squared) # [1, 4, 9, 16]

示例4：filter过滤

# python

data = [15, 20, 33, 42, 55]

even = list(filter(lambda x: x % 2 == 0, data))

print(even) # [20, 42]

示例5：reduce累积

# python

from functools import reduce

product = reduce(lambda x, y: x * y, [1, 2, 3, 4])

print(product) # 24

示例6：sorted自定义排序

# python

users = [{"name": "Alice", "age": 25}, {"name": "Bob", "age":

30}]

sorted_users = sorted(users, key=lambda u: u["age"],

reverse=True)

print(sorted_users) # [Bob, Alice]

示例7：函数组合

# python

def compose(f, g):

return lambda x: f(g(x))

add_two = lambda x: x + 2

square = lambda x: x ** 2

combined = compose(square, add_two)

print(combined(3)) # (3+2)^2=25

示例8：偏函数（functools.partial）

# python

from functools import partial

def multiply(a, b):

return a * b

double = partial(multiply, 2)

print(double(5)) # 10

示例9：函数记忆化（缓存）

# python

from functools import lru_cache

@lru_cache(maxsize=None)

def fibonacci(n):

if n <= 1:

return n

return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(50)) # 快速计算结果（无缓存会极慢）

示例10：回调函数

# python

def event_handler(callback):

print("事件发生！")

callback()

def on_click():

print("按钮被点击")

event_handler(on_click)

四. 装饰器（Decorator）

示例1：基础装饰器

# python

def simple_decorator(func):

def wrapper():

print("函数执行前")

func()

print("函数执行后")

return wrapper

@simple_decorator

def greet():

print("Hello World!")

greet()

# 输出：

# 函数执行前

# Hello World!

# 函数执行后

示例2：带参数的装饰器

# python

def repeat(n):

def decorator(func):

def wrapper(*args, **kwargs):

for _ in range(n):

result = func(*args, **kwargs)

return result

return wrapper

return decorator

@repeat(3)

def say_hello(name):

print(f"Hello {name}!")

say_hello("Alice")

# 输出3次：Hello Alice!

示例3：类装饰器

# python

class Logger:

def __init__(self, func):

self.func = func

def __call__(self, *args, **kwargs):

print(f"调用函数：{self.func.__name__}")

return self.func(*args, **kwargs)

@Logger

def calculate(x, y):

return x * y

print(calculate(3, 4))

# 输出：

# 调用函数：calculate

# 12

示例4：装饰器堆叠

# python

def bold(func):

def wrapper():

return "<b>" + func() + "</b>"

return wrapper

def italic(func):

def wrapper():

return "<i>" + func() + "</i>"

return wrapper

@bold

@italic

def text():

return "装饰器链式调用"

print(text()) # <b><i>装饰器链式调用</i></b>

示例5：保留元数据（使用functools.wraps）

# python

from functools import wraps

def preserve_metadata(func):

@wraps(func)

def wrapper(*args, **kwargs):

"""包装函数"""

return func(*args, **kwargs)

return wrapper

@preserve_metadata

def original():

"""原始函数文档"""

print(original.__name__) # original

print(original.__doc__) # 原始函数文档

示例6：带状态的装饰器

# python

def counter(func):

def wrapper(*args, **kwargs):

wrapper.calls += 1

print(f"第{wrapper.calls}次调用")

return func(*args, **kwargs)

wrapper.calls = 0

return wrapper

@counter

def example():

pass

example() # 第1次调用

example() # 第2次调用

示例7：异步函数装饰器

# python

import asyncio

def async_timer(func):

async def wrapper(*args, **kwargs):

start = asyncio.get_event_loop().time()

result = await func(*args, **kwargs)

end = asyncio.get_event_loop().time()

print(f"耗时：{end - start:.2f}秒")

return result

return wrapper

@async_timer

async def fetch_data():

await asyncio.sleep(1)

return "数据获取完成"

asyncio.run(fetch_data()) # 耗时：1.00秒

示例8：参数验证装饰器

# python

def validate_types(*types):

def decorator(func):

def wrapper(*args):

for arg, type_ in zip(args, types):

if not isinstance(arg, type_):

raise TypeError(f"参数 {arg} 类型错误，应为

{type_}")

return func(*args)

return wrapper

return decorator

@validate_types(int, int)

def add(a, b):

return a + b

print(add(2, 3)) # 5

# add("2", 3) # 触发TypeError

示例9：缓存装饰器（LRU）

# python

from functools import lru_cache

@lru_cache(maxsize=128)

def factorial(n):

return 1 if n <= 1 else n * factorial(n-1)

print(factorial(10)) # 3628800（首次计算）

print(factorial(10)) # 直接返回缓存结果

示例10：权限检查装饰器

# python

def require_role(role):

def decorator(func):

def wrapper(user, *args, **kwargs):

if user.get("role") != role:

raise PermissionError("权限不足")

return func(user, *args, **kwargs)

return wrapper

return decorator

@require_role("admin")

def delete_user(user):

print(f"用户 {user['name']} 已删除")

admin = {"name": "Alice", "role": "admin"}

guest = {"name": "Bob", "role": "guest"}

delete_user(admin) # 正常执行

# delete_user(guest) # 触发PermissionError

---

五. 递归函数

示例1：阶乘计算

# python

def factorial(n):

return 1 if n == 0 else n * factorial(n-1)

print(factorial(5)) # 120

示例2：目录遍历

# python

import os

def scan_dir(path, indent=0):

print(" " * indent + f"?? {os.path.basename(path)}")

for item in os.listdir(path):

full_path = os.path.join(path, item)

if os.path.isdir(full_path):

scan_dir(full_path, indent+4)

else:

print(" " * (indent+4) + f"?? {item}")

# scan_dir("/path/to/directory") # 实际使用时替换路径

示例3：汉诺塔问题

# python

def hanoi(n, source, target, auxiliary):

if n == 1:

print(f"移动圆盘 1 从 {source} 到 {target}")

return

hanoi(n-1, source, auxiliary, target)

print(f"移动圆盘 {n} 从 {source} 到 {target}")

hanoi(n-1, auxiliary, target, source)

hanoi(3, 'A', 'C', 'B')

示例4：快速排序

# python

def quicksort(arr):

if len(arr) <= 1:

return arr

pivot = arr[len(arr)//2]

left = [x for x in arr if x < pivot]

middle = [x for x in arr if x == pivot]

right = [x for x in arr if x > pivot]

return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1])) # [1, 1, 2, 3, 6, 8, 10]

示例5：二叉树的遍历

# python

class Node:

def __init__(self, value):

self.left = None

self.right = None

self.value = value

def inorder_traversal(root):

return (

inorder_traversal(root.left) + [root.value] +

inorder_traversal(root.right)

if root else []

# 构建树：

# 1

# / \

# 2 3

root = Node(1)

root.left = Node(2)

root.right = Node(3)

print(inorder_traversal(root)) # [2, 1, 3]

示例6：幂集生成（所有子集）

# python

def powerset(s):

if not s:

return [[]]

elem = s[0]

subsets = powerset(s[1:])

return subsets + [subset + [elem] for subset in subsets]

print(powerset([1,2,3])) # [[], [3], [2], [2,3], [1], [1,3],

[1,2], [1,2,3]]

示例7：最大公约数（欧几里得算法）

# python

def gcd(a, b):

return a if b == 0 else gcd(b, a % b)

print(gcd(48, 18)) # 6

示例8：组合数计算

# python

def combinations(n, k):

if k == 0 or k == n:

return 1

return combinations(n-1, k-1) + combinations(n-1, k)

print(combinations(5, 2)) # 10

示例9：全排列生成

# python

def permutations(arr):

if len(arr) <= 1:

return [arr]

result = []

for i in range(len(arr)):

first = [arr[i]]

rest = arr[:i] + arr[i+1:]

for p in permutations(rest):

result.append(first + p)

return result

print(permutations([1,2,3]))

# [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]

示例10：尾递归优化（Python需手动实现）

# python

def factorial_tail(n, accumulator=1):

if n == 0:

return accumulator

return factorial_tail(n-1, n * accumulator)

print(factorial_tail(5)) # 120

六. 匿名函数与lambda表达式

示例1：简单数学运算

# python

square = lambda x: x**2

print(square(5)) # 25

示例2：条件表达式

# python

is_positive = lambda x: True if x > 0 else False

print(is_positive(-5)) # False

示例3：多参数处理

# python

full_name = lambda first, last: f"{first} {last}"

print(full_name("张", "三")) # 张 三

示例4：闭包实现

# python

def multiplier(n):

return lambda x: x * n

double = multiplier(2)

print(double(8)) # 16

示例5：立即执行函数（IIFE）

# python

print((lambda x: x**3)(3)) # 27

示例6：字典排序

# python

students = [

{"name": "Alice", "score": 85},

{"name": "Bob", "score": 92}

]

sorted_students = sorted(students, key=lambda x: x["score"],

reverse=True)

print(sorted_students) # [Bob, Alice]

示例7：多条件排序

# python

data = [(2, "b"), (1, "a"), (2, "a")]

sorted_data = sorted(data, key=lambda x: (x[0], x[1]))

print(sorted_data) # [(1, 'a'), (2, 'a'), (2, 'b')]

示例8：过滤质数

# python

is_prime = lambda n: n > 1 and all(n%i !=0 for i in range(2, int

(n**0.5)+1))

print(list(filter(is_prime, range(20)))) # [2, 3, 5, 7, 11, 13,

17, 19]

示例9：矩阵转置

# python

matrix = [[1,2,3], [4,5,6]]

transpose = lambda m: list(zip(*m))

print(transpose(matrix)) # [(1,4), (2,5), (3,6)]

示例10：柯里化函数

# python

curry = lambda f: lambda x: lambda y: f(x, y)

add = curry(lambda x, y: x + y)

print(add(3)(5)) # 8

七. 函数的高级应用

示例1：生成器函数

# python

def countdown(n):

while n > 0:

yield n

n -= 1

for num in countdown(5):

print(num) # 5 4 3 2 1

示例2：协程实现

# python

def coroutine():

while True:

x = yield

print(f"收到：{x}")

c = coroutine()

next(c) # 激活协程

c.send(10) # 收到：10

示例3：生成器表达式

# python

squares = (x**2 for x in range(10))

print(sum(squares)) # 285

示例4：管道处理

# python

def read_file(filename):

with open(filename) as f:

for line in f:

yield line.strip()

def filter_comments(lines):

for line in lines:

if not line.startswith("#"):

yield line

pipeline = filter_comments(read_file("example.py"))

for line in pipeline:

print(line)

示例5：上下文管理器

# python

from contextlib import contextmanager

@contextmanager

def timer():

import time

start = time.time()

try:

yield

finally:

print(f"耗时：{time.time()-start:.2f}s")

with timer():

sum(range(1000000)) # 耗时：约0.02s

示例6：偏函数应用

# python

from functools import partial

def power(base, exponent):

return base ** exponent

square = partial(power, exponent=2)

print(square(5)) # 25

示例7：闭包状态保持

# python

def counter():

count = 0

def inc():

nonlocal count

count += 1

return count

return inc

c = counter()

print(c(), c(), c()) # 1 2 3

示例8：动态属性访问

# python

def get_attr(obj, attr):

return getattr(obj, attr, None)

class Person:

name = "Alice"

print(get_attr(Person, "name")) # Alice

示例9：函数组合

# python

def compose(*funcs):

def wrapper(arg):

for f in reversed(funcs):

arg = f(arg)

return arg

return wrapper

process = compose(str.upper, lambda s: s + "!")

print(process("hello")) # HELLO!

示例10：元编程（动态创建函数）

# python

def create_function(name):

code = f"def {name}():\n print('动态生成的函数！')"

exec(code, globals())

return locals()[name]

dynamic_func = create_function("special")

dynamic_func() # 动态生成的函数！

八. 函数式编程思想

示例1：纯函数

# python

# 纯函数：相同输入始终得到相同输出，无副作用

def pure_add(a, b):

return a + b

# 非纯函数：依赖外部状态

total = 0

def impure_add(a):

global total

total += a

return total

示例2：不可变数据结构

# python

def process_data(data):

# 创建新字典而不是修改原数据

return {**data, "processed": True}

original = {"id": 1}

new_data = process_data(original)

print(original) # {'id': 1}

print(new_data) # {'id': 1, 'processed': True}

示例3：函数链式调用

# python

from functools import reduce

data = [1, 2, 3, 4, 5]

result = reduce(lambda x,y: x+y,

filter(lambda x: x%2==0,

map(lambda x: x*2, data)))

print(result) # 12 (处理流程：x2 -> 过滤偶数 -> 求和)

示例4：模式匹配（Python 3.10+）

# python

def match_demo(value):

match value:

case (x, y):

print(f"元组：{x}, {y}")

case {"key": v}:

print(f"字典值：{v}")

case _:

print("未知类型")

match_demo((1,2)) # 元组：1, 2

match_demo({"key": 42}) # 字典值：42

示例5：惰性求值

# python

def lazy_evaluation():

yield 1

yield 2

yield 3

gen = lazy_evaluation()

print(next(gen)) # 1（按需生成）

示例6：记忆化实现

# python

def memoize(func):

cache = {}

def wrapper(*args):

if args not in cache:

cache[args] = func(*args)

return cache[args]

return wrapper

@memoize

def fibonacci(n):

return n if n <=1 else fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(50)) # 快速计算

示例7：高阶函数组合

# python

def both(pred1, pred2):

return lambda x: pred1(x) and pred2(x)

is_positive_even = both(lambda x: x > 0, lambda x: x%2 ==0)

print(is_positive_even(4)) # True

示例8：函数柯里化

# python

from functools import partial

def curry(func, arity):

def curried(*args):

if len(args) >= arity:

return func(*args)

return partial(curried, *args)

return curried

@curry(arity=3)

def add_three(a, b, c):

return a + b + c

print(add_three(1)(2)(3)) # 6

示例9：类型安全的函数式操作

# python

from typing import Callable, TypeVar, Type

# 定义一个类型变量 T

T = TypeVar('T')

# 示例：定义一个函数，接受一个类型并返回该类型的实例

def factory(cls: Type[T]) -> T:

return cls()

# 示例类

class Example:

def __init__(self):

self.value = 42

# 使用工厂函数创建 Example 的实例

example_instance: Example = factory(Example)

print(example_instance.value) # 输出: 42