python中list和tuple的22种操作方法

列表list

列表（list）作为 Python 中最常用的数据类型之一，是一个可增加、删除元素的可变（mutable）容器。

创建列表

lst = [] #创建空列表
lst1 = [1,'xiaoming',29.5,'17312662388']
lst2 = [['hello','world'],[12,'abc'],['冰箱','空调']]

查看列表长度

len(lst) # 0
len(lst1) # 4
len(lst2) # 3

遍历列表

In [16]: for t in lst1:
    ...:     print(t)
    ...: 
1
xiaoming
29.5
17312662388

In [17]: for t1,t2 in lst2:
    ...:     print(t1,t2)
    ...: 
hello world
12 abc
冰箱 空调

​

元素在列表中的位置

In [18]: ls_3=[1, 3, 12.3, 'apple', 0.001, 'apple', 'orange', 1, 2, 3, 4]
# 从列表ls_3 中找出"apple" 第一个匹配项的索引位置
In [19]: ls_3.index("apple")
Out[19]: 3

In [20]: ls_3.index(3)
Out[20]: 1

列表中增加元素

• 方法1 ，使用列表的append方法在列表尾部添加元素

In [21]: lst = ['abc','123']
In [22]: lst.append('efg')
In [23]: lst
Out[23]: ['abc', '123', 'efg']

• 方法2，使用列表的insert方法插入元素

In [24]: lst = ['abc','123']
In [25]: lst.insert(1,'hello')
In [26]: lst
Out[26]: ['abc', 'hello', '123']

合并列表

• 方法1，使用列表的extend方法添加另一列表

ls_3 = ['abc','123']
ls_3.extend([1, 2, 3]) 
ls_3.extend([4,5])
print (ls_3)
# ['abc', '123', 1, 2, 3, 4, 5]

• 方法2，直接使用运算符+合并列表

In [27]: ls_3 = ['abc','123']
In [28]: ls_4 = [4,5]
In [29]: ls_3+ls_4
Out[29]: ['abc', '123', 4, 5]

• 方法3，使用*合并列表

In [27]: ls_3 = ['abc','123']
In [28]: ls_4 = [4,5]
In [31]: [*ls_3]
Out[31]: ['abc', '123']
In [32]: [ls_3]
Out[32]: [['abc', '123']]

In [33]: [*ls_3,*ls_4]
Out[33]: ['abc', '123', 4, 5]

移除列表元素

• 方法1，使用列表的pop方法移除元素

列表的pop默认移除最后一个元素，一个移除指定元素

In [35]: lst = ['abc', '123', 'efg','苹果','香蕉']
# 列表的pop方法返回移除的元素
In [36]: a = lst.pop()
In [37]: a
Out[37]: '香蕉'
In [38]: lst
Out[38]: ['abc', '123', 'efg', '苹果']
In [39]: b = lst.pop(1)
In [40]: b
Out[40]: '123'
In [41]: lst
Out[41]: ['abc', 'efg', '苹果']

• 方法2，使用列表的remove方法移除元素

lst = ['abc', '123', 'efg']
# 列表的remove方法没有返回值
a = lst.remove('efg')
print(a) # None
print(lst) # ['abc', '123']

• 方法3，使用关键字del删除列表中的元素

a = ['苹果','香蕉','橘子','香蕉']
del a[2]
a # ['苹果', '香蕉', '香蕉']

列表的深浅拷贝

lst = ['你好',['hello','world'],[12,'abc']]
# 列表的copy方法只能实现浅copy
copy1 = lst.copy()
copy1[1][0] = 3
print(lst) # ['你好', [3, 'world'], [12, 'abc']]
print(copy1) # ['你好', [3, 'world'], [12, 'abc']]

要想实现深度拷贝，需要使用 copy 模块的 deepcopy 函数

from copy import deepcopy
lst = ['你好',['hello','world'],[12,'abc']]
# 列表的copy方法只能实现浅copy
copy1 = deepcopy(lst)
copy1[1][0] = 3
print(lst) # ['你好', ['hello', 'world'], [12, 'abc']]
print(copy1) # ['你好', [3, 'world'], [12, 'abc']]

判断元素是否在列表中

列表所有数据类型的元素，都可以用该方法判断

a = [1,2,3]
1 in a # True
5 in a # False
b = ['你','好','啊']
'你' in b #True
c = [(1,2),(3,4)]
(1,2) in c # True
c = [([1,2],2),(3,4)]
([1,2],2) in c #True
d = [[1,2],[3,4]]
[1,2] in d # True
[1,3] in d # False
'ab' in 'abc' # True

列表的切片

a = list(range(1,20,3))
print(a) # [1, 4, 7, 10, 13, 16, 19]

切片的返回结果也是一个列表

• 使用 a[:3] 获取列表 a 的前三个元素
• 使用 a[-1] 获取 a 的最后一个元素，返回 int 型，值为 19
• 使用 a[:-1] 获取除最后一个元素的切片 [1, 4, 7, 10, 13, 16]
• 使用 a[1:5] 生成索引为 [1,5)（不包括索引 5）的切片 [4, 7, 10, 13]
• 使用 a[1:5:2] 生成索引 [1,5) 但步长为 2 的切片 [4,10]
• 使用 a[::3] 生成索引 [0,len(a)) 步长为 3 的切片 [1,10,19]
• 使用 a[::-1] 生成逆向索引 [len(a),0) 的切片 [19, 16, 13, 10, 7, 4, 1]
• 使用 a[::-3] 生成逆向索引 [len(a),0) 步长为 3 的切片 [19,10,1]

