Python函数-JXin的博客

学习笔记说明

这是一篇Python的学习笔记，关于Python函数，仅做记录

函数是可复用的代码块，用于封装特定功能。通过定义函数，可以避免重复代码，提高程序的可读性和可维护性。

定义函数

使用 def 关键字定义函数：

# 定义一个简单函数
def greet():
    print("Hello, World!")

# 调用函数
greet()  # Hello, World!

1
2
3
4
5
6

参数

位置参数

按照定义时的顺序传递参数：

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

result = add(3, 5)
print(result)  # 8

1
2
3
4
5

默认参数

为参数指定默认值，调用时可省略：

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")              # Hello, Alice!
greet("Bob", "Hi")          # Hi, Bob!

1
2
3
4
5

注意： 默认参数必须放在非默认参数后面。

# 错误示例
# def greet(greeting="Hello", name):  # SyntaxError!
#     pass

1
2
3

关键字参数

通过参数名传递，顺序可以任意：

def person_info(name, age, city):
    print(f"{name}, {age}岁, 来自{city}")

# 关键字参数，顺序无关
person_info(age=25, city="北京", name="Alice")
# Alice, 25岁, 来自北京

1
2
3
4
5
6

混合使用： 位置参数在前，关键字参数在后。

person_info("Alice", age=25, city="北京")  # 正确
# person_info(name="Alice", 25, "北京")   # 错误！位置参数不能在关键字参数后

1
2

可变参数

`*args` —— 接收任意数量的位置参数

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

# 调用
print(sum_all(1, 2, 3))     # 6
print(sum_all(1, 2, 3, 4))  # 10
print(sum_all())            # 0

1
2
3
4
5
6
7
8
9
10

args 的本质： 函数内部是一个元组。

def show_args(*args):
    print(type(args))  # <class 'tuple'>
    print(args)        # (1, 2, 3)

show_args(1, 2, 3)

1
2
3
4
5

`**kwargs` —— 接收任意数量的关键字参数

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用
print_info(name="Alice", age=25, city="北京")
# name: Alice
# age: 25
# city: 北京

1
2
3
4
5
6
7
8
9

kwargs 的本质： 函数内部是一个字典。

def show_kwargs(**kwargs):
    print(type(kwargs))  # <class 'dict'>
    print(kwargs)        # {'name': 'Alice', 'age': 25}

show_kwargs(name="Alice", age=25)

1
2
3
4
5

参数顺序规则

定义函数时，参数必须按以下顺序：

def func(位置参数, 默认参数, *args, **kwargs):
    pass

# 示例
def demo(a, b=2, *args, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"kwargs={kwargs}")

demo(1, 3, 4, 5, x=10, y=20)
# a=1, b=3
# args=(4, 5)
# kwargs={'x': 10, 'y': 20}

1
2
3
4
5
6
7
8
9
10
11
12
13

返回值

使用 return

函数通过 return 返回结果：

def square(x):
    return x ** 2

result = square(4)
print(result)  # 16

1
2
3
4
5

多返回值

Python 函数可以同时返回多个值（实际是返回元组）：

def min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = min_max([3, 1, 4, 1, 5])
print(minimum)  # 1
print(maximum)  # 5

# 本质上返回的是元组
result = min_max([3, 1, 4])
print(result)       # (1, 4)
print(type(result)) # <class 'tuple'>

1
2
3
4
5
6
7
8
9
10
11

没有 return

如果函数没有 return，默认返回 None：

def say_hello():
    print("Hello")

result = say_hello()  # Hello
print(result)         # None

1
2
3
4
5

文档字符串（Docstring）

用三引号编写函数的说明文档：

def calculate_bmi(weight, height):
    """
    计算 BMI 指数。
    
    参数:
        weight: 体重，单位千克
        height: 身高，单位米
    
    返回:
        BMI 值
    """
    return weight / (height ** 2)

# 查看文档
print(calculate_bmi.__doc__)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

作业

作业一：函数参数与列表操作综合

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

def add_items(base, items=None, *tags):
    if items is None:
        items = []
    items.append(base)
    for tag in tags:
        items.append(tag)
    return items

result1 = add_items(10)
print(result1)

result2 = add_items(20, [1, 2], 30, 40)
print(result2)

