python入门（6）函数系列 1

1. 函数

1.1 简介

在 Python 中，函数（Function）是一段可重复调用的代码块，用于执行特定的操作并返回结果。函数可以接受输入参数，可以有返回值，也可以不返回任何值。函数使得代码可以模块化、可重用，并提供了丰富的功能扩展。

1.2 函数类型

Python 中的函数可以分为以下几种类型：

（1）内置函数（Built-in Functions）：Python 提供了许多内置函数，可以直接使用而无需导入任何模块。这些函数包括数学计算、类型转换、文件操作、字符串处理等功能。

（2）用户自定义函数（User-defined Functions）：通过使用 def 关键字可以定义自己的函数。用户自定义函数可以根据需求编写自定义逻辑，并在程序中进行调用。

（3）匿名函数（Lambda Functions）：也称为匿名函数或 lambda 表达式。它们是一种简化函数定义的方式，通常用于简单的函数功能。匿名函数由关键字 lambda 开头，后跟参数和返回表达式。

（4）递归函数（Recursive Functions）：递归函数是指在函数体内调用自身的函数。它常用于解决可以分解为相同问题的子问题的情况。

请注意，函数的定义通常由关键字 def 开始，后跟函数名、参数列表、冒号和函数体。函数体是函数执行的具体操作，可以包含多条语句。函数可以返回一个值（使用 return 语句）或不返回任何值（默认返回 None）。

2. 内置函数

2.1 常用的内置函数

函数名	定义
abs()	返回一个数的绝对值
all()	判断可迭代对象中的所有元素是否都为 True
any()	判断可迭代对象中的任意元素是否为 True
bin()	将一个整数转换为二进制字符串
bool()	将一个值转换为布尔类型
chr()	返回指定 Unicode 码对应的字符
divmod()	返回两个数的商和余数
enumerate()	返回一个枚举对象，包含索引和元素
float()	将一个字符串或数字转换为浮点数
hex()	将一个整数转换为十六进制字符串
int()	将一个字符串或数字转换为整数
len()	返回对象的长度或元素个数
max()	返回可迭代对象中的最大值
min()	返回可迭代对象中的最小值
oct()	将一个整数转换为八进制字符串
ord()	返回一个字符的 Unicode 码值
pow()	返回 x 的 y 次幂，或者计算 x 的 y 次幂取模后的结果
print()	打印指定内容到控制台
range()	返回一个指定范围的整数序列
round()	对一个数进行四舍五入
str()	将一个对象转换为字符串
sum()	返回可迭代对象中所有元素的和
type()	返回对象的类型
zip()	将多个可迭代对象打包成元组的列表

2.2 函数定义、语法与示例

（1）abs(x)

• 定义：返回一个数的绝对值。
• 语法：abs(x)
• 示例代码：

result = abs(-10)
print(result)  # 输出：10

（2）chr(i)

• 定义：返回指定 Unicode 码对应的字符。
• 语法：chr(i)
• 示例代码：

character = chr(65)
print(character)  # 输出：'A'

（3）len(s)

• 定义：返回对象的长度或元素个数。
• 语法：len(s)
• 示例代码：

length = len("Hello, World!")
print(length)  # 输出：13

（4）range(start, stop, step)

• 定义：返回一个指定范围的整数序列。
• 语法：range(start, stop, step)

numbers = range(1, 5)
for num in numbers:
    print(num)

输出：

1
2
3
4

（5）all(iterable)

• 定义：判断可迭代对象中的所有元素是否都为 True。
• 语法：all(iterable)
• 示例代码：

result = all([True, False, True])
print(result)  # 输出：False

（6）any(iterable)

• 定义：判断可迭代对象中的任意元素是否为 True。
• 语法：any(iterable)
• 示例代码：

result = any([False, False, True])
print(result)  # 输出：True

（7）bin(x)

• 定义：将一个整数转换为二进制字符串。
• 语法：bin(x)
• 示例代码：

