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()
函数用于生成一个整数序列。
语法:
range(stop)
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()
方法用于返回可迭代对象中的最小值或者返回多个参数中的最小值。
语法:
min(iterable, *[, key, default])
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()
方法用于返回可迭代对象中的最大值或者返回多个参数中的最大值。
语法:
max(iterable, *[, key, default])
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()
方法用于获取一个对象的哈希值。
哈希值是一个整数,通常用于在字典等数据结构中快速查找和比较对象。
特点:
- 对于相同的对象(在具有相同内容的不可变对象的情况下),多次调用
hash()
方法会得到相同的结果。 - 对于可变对象(如列表、字典等),通常不建议使用
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.总结
今天的方法总结就到这里了,希望对大家有所帮助。
标签:输出,False,之旅,Python,奇妙,对象,print,True From: https://blog.csdn.net/weixin_61003764/article/details/140661399