《Python 基础方法的奇妙回顾之旅》

1.学习内容

1.1本篇博客主要是学过的方法进行总结:

1.1.1  print（）方法

print方法是Python中最常用到的方法，print() 方法用于将指定的对象输出到控制台。

语法：
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• objects：要输出的一个或多个对象，可以是字符串、数字、变量等。
• sep：指定在多个对象之间插入的分隔符，默认为一个空格' '。
• end：指定输出结束时添加的字符，默认为换行符'\n'。
• file：指定要将输出发送到的文件对象，默认为标准输出（控制台）。
• flush：指定是否强制刷新输出缓冲区，默认为 False。

案例：

# 输出一个字符串
print("Hello, World!")

# 输出多个对象，用默认分隔符
print("Python", "is", "great")

# 输出多个对象，自定义分隔符
print("Apple", "Banana", "Orange", sep=", ")

# 输出后不换行
print("This is a line", end=" ")
print("This is on the same line")

# 输出到文件
with open("output.txt", "w") as f:
    print("This will be written to the file", file=f)

1.1.2 input（）方法

在 Python 中，input() 方法用于从用户获取输入。

语法：
input([prompt])

• prompt（可选）：是一个字符串，作为提示信息显示给用户。

功能：它会等待用户在控制台输入内容，并按下回车键。然后，它返回用户输入的字符串值。

案例：

# 简单的获取用户输入
name = input("请输入您的名字：")
print("您好，" + name)

# 进行计算
num1 = int(input("请输入第一个数字："))
num2 = int(input("请输入第二个数字："))
result = num1 + num2
print("两数之和为：", result)

# 处理用户输入的字符串
message = input("请输入一段文字：")
print("您输入的文字长度为：", len(message))

1.1.3 type（）方法

在 Python 中，type() 方法用于返回对象的类型。

语法：type(object)

参数：object 是要获取类型的对象。

返回值：返回一个类型对象，表示传入对象的类型。

案例：

# 查看整数的类型
num = 5
print(type(num))  

# 查看字符串的类型
text = "Hello"
print(type(text))  

# 查看列表的类型
lst = [1, 2, 3]
print(type(lst))  

# 查看字典的类型
dct = {'key1': 'value1', 'key2': 'value2'}
print(type(dct))  

# 查看自定义类的实例的类型
class MyClass:
    pass

obj = MyClass()
print(type(obj))  

1.1.4 isinstance（） 方法

isinstance() 方法用于检查一个对象是否是特定类或特定类的子类的实例。

其语法如下：

isinstance(object, classinfo)

其中：

• object：要检查的对象。
• classinfo：可以是类对象、类元组或类类型。

该函数返回一个布尔值，如果 object 是 classinfo 的实例或者 classinfo 是一个由类对象组成的元组，且 object 是其中某个类的实例，则返回 True；否则返回 False。

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

示例 1：检查对象是否为特定类的实例

class Person:
    pass

person = Person()
print(isinstance(person, Person))  # True

示例 2：检查对象是否为特定类的子类的实例

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(isinstance(dog, Animal))  # True

示例 3：检查对象是否为多个类之一的实例

class Car:
    pass

class Bicycle:
    pass

class Motorcycle:
    pass

vehicle = Bicycle()
print(isinstance(vehicle, (Car, Bicycle, Motorcycle)))  # True

示例 4：检查对象的数据类型

number = 42
print(isinstance(number, int))  # True

text = "hello,world!"
print(isinstance(text, str))  # True

is_valid = True
print(isinstance(is_valid, bool))  # True

numbers = [1, 2, 3, 4, 5]
print(isinstance(numbers, list))  # True

通过使用 isinstance() 函数，可以方便地进行类型检查和条件判断，以便根据对象的类型执行不同的操作。它提供了一种简单的方法来确定对象的类型。如果对象的类型与指定的类或类元组不匹配，isinstance() 函数将返回 False。例如：

number = 42
print(isinstance(number, str))  # False

1.1.5 int（）方法

在 Python 中，int() 方法用于将一个数值或字符串转换为整数类型。

