Python知识复习指南

1.round函数

在 Python 里，round() 函数是一个内置函数，其用途是对数值进行四舍五入。下面从基本语法、参数、返回值、使用示例等方面来详细介绍：

基本语法

python

round(number, ndigits=None)

参数说明

number：这是必须要提供的参数，代表需要进行四舍五入操作的数字，可以是整数或者浮点数。

ndigits：此为可选参数，属于整数类型。若省略该参数或者将其设为 None，则会把 number 四舍五入为最接近的整数；若该参数为正整数，会把 number 四舍五入到指定的小数位数；若为负整数，则会把 number 四舍五入到小数点左边的相应位数。

返回值

返回四舍五入后的数字，返回值类型通常和输入的 number 类型相同。

使用示例

1. 四舍五入为整数

python

print(round(3.2))
print(round(3.7))

在这个例子中，由于没有指定 ndigits 参数，round() 函数会将数字四舍五入为最接近的整数。输出结果依次是 3 和 4。

2. 四舍五入到指定小数位数

python

print(round(3.14159, 2))
print(round(2.71828, 3))

这里指定了 ndigits 参数，round() 函数会把数字四舍五入到指定的小数位数。输出结果分别是 3.14 和 2.718。

3. 四舍五入到小数点左边的位数

python

print(round(1234, -1))
print(round(1234, -2))

当 ndigits 为负数时，round() 函数会把数字四舍五入到小数点左边的相应位数。输出结果分别是 1230 和 1200。

注意事项

在 Python 中，round() 函数采用的是 “银行家舍入法”（也称作 “四舍六入五成双”）。当需要舍弃的数字是 5 时，会看 5 前面的数字，若为奇数则进位，若为偶数则舍去。例如：

python

print(round(2.5))
print(round(3.5))

输出结果均为 2 和 4，这体现了 “四舍六入五成双” 的规则。

round() 函数本身的功能是将数字四舍五入到指定的小数位数，你所写的代码中 round(a, 2) 意思是将数字 a 四舍五入保留两位小数。但输出仅保留一位小数，可能有以下几种原因：

1. 四舍五入后末尾是 0

当四舍五入后的结果末尾为 0 时，Python 默认不会显示这个末尾的 0。例如，若输入 3.140，四舍五入保留两位小数后是 3.14；若输入 3.10，四舍五入保留两位小数后为 3.1，因为末尾的 0 不会显示。

2. 浮点数精度问题

浮点数在计算机里是以二进制形式存储的，有些十进制小数无法精确地用二进制表示，这就可能引发精度问题。不过在使用 round() 函数时，通常能避免大部分精度问题，但某些特殊情况下，结果可能不符合预期。

解决方案

如果你希望输出始终保留两位小数，可以使用字符串格式化的方式。下面是修改后的代码：

python

a = float(input())
b = round(a, 2)
print("{:.2f}".format(b))

在上述代码中，"{:.2f}".format(b) 运用了字符串格式化的方法，{:.2f} 代表将数字格式化为保留两位小数的浮点数。这样，不管四舍五入后的结果末尾是否为 0，都会输出保留两位小数的形式。

此外，在 Python 3.6 及之后的版本，还能使用 f-string 来实现相同的功能：

python

a = float(input())
b = round(a, 2)
print(f"{b:.2f}")

2.首字母大写函数

1. capitalize() 方法

capitalize() 方法用于将字符串的第一个字符转换为大写，其余字符转换为小写。

示例代码：

python

string = "hello world"
result = string.capitalize()
print(result)

代码解释：上述代码先定义了一个字符串 string，接着调用 capitalize() 方法对其进行处理，最后输出结果 Hello world。

2. title() 方法

title() 方法会将字符串中每个单词的首字母转换为大写，其余字母转换为小写。

示例代码：

python

string = "hello world"
result = string.title()
print(result)

代码解释：代码中定义了字符串 string，使用 title() 方法处理后，输出结果 Hello World。

3. 手动实现

你也可以通过切片和字符串拼接的方式手动实现首字母大写的功能。

示例代码：

python

string = "hello world"
if string:
    result = string[0].upper() + string[1:]
    print(result)
else:
    print(string)

