Python基础：函数的使用

什么是函数？

        函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

语法：

def 函数名（参数列表）:
    函数体

实例：

def hello_word():    #定义一个函数名为hello_word的函数
    print("hello word")    # 函数体输出“hello word”

hello_word()    #调用函数hello_word

调用函数

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

实例：

不带参数：

# 不带参数
def jiafa():    # 定义一个jiafa函数
    a = 10 + 20    
    print(a)


def chengfa():    # 定义一个chengfa函数
    b = 10 * 20
    print(b)   


# 调用函数
jiafa()    # 30
chengfa()    # 200

带参数：

ef jiafa1(a1,a2):    # 定义一个jiafa1函数
    c = a1 + a2
    print(c)

def chengfa1(b1,b2):    # 定义一个chengfa1函数
    '''该方法用于做乘法运算'''
    n = b1 * b2
    print(n)

# 调用函数
# 4和6在函数中，称为实参(真实的参数)
# 函数的小括号中定义的的变量称为形参(形式参数)，不代表真实的数据
jiafa1(4,6)    # 10
chengfa1(2,3)    # 6

Python函数的用法很广泛，可以用于处理不同的任务和问题。下面列出了一些Python函数的用法及其示例：

1. 参数传递

Python函数允许在调用时向它传递参数，从而让它执行相应的任务。函数有不同类型的参数：位置参数、默认参数和关键字参数。

• 位置参数：按照定义的顺序直接传递。

def greet(name, age):
    print(f"你好{name}，你今年{age}岁了！")

# 调用函数时需要按照参数顺序传递参数
greet("小明", 20)  # 输出：你好小明，你今年20岁了！

• 默认参数：在定义函数时给参数赋默认值。

实例1
def greet(name, age=18):
    print(f"你好{name}，你今年{age}岁了！")

# age参数有默认值18，可以不传入
greet("小明")  # 输出：你好小明，你今年18岁了！


# 实例2
# 当该带有默认值的参数被调用的时候，如果没有传实参，该函数会启用默认值
# 如果调用该函数传了实参，则不会启用默认值，而是将实参赋值给形参
def eat(foodname="大米饭"):
    print(f"中午吃{foodname}")


eat()    # 输出：中午吃大米饭
eat("大闸蟹")    # 输出：中午才大闸蟹

• 关键字参数：通过参数名称来传递参数。

def greet(name, age):
    print(f"你好{name}，你今年{age}岁了！")

# 使用参数名称来传递参数，允许参数的顺序随意
# 实参和形参的绑定，称为关键字函数
greet(age=20, name="小明")  # 输出：你好小明，你今年20岁了！

2. 函数返回值

Python函数可以返回一个值或多个值。在函数内部使用return语句返回值，并在调用函数时接收该值。

• 只返回一个值：

def square(number):
    """计算数字的平方"""
    result = number * number
    return result

# 调用函数
value = square(5)
print(value)  # 输出: 25

• 返回多个值：

def get_name_and_age():
    """返回名称和年龄"""
    name = "小明"
    age = 20
    return name, age

# 调用函数
name, age = get_name_and_age()
print(f"名称：{name}，年龄：{age}")  # 输出：名称：小明，年龄：20

3. 匿名函数

Python中的匿名函数（lambda函数）是一种简单的函数形式，通常用于一些简单的操作，例如对列表进行排序。

sorted_list = [(1, 'a'), (5, 'c'), (2, 'b'), (3, 'd')]
sorted_list.sort(key=lambda x: x[0])
print(sorted_list)  # 输出：[(1, 'a'), (2, 'b'), (3, 'd'), (5, 'c')]

以上代码通过lambda函数将元组列表按照第一个元素进行排序。

4. 递归函数

递归函数是一种在函数内调用自身的函数。它通常用于解决一些复杂的问题，例如树的遍历、计算阶乘等。

def factorial(number):
    """计算数字的阶乘"""
    if number == 1:
        return 1
    else:
        return number * factorial(number - 1)

# 调用函数
result = factorial(5)
print(result)  # 输出: 120

以上代码通过递归计算5的阶乘。

5. 函数作为参数和返回值

Python函数可以作为参数传递给其他函数，也可以作为函数的返回值返回。

• 函数作为参数：

def double(number):
    """将数字翻倍"""
    return number * 2

def apply(func, number):
    """应用函数"""
    return func(number)

# 调用函数，并使用double函数作为参数
result = apply(double, 5)
print(result)  # 输出：10

• 函数作为返回值：

def get_function(condition):
    """返回函数"""
    if condition:
        return lambda x: x + 5
    else:
        return lambda x: x + 10

# 调用函数，并使用返回的函数进行计算

传递多个参数

在Python中，函数可以接受任意数量或任意类型的参数，可以使用*args和**kwargs操作符实现。

*args操作符用于传递任意数量的位置参数：

def my_sum(*args):
    result = 0
    for value in args:
        result += value
    return result

print(my_sum(1, 3, 5, 7)) #输出 16

**kwargs操作符用于传递任意数量的关键字参数：

def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(key + ":" + str(value))

print_kwargs(color='red', size=10, price=100) 
#输出 color:red size:10 price:100

3. 装饰器