语法：
int(x, base=10)

• x：要转换为整数的数字或字符串。
• base（可选）：指定进制，默认为十进制。取值可以是 0、2 到 36 之间的整数。

返回值：返回一个整数。

案例：

# 将浮点数转换为整数
num1 = int(3.14)
print(num1)  # 3

# 将字符串转换为整数
num2 = int("123")
print(num2)  # 123

# 按照指定进制转换
num3 = int("1010", 2)
print(num3)  # 10

num4 = int("12", 16)
print(num4)  # 18

1.1.6 float（）方法

在 Python 中，float() 方法用于将一个数值或字符串转换为浮点数类型。
float(x)

• x：可以是整数、浮点数或字符串。

返回值：返回一个浮点数。

案例：

# 将整数转换为浮点数
num1 = float(5)
print(num1)  # 5.0

# 将字符串转换为浮点数
num2 = float("3.14")
print(num2)  # 3.14

num3 = float("5")
print(num3)  # 5.0

1.1.7 bool（）方法

在 Python 中，bool() 方法用于将一个值转换为布尔类型（True 或 False）。

以下是一些转换规则：

• 对于数值类型，0 被转换为 False，其他数值（包括负数）都被转换为 True。

• 对于字符串类型，空字符串 "" 被转换为 False，非空字符串被转换为 True。

• 对于列表、元组、字典等容器类型，如果容器为空（不包含任何元素），则转换为 False，否则转换为 True。

• None 被转换为 False。

案例：

# 数值类型
print(bool(0))  # False
print(bool(5))  # True
print(bool(-3))  # True

# 字符串类型
print(bool(""))  # False
print(bool("hello"))  # True

# 列表类型
print(bool([]))  # False
print(bool([1, 2]))  # True

# 字典类型
print(bool({}))  # False
print(bool({'key': 'value'}))  # True

# None 类型
print(bool(None))  # False

1.1.8  str()方法

在 Python 中，str() 方法用于将对象转换为字符串形式。

语法：
str(object)

参数：object 是要转换为字符串的对象。

返回值：返回对象的字符串表示。

# 转换整数
num = 123
print(str(num))  # '123'

# 转换浮点数
float_num = 3.14
print(str(float_num))  # '3.14'

# 转换列表
lst = [1, 2, 3]
print(str(lst))  # '[1, 2, 3]'

# 转换字典
dct = {'a': 1, 'b': 2}
print(str(dct))  # "{'a': 1, 'b': 2}"

# 转换自定义类的对象
class MyClass:
    def __init__(self, name):
        self.name = name

obj = MyClass('Example')
print(str(obj))  # <__main__.MyClass object at 0x...> （具体输出取决于类的定义）

通过 str() 方法，我们可以将各种类型的对象转换为易于处理和展示的字符串形式。

1.1.9  bin（）方法

在 Python 中，bin() 是一个内置函数，用于将整数转换为二进制字符串表示形式。

语法：bin(number)

参数：number 是要转换为二进制字符串的整数。

返回值：返回一个以 0b 开头的字符串，表示给定整数的二进制表示。

案例

print(bin(0))  # 输出：0b0 
print(bin(5))  # 输出：0b101 
print(bin(-5))  # 输出：-0b101 
print(bin(30))  # 输出：0b11110 
print(bin(-30))  # 输出：-0b11110 

如果需要去掉 0b 前缀，可以使用字符串的切片操作，例如：

num = 10
binary = bin(num)[2:]  
print(binary)  # 输出：1010

bin() 函数可以处理的整数范围取决于 Python 解释器的位数和平台。在大多数情况下，可以处理的整数范围是很大的，足以满足一般编程需求。

需要注意的是，bin() 函数只能用于整数。如果尝试对非整数使用 bin() 函数，将会引发 TypeError。此外，对于负数，bin() 函数会先将其转换为对应的正数（即取其绝对值），然后再进行二进制转换，所以返回的二进制字符串实际上是对应正数的二进制表示。

