Python函数¶

def 函数名(形参): 
    函数体

# 定义add函数实现两数之和
def add(a, b):
    return a + b

print(add(1, 2)) # 3

# 参数默认值

def add(a, b=1, c=2):
    return a + b + c

ret = add(1)

i = 10
def func(a = i):
    print(a)

i = 5
func()  # 10

def func(a, L=[]):
    L.append(a)
    return L

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

# 创建一个列表
fruits = ["苹果", "香蕉", "樱桃"]

# 添加元素
fruits.append("橙子")
print(fruits)  # 输出: ['苹果', '香蕉', '樱桃', '橙子']

# 修改元素
fruits[1] = "蓝莓"
print(fruits)  # 输出: ['苹果', '蓝莓', '樱桃', '橙子']

# 删除元素
del fruits[2]
print(fruits)  # 输出: ['苹果', '蓝莓', '橙子']

# 创建一个字符串
message = "Hello"

# 尝试修改字符会导致错误
# message[0] = "h"  # 抛出 TypeError: 'str' object does not support item assignment

# 创建一个新的字符串
new_message = "h" + message[1:]
print(new_message)  # 输出: "hello"

# 创建一个元组
coordinates = (10, 20, 30)

# 尝试修改元素会导致错误
# coordinates[1] = 25  # 抛出 TypeError: 'tuple' object does not support item assignment

# 创建一个新的元组
new_coordinates = coordinates + (40,)
print(new_coordinates)  # 输出: (10, 20, 30, 40)

def func(a, b = 1, c = 2):
    return a + b + c

# 使用默认的位置参数指定a、b、c的值
print(func(1, 2, 3))  # 6
# 使用关键字参数指定c的值，b的值使用默认值
print(func(1, c = 3))  # 5

def func(a, b = 2, c = 2):
    return a + b + c

# 关键字参数先于位置参数，编译报错
# SyntaxError: positional argument follows keyword argument
print(func(a = 2, 2, 3))  # 5

# *args
def func(*args):
    for arg in args:
        print(arg, end=" ")

# 传入3个参数
func(1, 2, 3)  # 1 2 3
# 传入一个列表对象
li = [1, 2, 3]
func(*li)  # 1, 2, 3

# **kwargs
def func(**kwargs):
    for key, value in kwargs.items():
        print(key, value, end=" ")
    print()

# 传入3个键值对
func(name = "zhangsan", b = 2, c = 3)  # name zhangsan b 2 c 3
# 传入一个字典对象
dic = {"a": 1, "b": 2, "c": 3}
func(**dic)  # a 1 b 2 c 3

# 回调函数
def add(a, b):
    return a + b

def sub(a, b):
    return a - b

def calc(a, b, op):
    return op(a, b)

# 传入add函数，add函数就是回调函数
print(calc(1, 2, add))  # 3
# 传入sub函数，sub函数就是回调函数
print(calc(1, 2, sub))  # -1

# 返回函数
def get_math_func(type):
    # 定义一个加法函数
    def add(a, b):
        return a + b

    # 定义一个减法函数
    def sub(a, b):
        return a - b

    # 返回加法函数
    if type == "add":
        return add
    # 返回减法函数
    else:
        return sub

# 调用get_math_func，返回一个函数
func = get_math_func("add")
# 调用返回的函数
print(func(1, 2))  # 3

def greet():
    message = "Hello, World!"  # 局部变量
    print(message)

greet()          # 输出: Hello, World!
print(message)   # 抛出 NameError: name 'message' is not defined

counter = 10  # 全局变量

def increment():
    global counter # 修改全局变量
    counter += 1
    print(counter)

increment()  # 输出: 11
print(counter)  # 输出: 11

def outer():
    outer_var = "I'm outside!"

    def inner():
        print(outer_var)  # 访问外层函数的变量

    inner()

outer()  # 输出: I'm outside!

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        print(count)

    inner()  # 输出: 1
    print(count) # 输出: 1

outer()

print(len("Hello"))  # 输出: 5

