【Python】—— 公共的方法

最新推荐文章于 2024-07-15 18:19:17 发布

起飞的风筝

最新推荐文章于 2024-07-15 18:19:17 发布

阅读量997

点赞数 33

分类专栏： python基础文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_56069910/article/details/139151663

版权

python基础专栏收录该内容

19 篇文章 12 订阅

订阅专栏

首先，对于Python一些公共操作大致如下图所示：

（一）公共操作

1.1 公共操作之运算符加号

在 Python 中，+ 号运算符主要用于执行加法操作，但其用途并不止于此。

数值加法：

这是 + 运算符最常见的用途。当两个数字相加时，它返回它们的和。

res = 1 + 2  # res 的值为 3

字符串连接：

当 + 运算符用于字符串时，它会将两个字符串连接在一起。

message = "Hello, " + "world"  # message 的值为 "Hello, world"

列表连接：

对于列表，+ 运算符通常不能用来直接连接它们，因为列表没有定义 __add__ 方法来支持这种操作；
但是，你可以使用 extend() 方法来将一个列表的内容添加到另一个列表的末尾，或者使用列表推导式（list comprehension）和 + 运算符来合并两个列表。

list1 = [1, 2, 3]  
list2 = [4, 5, 6]  
list1.extend(list2)  # list1 现在是 [1, 2, 3, 4, 5, 6]  

# 或者使用列表推导式  
list3 = list1 + list2  # list3 是 [1, 2, 3, 4, 5, 6, 4, 5, 6]

注意，在上面的列表推导式中，list3 是 list1 和 list2 的内容合并而成的，而不是简单的连接。

元组连接：

和列表一样，元组也不能直接用 + 运算符连接，因为元组也没有定义 __add__ 方法。但你可以使用 + 运算符和元组字面量来创建新的元组。

tuple1 = (1, 2, 3)  
tuple2 = (4, 5, 6)  
tuple3 = tuple1 + tuple2  # tuple3 是 (1, 2, 3, 4, 5, 6)

1.2 公共操作之运算符乘号

在Python中，*号运算符有多种用途，主要包括数值乘法、字符串和列表的重复、以及函数定义中的参数解包等。

数值乘法：

*运算符在数值上用于乘法操作。

res = 2 * 3  # res 的值为 6

字符串重复：

当*运算符用于字符串时，它可以将字符串重复指定的次数。

str = "H"  
new_str= str * 3  # new_str的值为 "HHH"

列表重复：

与字符串类似，*运算符也可以用于列表，将列表重复指定的次数。

lst = [1, 2, 3]  
new_list= lst * 3  # new_list的值为 [1, 2, 3, 1, 2, 3, 1, 2, 3]

元祖重复：

与字符串类似，*运算符也可以用于元祖，将元祖重复指定的次数。

tuple1 = (1, 2)  
tuple2 = tuple1 * 3  # tuple2 是 (1, 2, 1, 2, 1, 2)

1.3 公共操作之运算符判断数据是否存在

在Python中，我们通常不直接使用运算符来判断数据是否存在，而是使用特定的数据结构和方法来检查数据是否存在于某个集合或列表中。但是，如果你想要通过某种条件判断（例如，使用比较运算符来检查一个值是否在某个范围内），那么你可以使用条件语句（如if）。

然而，对于检查一个元素是否存在于一个集合（set）、列表（list）或字典（dict）中，我们通常会使用以下方法：

列表: 使用in关键字。

list = [1, 2, 3, 4, 5]  
if 3 in list :  
    print("3 exists in the list.")  
else:  
    print("3 does not exist in the list.")

或者如下：

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

print(1 in list)  # True
print(7 in list)  # False

字典: 使用键（key）来检查。

dict = {'a': 1, 'b': 2, 'c': 3}  
if 'a' in dict :  
    print("'a' exists in the dictionary.")  
else:  
    print("'a' does not exist in the dictionary.")

（二）公共方法

在Python中，公共方法（或通常所说的方法）是类定义的函数，它们可以在类的实例上被调用。公共方法通常用于封装与对象状态相关的操作。

2.1 公共方法-len

len是一个内置函数（不是类的方法），用于返回对象的长度或项目数。这个函数是“公共”的，因为它可以在任何Python代码中使用，无需特定的类或模块导入。

len 函数可以接受多种类型的参数，包括字符串、列表、元组、字典、集合等，并返回它们包含的元素数量。

字符串

str = "hello"  
print(len(str))  # 输出: 5

列表

lst = [1, 2, 3, 4, 5]  
print(len(lst))  # 输出: 5

元组

tup = (1, 2, 3)  
print(len(tup))  # 输出: 3

字典

dict = {'a': 1, 'b': 2, 'c': 3}  
print(len(dict))  # 输出: 3

集合

num = {1, 2, 3, 2, 3, 4}  # 注意：集合中的重复元素会被自动去重  
print(len(num))  # 输出: 4

2.2 公共方法-del

在Python中，del是一个内建操作，用于删除对象（比如变量、列表元素、字典项等）。虽然它不是一个“方法”（method），但它确实是一种用于对象管理的公共机制。

使用del删除变量

x = 10  
print(x)  # 输出: 10  
del x  
# 尝试打印x将引发NameError，因为x已经被删除了  
print(x)  # NameError: name 'x' is not defined

使用del删除列表元素