二进制在计算机科学中有广泛的应用，例如在位操作、编码、解码二进制数据以及理解计算机底层的工作原理等方面。通过 bin() 函数将整数转换为二进制字符串，更便于进行与二进制相关的处理和分析。

1.1.10  oct()方法

在 Python 中，oct() 函数用于将整数转换为八进制字符串。

语法：oct(number)

参数：number 是要转换的整数。

返回值：返回一个以 0o 开头的表示八进制的字符串。

案例：

print(oct(10))  # 输出：0o12 
print(oct(20))  # 输出：0o24 
print(oct(15))  # 输出：0o17 

# 负数的八进制表示
print(oct(-10))  # 输出：-0o12 

在上述示例中，oct(10) 将整数 10 转换为八进制字符串 0o12，oct(20) 将 20 转换为 0o24，以此类推。对于负数，如 -10，其八进制表示为 -0o12。

需要注意的是，oct() 函数只能接受整数作为参数。如果尝试传入非整数类型的值，将会引发 TypeError 异常。例如：

print(oct(3.14))  # 会引发 TypeError

1.1.11  hex()方法

在 Python 中，hex() 方法用于将整数转换为十六进制字符串。

语法：hex(number)

参数：number 为要转换的整数。

返回值：返回一个以 0x 开头的十六进制字符串。

案例：

# 正数转换
print(hex(10))  # 输出：0xa
print(hex(255))  # 输出：0xff

# 负数转换
print(hex(-10))  # 输出：-0xa

# 十六进制的简单应用
num = 0x1f
print(num)  # 输出：31

通过 hex() 方法，我们可以方便地将整数转换为十六进制字符串，这在处理与十六进制相关的操作时非常有用，比如在处理某些特定的编码、位操作或与其他系统交互时。

1.1.12  range()方法

在 Python 中，range() 函数用于生成一个整数序列。

语法：

1. range(stop)
2. range(start, stop, step)

参数说明：

• start（可选）：序列的起始值，默认为 0。
• stop：序列的结束值，但不包含该值。
• step（可选）：序列的步长，默认为 1。

返回值：返回一个可迭代的对象。

案例：

# 示例 1：只有一个参数，默认从 0 开始，步长为 1
for i in range(5):
    print(i)  
# 输出：0 1 2 3 4

# 示例 2：指定起始值和结束值
for i in range(2, 7):
    print(i)  
# 输出：2 3 4 5 6

# 示例 3：指定起始值、结束值和步长
for i in range(1, 10, 2):
    print(i)  
# 输出：1 3 5 7 9

# 示例 4：使用 range() 生成一个列表
my_list = list(range(5))
print(my_list)  
# 输出：[0, 1, 2, 3, 4]

range() 函数在循环中经常被用于控制循环的次数和范围，是一种非常实用的工具。

1.1.13  chr()方法

在 Python 中，chr() 函数用于将一个整数转换为对应的 ASCII 字符。

语法：chr(i)

参数：i 是一个整数，表示要转换的 ASCII 值。

返回值：返回对应的 ASCII 字符。

案例：

print(chr(65))  # 输出：A
print(chr(97))  # 输出：a
print(chr(48))  # 输出：0

# 循环打印 ASCII 值在 65 到 90 之间的字符（即大写字母 A 到 Z）
for i in range(65, 91):
    print(chr(i), end=" ")

通过 chr() 函数，我们可以根据 ASCII 码值获取对应的字符，这在处理与字符编码相关的操作时非常有用。

1.1.14  ord()方法

在 Python 中，ord() 函数用于获取字符的 ASCII 值。

语法：ord(c)

参数：c 是一个字符。

返回值：返回字符对应的 ASCII 整数值。

案例：

print(ord('A'))  # 输出：65
print(ord('a'))  # 输出：97
print(ord('0'))  # 输出：48

# 遍历字符串，获取每个字符的 ASCII 值
string = "Hello"
for char in string:
    print(ord(char), end=" ")

通过 ord() 函数，我们可以方便地获取字符对应的 ASCII 码值，这在处理字符编码和比较等操作时很有用。

1.1.15  min()方法