binary = bin(10)
print(binary)  # 输出：'0b1010'

（8）bool(x)

• 定义：将一个值转换为布尔类型。
• 语法：bool(x)
• 示例代码：

result = bool(0)
print(result)  # 输出：False

（9）divmod(a, b)

• 定义：返回两个数的商和余数。
• 语法：divmod(a, b)
• 示例代码：

result = divmod(10, 3)
print(result)  # 输出：(3, 1)

（10）enumerate(iterable, start=0)

• 定义：返回一个枚举对象，包含索引和元素。
• 语法：enumerate(iterable, start=0)
• 示例代码

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)

输出：

1 apple
2 banana
3 cherry

（11）float(x)

• 定义：将一个字符串或数字转换为浮点数。
• 语法：float(x)
• 示例代码：

result = float("3.14")
print(result)  # 输出：3.14

（12）hex(x)

• 定义：将一个整数转换为十六进制字符串。
• 语法：hex(x)
• 示例代码：

hexadecimal = hex(255)
print(hexadecimal)  # 输出：'0xff'

（13）int(x, base=10)

• 定义：将一个字符串或数字转换为整数。
• 语法：int(x, base=10)
• 示例代码：

number = int("42")
print(number)  # 输出：42

（14）max(iterable, *args, key=None)

• 定义：返回可迭代对象中的最大值。
• 语法：max(iterable, *args, key=None)
• 示例代码：

maximum = max([3, 7, 2, 9, 5])
print(maximum)  # 输出：9

（15）min(iterable, *args, key=None)

• 定义：返回可迭代对象中的最小值。
• 语法：min(iterable, *args, key=None)
• 示例代码：

minimum = min([3, 7, 2, 9, 5])
print(minimum)  # 输出：2

（16）oct(x)

• 定义：将一个整数转换为八进制字符串。
• 语法：oct(x)
• 示例代码：

octal = oct(8)
print(octal)  # 输出：'0o10'

（17）ord(c)

• 定义：返回一个字符的 Unicode 码值。
• 语法：ord(c)
• 示例代码：

unicode_value = ord('A')
print(unicode_value)  # 输出：65

（18）pow(x, y[, z])

• 定义：返回 x 的 y 次幂，或者计算 x 的 y 次幂取模后的结果。
• 语法：pow(x, y[, z])
• 示例代码：

result = pow(2, 3)
print(result)  # 输出：8

（19）print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• 定义：打印指定内容到控制台。
• 语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
• 示例代码：

print("Hello, World!")  # 输出：Hello, World!

（20）round(number, ndigits)

• 定义：对一个数进行四舍五入。
• 语法：round(number,ndigits)
• 示例代码：

rounded_number = round(3.14159, 2)
print(rounded_number)  # 输出：3.14

（21）str(object='')

• 定义：将一个对象转换为字符串。
• 语法：str(object='')
• 示例代码：

string = str(42)
print(string)  # 输出：'42'

（22）sum(iterable[, start])

• 定义：返回可迭代对象中所有元素的和。
• 语法：sum(iterable[, start])
• 示例代码：

total = sum([1, 2, 3, 4, 5])
print(total)  # 输出：15

（23）type(object)

• 定义：返回对象的类型。
• 语法：type(object)
• 示例代码：

data_type = type(42)
print(data_type)  # 输出：<class 'int'>

（24）zip(*iterables)

• 定义：将多个可迭代对象打包成元组的列表。
• 语法：zip(*iterables)
• 示例代码：

numbers = [1, 2, 3]
letters = ['A', 'B', 'C']
zipped = zip(numbers, letters)
print(list(zipped))  # 输出：[(1, 'A'), (2, 'B'), (3, 'C')]

以上示例代码仅供参考，具体使用时可以根据需要进行适当调整。

3. 用户自定义函数

在Python中，用户可以通过定义自定义函数来实现自己所需的功能。以下是Python中的一些用户自定义函数的类型：