代码解释：该代码首先检查字符串是否为空，若不为空，将字符串的第一个字符转换为大写，再与剩余部分拼接起来；若为空，则直接输出原字符串。

总结

若只需将整个字符串的第一个字符大写，其余字符小写，可使用 capitalize() 方法。

若要将字符串中每个单词的首字母大写，其余字母小写，可使用 title() 方法。

若需要自定义实现逻辑，可以通过手动切片和拼接的方式来完成。

3.python中去掉空格的方法有以下几种

1.使用lstrip()函数去掉左边空格

2.使用rstrip()函数去掉右边空格

3.使用strip()函数去掉左右两边空格

4.使用replace()函数去掉所有空格

4.列表元素删除

方法一：使用pop删除【pop后跟下标值】

复制代码

1 2 3

s = input().split() s.pop(0)#删除s列表中下标为0的元素 print(com)

方法二：使用remove删除【remove后跟元素值】

1 2 3

com = input().split() com.remove(com[0]) print(com)

5.pop函数

在 Python 里，pop() 函数并非独立函数，而是部分内置数据类型（如列表 list、字典 dict、集合 set 中只有 pop() 但无参数）所具备的方法，下面分别介绍不同数据类型中 pop() 方法的用法。

列表（list）中的 pop() 方法

语法

python

list.pop([index])

参数

index：这是可选参数，代表要移除并返回的元素的索引。若不提供该参数，默认移除并返回列表的最后一个元素。

返回值

返回被移除的元素。

示例

python

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 不指定索引，移除并返回最后一个元素
last_element = my_list.pop()
print("移除的最后一个元素:", last_element)
print("移除后的列表:", my_list)

# 指定索引，移除并返回指定位置的元素
second_element = my_list.pop(1)
print("移除的第二个元素:", second_element)
print("再次移除后的列表:", my_list)

字典（dict）中的 pop() 方法

语法

python

dict.pop(key[, default])

参数

key：这是必需参数，代表要移除的键。

default：此为可选参数，若指定的键不存在于字典中，就返回该默认值。若不提供该参数，且键不存在，会抛出 KeyError 异常。

返回值

返回指定键对应的值，若键不存在且提供了 default 参数，则返回 default。

示例

python

# 创建一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 移除指定键并返回对应的值
value_b = my_dict.pop('b')
print("移除的键 'b' 对应的值:", value_b)
print("移除后的字典:", my_dict)

# 尝试移除不存在的键，提供默认值
value_d = my_dict.pop('d', '键不存在')
print("尝试移除键 'd' 的结果:", value_d)
print("再次操作后的字典:", my_dict)

集合（set）中的 pop() 方法

语法

python

set.pop()

参数

无。

返回值

随机移除并返回集合中的一个元素。若集合为空，会抛出 KeyError 异常。

示例

python

# 创建一个集合
my_set = {1, 2, 3, 4, 5}

# 移除并返回集合中的一个元素
random_element = my_set.pop()
print("移除的随机元素:", random_element)
print("移除后的集合:", my_set)

总结

列表的 pop() 方法主要用于根据索引移除元素。

字典的 pop() 方法用于根据键移除元素，还可指定默认值来避免键不存在时的异常。

集合的 pop() 方法会随机移除一个元素。

6.sort函数

使用sort函数对列表降序排序

        旧列表.sort(reverse = True)        

        sort函数用法：

        列表名.sort(reverse = False)  其中，reverse = True 降序， reverse = False 升序（默认） 

7.reserve函数

在 Python 里，并没有独立的 reverse 函数，但有与反转操作相关的方法和函数，下面为你详细介绍它们在不同数据类型中的使用。

列表（list）的 reverse() 方法

语法

python

list.reverse()

描述

reverse() 是列表对象的一个方法，它会对列表进行原地反转操作，也就是直接修改原列表，将列表中的元素顺序颠倒，该方法没有返回值（返回 None）。

示例

python

my_list = [1, 2, 3, 4, 5]
print("反转前的列表:", my_list)
result = my_list.reverse()
print("反转后的列表:", my_list)
print("reverse() 方法的返回值:", result)

代码解释

定义了一个列表 my_list。

调用 reverse() 方法对列表进行反转操作。

打印反转后的列表和 reverse() 方法的返回值，可看到列表元素顺序颠倒，而返回值为 None。