print(result1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

作业二：关键字参数与字典操作综合

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

def merge_data(base, **extra):
    result = base.copy() # 浅拷贝
    for key, value in extra.items():
        if key in result:
            result[key] += value
        else:
            result[key] = value
    return result

data = {"a": 10, "b": [1, 2]}
merged = merge_data(data, a=5, b=[3], c="hello")
print(merged)

print(len(merged))
print(merged.get("d", "not found"))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

作业三：多返回值与容器遍历综合

阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。

def split_data(data):
    mid = len(data) // 2
    return data[:mid], data[mid:]

nums = [1, 2, 3, 4, 5, 6]
first, second = split_data(nums)
print(first, second)

def find_indices(items, target):
    indices = []
    for i, item in enumerate(items):
        if item == target:
            indices.append(i)
    return indices

scores = [85, 92, 85, 78, 85]
positions = find_indices(scores, 85)
print(positions)

result = second + [len(positions)]
print(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

作业四：函数综合编程

请按照要求实现以下三个函数，并编写测试代码手动调用每个函数，验证功能是否正确。

任务 1：列表扁平化

实现函数 flatten，接收一个可能包含嵌套列表的列表（如 [1, [2, 3], [[4], 5]]），返回一个将所有元素展开后的一维列表（如 [1, 2, 3, 4, 5]）。

nested1 = [1, [2, 3], [[4], 5]]
print(flatten(nested1))  # [1, 2, 3, 4, 5]

nested2 = [[[1]], 2, [3, [4, [5]]]]
print(flatten(nested2))  # [1, 2, 3, 4, 5]

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

1
2
3
4
5
6
7
8

任务 2：列表/元组转链表

实现函数 to_linked_list，接收一个列表或元组，将其转换为一个链表结构并返回。

linked1 = to_linked_list((1, 2, 3))
print(linked1)
# {'value': 1, 'next': {'value': 2, 'next': {'value': 3, 'next': None}}}

linked2 = to_linked_list([10, 20])
print(linked2)
# {'value': 10, 'next': {'value': 20, 'next': None}}

print(to_linked_list([]))  # None

1
2
3
4
5
6
7
8
9

任务 3：字典合并

实现函数 merge_dicts，接收不定数量的字典参数，将它们合并为一个大字典。

合并规则：求并集，如果有相同的键，后传入的字典中的值覆盖先传入的字典中的值（浅合并即可）

d1 = {"a": 1, "b": [1, 2]}
d2 = {"b": [3], "c": "hello"}
d3 = {"a": 10, "d": True}

merged = merge_dicts(d1, d2, d3)
print(merged)
# {'a': 10, 'b': [3], 'c': 'hello', 'd': True}

print(merge_dicts(d1))
# {'a': 1, 'b': [1, 2]}

print(merge_dicts())
# {}

1
2
3
4
5
6
7
8
9
10
11
12
13

作业答案

作业一

(10)
(1, 2, 20, 30, 40)
(10)

1
2
3

作业二

{"a": 15, "b": [1, 2, 3], "c": "hello"}
3
not found

1
2
3

作业三

[1, 2, 3]
[4, 5, 6]
[0, 2, 4]
[4, 5, 6, 3]

1
2
3
4

作业四

任务1

def flatten(lst):
    result = []
    for item in lst:
        if type(item) == list:
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

1
2
3
4
5
6
7
8

任务2

def to_linked_list(lst):
    if not lst:
        return None
    head = {"value": lst[0], "next": None}
    current = head
    for item in lst[1:]:
        current["next"] = {"value": item, "next": None}
        current = current["next"]
    return head

1
2
3
4
5
6
7
8
9

任务3

def merge_dicts(*args):
    result = {}
    for d in args:
        result.update(d)
    return result

1
2
3
4
5

Python函数

定义函数

参数

位置参数

默认参数

关键字参数

可变参数

*args —— 接收任意数量的位置参数

**kwargs —— 接收任意数量的关键字参数

参数顺序规则

返回值

使用 return

多返回值

没有 return

文档字符串（Docstring）

作业

作业一：函数参数与列表操作综合

作业二：关键字参数与字典操作综合

作业三：多返回值与容器遍历综合

作业四：函数综合编程

作业答案

作业一

作业二

作业三

作业四

任务1

任务2

任务3

`*args` —— 接收任意数量的位置参数

`**kwargs` —— 接收任意数量的关键字参数