在 Python 中，min() 方法用于返回可迭代对象中的最小值或者返回多个参数中的最小值。

语法：

1. min(iterable, *[, key, default])
2. min(arg1, arg2, *args[, key])

参数说明：

• 对于第一种语法，iterable 是一个可迭代对象，比如列表、元组、字符串等。key 是一个可选的参数，用于指定一个函数来对每个元素进行处理后再比较。default 也是可选的，当 iterable 为空时返回该默认值。
• 对于第二种语法，arg1, arg2, *args 是要比较的多个值。key 同样是可选的用于处理每个值的函数。

返回值：返回可迭代对象中的最小值或者多个参数中的最小值。

案例：

# 可迭代对象中的最小值
numbers = [5, 2, 8, 1, 7]
print(min(numbers))  # 输出：1

# 带 key 参数，基于绝对值比较
numbers = [-5, 2, -8, 1, 7]
print(min(numbers, key=abs))  # 输出：1

# 多个参数中的最小值
print(min(10, 5, 8))  # 输出：5

# 字符串中的最小值（按照字符的 ASCII 值）
text = "Python"
print(min(text))  # 输出：'h'

1.1.16  max()方法

在 Python 中，max() 方法用于返回可迭代对象中的最大值或者返回多个参数中的最大值。

语法：

1. max(iterable, *[, key, default])
2. max(arg1, arg2, *args[, key])

参数说明：

• 对于第一种语法，iterable 是一个可迭代对象，如列表、元组、字符串等。key 是一个可选参数，用于指定一个函数来对每个元素进行处理后再比较。default 也是可选的，当 iterable 为空时返回该默认值。
• 对于第二种语法，arg1, arg2, *args 是要比较的多个值。key 同样是可选的，用于处理每个值的函数。

返回值：返回可迭代对象中的最大值或者多个参数中的最大值。

案例：

# 可迭代对象中的最大值
numbers = [5, 2, 8, 1, 7]
print(max(numbers))  # 输出：8

# 带 key 参数，基于元素的长度比较
words = ["apple", "banana", "cherry"]
print(max(words, key=len))  # 输出："banana"

# 多个参数中的最大值
print(max(10, 5, 8))  # 输出：10

# 字符串中的最大值（按照字符的 ASCII 值）
text = "Python"
print(max(text))  # 输出：'y'

1.1.17  id()方法

在 Python 中，id() 函数用于返回对象的唯一标识符。这个标识符是基于对象的内存地址生成的。

语法：id(object)

参数：object 是要获取标识符的对象。

返回值：返回对象的唯一整数标识符。

案例：

# 整数对象
num1 = 5
num2 = 5
print(id(num1))  
print(id(num2))  
# 通常对于小整数，Python 会进行缓存，所以 num1 和 num2 的 id 可能相同

# 列表对象
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(id(list1))  
print(id(list2))  
# 两个不同的列表对象的 id 通常不同

# 同一个列表对象的不同引用
list3 = list1
print(id(list3))  
# list3 和 list1 指向同一个列表对象，所以 id 相同

需要注意的是，id() 的值在程序的一次执行中是唯一的，但在不同的执行中可能不同。而且，对于不可变对象（如整数、字符串等），如果值相同，它们可能会共享相同的内存地址，从而具有相同的 id。但对于可变对象（如列表、字典等），即使值相同，它们也具有不同的 id。

1.1.18  abs()方法

在 Python 中，abs() 方法用于返回一个数的绝对值。

语法：abs(x)

参数：x 是一个数值，可以是整数、浮点数或复数。

返回值：返回 x 的绝对值。

案例：

print(abs(-5))  # 输出：5
print(abs(3.14))  # 输出：3.14
print(abs(-2.5))  # 输出：2.5

# 处理复数
complex_num = 3 + 4j
print(abs(complex_num))  # 输出：5.0

1.1.19  all()方法

在 Python 中，all() 方法用于判断可迭代对象中所有元素的布尔值是否都为 True 。

语法：all(iterable)

参数：iterable 是一个可迭代对象，如列表、元组、字符串等。

