1. 定义函数

函数是一种封装了特定功能的代码块，可以通过定义函数来提高代码的可重用性和可维护性。在Python中，可以使用def关键字来定义函数。

以下是一个简单的例子，演示了如何定义一个函数：

def say_hello():
  print("Hello, World!")

在这个例子中，我们定义了一个名为say_hello的函数，它的功能是打印输出"Hello, World!"。

1.1 向函数传递信息

函数可以通过参数来接收外部传递的信息。在定义函数时，我们可以在函数名后的括号内指定参数的名称。

以下是一个示例，演示了如何定义一个带有参数的函数：

def say_hello(name):
  print(f"Hello, {name}!")

在这个例子中，我们定义了一个名为say_hello的函数，并指定了一个名为name的参数。函数被调用时，可以向参数传递一个值，这个值将会被函数使用。

1.2 实参和形参

在函数定义中，我们使用的参数名称称为形参（parameter），而在函数调用时实际传递给参数的值称为实参（argument）。

以下是一个示例，演示了函数定义中的形参和函数调用中的实参的关系：

def say_hello(name):
  print(f"Hello, {name}!")
say_hello("Alice")

在这个例子中，函数定义中的name是形参，而函数调用时传递给name的"Alice"是实参。

2. 传递实参

在调用函数时，我们可以通过不同的方式来传递实参，包括位置实参、关键字实参和默认值。

2.1 位置实参

位置实参是按照形参定义的顺序依次传递给函数的实参。

以下是一个示例，演示了如何使用位置实参来调用函数：

def greet_user(name, age):
  print(f"Hello, {name}!")
  print(f"You are {age} years old.")
greet_user("Alice", 18)

在这个例子中，我们定义了一个接收两个参数的函数greet_user，通过位置实参传递给函数的值分别为"Alice"和18。

2.2 关键字实参

关键字实参是使用参数名和对应的值来传递给函数的实参。通过使用参数名，可以不用考虑参数的顺序。

以下是一个示例，演示了如何使用关键字实参来调用函数：

def greet_user(name, age):
  print(f"Hello, {name}!")
  print(f"You are {age} years old.")
greet_user(age=18, name="Alice")

在这个例子中，我们使用参数名来指定传递给函数的值，而不需要按照定义顺序传递。

2.3 默认值

可以在函数定义时为参数指定默认值，如果在函数调用时未传递对应的实参，则使用默认值。

以下是一个示例，演示了如何使用默认值来定义函数：

def greet_user(name, age=18):
  print(f"Hello, {name}!")
  print(f"You are {age} years old.")
greet_user("Alice")
greet_user("Bob", 20)

在这个例子中，我们为参数age指定了默认值为18。通过省略调用时的实际值，函数会使用默认值作为实参。

2.4 等效的函数调用

在Python中，可以通过不同的方式来传递实参，但是等效的函数调用会产生相同的结果。

以下是一个示例，演示了等效的函数调用:

def greet_user(name, age=18):
  print(f"Hello, {name}!")
  print(f"You are {age} years old.")
# 等效的函数调用
greet_user("Alice")
greet_user(name="Alice")
greet_user(age=18, name="Alice")
greet_user(age=18)

在这个例子中，四个函数调用对应的实参都是一样的，都会输出相同的结果。

2.5 避免实参错误

在调用函数时，需要注意传递实参的正确性。如果传递的实参有误，可能导致函数无法正常执行。

以下是一些常见的实参错误和如何避免它们：

参数数量错误：确保调用函数时传递了正确的参数数量。

参数顺序错误：确保按照形参的顺序传递实参，或者使用关键字实参。

参数类型错误：确保传递给函数的实参类型与形参要求一致。

通过正确理解函数的调用方式和参数传递规则，可以避免实参错误并确保函数的正常执行。

Python学习笔记：

3. 返回值

3.1 返回简单的值

函数可以通过return语句返回一个值，返回值可以是任意类型的数据。使用return语句可以将函数的结果传递给调用函数的地方。

以下是一个示例，演示了如何返回简单的值：

def add_numbers(a, b):
  return a + b
result = add_numbers(5, 3)
print(result)

在这个例子中，我们定义了一个add_numbers函数，它会返回两个数的和。调用函数后，返回的结果被赋值给变量result，并打印输出。

3.2 让实参变成可选的

在函数定义时，可以使用默认值来让某些参数变成可选的。如果调用函数时省略了这些参数，函数会使用默认值进行计算。

以下是一个示例，演示了如何使用默认值来让实参变成可选的：

def get_full_name(first_name, last_name, middle_name=""):
  if middle_name:
    full_name = f"{first_name} {middle_name} {last_name}"
  else:
    full_name = f"{first_name} {last_name}"
  return full_name
name1 = get_full_name("Alice", "Smith")
name2 = get_full_name("Bob", "Johnson", "A")
print(name1)
print(name2)

在这个例子中，我们定义了一个get_full_name函数，它接收三个参数：first_name、last_name和middle_name。通过给middle_name设置默认值为空字符串，我们可以在调用函数时省略这个参数。在函数中，根据middle_name是否有值来拼接全名，并返回结果。

3.3 返回字典

函数可以返回任意类型的数据，包括字典。返回字典可以提供更多的灵活性，可以在函数中包含更多的信息。

以下是一个示例，演示了如何返回字典：

def get_student_info(name, age):
  student = {
    "name": name,
    "age": age
  }
  return student
