Python中列表list常用方法总结
在 Python 中,列表(List)是一种有序的数据集合,可以存储任意类型的数据,例如整数、浮点数、字符串、元组、列表等。因为列表是有序的,所以可以通过下标(索引)来访问和修改列表中的元素。Python 中的列表是可变的,也就是说可以动态增加和删除元素。
创建列表的方法有多种,其中最常见的是使用中括号 [] ,并在其中用逗号 , 分隔出各个元素。例如,以下是一个创建列表的例子:
a = [1, 2, 3, 4, 5] # 创建一个包含五个整数的列表
b = ['apple', 'banana', 'orange'] # 创建一个包含三个字符串的列表
c = [1, 'apple', 3.14, [4, 5, 6]] # 创建一个包含不同类型的元素的列表
可以通过下标来访问和修改列表中的元素,下标从0开始计数。例如,可以使用以下方式访问和修改列表中的元素:
a = [1, 2, 3, 4, 5]
print(a[0]) # 访问第一个元素,输出1
a[2] = 100 # 修改第三个元素为100
print(a) # 输出[1, 2, 100, 4, 5]
可以使用 len() 函数获取列表的长度,使用 + 运算符连接两个列表,使用 * 运算符重复一个列表中的元素。例如,以下是一些常见的操作:
a = [1, 2, 3, 4, 5]
length = len(a) # 获取列表的长度,结果为5
b = a + [6, 7, 8] # 连接两个列表
c = a * 2 # 重复a中的元素两次
print(b) # 输出[1, 2, 3, 4, 5, 6, 7, 8]
print(c) # 输出[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
还可以使用列表的一些内置函数来对列表进行操作,例如 append() 方法可以向列表中添加一个元素, pop() 方法可以删除列表中的一个元素等。例如,以下是一些常见的列表操作:
a = [1, 2, 3, 4, 5]
a.append(6) # 向列表中添加一个元素6
a.pop(0) # 删除并返回列表中的第一个元素1
a.sort(reverse=True) # 将列表中的元素从大到小排序
print(a) # 输出[6, 5, 4, 3, 2]
1. clear() 移除列表中的所有元素
Python中列表list的clear()方法用于从列表中删除所有项目。它不返回任何值,只是修改了原始列表。
my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list) # 输出[]
2. copy() 返回列表的一个副本
在Python中,list类型的copy()方法用于创建一个原列表的副本,返回一个新的列表对象。副本是原列表的浅拷贝,即只复制了列表对象本身,而不是列表中的元素对象。如果列表中的元素是可变对象,修改副本中的元素也会影响原列表中的元素,因为副本和原列表引用了同一批元素对象。 示例代码:
my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list) # [1, 2, 3]
new_list[0] = 4
print(new_list) # [4, 2, 3]
print(my_list) # [1, 2, 3]
在上面的示例中,我们首先使用copy()方法创建一个新的列表对象new_list,其内容与原列表my_list相同。然后,我们通过修改new_list的第一个元素,演示了副本和原列表之间的区别。
我们可以看到,新列表中的第一个元素被修改为了4,而原列表中的第一个元素仍然是1。这是因为new_list和my_list引用了不同的元素对象。
3.count() 统计某个元素在列表中出现的次数
在Python中,列表(list)类型提供了 count() 方法,用于统计某个元素在列表中出现的次数。 count() 方法接受一个参数,表示要统计的元素。该方法返回一个整数,表示元素在列表中出现的次数。 示例代码:
my_list = [1, 2, 3, 1, 4, 1]
count_1 = my_list.count(1)
print(count_1) # 输出"3",表示数字1在列表中出现了3次
以上示例中,我们创建了一个包含6个元素的列表 my_list ,其中数字 1 出现了3次。我们使用 count() 方法统计数字 1 在列表中出现的次数,并将结果保存到变量 count_1 中,输出结果为 3 。
注意, count() 方法只能用于统计指定元素在列表中出现的次数。如果要统计列表中满足某个条件的元素个数,可以使用列表推导式或循环等方式实现。
4. extend() 在列表的末尾一次性追加另一个序列中的多个值
在 Python 中,列表(list)类型提供了 extend() 方法,用于将一个列表中的所有元素添加到另一个列表中。 extend() 方法接受一个参数,表示要添加的列表。该方法将要添加的列表元素逐个添加到原列表末尾,返回值为 None 。 示例代码:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1) # 输出[1, 2, 3, 4, 5, 6]
在上述示例代码中,我们首先创建了两个列表list1和list2,分别包含了数字1~6。接着,我们使用 extend() 方法将list2中的所有元素添加到list1末尾,最后输出list1,结果为 [1, 2, 3, 4, 5, 6] 。
需要注意的是, extend() 方法会修改原列表,而不是创建一个新列表。如果需要创建一个新的列表,可以使用加法运算符或列表推导式实现。例如:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
new_list = list1 + list2
print(new_list) # 输出[1, 2, 3, 4, 5, 6]
以上代码中,我们使用加法运算符将list1和list2连接起来,创建一个新的列表new_list,最后输出new_list,结果同样为 [1, 2, 3, 4, 5, 6] 。
5. index() 返回元素在列表中的索引
在 Python 中,列表(list)类型提供了 index() 方法,用于查找指定元素在列表中的索引位置。 index() 方法接受一个参数,表示要查找的元素。如果列表中包含该元素,则返回其在列表中的第一个出现位置的索引值,否则会抛出 ValueError 异常。 示例代码:
my_list = [1, 2, 3, 4, 5, 6]
index = my_list.index(3)
print(index) # 输出2
在上述示例代码中,我们首先创建了一个列表my_list,包含了数字1~6。接着,我们使用 index() 方法查找数字3在列表中的索引位置,并将结果保存到变量index中,最后输出index,结果为 2 。
如果要查找的元素在列表中出现了多次, index() 方法只会返回其第一次出现的索引位置。如果要查找所有出现位置的索引值,可以使用列表推导式实现。例如:
my_list = [1, 2, 3, 2, 4, 5, 2, 6]
indices = [i for i, x in enumerate(my_list) if x == 2]
print(indices) # 输出[1, 3, 6]
以上代码中,我们首先创建了一个列表my_list,包含了数字1~6,同时数字2在列表中出现了三次。接着,我们使用列表推导式查找所有数字2在列表中出现的索引位置,并将结果保存到变量indices中,最后输出indices,结果为 [1, 3, 6] 。
6. insert() 将元素插入到列表中的指定位置
在 Python 中,列表(list)类型提供了 insert() 方法,用于在指定位置插入一个元素。 insert() 方法接受两个参数,第一个参数表示要插入元素的位置,第二个参数表示要插入的元素。如果要插入的位置大于列表的长度,则会将元素插入到列表的末尾。 示例代码:
my_list = [1, 2, 3, 4, 5]
my_list.insert(2, "hello")
print(my_list) # 输出[1, 2, 'hello', 3, 4, 5]
在上述示例代码中,我们首先创建了一个列表my_list,包含了数字1~5。接着,我们使用 insert() 方法在索引为2的位置插入字符串"hello",最后输出列表my_list,结果为 [1, 2, 'hello', 3, 4, 5] 。
需要注意的是, insert() 方法会直接修改原列表,而不是创建一个新的列表。如果需要在原列表的基础上创建一个新的列表,则需要使用列表的切片(slice)操作。例如:
my_list = [1, 2, 3, 4, 5]
new_list = my_list[:2] + ["hello"] + my_list[2:]
print(new_list) # 输出[1, 2, 'hello', 3, 4, 5]
以上代码中,我们首先创建了一个列表my_list,包含了数字1~5。然后,我们使用切片操作将原列表分成两部分,再在中间插入字符串"hello",最后将两部分合并成一个新的列表new_list,结果与 insert() 方法的示例代码相同。
7. pop() 移除列表中的一个元素,并返回该元素的值
在 Python 中,列表(list)类型提供了 pop() 方法,用于从列表中删除一个元素,并返回该元素的值。默认情况下, pop() 方法会删除列表中的最后一个元素,即索引为-1的元素。也可以传递一个参数,表示要删除的元素的索引,例如 pop(0) 表示删除列表中的第一个元素。 示例代码:
my_list = [1, 2, 3, 4, 5]
last_element = my_list.pop()
print(last_element) # 输出5
print(my_list) # 输出[1, 2, 3, 4]
在上述示例代码中,我们首先创建了一个列表my_list,包含了数字1~5。接着,我们使用 pop() 方法删除列表中的最后一个元素,将返回值保存到变量last_element中,并输出last_element的值,结果为5。最后,我们输出my_list的值,结果为 [1, 2, 3, 4] 。 需要注意的是, pop() 方法会直接修改原列表,而不是创建一个新的列表。如果需要在原列表的基础上创建一个新的列表,则需要使用列表的切片(slice)操作。例如:
my_list = [1, 2, 3, 4, 5]
new_list = my_list[:-1]
print(new_list) # 输出[1, 2, 3, 4]
以上代码中,我们首先创建了一个列表my_list,包含了数字1~5。然后,我们使用切片操作将原列表的最后一个元素删除,将剩余部分赋值给一个新的列表new_list,最后输出new_list的值,结果与 pop() 方法的示例代码相同。
8. remove() 移除列表中某个值的第一个匹配项
在 Python 中,列表(list)类型提供了 remove() 方法,用于从列表中删除匹配特定元素的第一个元素。方法的参数是要删除的元素的值,如果列表中不存在该元素,则会抛出ValueError异常。如果列表中存在多个匹配的元素,则只会删除第一个匹配的元素。 示例代码:
my_list = [1, 2, 3, 4, 5, 4]
my_list.remove(4)
print(my_list) # 输出[1, 2, 3, 5, 4]
在上述示例代码中,我们首先创建了一个列表my_list,包含了数字1~5和一个额外的数字4。然后,我们使用 remove() 方法删除第一个匹配的元素4,最后输出my_list的值,结果为 [1, 2, 3, 5, 4] 。 需要注意的是, remove() 方法会直接修改原列表,而不是创建一个新的列表。如果需要在原列表的基础上创建一个新的列表,则需要使用列表的切片(slice)操作,或者使用列表推导式(list comprehension)。例如:
my_list = [1, 2, 3, 4, 5, 4]
new_list = [x for x in my_list if x != 4]
print(new_list) # 输出[1, 2, 3, 5]
以上代码中,我们首先创建了一个列表my_list,包含了数字1~5和一个额外的数字4。然后,我们使用列表推导式创建一个新列表new_list,该列表中包含了my_list中所有不等于4的元素。最后输出new_list的值,结果与 remove() 方法的示例代码相同。
9. reverse() 反转列表中的元素
在 Python 中,list提供了reverse()方法,用于翻转(反转)列表中元素的顺序,即将列表中第一个元素变为最后一个,第二个变为倒数第二个,以此类推。该方法不接受任何参数。示例如下:
my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list) # 输出 [5, 4, 3, 2, 1]
在上述代码中,我们首先创建了一个包含数字1~5的列表my_list。然后,我们使用 reverse() 方法翻转该列表中元素的顺序,并输出翻转后的列表。结果为 [5, 4, 3, 2, 1] 。 需要注意的是, reverse() 方法会直接修改原列表,而不是创建一个新列表。如果需要在原列表的基础上创建一个新的列表,则需要使用列表的切片(slice)操作。例如:
my_list = [1, 2, 3, 4, 5]
new_list = my_list[::-1]
print(new_list) # 输出 [5, 4, 3, 2, 1]
以上代码中,我们首先创建了一个包含数字1~5的列表my_list。然后,我们使用my_list[::-1]切片操作生成一个新的列表new_list,该列表包含了my_list中所有元素的倒序排列。最后输出new_list的值,结果与 reverse() 方法的示例代码相同。
10. sort() 对原列表进行排序
在 Python 中,list提供了 sort() 方法,用于对列表中的元素进行排序。该方法可以接受多个参数,但最重要的是 key 和 reverse 参数。 key 参数是一个函数,用于指定排序规则。例如,可以将列表中的元素按照它们的长度进行排序,示例如下:
my_list = ["apple", "banana", "cherry", "pear"]
my_list.sort(key=len)
print(my_list) # 输出 ["pear", "apple", "banana", "cherry"]
在上述代码中,我们首先创建了一个包含四个字符串的列表my_list。然后,我们使用 sort() 方法对该列表进行排序,并使用 len 函数作为 key 参数,指定按字符串长度进行排序。输出结果为 ["pear", "apple", "banana", "cherry"] ,即按字符串长度从小到大排序的结果。 reverse 参数是一个布尔值,用于指定是否按照降序进行排序。例如,可以将列表中的元素按照它们的值进行降序排序,示例如下:
my_list = [3, 6, 1, 8, 2, 9]
my_list.sort(reverse=True)
print(my_list) # 输出 [9, 8, 6, 3, 2, 1]
在上述代码中,我们首先创建了一个包含六个数字的列表my_list。然后,我们使用 sort() 方法对该列表进行排序,并指定 reverse=True ,即按降序进行排序。输出结果为 [9, 8, 6, 3, 2, 1] ,即按数字大小从大到小排序的结果。 需要注意的是, sort() 方法会直接修改原列表,而不是创建一个新列表。如果需要在原列表的基础上创建一个新的列表,则需要使用列表的切片(slice)操作。例如:
my_list = [3, 6, 1, 8, 2, 9]
new_list = sorted(my_list, reverse=True)
print(new_list) # 输出 [9, 8, 6, 3, 2, 1]
在上述代码中,我们使用了内置函数 sorted() 对 my_list 进行排序,并将结果保存到新列表 new_list 中。由于 sorted() 方法不会修改原列表,因此该方法返回的结果是一个新的列表。最后输出new_list的值,结果与 sort() 方法的示例代码相同。
11. fromkeys() 创建一个新字典,以序列中元素做此字典所有键的键,值全部为同一个value
在 Python 中, fromkeys() 是字典类型的一个方法,用于创建一个新字典并指定字典中的所有键的默认值。不过,我们同样可以使用列表类型的 fromkeys() 方法,用于创建一个新列表并指定列表中所有元素的默认值。 fromkeys() 方法的语法如下:
new_list = list.fromkeys(seq, value)
其中, seq 是一个序列,用于指定新列表中的所有元素; value 是一个可选参数,用于指定新列表中所有元素的默认值,默认值为 None 。 fromkeys() 方法会返回一个新的列表对象。 下面是使用 fromkeys() 方法创建新列表的示例代码:
my_list = list.fromkeys(['apple', 'banana', 'cherry'], 0)
print(my_list) # 输出 [0, 0, 0]
在上述代码中,我们使用 fromkeys() 方法创建了一个包含三个字符串的列表,新列表中所有元素的默认值都为 0 。输出结果为 [0, 0, 0] 。 需要注意的是, fromkeys() 方法会将所有元素的默认值设置为同一个对象,因此如果 value 参数是可变类型的对象(如列表、字典等),则新列表中所有元素都会指向同一个对象。如果需要避免这种情况,可以将 value 参数设置为不可变类型的对象(如数字、字符串等)或使用列表生成式生成新列表。
12.get() 返回指定键的值,如果值不在字典中返回默认值
在 Python 中,列表类型有一个名为 get() 的方法,该方法用于获取指定索引位置上的元素,如果该索引不存在则返回默认值。 get() 方法的语法如下:
list.get(index, default=None)
其中, index 表示要获取元素的索引位置, default 是可选参数,表示如果指定索引位置上不存在元素,则返回的默认值,默认为 None 。 下面是使用 get() 方法获取列表元素的示例代码:
my_list = ['apple', 'banana', 'cherry']
print(my_list.get(1)) # 输出 'banana'
print(my_list.get(3, 'orange')) # 输出 'orange'
在上述代码中,我们首先创建了一个包含三个字符串的列表 my_list 。然后使用 get() 方法获取了第二个元素,即索引位置为 1 的元素,输出结果为 'banana' 。接下来使用 get() 方法获取了列表中不存在的第四个元素,同时通过 default 参数设定了默认值为 'orange' ,输出结果为 'orange' 。
需要注意的是,如果使用索引操作获取列表元素时,如果指定的索引位置不存在元素,Python 解释器会抛出 IndexError 异常,而 get() 方法则会返回默认值。因此,在使用 get() 方法时需要确认是否需要返回默认值,并根据需要选择是否使用 get() 方法。
13. items() 返回一个包含所有字典项的列表
在 Python 中,列表类型有一个名为 items() 的方法,该方法用于返回列表中所有元素的键值对。 items() 方法的语法如下:
list.items()
下面是使用 items() 方法遍历列表中的所有元素的示例代码:
my_list = ['apple', 'banana', 'cherry']
for key, value in enumerate(my_list):
print(key, value)
在上述代码中,我们首先创建一个包含三个字符串的列表 my_list ,然后使用 items() 方法获取列表中所有元素的键值对,接着使用 enumerate() 函数遍历所有元素,并打印每一个元素的键和值。 运行上述代码,输出结果如下:
0 apple
1 banana
2 cherry
需要注意的是,列表类型并没有 items() 方法,上述代码中的 items() 方法其实是使用了 enumerate() 函数生成的枚举对象的方法。 enumerate() 函数用于将一个可遍历的数据对象组合为一个索引序列,同时列出数据和数据下标,返回一个枚举对象,该对象可以用于遍历列表的所有元素。
14. keys() 返回字典中所有键的列表
在 Python 中,列表类型没有 keys() 方法。 keys() 方法只适用于字典类型。 如果想要获取列表中每个元素的索引作为键,可以使用 enumerate() 函数生成一个包含索引和元素值的元组的枚举对象,然后将其转换为字典类型,其中索引作为键,元素值作为值。示例代码如下:
my_list = ['apple', 'banana', 'cherry']
my_dict = dict(enumerate(my_list))
print(my_dict)
在上述代码中,我们首先创建一个包含三个字符串的列表 my_list ,然后使用 enumerate() 函数生成一个枚举对象,该对象包含列表中所有元素的索引和元素值的元组,接着使用 dict() 函数将其转换为字典类型,其中索引作为键,元素值作为值,最后打印字典类型的结果。 运行上述代码,输出结果如下:
{0: 'apple', 1: 'banana', 2: 'cherry'}
需要注意的是,由于字典是无序的,因此输出结果的顺序可能与输入列表的顺序不一致。
15. setdefault() 和get()方法类似, 但如果键不存在于字典中,将会添加键并将值设为默认值
在 Python 中,列表类型没有 setdefault() 方法。 setdefault() 方法只适用于字典类型。 字典类型的 setdefault() 方法用于获取指定键的值,如果该键不存在,则返回默认值并将其添加到字典中。如果该键已经存在,则直接返回其对应的值。具体用法如下:
d = {'a': 1, 'b': 2}
value1 = d.setdefault('c', 3) # 返回 3,将 {'c': 3} 添加到 d 中
value2 = d.setdefault('b', 4) # 返回 2,d 中 'b' 对应的值已经是 2
在上述代码中,首先创建了一个字典 d ,然后调用了两次 setdefault() 方法。第一次调用传入的键 'c' 在字典中不存在,因此该方法返回默认值 3 ,并将键值对 {'c': 3} 添加到字典 d 中;第二次调用传入的键 'b' 在字典中已经存在,因此该方法返回该键对应的值 2 ,并不会修改字典 d 。
需要注意的是,在调用 setdefault() 方法时,第一个参数是要获取或设置的键,第二个参数是默认值,可以省略。如果省略第二个参数,则默认值为 None 。如果需要在列表类型中实现类似 setdefault() 方法的功能,可以在获取元素时使用 try-except 语句,如果索引超出了范围,则返回默认值并将其添加到列表末尾,否则直接返回该元素。具体用法如下:
my_list = ['apple', 'banana']
try:
value1 = my_list[2] # 索引超出范围,抛出 IndexError 异常
except IndexError:
value1 = 'cherry' # 返回默认值 'cherry'
my_list.append(value1) # 将默认值添加到列表末尾
try:
value2 = my_list[1] # 索引未超出范围,直接返回元素值 'banana'
except IndexError:
value2 = None # 该行代码不会执行
在上述代码中,首先创建了一个包含两个字符串的列表 my_list ,然后使用 try-except 语句获取了列表中第三个元素(超出了索引范围),由于捕获到了 IndexError 异常,因此返回默认值 cherry 并将其添加到列表末尾。接着又使用 try-except 语句获取了列表中第二个元素(未超出索引范围),由于没有异常,因此直接返回该元素的值 banana 。
16.max() 返回列表中的最大值
在 Python 中,可以使用内置函数 max() 来获取列表中的最大值。 max() 函数接受一个可迭代对象作为参数,并返回其中最大的元素。 例子:
numbers = [3, 5, 1, 9, 7, 2]
max_number = max(numbers)
print(max_number) # 输出 9
在上面的例子中,我们创建了一个包含一些整数的列表 numbers ,并使用 max() 函数获取其中的最大值,并将其保存为变量 max_number 。最后,我们打印输出该变量的值,即列表中的最大值 9 。 需要注意的是,如果列表中存在不同类型的元素,那么 max() 函数将会抛出一个 TypeError 异常。因此,在使用 max() 函数之前,需要确保列表中的元素类型是相同的。
min方法同理,返回列表中最小的值
17.len() 返回列表中元素的个数
在 Python 中,可以使用内置函数 len() 来获取列表中元素的数量。 len() 函数接受一个可迭代对象作为参数,并返回其中元素的数量或长度。 例子:
numbers = [3, 5, 1, 9, 7, 2]
length = len(numbers)
print(length) # 输出 6
在上面的例子中,我们创建了一个包含一些整数的列表 numbers ,并使用 len() 函数获取其中元素的数量,并将其保存为变量 length 。最后,我们打印输出该变量的值,即列表的长度 6 。
需要注意的是,如果列表中包含一个元素,这个元素也是列表,则 len() 函数将会返回该元素列表包含的元素数量,而不是元素列表本身的数量。如果需要对嵌套的列表进行递归计数,则需要编写递归函数或者使用第三方库,如 iteration_utilities 。
18.any() 如果列表中的任一元素为True,则返回True
在 Python 中, any() 函数用于检查给定可迭代对象中是否存在任何一个元素为 True。如果存在,则返回 True,否则返回 False。可迭代对象可以是列表、元组、集合、字典等。 下面是一个例子:
numbers = [0, 1, 2, 3, 4]
result = any(numbers)
print(result) # 输出 True
在上面的例子中,我们定义了一个包含一些数字的列表 numbers 。我们将该列表作为参数传递给 any() 函数。由于列表中存在数字 1 ,该函数将返回 True。 需要注意的是,当可迭代对象中的所有元素都是 False 或为空时, any() 函数将返回 False。因此,在使用该函数时需要注意检查空值情况。
19. all() 如果列表中的所有元素都为True,则返回True 3
列表也就是list类型有一个all()方法,该方法用于判断列表中的所有元素是否为真(非0,非空,非None等)。如果列表为空,all()方法也返回True。
下面是使用all()方法的示例代码:
my_list = [1, 2, 3, 4]
print(all(my_list)) # 输出 True
my_list = [1, 0, 3, 4]
print(all(my_list)) # 输出 False
my_list = []
print(all(my_list)) # 输出 True
在第一个示例中,列表my_list中的所有元素都是真,所以all()方法返回True。
在第二个示例中,列表my_list中的第二个元素为假(即0),所以all()方法返回False。
在第三个示例中,列表my_list为空,all()方法返回True。
20. enumerate() 将可遍历的对象组合为一个索引序列,同时列出数据和数据下标
在Python中,列表也就是list类型有一个enumerate()方法,该方法用于将一个列表中的每个元素和它的下标组成一个元组返回。这样就不必手动创建一个计数器来处理列表的每个元素了。 下面是使用enumerate()方法的示例代码:
my_list = ['apple', 'banana', 'orange']
for idx, val in enumerate(my_list):
print(idx, val)
输出结果为:
0 apple
1 banana
2 orange
在上面的代码中,我们使用enumerate()方法对列表my_list进行迭代循环,每次循环将当前元素的下标和值组成一个元组返回,然后打印出来。 需要注意的是,enumerate()方法默认从0开始计数,但是我们也可以指定起始计数值,例如:
my_list = ['apple', 'banana', 'orange']
for idx, val in enumerate(my_list, start=1):
print(idx, val)
输出结果为:
1 apple
2 banana
3 orange
在这个示例中,我们使用了start参数来指定enumerate()方法的起始计数值为1,并且打印出了带有计数值的结果。
21. filter() 用于过滤序列,过滤掉不符合条件的元素
该方法用于根据函数返回值的真假来过滤一个列表,返回一个新的列表。该函数接受两个参数,第一个参数是一个函数,该函数接受一个参数并返回真或假;第二个参数是要被过滤的列表。 下面是一个使用filter()方法的示例代码:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
new_list = list(filter(lambda x: x % 2 == 0, my_list))
print(new_list)
输出结果为:[2, 4, 6, 8] 在上面的代码中,我们首先定义了一个列表my_list,然后使用filter()方法过滤出其中的偶数元素,并将结果存储到一个新的列表new_list中,最后打印出来。
需要注意的是,filter()方法返回的是一个filter对象,如果需要将它转换成一个列表,需要使用list()方法。同时也可以使用列表解析(list comprehension)的方式来实现同样的功能,例如:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
new_list = [x for x in my_list if x % 2 == 0]
print(new_list)
输出结果为:
[2, 4, 6, 8]
在这个示例中,我们使用了列表解析的方式来实现同样的功能,代码更加简洁。
22. map() 对列表中所有元素进行指定操作,并返回新列表
该方法用于将一个列表中的每一个元素都执行一个指定的函数,返回一个新的列表,新列表中的元素就是每个元素执行函数的结果。 下面是一个使用 map() 方法的示例代码:
my_list = [1, 2, 3, 4, 5]
new_list = list(map(lambda x: x * 2, my_list))
print(new_list)
输出结果为:[2, 4, 6, 8, 10] 在上面的代码中,我们定义了一个列表 my_list,然后使用 map() 方法将列表中的每个元素都乘以 2,最后将得到的结果存储到一个新的列表 new_list 中,并打印出来。
需要注意的是,map() 方法返回的是一个 map 对象,如果需要将它转换成一个列表,需要使用 list() 方法。同时也可以使用列表解析(list comprehension)的方式来实现同样的功能,例如:
my_list = [1, 2, 3, 4, 5]
new_list = [x * 2 for x in my_list]
print(new_list)
输出结果为:
[2, 4, 6, 8, 10]
在这个示例中,我们使用了列表解析的方式来实现同样的功能,代码更加简洁。
23. reduce() 对列表中的所有元素进行累积操作,返回计算结果
在 Python 中, reduce 是 functools 模块提供的一个函数。 reduce 函数的作用是对一个序列做连续的操作,并返回最终结果。该函数需要两个参数:一个是函数,一个是序列。
该函数将对序列中相邻的两个元素运用函数,并将结果与下一个元素继续执行函数,直到序列中只剩下一个元素,最终返回这个元素。 下面是一个使用 reduce() 方法对列表求和的示例代码:
from functools import reduce
my_list = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, my_list)
print(result)
输出结果为: 15 在上面的代码中,我们使用 reduce() 方法来对列表中的所有元素求和。函数 lambda x, y: x + y 用于将两个元素相加,而 reduce() 方法将该函数应用到列表中的所有元素,最终返回求和的结果。
需要注意的是, reduce 函数在 Python 3.x 中已经被移到了 functools 模块中,并且在 Python 3.x 中必须使用 from functools import reduce 的方式导入该函数。
24. reverse() 将列表中的元素反转
在 Python 中, list 是一种内置的序列类型,它用于存储一组有序的元素。 list 列表提供了一系列方法用于对序列进行操作,其中包括 reverse() 方法。 reverse() 方法用于对列表中的元素进行反转。该方法没有参数,只是将列表中的元素顺序进行翻转,直接修改原列表,不返回任何值。
下面是一个使用 reverse() 方法将列表元素反转的示例代码:
my_list = [1, 2, 3, 4, 5]
print("Original List:", my_list)
my_list.reverse()
print("Reversed List:", my_list)
输出结果为:
Original List: [1, 2, 3, 4, 5]
Reversed List: [5, 4, 3, 2, 1]
在上面的代码中,我们首先定义了一个列表 my_list ,然后使用 reverse() 方法将列表中的元素进行反转,最终输出了反转后的列表。
需要注意的是, reverse() 方法对原列表进行操作,所以在输出反转后的列表时要使用原列表名。
25. slice() 创建一个切片对象,用于切片操作
在 Python 中,列表( list )是一种序列类型,可以通过索引操作访问其中的元素。
此外,还可以通过切片(slice)操作,从一个列表中获取子列表。切片操作可以选择列表的一部分来返回一个新的列表对象。
切片操作使用冒号(:)表示,它在两个索引之间进行,中间用冒号分隔。下面是一些常用的切片操作:
a[start:end] # 从索引 start 开始,到索引 end(不包括 end)结束
a[start:] # 从索引 start 开始,中间所有的元素
a[:end] # 从开始到索引 end(不包括 end)之间的元素
a[:] # 所有元素,相当于 a.copy()
a[start:end:step] # 从 start 开始,到 end(不包括 end)结束,步长为 step
其中, start 表示起始索引(包含在切片中), end 表示结束索引(不包含在切片中), step 表示步长,默认值为 1。
下面是一些示例代码,演示如何使用切片从列表中获取子列表:
a = [1, 2, 3, 4, 5, 6]
# 获取索引为 2 到索引为 4(不包括)之间的元素,即 [3, 4]
print(a[2:4])
# 获取索引为 0 到索引为 3(不包括)之间的元素,即 [1, 2, 3]
print(a[:3])
# 获取索引为 3 到列表末尾之间的元素,即 [4, 5, 6]
print(a[3:])
# 获取列表中的所有元素,即 [1, 2, 3, 4, 5, 6]
print(a[:])
# 获取列表中的所有偶数元素,即 [2, 4, 6]
print(a[1::2])
切片操作是 Python 中非常强大和常用的操作之一,它可以方便地从一个序列中获取需要的子序列。除了列表之外,其他序列类型(如字符串、元组等)也都支持切片操作。
26. sum() 返回列表中所有元素的和
在 Python 中, sum() 函数用于计算序列(如列表、元组等)中所有元素的总和。它接受一个序列作为参数,并返回该序列中所有元素的总和。下面是一个简单的示例代码,演示如何使用 sum() 函数计算列表中所有元素的总和:
a = [1, 2, 3, 4, 5]
total = sum(a)
print(total) # 输出:15
在上面的代码中,我们定义了一个列表 a ,然后使用 sum() 函数计算列表中所有元素的总和,并将结果保存在变量 total 中,最后输出 total 的值为 15。
需要注意的是, sum() 函数只能用于序列中元素类型为数值的情况,例如整数、浮点数等。如果序列中包含其他类型的元素,例如字符串或其他非数值类型的对象,则会抛出 TypeError 类型错误。
在实际开发中, sum() 函数可以用于计算列表中数值型元素的平均数,例如:
a = [1, 2, 3, 4, 5]
avg = sum(a) / len(a)
print(avg) # 输出:3.0
在上面的代码中,我们首先使用 sum() 函数计算列表 a 中所有元素的总和,然后计算该列表的平均数,并将结果保存在变量 avg 中,最后输出 avg 的值为 3.0。
27. zip() 将两个列表压缩成一个元组对列表,返回一个zip对象
在 Python 中, zip() 函数用于将多个列表中的元素进行逐个配对,形成一个元组,从而得到一个新的序列。它接受一个或多个可迭代对象作为参数,并返回一个由元组组成的迭代器。下面是一个简单的示例代码,演示如何使用 zip() 函数将两个列表进行配对:
a = [1, 2, 3]
b = ['a', 'b', 'c']
result = zip(a, b)
for item in result:
print(item)
在上面的代码中,我们定义了两个列表 a 和 b ,分别包含数值和字符串类型的元素。然后使用 zip() 函数将这两个列表进行逐个配对,并得到一个新的迭代器对象 result 。最后使用 for 循环遍历该迭代器,并输出每个配对的元素。运行上述代码,输出如下:
(1, 'a')
(2, 'b')
(3, 'c')
此外,如果两个列表的长度不同,则 zip() 函数会以较短列表的长度为准,忽略较长列表中多余的元素。例如:
a = [1, 2, 3]
b = ['a', 'b']
result = zip(a, b)
for item in result:
print(item)
在上面的代码中,列表 b 的长度为 2,小于列表 a 的长度 3。因此,在使用 zip() 函数时, b 列表中多余的元素会被忽略。运行上述代码,输出如下:
(1, 'a')
(2, 'b')
需要注意的是, zip() 函数返回的是一个迭代器对象,如果需要将其转换成列表或其他类型的序列,则可以通过 list() 等函数进行转换。例如:
a = [1, 2, 3]
b = ['a', 'b', 'c']
result = list(zip(a, b))
print(result) # 输出:[(1, 'a'), (2, 'b'), (3, 'c')]
以上就是Python中列表list常用方法总结的详细内容,更多关于Python列表list的资料请关注编程网其它相关文章!
免责声明:
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341