内置函数 reversed()

语法

python

reversed(seq)

参数

seq：表示要进行反转操作的序列，如列表、元组、字符串等。

描述

reversed() 是一个内置函数，它会返回一个反向迭代器对象，而不会改变原序列。你可以使用 list()、tuple() 等函数将这个迭代器对象转换为对应的序列类型。

示例

python

my_list = [1, 2, 3, 4, 5]
reversed_iterator = reversed(my_list)
reversed_list = list(reversed_iterator)
print("原列表:", my_list)
print("反转后的列表:", reversed_list)

my_string = "Python"
reversed_string = ''.join(reversed(my_string))
print("原字符串:", my_string)
print("反转后的字符串:", reversed_string)

代码解释

对于列表，使用 reversed() 函数得到一个反向迭代器，再用 list() 函数将其转换为列表。

对于字符串，使用 reversed() 函数得到反向迭代器后，用 join() 方法将迭代器中的字符连接成字符串。

8.ord函数

在 Python 中，ord() 是一个内置函数，其作用是返回单个 Unicode 字符对应的整数（即 Unicode 码点）。下面从基本用法、应用场景、注意事项等方面为你详细介绍。

基本语法

python

ord(c)

其中，c 为一个长度为 1 的字符串，也就是单个 Unicode 字符。函数返回值是一个整数，代表该字符对应的 Unicode 码点。

示例代码

以下是一些使用 ord() 函数的示例：

python

# 获取字符 'A' 的 Unicode 码点
print(ord('A'))  # 输出: 65

# 获取字符 'a' 的 Unicode 码点
print(ord('a'))  # 输出: 97

# 获取中文字符 '你' 的 Unicode 码点
print(ord('你'))  # 输出: 20320

应用场景

字符编码处理：在处理字符编码时，有时需要知道某个字符的具体码点，以便进行编码转换或比较操作。例如，在 ASCII 编码中，大写字母 A - Z 的码点范围是 65 – 90，小写字母 a - z 的码点范围是 97 – 122。可以使用 ord() 函数来判断一个字符是否为字母：

python

char = 'B'
if 65 <= ord(char) <= 90 or 97 <= ord(char) <= 122:
    print(f'{char} 是字母')
else:
    print(f'{char} 不是字母')

加密算法：在简单的加密算法中，可以通过对字符的码点进行运算来实现加密和解密。例如，将每个字符的码点加上一个固定的偏移量：

python

def simple_encrypt(text, offset):
    encrypted_text = ""
    for char in text:
        encrypted_char = chr(ord(char) + offset)
        encrypted_text += encrypted_char
    return encrypted_text

plain_text = "hello"
encrypted = simple_encrypt(plain_text, 3)
print(encrypted)

注意事项

参数必须是单个字符：ord() 函数的参数必须是长度为 1 的字符串。如果传入的字符串长度不为 1，会引发 TypeError 异常。例如：

python

try:
    print(ord('abc'))
except TypeError as e:
    print(f"错误: {e}")

与 chr() 函数配合使用：chr() 函数与 ord() 函数是相反的操作，chr() 函数可以将一个整数（Unicode 码点）转换为对应的字符。例如：

python

9.hex函数

在 Python 里，hex() 是一个内置函数，主要用于把整数转换为以 0x 开头的十六进制字符串。下面从基本用法、应用场景、注意事项等方面进行详细介绍。

基本语法

python

hex(x)

其中，x 是需要转换的整数，这个整数可以是十进制、二进制或者八进制形式。函数返回值是一个以 0x 开头的十六进制字符串。

示例代码

以下是一些使用 hex() 函数的示例：

python

# 十进制整数转换为十六进制字符串
decimal_num = 255
hex_str = hex(decimal_num)
print(hex_str)  # 输出: 0xff

# 二进制整数转换为十六进制字符串
binary_num = 0b1010
hex_str = hex(binary_num)
print(hex_str)  # 输出: 0xa

# 八进制整数转换为十六进制字符串
octal_num = 0o12
hex_str = hex(octal_num)
print(hex_str)  # 输出: 0xa

应用场景

计算机底层编程：在处理内存地址、颜色值等场景时，十六进制表示法非常常见。例如，在图形编程中，颜色值通常用十六进制表示。可以使用 hex() 函数将十进制颜色值转换为十六进制字符串：