info = get_student_info("Alice",

4. 传递列表

在Python中，可以将列表作为实参传递给函数，允许我们对其进行修改或进行其他操作。

4.1 在函数中修改列表

如果要在函数内部修改传递的列表，可以直接通过索引或切片运算来修改列表中的元素。修改后，列表将保持修改。

例如，我们定义一个函数，将列表中所有元素增加1：

def increment_list(numbers):
    for i in range(len(numbers)):
        numbers[i] += 1
my_list = [1, 2, 3, 4, 5]
increment_list(my_list)
print(my_list)

运行结果：

[2, 3, 4, 5, 6]

在上述代码中，我们通过遍历列表，并使用索引运算符来修改每个元素的值。最终，实际的列表被修改为[2, 3, 4, 5, 6]。

4.2 禁止函数修改列表

如果希望禁止函数修改传递的列表，可以通过将列表的副本传递给函数来实现。可以使用切片运算符或list()函数来创建副本。

例如，我们定义一个函数，将列表中的所有元素转换成大写，并打印修改后的列表，但不改变实际的列表：

def print_uppercase_list(numbers):
    numbers_copy = numbers[:]
    for i in range(len(numbers_copy)):
        numbers_copy[i] = str(numbers_copy[i]).upper()
    print(numbers_copy)
my_list = [1, 2, 3, 4, 5]
print_uppercase_list(my_list)
print(my_list)

运行结果：

['1', '2', '3', '4', '5']
[1, 2, 3, 4, 5]

在上述代码中，我们通过创建一个切片副本numbers_copy = numbers[:]，并在函数内部修改副本，从而保持原始列表的不变性。

5. 传递任意数量的实参

有时候，函数需要接受任意数量的实参，我们可以使用特定的语法来实现这一功能。

5.1 结合使用位置实参和任意数量的实参

要创建一个可以接受任意数量实参的函数，可以使用星号(*)将多个实参包装成一个元组。然后，我们可以像处理其他元组一样处理这个元组。

例如，我们定义一个函数，用于打印指定数量的商品：

def print_items(quantity, *items):
    print(f"There are {quantity} items:")
    for item in items:
        print(item)
print_items(3, "Apple", "Banana", "Orange")

运行结果：

There are 3 items:
Apple
Banana
Orange

在上述代码中，*items将后续的参数打包成一个元组，以便我们可以循环迭代并打印出每个商品。

5.2 使用任意数量的关键字实参

有时候，我们希望接受任意数量的关键字实参。可以使用双星号(**)将多个关键字实参包装成一个字典。然后，我们可以像处理其他字典一样处理这个字典。

例如，我们定义一个函数，用于打印客户的个人信息：

def print_customer_info(name, **info):
    print(f"Customer name: {name}")
    for key, value in info.items():
        print(f"{key}: {value}")
print_customer_info("John", age=25, location="New York", occupation="Engineer")

运行结果：

Customer name: John
age: 25
location: New York
occupation: Engineer

在上述代码中，**info将后续的关键字参数打包成一个字典，以便我们可以循环迭代并打印出每个键值对。

6. 将函数存储在模块中

在Python中，我们可以将函数存储在模块中，以便在需要时使用。模块是一个包含Python代码的文件，可以包含函数、类、变量等。

6.1 导入整个模块

要使用模块中的函数，我们需要先导入整个模块。使用import关键字可以导入整个模块，并使用模块名来访问其中的函数。

例如，我们在名为my_module.py的文件中定义了一个求和函数add()：

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

然后，在另一个文件中导入该模块，并使用其中的函数：

import my_module
result = my_module.add(3, 4)
print(result)

运行结果：

7

在上述代码中，我们使用import my_module导入了整个模块，并通过my_module.add()调用了其中的函数。

6.2 导入特定的函数

不必导入整个模块，我们也可以选择性地导入模块中的特定函数。使用from关键字可以导入特定的函数。

例如，我们在名为my_module.py的文件中定义了两个函数add()和subtract()：

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

然后，在另一个文件中导入特定的函数，并直接使用函数名调用：

from my_module import add, subtract
result1 = add(3, 4)
result2 = subtract(7, 2)
print(result1)
print(result2)

运行结果：

7
5

在上述代码中，我们使用from my_module import add, subtract导入了特定的函数，并直接使用函数名调用。

6.3 使用as给函数指定别名

如果导入的函数名与当前命名空间中的其他名称冲突，可以使用as关键字给函数指定别名。

例如，我们在名为my_module.py的文件中定义了一个求和函数add()：

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

然后，在另一个文件中导入函数，并给其指定了别名sum()：

from my_module import add as sum
result = sum(3, 4)
print(result)

运行结果：

7

在上述代码中，我们使用from my_module import add as sum导入函数，并将其别名设置为sum，从而避免了与Python内置sum()函数的冲突。

6.4 使用as给模块指定别名

与给函数指定别名类似，我们也可以给导入的模块指定别名。使用as关键字可以给模块指定别名。

例如，我们在名为my_module.py的文件中定义了一个求和函数add()：

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

然后，在另一个文件中导入模块，并给其指定了别名mm：

import my_module as mm
result = mm.add(3, 4)
print(result)

运行结果：

7

在上述代码中，我们使用import my_module as mm导入模块，并将其别名设置为mm，从而简化了模块名的使用。

6.5 导入模块中的所有函数

有时候，我们希望导入模块中的所有函数，可以使用import语句的*通配符来实现。

例如，我们在名为my_module.py的文件中定义了一个求和函数add()和一个求差函数subtract()：

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

然后，在另一个文件中导入模块中的所有函数，并直接使用函数名调用：

from my_module import *
result1 = add(3, 4)
result2 = subtract(7, 2)
print(result1)
print(result2)

运行结果：

7
5

在上述代码中，我们使用from my_module import *导入了模块中的所有函数，并直接使用函数名调用。