lst = [1, 2, 3, 4, 5]  
print(lst)  # 输出: [1, 2, 3, 4, 5]  
del lst[2]  # 删除索引为2的元素（即数字3）  
print(lst)  # 输出: [1, 2, 4, 5]

使用del删除切片

lst = [1, 2, 3, 4, 5]  
print(lst)  # 输出: [1, 2, 3, 4, 5]  
del lst[1:3]  # 删除索引从1到2（不包括3）的元素  
print(lst)  # 输出: [1, 4, 5]

使用del删除字典项

dict = {'a': 1, 'b': 2, 'c': 3}  
print(dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}  

del dict ['b']  # 删除键为'b'的项  
print(dict)  # 输出: {'a': 1, 'c': 3}

2.3 公共方法-max和min

在Python中，max()和min()是两个常用的内置函数，也称为公共方法，因为它们可以用于多种数据类型，如列表、元组、字典（仅当比较键时）和字符串等。这些函数用于返回给定可迭代对象（如列表或元组）中的最大或最小值。

对于数值列表：

numbers = [1, 3, 5, 7, 9]  
max_value = max(numbers)  # 返回 9  
min_value = min(numbers)  # 返回 1

对于字符串列表（比较字符串的字典序）：

words = ['apple', 'banana', 'cherry']  
max_word = max(words)  # 返回 'cherry'  
min_word = min(words)  # 返回 'apple'

使用key参数：如果你想要基于某个特定属性或函数的结果来找到最大或最小值，你可以使用key参数。例如，如果你有一个包含字典的列表，并且你想要基于字典中的某个值来找到具有最大或最小该值的字典，可以这样做：

dicts = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]  

oldest = max(dicts, key=lambda d: d['age'])  # 返回 {'name': 'Bob', 'age': 30}  
youngest = min(dicts, key=lambda d: d['age'])  # 返回 {'name': 'Charlie', 'age': 20}

default参数：当可迭代对象为空时，max()和min()函数会抛出ValueError。但是，你可以使用default参数来提供一个默认值，以避免这种情况：

empty_list = []  
max_value = max(empty_list, default=0)  # 返回 0，而不是抛出异常

注意：当使用max()和min()函数与字典一起时，它们默认比较字典的键（key），而不是值（value）。如果你想要基于值来比较字典，你需要使用key参数来指定一个函数，该函数返回你想要比较的值。

2.4 公共方法-range

range()函数的主要用途是在for循环中迭代数字序列，而无需手动创建这些数字。它也可以用于生成用于列表推导式、集合推导式或其他需要数字序列的场合。

range()函数的基本定义是接受一个、两个或三个参数，并返回一个序列的数字。这些参数分别是：

start（可选，默认为0）：序列的起始值。
stop（必需）：序列的结束值（不包括此值）。
step（可选，默认为1）：序列中每个数字之间的增量。

特点

range()函数生成的序列是不可变的。
range()函数返回的是一个范围对象（range object），它是一个迭代器（iterator），可以节省内存。
range()函数生成的数字序列不包括stop参数指定的值。

示例1：基本用法

for i in range(5):  # 相当于 for i in [0, 1, 2, 3, 4]  
    print(i)

示例2：指定起始值和结束值

for i in range(2, 7):  # 相当于 for i in [2, 3, 4, 5, 6]  
    print(i)

示例3：指定起始值、结束值和步长

for i in range(1, 10, 2):  # 相当于 for i in [1, 3, 5, 7, 9]  
    print(i)

示例4：用于列表推导式

squares = [i**2 for i in range(5)]  # 生成 [0, 1, 4, 9, 16]  
print(squares)

示例5：查看range()对象的属性

尽管range()对象通常用于迭代，但你也可以查看它的start、stop和step属性（注意这些属性在Python 3中是可以访问的，但在Python 2中range()返回的是一个列表，没有这些属性）。

r = range(2, 7, 2)  
print(r.start)  # 输出 2  
print(r.stop)   # 输出 7  
print(r.step)   # 输出 2

2.5 公共方法-enumerate

enumerate 函数接受一个可迭代对象（如列表、元组或字符串）和一个可选的start 索引值（默认为0）作为输入，并返回一个枚举对象。这个枚举对象是一个迭代器，它生成元组，每个元组包含两个元素：一个是原始数据对象的索引（从 start 开始），另一个是该索引处的值。

特点

enumerate() 函数返回一个枚举对象，该对象是一个迭代器，支持在循环中迭代。
枚举对象生成的元组包含两个元素：索引和值。
索引值可以从指定的 start 值开始（默认为0）。

示例1：基本用法

fruits= ['apple', 'banana', 'watermelon', 'pear']  
for index, fruit in enumerate(fruits):  
    print(f'Index {index}: {fruit}')  
  
# 输出:  
# Index 0: apple
# Index 1: banana
# Index 2: watermelon
# Index 3: pear

示例2：指定起始索引

fruits= ['apple', 'banana', 'watermelon', 'pear']  
for index, fruit in enumerate(fruits, start=1):  
    print(f'Index {index}: {fruit}')  
  
# 输出:  
# Index 0: apple
# Index 1: banana
# Index 2: watermelon
# Index 3: pear

示例3：在字符串上使用

str = 'hello'  
for index, char in enumerate(str):  
    print(f'Character at index {index}: {char}')  
  
# 输出:  
# Character at index 0: h  
# Character at index 1: e  
# Character at index 2: l  
# Character at index 3: l  
# Character at index 4: o