python

red = 255
green = 128
blue = 0
color_hex = f"#{hex(red)[2:]}{hex(green)[2:]}{hex(blue)[2:]}"
print(color_hex)  # 输出: #ff8000

调试和日志记录：在调试程序时，有时需要查看变量的十六进制表示，以便更好地理解数据在内存中的存储形式。

注意事项

参数必须是整数：hex() 函数的参数必须是整数类型。如果传入的不是整数，会引发 TypeError 异常。例如：

python

try:
    print(hex(3.14))
except TypeError as e:
    print(f"错误: {e}")

去除 0x 前缀：如果不需要 0x 前缀，可以使用切片操作来去除。例如：

python

num = 10
hex_str = hex(num)
hex_str_without_prefix = hex_str[2:]
print(hex_str_without_prefix)  # 输出: a

与其他进制转换函数的关系

Python 还提供了 bin() 和 oct() 函数，分别用于将整数转换为二进制和八进制字符串。这些函数的使用方法和 hex() 类似。例如：

python

num = 10
binary_str = bin(num)
octal_str = oct(num)
print(binary_str)  # 输出: 0b1010
print(octal_str)   # 输出: 0o12

10.pow()函数

在 Python 中，pow() 函数用于计算幂运算，它既可以作为内置函数使用，也可以作为 math 模块中的函数使用。下面为你详细介绍 pow() 函数的相关信息。

内置 pow() 函数

语法

python

pow(x, y, [z])

x：底数，即要进行幂运算的基数，可以是整数、浮点数。

y：指数，用于指定底数要乘方的次数，可以是整数、浮点数。

z（可选）：模，用于对幂运算的结果取模，是一个整数参数。若提供了该参数，函数会返回 (x ** y) % z 的结果，这在进行大数值的幂模运算时非常高效。

示例代码

python

# 计算 2 的 3 次方
result1 = pow(2, 3)
print("2 的 3 次方:", result1)

# 计算 2.5 的 2 次方
result2 = pow(2.5, 2)
print("2.5 的 2 次方:", result2)

# 计算 (3 ** 4) % 5
result3 = pow(3, 4, 5)
print("(3 ** 4) % 5 的结果:", result3)

代码解释

第一个示例是计算整数的幂，pow(2, 3) 等价于 2 ** 3，结果为 8。

第二个示例计算浮点数的幂，pow(2.5, 2) 等价于 2.5 ** 2，结果为 6.25。

第三个示例进行了幂模运算，先计算 3 的 4 次方得 81，再对 5 取模，结果为 1。

math 模块中的 pow() 函数

语法

python

import math
math.pow(x, y)

x：底数，可以是整数、浮点数。

y：指数，可以是整数、浮点数。

示例代码

python

import math

# 计算 2 的 3 次方
result = math.pow(2, 3)
print("math.pow 计算 2 的 3 次方:", result)

代码解释

math.pow(2, 3) 同样是计算 2 的 3 次方，但与内置 pow() 函数不同的是，math.pow() 函数的返回值始终是浮点数类型。

内置 pow() 与 math.pow() 的区别

返回值类型：内置 pow() 函数返回值的类型取决于参数的类型，若参数为整数，结果也为整数；若参数包含浮点数，结果为浮点数。而 math.pow() 函数的返回值始终是浮点数。

功能特性：内置 pow() 函数支持第三个参数（模），可进行幂模运算；math.pow() 函数不支持该功能。

综上所述，在进行普通的幂运算时，可根据是否需要进行幂模运算以及对返回值类型的要求来选择使用内置 pow() 函数还是 math.pow() 函数。

11.count函数

在 Python 里，count() 是一个非常实用的方法，多个内置数据类型都提供了该方法，主要用于统计某个元素在对象中出现的次数。下面为你分别介绍不同数据类型中 count() 方法的使用。

字符串中的 count() 方法

语法

python

str.count(sub, start=0, end=len(str))

sub：要统计的子字符串。

start（可选）：开始搜索的索引位置，默认为 0。

end（可选）：结束搜索的索引位置，默认为字符串的长度。

示例代码

python