返回值：如果可迭代对象中所有元素的布尔值都为 True ，则返回 True ；否则返回 False 。需要注意的是，对于空的可迭代对象，all() 方法返回 True 。

案例：

# 列表中所有元素都为 True
list1 = [True, True, True]
print(all(list1))  # 输出：True

# 列表中有一个元素为 False
list2 = [True, False, True]
print(all(list2))  # 输出：False

# 列表中所有元素都为非零数值（在布尔上下文中被视为 True）
list3 = [1, 2, 3]
print(all(list3))  # 输出：True

# 列表中有一个元素为 0（在布尔上下文中被视为 False）
list4 = [1, 0, 2]
print(all(list4))  # 输出：False

# 空列表
list5 = []
print(all(list5))  # 输出：True

1.1.20  any()方法

在 Python 中，any() 方法用于判断可迭代对象中是否存在至少一个元素的布尔值为 True 。

语法：any(iterable)

参数：iterable 是一个可迭代对象，比如列表、元组、字符串等。

返回值：如果可迭代对象中至少有一个元素的布尔值为 True ，则返回 True ；如果可迭代对象为空或者所有元素的布尔值都为 False ，则返回 False 。

案例：

# 列表中存在 True 元素
list1 = [False, True, False]
print(any(list1))  # 输出：True

# 列表中所有元素都为 False
list2 = [False, False, False]
print(any(list2))  # 输出：False

# 列表中存在非零数值（在布尔上下文中视为 True）
list3 = [0, 0, 1]
print(any(list3))  # 输出：True

# 列表中所有元素都为 0（在布尔上下文中视为 False）
list4 = [0, 0, 0]
print(any(list4))  # 输出：False

# 空列表
list5 = []
print(any(list5))  # 输出：False

1.1.21  callable()方法

在 Python 中，callable() 方法用于检查一个对象是否是可调用的（即是否可以像函数一样被调用）。

语法：callable(object)

参数：object 是要检查的对象。

返回值：如果对象是可调用的，则返回 True；否则返回 False。

案例：

def my_function():
    pass

print(callable(my_function))  # 输出：True

class MyClass:
    def __call__(self):
        pass

my_instance = MyClass()
print(callable(my_instance))  # 输出：True

# 普通变量不可调用
x = 5
print(callable(x))  # 输出：False

# 内置函数是可调用的
print(callable(print))  # 输出：True

在上述案例中，定义的函数 my_function 、实现了 __call__ 方法的类的实例 my_instance 以及内置函数 print 都是可调用的，而普通变量 x 不可调用。

1.1.22  dir()方法

dir() 方法如果没有参数，返回当前作用域内的变量、方法和定义的类型列表。如果给定一个对象作为参数，它将返回该对象的属性和方法的列表。

案例：

# 没有参数的情况
print(dir())

# 对于整数对象
num = 5
print(dir(num))

# 对于字符串对象
text = "Hello"
print(dir(text))

# 对于自定义类的对象
class MyClass:
    def __init__(self):
        self.value = 10

    def my_method(self):
        pass

obj = MyClass()
print(dir(obj))

dir() 方法主要用于在编程过程中探索和了解对象的属性和方法，有助于开发和调试。

1.1.23  divmod()方法

在 Python 中，divmod() 方法用于同时执行除法和取余运算，并返回一个包含商和余数的元组。

语法：divmod(a, b)

参数：

• a：被除数。
• b：除数。

返回值：返回一个元组，其中第一个元素是 a 除以 b 的商，第二个元素是 a 除以 b 的余数

案例：

# 整数的除法和取余
print(divmod(10, 3))  # 输出：(3, 1) ，10 除以 3 的商是 3，余数是 1

# 负数的情况
print(divmod(-10, 3))  # 输出：(-4, 2) ，-10 除以 3 的商是 -4，余数是 2

# 浮点数也可以，但结果会被截断为整数
print(divmod(7.5, 2.5))  # 输出：(3, 0)

1.1.24  exit()方法

在 Python 中，exit() 方法用于退出程序。