3.1 无参数函数

无参数函数：这是最简单的函数类型，它不接受任何参数。

定义语法：

def function_name():
    # 函数体
    # 可以执行一些操作或返回值

示例代码：

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

greet()  # 输出：Hello, World!

3.2 带参数函数

带参数函数：这种函数接受一个或多个参数，并在函数体内使用这些参数。 定义语法：

def function_name(parameter1, parameter2, ...):
    # 函数体
    # 可以使用参数执行一些操作或返回值

示例代码：

def greet(name):
    print("Hello, " + name + "!")

greet("Alice")  # 输出：Hello, Alice!

3.3 返回值函数

返回值函数：这种函数在执行完一些操作后返回一个值。 定义语法：

def function_name(parameter1, parameter2, ...):
    # 函数体
    # 可以使用参数执行一些操作
    # 返回值
    return value

示例代码：

def add_numbers(num1, num2):
    sum = num1 + num2
    return sum

result = add_numbers(3, 5)
print(result)  # 输出：8

3.4  包含默认参数的函数

包含默认参数的函数：这种函数允许在定义时为参数设置默认值，如果调用函数时没有提供该参数，则使用默认值。 定义语法：

def function_name(parameter1=default_value1, parameter2=default_value2, ...):
    # 函数体
    # 可以使用参数执行一些操作或返回值

示例代码：

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

greet()  # 输出：Hello, World!
greet("Alice")  # 输出：Hello, Alice!

用户自定义函数可以根据具体需求来定义，可以用于封装重复的代码，实现特定的功能，提高代码的可读性和复用性。函数可以在程序中的任何地方调用，可以接受参数，执行一系列操作，并返回结果。常见的使用场景包括但不限于：

• 封装重复的代码块，提高代码的可维护性和复用性。
• 实现特定的功能，例如计算、数据处理、字符串操作等。
• 模块化程序设计，将程序拆分成多个函数，每个函数负责特定的任务。
• 提供代码的抽象层次，使得代码更易理解和组织。
• 编写可测试的代码，通过函数进行单元测试和模块测试。

通过合理使用用户自定义函数，可以使程序结构更清晰，逻辑更简洁，提高代码的可读性和可

3.5 自定义函数-小游戏示例

import random

def generate_random_number():
    """生成随机数"""
    return random.randint(1, 100)

def guess_number(secret_number):
    """猜数字游戏"""
    attempts = 0

    while True:
        attempts += 1
        guess = int(input("猜一个1到100之间的数字: "))

        if guess < secret_number:
            print("太小了！再试一次。")
        elif guess > secret_number:
            print("太大了！再试一次。")
        else:
            print(f"恭喜你，猜对了！你用了{attempts}次尝试。")
            break

# 生成随机数
number_to_guess = generate_random_number()

# 开始游戏
print("猜数字游戏开始！")
guess_number(number_to_guess)

这个示例中，我们首先定义了两个函数：

• generate_random_number()：用于生成一个1到100之间的随机数作为要猜的秘密数字。
• guess_number(secret_number)：接收一个秘密数字作为参数，并使用一个循环来让玩家猜测数字，直到猜对为止。

在主程序中，我们先生成一个随机数作为秘密数字，然后调用guess_number()函数开始游戏。玩家每次猜测一个数字，程序会根据猜测的结果给出相应的提示，直到猜对为止。

4. 匿名函数

4.1 定义与语法

在Python中，匿名函数（lambda函数）是一种特殊类型的函数，它可以在不使用def关键字定义函数的情况下创建函数。它通常用于定义简单的函数或在需要临时函数的地方使用。

匿名函数的定义语法如下：

lambda arguments: expression

其中：

• lambda是关键字，用于表示定义一个匿名函数。
• arguments是函数的参数，可以是一个或多个参数。
• expression是函数的返回值表达式。