text = "hello, hello, world"
# 统计 'hello' 在字符串中出现的次数
count = text.count('hello')
print("'hello' 出现的次数:", count)

# 从索引 7 开始统计 'hello' 出现的次数
count = text.count('hello', 7)
print("从索引 7 开始，'hello' 出现的次数:", count)

列表中的 count() 方法

语法

python

list.count(x)

x：要统计的元素。

示例代码

python

numbers = [1, 2, 3, 2, 4, 2]
# 统计 2 在列表中出现的次数
count = numbers.count(2)
print("2 出现的次数:", count)

元组中的 count() 方法

语法

python

tuple.count(x)

x：要统计的元素。

示例代码

python

fruits = ('apple', 'banana', 'apple', 'cherry')
# 统计 'apple' 在元组中出现的次数
count = fruits.count('apple')
print("'apple' 出现的次数:", count)

注意事项

返回值：count() 方法返回的是元素或子字符串出现的次数，返回值类型为整数。

不修改原对象：count() 方法不会对原字符串、列表或元组进行修改，只是返回统计结果。

区分大小写：在字符串中使用 count() 方法时，是区分大小写的。例如，'Hello'.count('h') 的结果为 0。

11.index函数

在 Python 中，index() 是一个常用的方法，多个内置数据类型都提供了该方法，主要用于查找指定元素在对象中第一次出现的位置索引。以下将分别介绍不同数据类型中 index() 方法的使用。

字符串中的 index() 方法

语法

python

str.index(sub, start=0, end=len(str))

sub：要查找的子字符串。

start（可选）：开始搜索的索引位置，默认为 0。

end（可选）：结束搜索的索引位置，默认为字符串的长度。

示例代码

python

text = "hello, world"
# 查找 'world' 在字符串中第一次出现的索引
index = text.index('world')
print("'world' 第一次出现的索引:", index)

# 从索引 7 开始查找 'l' 第一次出现的索引
index = text.index('l', 7)
print("从索引 7 开始，'l' 第一次出现的索引:", index)

异常处理

如果指定的子字符串未找到，index() 方法会抛出 ValueError 异常。你可以使用 try-except 语句来捕获并处理该异常，示例如下：

python

try:
    text = "hello"
    index = text.index('x')
    print(index)
except ValueError:
    print("未找到指定子字符串")

列表中的 index() 方法

语法

python

list.index(x, start=0, end=len(list))

x：要查找的元素。

start（可选）：开始搜索的索引位置，默认为 0。

end（可选）：结束搜索的索引位置，默认为列表的长度。

示例代码

python

numbers = [1, 2, 3, 2, 4]
# 查找 2 在列表中第一次出现的索引
index = numbers.index(2)
print("2 第一次出现的索引:", index)

# 从索引 2 开始查找 2 第一次出现的索引
index = numbers.index(2, 2)
print("从索引 2 开始，2 第一次出现的索引:", index)

同样，如果指定的元素未找到，index() 方法也会抛出 ValueError 异常，需要进行异常处理。

元组中的 index() 方法

语法

python

tuple.index(x, start=0, end=len(tuple))

x：要查找的元素。

start（可选）：开始搜索的索引位置，默认为 0。

end（可选）：结束搜索的索引位置，默认为元组的长度。

示例代码

python

fruits = ('apple', 'banana', 'cherry', 'banana')
# 查找 'banana' 在元组中第一次出现的索引
index = fruits.index('banana')
print("'banana' 第一次出现的索引:", index)

当指定元素不在元组中时，同样会抛出 ValueError 异常。

注意事项

索引从 0 开始：Python 中的索引是从 0 开始计数的，即第一个元素的索引为 0。

仅返回首次出现的索引：index() 方法只返回指定元素第一次出现的索引，如果需要查找所有出现的位置，需要编写额外的代码。

异常处理：在使用 index() 方法时，要注意处理可能出现的 ValueError 异常，避免程序崩溃。

12.find函数

在 Python 中，find() 是字符串对象所拥有的方法，其用途是查找子字符串在原字符串里首次出现的位置索引。若未找到指定的子字符串，则返回 -1。以下为你详细介绍它的用法。

语法

python

str.find(sub, start=0, end=len(str))

sub：这是必须要提供的参数，代表要查找的子字符串。