# 闭包
def outer():
    count = 0 # 非全局作用的变量（外部函数的变量）

    # 嵌套函数（内层函数）
    def inner():
        nonlocal count 
        count += 1 # 非全局作用域的变量引用
        return count

    return inner # 返回内层函数

# 调用outer函数，返回inner函数
func = outer()
# 调用inner函数
print(func())  # 1

# 闭包示例
def create_funcs():
    funcs = []
    for i in range(3):
        def func():
            return i
        funcs.append(func)
    return funcs

functions = create_funcs()
for f in functions:
    print(f())  # 输出: 2, 2, 2

# 使用默认参数解决闭包问题
def create_funcs():
    funcs = []
    for i in range(3):
        def func(i=i):
            return i
        funcs.append(func)
    return funcs

functions = create_funcs()
for f in functions:
    print(f())  # 输出: 0, 1, 2

lambda 形式参数: 函数体

# Lambda表达式
# 正常定义函数
def add(a, b = 1):
    return a + b

# 使用Lambda表达式定义函数
add_lambda = lambda a, b = 1: a + b

# 调用add函数
print(add(1))  # 2
# 调用add_lambda函数
print(add_lambda(1))  # 2

# map函数
li = [1,2,3,4,5]
# 使用map函数计算每个元素的平方
result = map(lambda x: x * x, li)
# 转换为列表
print(list(result))  # [1, 4, 9, 16, 25]

# filter函数
li = [1,2,3,4,5]
# 使用filter函数过滤偶数
result = filter(lambda x: x % 2 == 0, li)
# 转换为列表
print(list(result))  # [2, 4]

# reduce函数
from functools import reduce
li = [1,2,3,4,5]
# 使用reduce函数计算所有元素的和
result = reduce(lambda x, y: x + y, li)
print(result)  # 15

# sorted函数
li = [36, 5, -12, 9, -21]
# 使用sorted函数对列表排序
result = sorted(li)
print(result)  # [-21, -12, 5, 9, 36]
# 按照元素的绝对值进行排序
result = sorted(li, key = lambda x: abs(x))
print(result)  # [5, 9, -12, -21, 36]
# 对字典元素进行排序——按照value排序
dic = {"a": 1, "c": 3, "b": 2}
result = sorted(dic, key = lambda x: dic[x])
print(result)  # ['a', 'b', 'c']

def add(a: int, b: int) -> int:
    return a + b

print(add(1, 2))  # 3

def add(a: int, b: int) -> int:
    return a + b

print(add(1.2, 2)) # 3.2

def add(li : list[int]) -> None :
    for e in li:
        print(e, end=" ")

print([1,2,True, "hello"])  # [1, 2, True, 'hello']

def add(a, b):
    return a + b

# 获取add函数的名称
print(add.__name__)  # add

# 定义装饰器
def log(func):
    def toWrap(a, b):
        print("Something is happening before the function is called.")
        ret = func(a, b)
        print("Something is happening after the function is called.")

        return ret
    return toWrap

# 使用装饰器
@log
def add(a, b):
    print("加法运算")
    return a + b

print(add(1, 2)) 

输出结果：
Something is happening before the function is called.
加法运算
Something is happening after the function is called.
3

# 定义带参数的装饰器
def log(prefix = "RUN: "):
    def log_decorator(func):
        def toWrap(a, b):
            print(prefix + "Something is happening before the function is called.")
            ret = func(a, b)
            print(prefix + "Something is happening after the function is called.")

            return ret # toWrap函数返回
        return toWrap # log_decorator函数返回
    return log_decorator # log函数返回

# 使用装饰器
@log()
def add(a, b):
    print("加法运算")
    return a + b

print(add(1, 2))

输出结果：
RUN: Something is happening before the function is called.
加法运算
RUN: Something is happening after the function is called.
3

def decor1(func):
    def wrap1():
        print("Inside decor1")
        func()
    return wrap1

def decor2(func):
    def wrap2():
        print("Inside decor2")
        func()
    return wrap2

@decor1
@decor2
def hello():
    print("Hello World")

hello()

输出结果：
Inside decor1
Inside decor2
Hello World