需要注意的是，a[1:5:-1]执行会返回空列表，不是生成[1,5)的逆向索引，如果要生成[1,5)的逆向索引，可以用如下方式：

a[1:5:-1]  # []
b = a[1:5]
b[::-1] # [13, 10, 7, 4]

列表的操作符

列表的操作符只支持+、*

In [44]: [1, 2,]+[2, 3] #列表合并
Out[44]: [1, 2, 2, 3]

In [42]: [1]*3  #列表元素重复
Out[42]: [1, 1, 1]

In [43]: [1,2]*3
Out[43]: [1, 2, 1, 2, 1, 2]

列表中某个元素的数量

a = ['苹果','香蕉','橘子','香蕉']
print(a.count('苹果')) # 1
print(a.count('香蕉')) # 2

列表转化为集合

a = ['苹果','香蕉','橘子','香蕉']
set(a) # {'橘子', '苹果', '香蕉'}

# 集合里面必须是不可哈希对象(不可变对象)
a = [[1,2],[1,2],[1,2,3]]
set(a) # 报错 unhashable type: 'list'

判断中有无重复元素

# 方法1
def judge_duplicated(lst):
    for x in lst:
        if lst.count(x) > 1: # 判断 x 元素在 lst 中的出现次数
            return True # 重复返回ture
    return False  # 无重复返回false
# 方法2
def judge_duplicated(lst):
    return len(lst) != len(set(lst)) # 重复返回ture，不重复返回False

列表使用python内置函数

python内置函数无需import

len([1,2,3,4,5]) # 列表长度 5
max([1, 5, 65, 5]) #返回列表最大值 65
min([1, -1, 89]) #返回列表最小值 -1
sorted(['10','3','2']) # 从小到大 ['10', '2', '3']
# 注意：max，min，sorted只能用在全数值型列表中

# 也可以判断字符串大小，判断字符串大小是根据字符串首字符ASCII编码判断的
max(['10','3','2']) # 返回`3`
# 判断字符串直接用运算符
# '10'>'3' False
# '10'<'3' True

列表数据重洗

from random import shuffle
a = [1,3,2,5,6]
shuffle(a) # 重洗数据
a # [3, 2, 6, 1, 5]

列表逆置

• 方法1，使用列表的reverse方法对列表元素逆置

# 方法一
In [52]: a = [1,3,2,5,6]
In [53]: a.reverse()
In [54]: a
Out[54]: [6, 5, 2, 3, 1]

• 方法2，使用python内置函数reversed方法对列表元素逆置

# 方法2
In [52]: a = [1,3,2,5,6]
In [56]: list(reversed(a))
Out[56]: [6, 5, 2, 3, 1]

• 方法3，利用列表的切片

In [102]: a = [1,3,2,5,6]
In [103]: a[::-1]
Out[103]: [6, 5, 2, 3, 1]

列表排序规则

• 一般的列表元素排序

# sorted(a) a要求必须是数值型
a = [1,3,2,5,6]
sorted(a)

• 按照列表的某个位置排序

如下所示，按照每一个列表的第二个位置排序：

# 方法一
In [45]: a=[[1,2],[4,1],[9,10],[13,-3]]
In [46]: a.sort(key=lambda x: x[1])
In [47]: a
Out[47]: [[13, -3], [4, 1], [1, 2], [9, 10]]
# 方法二
In [48]: a=[[1,2],[4,1],[9,10],[13,-3]]
In [49]: sorted(a,key = lambda x: x[1] )
Out[49]: [[13, -3], [4, 1], [1, 2], [9, 10]]

列表重复最多的元素

• 找到列表重复最多的元素

In [50]: a = [1,2,3,3,4,2,3]
In [51]: max(a,key=lambda x: a.count(x), default=1)
Out[51]: 3

元组tuple

元祖与列表很相似，只不过元组是不可变（immutable）对象(即不可哈希对象)，元组中的元素不能修改，没有增加、删除元素的方法。元组一旦创建后，长度就被唯一确定

创建元素

tup_0 = tuple() #创建空元组
tup_1 = () #创建空元组
tup_2 = (1, ) #创建只包含一个元素的元组，注意要有逗号,否则会被认为元素本身
tup_3 = (1, 3, "apple", 66) #创建多元素元组

元组除了没有增加、删除元素的方法，不能修改，其他用法与list完全一样，如果我们想要高效的操作元祖，大可用python内置函数list将元祖转化为列表

上述列表中的操作，除了增加、删除元素的操作之外，其他的列表操作方法完全可以用在元组上，这里就不一一介绍了

这里仅说明一些需要注意的点

对于元组，里面的元素可以是任意数据类型，这就意味着也可以是列表、字典等可哈希类型，如下所示：

In [82]: a = ([1,2],)
In [83]: a[0][0]=3
In [84]: a
Out[84]: ([3, 2],)
In [79]: type(a)
Out[79]: tuple

刚刚明明说好元组中的元素不能改变，为什么这里变了？

这里元组中存的列表的地址，换句话说列表的地址没有改变，只是地址对应的内容变了，如下

In [85]: lst = [1,2]
In [91]: id(lst) # id获取地址
Out[91]: 2763791008392

In [89]: tup=(lst,)
In [90]: tup
Out[90]: ([1, 2],)

In [92]: lst[0]=3
In [93]: lst
Out[93]: [3, 2]
In [94]: tup
Out[94]: ([3, 2],)

In [95]: id(lst)
Out[95]: 2763791008392

可以看到，列表的地址并没有改变