start（可选）：表示开始搜索的索引位置，默认值为 0，也就是从字符串的起始位置开始查找。

end（可选）：表示结束搜索的索引位置，默认值为字符串的长度，意味着搜索会一直到字符串的末尾。

示例代码

python

# 示例 1：基本查找
text = "Hello, World!"
# 查找 'World' 首次出现的索引
index = text.find('World')
print("'World' 首次出现的索引:", index)

# 示例 2：指定起始位置查找
# 从索引 7 开始查找 'l' 首次出现的索引
index = text.find('l', 7)
print("从索引 7 开始，'l' 首次出现的索引:", index)

# 示例 3：指定起始和结束位置查找
# 从索引 0 到 5 之间查找 'o' 首次出现的索引
index = text.find('o', 0, 5)
print("从索引 0 到 5 之间，'o' 首次出现的索引:", index)

# 示例 4：未找到子字符串
# 查找 'Python' 首次出现的索引
index = text.find('Python')
print("'Python' 首次出现的索引:", index)

代码解释

在示例 1 里，text.find('World') 从字符串开头开始查找 'World'，其首次出现的索引是 7。

示例 2 中，text.find('l', 7) 从索引 7 开始查找 'l'，首次出现的索引是 10。

示例 3 里，text.find('o', 0, 5) 在索引 0 到 5 的范围内查找 'o'，首次出现的索引是 4。

示例 4 中，由于字符串 text 里不存在 'Python'，所以 text.find('Python') 返回 -1。

find() 与 index() 的对比

find() 和 index() 方法都能用于查找子字符串在原字符串中的位置，不过它们的不同之处在于：当未找到指定的子字符串时，find() 方法返回 -1，而 index() 方法会抛出 ValueError 异常。所以，若你期望在未找到子字符串时程序不会崩溃，使用 find() 方法是个不错的选择。

12.eval()函数

在 Python 中，eval() 是一个内置函数，其作用是将字符串当作 Python 表达式来执行，并返回表达式的计算结果。下面从基本语法、使用示例、应用场景、注意事项等方面为你详细介绍。

基本语法

python

eval(expression, globals=None, locals=None)

expression：这是一个必需的字符串参数，代表要被求值的 Python 表达式。

globals（可选）：是一个字典，用于指定全局命名空间。若未提供该参数，默认使用当前的全局命名空间。

locals（可选）：是一个映射对象，用于指定局部命名空间。若未提供该参数，默认使用当前的局部命名空间。

使用示例

python

# 示例 1：简单的数学表达式计算
expression1 = "2 + 3 * 4"
result1 = eval(expression1)
print("2 + 3 * 4 的计算结果:", result1)

# 示例 2：使用全局和局部命名空间
x = 10
y = 20
globals_dict = {'x': x}
locals_dict = {'y': y}
expression2 = "x + y"
result2 = eval(expression2, globals_dict, locals_dict)
print("x + y 的计算结果:", result2)

应用场景

动态计算：当你需要根据用户输入的表达式进行动态计算时，eval() 函数就非常有用。例如，实现一个简单的计算器程序：

python

expression = input("请输入一个数学表达式: ")
result = eval(expression)
print("计算结果:", result)

配置文件处理：在某些情况下，配置文件中可能包含 Python 表达式，你可以使用 eval() 函数来解析并执行这些表达式。

注意事项

安全风险：eval() 函数会执行任意的 Python 表达式，这意味着如果传入的字符串来自不可信的来源（如用户输入），可能会导致安全问题，例如执行恶意代码。例如：

python

malicious_input = "__import__('os').system('rm -rf /')"  # 危险代码
try:
    eval(malicious_input)
except Exception as e:
    print(f"执行出现错误: {e}")

为避免此类安全风险，应尽量避免对不可信的输入使用 eval() 函数，或者使用更安全的替代方法。

性能问题：eval() 函数在执行时需要解析和编译字符串，相对直接执行代码来说，性能较低。因此，在性能要求较高的场景中，应谨慎使用。

综上所述，eval() 函数在某些特定场景下非常有用，但由于其存在安全风险和性能问题，使用时需要格外小心。

13.python取商取余取除

def fun(x,y):

    if y!=0:

        a=x//y（取商）

        b=x%y（取余）

        c=x/y（取非整除结果

        print('%.2f'%(x/y)) 