装饰器是一种高级函数，可以动态地修改函数的行为。函数可以通过@符号接受一个装饰器，装饰器会在函数执行前或执行后进行相应的操作。

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数执行前")
        result = func(*args, **kwargs)
        print("函数执行后")
        return result
    return wrapper

@my_decorator
def my_function():
    print("函数执行")

my_function()
#输出：
# 函数执行前
# 函数执行
# 函数执行后

4. 匿名函数

匿名函数也称为lambda函数，它是一个用于临时定义函数的快捷方式。它通常用于简单的操作，例如对列表进行排序。

sorted_list = [(1, 'a'), (5, 'c'), (2, 'b'), (3, 'd')]
sorted_list.sort(key=lambda x: x[0])
print(sorted_list)  # 输出：[(1, 'a'), (2, 'b'), (3, 'd'), (5, 'c')]

5. 递归函数

递归函数可以像函数式编程中一样，以声明式的方式解决问题。递归函数可以直接或者间接地调用自己。

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

6. 函数的默认值

在定义函数时，可以为函数的参数提供默认值。如果调用函数时不提供该参数的值，则该参数使用默认值。默认值可以是任何Python对象。

def my_function(name='World'):
    print("Hello, " + name + "!")

# 使用默认参数调用函数
my_function()

# 传递自定义参数调用函数
my_function("John")

7. lambda 函数

Lambda函数是一种匿名函数，它可以在一行代码中定义一小段函数。Lambda函数在函数式编程中使用很广泛。

lambda函数，也称匿名函数，是一种快速定义函数的方式。它是一个小型、临时的、只有单个表达式的函数，没有函数名，可以在需要一个函数但不希望为它命名的地方使用。

lambda函数通常用于函数式编程中，它可以编写短小并且只在某个地方使用的函数。常用于参数中需要一个函数的情况。与普通函数相比，lambda函数具有更短的代码、更少的开销和更清晰的代码结构。

以下是一个简单的例子，演示如何使用lambda函数来计算两个数的和：

sum = lambda a, b: a + b

result = sum(5, 3)

print(result) #输出8

在这个例子中，我们使用lambda函数定义了一个函数sum，它接受两个参数a和b，返回它们的和。我们使用lambda函数将sum定义为一个临时函数，并将它赋值给一个变量。我们将参数5和3传递给sum函数，并将返回结果8存储在result变量中。

通过这种方式，我们可以使用lambda函数来编写短小、精简、简洁的函数，用于一些需要简单计算的场景，减少函数定义的复杂度，提高代码的可读性。

8. map() 函数

map()函数是Python内置的一个高阶函数，它用于对一个可迭代对象的每个元素应用一个给定的函数，返回一个新的可迭代对象，包含所有经过函数处理后的元素。

map()函数接受两个参数，第一个参数是一个函数，它将用于对可迭代对象进行处理；第二个参数是可迭代对象，它包含要进行处理的元素。

被处理的可迭代对象中，每个元素都将传递给函数进行处理。函数处理完每个元素后，将返回一个新的元素，创建一个新的可迭代对象，其中包含所有经过函数处理后的元素。

以下是一个简单的例子，演示如何使用map()函数将一个列表中的元素转换为字符串：

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

def convert_to_string(num):
    return str(num)

string_numbers = list(map(convert_to_string, numbers))

print(string_numbers) #输出['1', '2', '3', '4', '5']

在这个例子中，我们定义了一个convert_to_string函数，它接受一个数字并将其转换为字符串。我们使用map()函数并将convert_to_string函数作为参数传递给它，将numbers列表作为第二个参数传递给它。map()函数迭代numbers列表中的每个元素，并将它们传递给convert_to_string函数进行处理。convert_to_string函数将每个元素转换为字符串，并返回新的元素。创建一个新的字符串列表string_numbers来存储这些新的元素。

通过这种方式，我们可以轻松地使用map()函数来应用一个函数到一个可迭代对象的每个元素，并用这些处理过的元素来创建一个新的可迭代对象。这种方法可以大大提高代码的可读性和复用性。

9. filter() 函数

filter()函数是Python内置的一个高阶函数，它用于过滤iterable（可迭代对象）中的元素，返回一个经过筛选后的新的可迭代对象。

filter()函数接受两个参数，第一个参数是一个函数，它将用于过滤可迭代对象；第二个参数是可迭代对象，它包含要进行筛选的元素。

被过滤的可迭代对象中，每个元素都将传递给函数进行计算，当函数返回True时，该元素将被保留，否则被过滤掉。

以下是一个简单的例子，演示如何使用filter()函数来过滤出一个列表中的偶数元素：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(num):
    return num % 2 == 0

even_numbers = list(filter(is_even, numbers))

print(even_numbers) #输出[2, 4, 6, 8, 10]

在这个例子中，我们定义了一个is_even函数，它接受一个数字，当数字为偶数时返回True，否则返回False。我们使用filter()函数并将is_even函数作为参数传递给它，将numbers列表作为第二个参数传递给它。filter()函数迭代numbers列表中的每个元素，并将它们传递给is_even函数进行计算。当is_even函数返回True时，该元素将被保留，并添加到新生成的列表even_numbers中。

通过这种方式，我们可以使用filter()函数轻松地过滤出符合特定条件的元素，并用它们来创建新的列表，提高程序的灵活性和可读性。