匿名函数通常用于需要一个简短的函数定义，并且只在特定上下文中使用的场景。它们的主要特点是简洁、方便和临时性。

4.2 常见的匿名函数（lambda函数）

在Python中，匿名函数（lambda函数）可以用于创建一些简单的函数，常见的匿名函数包括：

1. 一元函数：只有一个参数的匿名函数。
2. 二元函数：有两个参数的匿名函数。
3. 条件函数：根据条件返回不同值的匿名函数。

下面是对每种匿名函数类型的具体说明以及示例代码：

（1）一元函数： 一元函数只有一个参数，并返回一个表达式的值。

# 一元函数示例
square = lambda x: x**2
result = square(5)
print(result)
# 输出: 25

（2）二元函数： 二元函数有两个参数，并返回一个表达式的值。

# 二元函数示例
add = lambda x, y: x + y
result = add(3, 4)
print(result)
# 输出: 7

（3）条件函数： 条件函数根据条件返回不同的值，通常用于简单的条件判断。

# 条件函数示例
is_even = lambda x: 'Even' if x % 2 == 0 else 'Odd'
result = is_even(5)
print(result)
# 输出: Odd

匿名函数在需要临时定义简单函数的场景下非常有用，它们可以简化代码并提高可读性。然而，对于复杂的逻辑和较长的函数体，建议使用命名函数来提高代码的可维护性。

4.3 匿名函数使用场景：

（1）对序列进行排序：

my_list = ['apple', 'banana', 'cherry', 'date']
sorted_list = sorted(my_list, key=lambda x: len(x))
print(sorted_list)
# 输出: ['date', 'apple', 'cherry', 'banana']

（2）过滤序列中的元素：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_list = list(filter(lambda x: x % 2 == 0, my_list))
print(filtered_list)
# 输出: [2, 4, 6, 8, 10]

（3）映射序列的元素：

my_list = [1, 2, 3, 4, 5]
doubled_list = list(map(lambda x: x * 2, my_list))
print(doubled_list)
# 输出: [2, 4, 6, 8, 10]

（4）作为函数参数传递：

def apply_operation(x, operation):
    return operation(x)

result = apply_operation(5, lambda x: x * x)
print(result)
# 输出: 25

需要注意的是，匿名函数通常适用于简单的操作，如果函数逻辑比较复杂或需要多个语句，建议使用常规的命名函数来提高代码可读性和可维护性。

5. 递归函数

5.1 定义

递归函数是指在函数的定义中调用自身的函数。它是一种解决问题的常用方法，特别适合用于处理具有递归结构的问题，例如树形结构、图形结构等。Python中可以使用递归函数来解决各种问题。

5.2 示例场景

（1）计算阶乘：递归函数可以用来计算一个数的阶乘。

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

# 示例
result = factorial(5)
print(result)  # 输出: 120

（2）斐波那契数列：递归函数可以用来生成斐波那契数列。

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

# 示例
result = fibonacci(6)
print(result)  # 输出: 8

（3）遍历树形结构：递归函数可以用来遍历树形结构，例如二叉树。

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def traverse_tree(node):
    if node is not None:
        # 先处理左子树
        traverse_tree(node.left)
        # 处理当前节点
        print(node.value)
        # 再处理右子树
        traverse_tree(node.right)

# 示例
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

traverse_tree(root)
# 输出:
# 4
# 2
# 5
# 1
# 3

递归函数的定义需要注意以下几点：

• 设定递归的终止条件，即递归的出口。
• 将问题分解为更小的子问题，递归调用函数解决子问题。
• 递归调用需要保证能够收敛到终止条件，否则会导致无限递归。

递归函数的使用场景包括但不限于：数学运算、数据结构的遍历和操作、问题分解与求解等。使用递归函数能够简洁地表达问题，但需要注意递归深度和性能问题。在使用递归函数时，应确保问题适合使用递归解决，并考虑可能的优化措施，例如尾递归优化等。