它通常用于在程序执行过程中，根据某些条件提前终止程序的运行。

案例：

import sys

# 假设当某个条件满足时，退出程序
condition = True
if condition:
    print("Exiting the program.")
    sys.exit(0)  # 0 通常表示正常退出

在上述案例中，如果 condition 为 True ，程序会输出提示信息并使用 sys.exit(0) 退出程序。

需要注意的是，exit() 方法的使用应该谨慎，确保在必要的情况下才终止程序，以免导致未完成的重要操作或数据丢失。

1.1.25  globals()方法

在 Python 中，globals() 方法返回一个包含当前全局符号表的字典。

全局符号表包含了在当前模块中定义的全局变量和函数。

案例1：

x = 10
def my_function():
    print(globals()['x'])

my_function()

在上述案例中，在 my_function 函数内部使用 globals()['x'] 访问了全局变量 x 。

案例2：

globals()['y'] = 20
print(y) 

这里通过 globals() 直接在全局符号表中添加了一个新的变量 y ，并成功在后续使用。

需要注意的是，虽然可以通过 globals() 来操作全局变量，但过度使用可能会导致代码的可读性和可维护性降低，并且可能引起意外的副作用。

1.1.26  locals()方法

locals() 方法返回一个包含当前局部符号表的字典。局部符号表包含在当前函数或方法中定义的局部变量。

案例：

def my_function():
    x = 10
    y = 20
    print(locals())

my_function()

在上述案例中，在 my_function 函数内部调用 locals() 会返回一个包含函数内部定义的局部变量 x 和 y 的字典。

需要注意的是，locals() 的返回值是一个只读的字典，对其进行修改不会影响实际的局部变量。并且，通常情况下，我们更多地是使用局部变量进行计算和操作，而不是通过 locals() 来直接访问和处理它们。

1.1.27  hash()方法

在 Python 中，hash() 方法用于获取一个对象的哈希值。

哈希值是一个整数，通常用于在字典等数据结构中快速查找和比较对象。

特点：

1. 对于相同的对象（在具有相同内容的不可变对象的情况下），多次调用 hash() 方法会得到相同的结果。
2. 对于可变对象（如列表、字典等），通常不建议使用 hash() ，因为它们的内容可能会改变，导致哈希值不一致。

案例：

# 不可变对象
print(hash(10))  
print(hash("hello"))  
print(hash((1, 2, 3)))  

# 对于自定义的不可变类的对象
class MyImmutableClass:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        return self.value == other.value

    def __hash__(self):
        return hash(self.value)

obj1 = MyImmutableClass(5)
print(hash(obj1))

需要注意的是，如果自定义类的对象要在集合或作为字典的键使用，就需要同时实现 __eq__ （用于比较相等性）和 __hash__ 方法。

1.1.28  len()方法

在 Python 中，len() 方法用于返回对象的长度（元素个数）。

语法：len(object)

参数：object 是要获取长度的对象，可以是字符串、列表、元组、字典、集合等。

返回值：返回对象中元素的个数。

案例：

# 字符串
string = "Hello World"
print(len(string))  # 输出：11

# 列表
list1 = [1, 2, 3, 4, 5]
print(len(list1))  # 输出：5

# 元组
tuple1 = (10, 20, 30)
print(len(tuple1))  # 输出：3

# 字典
dict1 = {'a': 1, 'b': 2, 'c': 3}
print(len(dict1))  # 输出：3 （返回的是键值对的数量）

# 集合
set1 = {1, 2, 3, 4}
print(len(set1))  # 输出：4

通过 len() 方法，我们可以方便地获取各种对象的长度信息，这在处理数据和控制程序逻辑时非常有用。

1.1.29  pow()方法

在 Python 中，pow() 方法用于计算幂运算。

语法：pow(base, exp[, mod])

参数：

• base：底数。
• exp：指数。
• mod（可选）：取模运算的模数。

返回值：

• 如果只提供了 base 和 exp，则返回 base 的 exp 次幂。
• 如果提供了 mod，则返回 (base ** exp) % mod 的结果。