x=int(input())

y=int(input())

fun(x,y)

 14.python的可变参数：

*args

*args 用于传递非关键字可变参数，这些参数会被封装成一个元组。下面是示例代码：

python

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


print(sum_numbers(1, 2, 3))
print(sum_numbers(1, 2, 3, 4, 5))

在这个例子中，sum_numbers 函数可以接收任意数量的参数，然后将这些参数相加。

2. **kwargs

**kwargs 用于传递关键字可变参数，这些参数会被封装成一个字典。以下是示例代码：

python

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


print_info(name="Alice", age=25, city="New York")

在这个例子中，print_info 函数可以接收任意数量的关键字参数，然后将这些参数的键值对打印出来。

3. 结合使用 *args 和 **kwargs

在一个函数里，*args 和 **kwargs 可以结合使用，不过要保证 *args 位于 **kwargs 之前。示例如下：

python

def example_function(*args, **kwargs):
    print("Non-keyword arguments:")
    for arg in args:
        print(arg)
    print("Keyword arguments:")
    for key, value in kwargs.items():
        print(f"{key}: {value}")


example_function(1, 2, 3, name="Bob", age=30)

这个函数既可以接收非关键字参数，也可以接收关键字参数。

15.抛错机制

在 Python 里，抛错机制也就是异常处理机制，该机制能够让程序在运行时应对错误与异常状况。下面会详细介绍 Python 的抛错机制，涵盖异常类型、抛出异常、捕获异常以及自定义异常等方面。

1. 异常类型

Python 有许多内置的异常类型，用于表示不同的错误状况。以下是一些常见的异常类型：

SyntaxError：当代码存在语法错误时会抛出此异常。

IndentationError：代码缩进存在错误时会抛出该异常。

NameError：尝试访问未定义的变量时会触发此异常。

TypeError：操作或函数应用于不恰当类型的对象时会抛出此异常。

ValueError：函数接收到合适类型但值不恰当的参数时会触发此异常。

IndexError：尝试访问序列中不存在的索引时会抛出此异常。

KeyError：尝试访问字典中不存在的键时会触发此异常。

2. 抛出异常

你可以使用 raise 语句来手动抛出异常。示例如下：

python

def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("除数不能为零")
    return a / b


try:
    result = divide(10, 0)
except ZeroDivisionError as e:
    print(f"发生异常: {e}")

在这个例子中，当除数为零时，divide 函数会抛出 ZeroDivisionError 异常。

3. 捕获异常

使用 try-except 语句可以捕获并处理异常。示例如下：

python

try:
    num = int("abc")
except ValueError as e:
    print(f"发生异常: {e}")

在这个例子中，int("abc") 会引发 ValueError 异常，try-except 语句捕获该异常并输出错误信息。

你还可以使用多个 except 子句来捕获不同类型的异常：

python

try:
    num = int("abc")
    result = 10 / num
except ValueError as e:
    print(f"值错误: {e}")
except ZeroDivisionError as e:
    print(f"除零错误: {e}")

4. else 和 finally 子句

else 子句：在 try 块没有抛出异常时执行。

finally 子句：无论 try 块是否抛出异常，都会执行。

示例如下：

python

try:
    num = int("123")
except ValueError as e:
    print(f"发生异常: {e}")
else:
    print(f"转换成功: {num}")
finally:
    print("无论是否发生异常，都会执行此语句")

5. 自定义异常

你可以通过继承 Exception 类来创建自定义异常。示例如下：

python

class MyError(Exception):
    def __init__(self, message):
        self.message = message


def check_age(age):
    if age < 0:
        raise MyError("年龄不能为负数")
    return age


try:
    age = check_age(-5)
except MyError as e:
    print(f"发生自定义异常: {e.message}")

在这个例子中，MyError 是一个自定义异常类，当年龄为负数时，check_age 函数会抛出该异常。

综上所述，Python 的抛错机制借助异常类型、抛出异常、捕获异常和自定义异常等功能，让程序能够在运行时处理各种错误和异常状况，增强了程序的健壮性和可靠性。

分享

如何在Python中捕获多个异常？

请给出一个使用自定义异常的Python示例。

Python异常处理机制的作用是什么？

作者：哒哒等等