案例：

# 计算幂
print(pow(2, 3))  # 输出：8 （2 的 3 次方）

# 带取模运算
print(pow(2, 3, 5))  # 输出：3 （(2 ** 3) % 5 ）

# 负数的幂
print(pow(-2, 3))  # 输出：-8 （-2 的 3 次方）

# 小数的幂
print(pow(1.5, 2))  # 输出：2.25

通过 pow() 方法，我们可以灵活地进行幂运算和取模运算。

1.1.30  round()方法

在 Python 中，round() 方法用于对浮点数进行四舍五入。

语法：round(number[, ndigits])

参数：

• number：要进行四舍五入的数字。
• ndigits（可选）：表示要保留的小数位数。如果省略，默认为 0，即将数字四舍五入到最接近的整数。

返回值：四舍五入后的结果。

案例：

# 四舍五入到整数
print(round(3.14))  # 输出：3
print(round(3.8))  # 输出：4

# 保留一位小数
print(round(3.1415, 1))  # 输出：3.1
print(round(3.1455, 1))  # 输出：3.1 （注意 5 的进位规则）

# 保留两位小数
print(round(3.14159, 2))  # 输出：3.14
print(round(3.14559, 2))  # 输出：3.15

需要注意的是，当要保留的小数位恰好为 5 时，Python 的 round() 方法会根据前一位的奇偶性来决定进位。如果前一位是奇数，则进位；如果前一位是偶数，则不进位。

1.1.31  sorted()方法

在 Python 中，sorted() 方法用于对可迭代对象进行排序，并返回一个新的已排序列表。

语法：sorted(iterable, key=None, reverse=False)

参数说明：

• iterable：要排序的可迭代对象，例如列表、元组、字符串等。
• key（可选）：指定一个函数，用于从每个元素中提取用于比较的键。
• reverse（可选）：如果为 True，则排序结果将按降序排列；如果为 False（默认值），则按升序排列。

返回值：一个新的已排序列表。

案例：

# 对列表进行升序排序
numbers = [5, 2, 8, 1, 9]
print(sorted(numbers))  # 输出：[1, 2, 5, 8, 9]

# 对列表进行降序排序
print(sorted(numbers, reverse=True))  # 输出：[9, 8, 5, 2, 1]

# 基于字符串长度对列表进行排序
words = ["apple", "banana", "cherry", "date"]
print(sorted(words, key=len))  # 输出：['date', 'apple', 'cherry', 'banana']

# 对字典的键进行排序
my_dict = {'c': 3, 'a': 1, 'b': 2}
print(sorted(my_dict.keys()))  # 输出：['a', 'b', 'c']

# 对元组进行排序
tuple_data = (5, 2, 8, 1, 9)
print(sorted(tuple_data))  # 输出：[1, 2, 5, 8, 9]

通过这些案例，您可以看到 sorted() 方法的灵活性和实用性，能够根据不同的需求对各种可迭代对象进行排序。

1.1.32  sum()方法

在 Python 中，sum() 方法用于对可迭代对象中的数值元素进行求和。

语法：sum(iterable, start=0)

参数说明：

• iterable：要进行求和的可迭代对象，例如列表、元组等，其中的元素应为数值类型（如整数、浮点数等）。
• start（可选）：指定求和的起始值。默认值为 0。

返回值：求和的结果。

案例：

# 对列表中的整数求和
numbers = [1, 2, 3, 4, 5]
print(sum(numbers))  # 输出：15

# 对列表中的浮点数求和
floats = [1.5, 2.5, 3.5]
print(sum(floats))  # 输出：7.5

# 指定起始值求和
numbers = [1, 2, 3]
print(sum(numbers, 10))  # 输出：16 （10 + 1 + 2 + 3）

# 对元组中的整数求和
tuple_numbers = (5, 10, 15)
print(sum(tuple_numbers))  # 输出：30

通过 sum() 方法，我们可以方便地对一系列数值进行求和计算。

2.总结

今天的方法总结就到这里了，希望对大家有所帮助。