测试开发之Python核心笔记（4）：列表与元组

核心笔记（4）：列表与元组"/>

测试开发之Python核心笔记（4）：列表与元组

元组和列表都是容器，容器里面可以放各种类型的数据，同一个列表，允许放不同数据类型的数据。

4.1 声明

声明列表两种方法：

inibasenames = ["pytest.ini", "tox.ini", "setup.cfg"] # 测试框架pytest的3类配置文件，推荐pytest.ini，通常放到项目根目录
li = list("requests")  # ['r', 'e', 'q', 'u', 'e', 's', 't', 's']
lis =  list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
lis = []  # 声明空列表

声明元组两种方法：

tup = ('spring', 'summer', 'autumn', 'winter')  # ('spring', 'summer', 'autumn', 'winter')
tu = tuple("selenium")  # ('s', 'e', 'l', 'e', 'n', 'i', 'u', 'm')
t = ()  # 声明空元组

4.2 相同点与区别

4.2.1 相同点

• 都可以放置任意数据类型
• 都支持负数索引
  • -1 表示最后一个元素，-2 表示倒数第二个元素
• 都支持切片操作
  • l[1:3] ，返回列表中索引从1到2的子列表
  • tup[1:3] ， 返回元组中索引从1到2的子元组
• 都可以随意嵌套
  • l = [[1, 2, 3], [4, 5]] ， 列表的每一个元素也是一个列表
  • tup = ((1, 2, 3), (4, 5, 6)) ，元组的每一个元素也是一个元组

4.2.2 区别

• 列表是动态的，可以随意地增加、删减或者改变元素，长度会变化

l = [1, 2, 'hello', 'world']
print(len(l))  # 原始长度是4
l.append("!")  # 增加
print(len(l))  # 长度编程5
l.remove(1)  # 删除
l[0] = "Say"  # 修改
print(l)

• 元组是静态的，长度固定，无法增加、删减或者改变

在Pycharm中输入下面的代码，Pycharm会错误提示。执行时会报TypeError。

l = (1, 2, 'hello', 'world')
l[0] = "Say"  # TypeError: 'tuple' object does not support item assignment

• 切片复制时，列表产生新对象而元组不产生新对象

  • 列表产生新对象

  l = [3, 2, 3, 7, 8, 1]
  l2=l[:]
  assert id(l2)==id(l)  # False，l2是个新对象
  

  • 元组不产生新对象

  t=(1,2,3,4,5)
  t2=t[:]
  assert id(t)==id(t2)  # True，l2和l1是同一个对象
  

4.4 列表和元组的操作

4.4.1 共有的操作

已知列表l = [3, 2, 3, 7, 8, 1] ，元组 t=(3,2,3,7,8,1)

# 统计，得到个数
l.count(3)
t.count(3)
# 查找，第一次出现元素的下标
l.index(7)
t.index(7)
# 反转，得到新的迭代器，通过tuple或者list转成元组或者列表。
l2=list(reversed(l))
t2=tuple(reversed(t))  # 
# 排序，得到一个新列表，即便是元组也得到新列表
l3=sorted(l)
t3=sorted(t)
# 长度
l_length = len(l)
t_length = len(t)
# 压缩，两个列表或者两个元组对应索引处的元素拼接
print(list(zip([1, 2, 3], ['a', 'b', 'c'])))  # 输出[(1, 'a'), (2, 'b'), (3, 'c')]
print(tuple(zip((1, 2, 3), ('a', 'b', 'c'))))  # 输出 ((1, 'a'), (2, 'b'), (3, 'c'))

4.4.2 列表独有的操作

l = [1, 2, 'hello', 'world']
print(id(l))
l.append("!")  # 追加，原列表上追加
l.remove(1)  # 删除，删除特定元素a，没有返回值
print(l.pop(0))  # 参数是下标，不带参数默认删除最后一个，并返回被删除的值 
l[0] = "Say"
print(l)
l.sort()  # 原地排序，原列表排序
l.reverse()  # 原地反转，原列表反转
l.extend(["你好", "Hello"])
l.insert(2, "!")
print(id(l))

在Pycharm中，按两下shift，输入list或者tuple，并勾选include non-project items，可以查询Python内置的列表和元祖操作的所有方法及具体用法。

4.5 赋值与修改

4.5.1 列表赋值与修改

由于列表是可变的，当多个变量指向同一个列表对象时，当列表对象变化后，所有变量的值都会变化。

>>> l1 = [1, 2, 3]
>>> l2=l1
>>> l1
[1, 2, 3]
>>> l2
[1, 2, 3]
>>> l1.append(4)  # 在原对象上修改
>>> l1
[1, 2, 3, 4]
>>> l2  # l2也变了
[1, 2, 3, 4]

4.5.2 元组的赋值与修改

由于元组是不可变的，当对元组进行修改时，是生成新的元组，不是在原来的元组对象上修改。因此对元组的改变，只会影响原来变量的值。

>>> t1=(1, 2, 3)
>>> t2=t1
>>> t2
(1, 2, 3)
>>> t1=t1+(5,)  # 会产生新对象，t1指向新对象
>>> t1
(1, 2, 3, 5)
>>> t2  # t2不变
(1, 2, 3)

可见，在Python中：

• 变量的赋值，只是表示让变量名指向了某个对象，而一个对象，可以被多个变量指向。
• 可变对象（列表、字典、集合等）的改变，会影响所指向该对象的变量。
• 对于不可变对象（字符串、整型、元组等等），所有指向该对象的变量的值总是一样的，也不会改变。但是通过某些操作（例如+=）更新不可变对象的值时，会返回一个新对象。

4.6 使用场景

• 如果存储的数据不变，适合用元组，比如存放经纬度、四季、12个月份等
• 如果存储的数据是可变的，适合用列表。

4.7 列表解析

根据已有字符串、列表、元组、字典生产新列表。数据全部放在内存。

• [x*x for x in [3, 2, 3, 7, 8, 1]]
• [x*x for x in (3, 2, 3, 7, 8, 1)]
• [x * x for x in range(1, 11)]
• [x * x for x in range(1, 11) if x % 2 == 0] # 可以使用if语句
• [m + n for m in ‘ABC’ for n in ‘XYZ’]
• [item for item in lst if lst.count(item) == 1] # 保留唯一值
• [k + ‘=’ + v for k, v in d.items()] #字典键值对用等号连接
• [round(random(),2) for _ in range(10)] # 生成随机小数
• [w.lower() for w in a if isinstance(w,str)] # 全部转为小写

列表解析常与 if、for、嵌套 for、map、lambda 等结合使用。

4.8 序列解包

可以将包含N个元素的元组或者列表，分解成N个独立的变量。

data = ['ACME', 50, 19.8, (2020, 5, 23)]
name, shares, price, date = data
print(name)  # 输出ACME
print(shares)   # 输出50
print(price)  # 输出19.8
print(date)  # 输出(2020, 5, 23)
name, shares, price, (year, month, day) = data
print(year, month, day)   # 输出2020 5 23

当元素的数量和变量的数量不匹配时会报错。

解包操作时，对于不关心的数据可以丢，只需要在相应的位置上用一个用不到的变量名即可，例如_。

data = ['ACME', 50, 19.8, (2020, 5, 23)]
_, shares, price, _ = data  # 丢弃列表中的第一个元素和最后一个元素。

还可以从N个元素的元组或者列表中，分解出小于N个元素。例如多名大众评委给选手打分组成的列表，去掉最高分和一个最低分之后，计算总分。

def total_score(scores):minimum, *middles, maximum = sorted(scores)  # 排序后的成绩，中间所有成绩放入到middles列表中return sum(middles)if __name__ == '__main__':scores = [1, 2, 3, 4, 5, 6, 7, 8]print(total_score(scores))

4.9 all 和 any

all(iterable)函数，接受一个迭代器，如果迭代器的所有元素都为真，返回 True，否则返回 False：

all([1,0,3,6])  # False
all([1,2,3])  # True
all((1, 0, 3, 6))  # False

any(iterable)函数，接受一个迭代器，如果迭代器里有一个元素为真，返回 True，否则返回 False：

any([0,0,0,[]])  # False
any([0,0,1])  # True
any((1, 0, 0, 0))  # True

4.10 面试题

1. 判断 list 内有无重复元素

如果列表中有重复元素，则返回True，没有重复元素则返回False。

def is_duplicated(lst):  # 定义一个函数，函数名是is_duplicated，参数是lstfor x in lst:if lst.count(x) > 1:   # 借助count统计功能return Truereturn Falsedef is_duplicated_2(lst):return len(li) != len(set(li))  # 借助集合set具有去重功能if __name__ == '__main__':li = [1, -2, 3, 4, 1, 2]print(is_duplicated(li))print(is_duplicated_2(li))

2. 找出列表中的所有重复元素

借助count统计个数，大于1个的说明是重复元素，添加到新的列表中，返回。

def find_duplicated(lst):li = []for i in lst:if lst.count(i) > 1 and i not in li:li.append(i)return liif __name__ == '__main__':my_list = [1, -2, 3, 4, 1, 2]print(find_duplicated(my_list))

3. 找出列表出现次数最多的元素

看到题目中出现了次数，就想count方法，看到“最”，想到 Python 内置的max 函数。

def find_max_count(lst):if lst is None or len(lst) == 0:return Nonereturn max(lst, key=lambda x: lst.count(x))if __name__ == '__main__':my_list = [1, -2, 3, 2, 4, 1, 2]my_list2=[]print(find_max_count(my_list))print(find_max_count(my_list2))

上面的办法在最多的元素有多个时，默认只返回一个。那么如何可以返回多个呢？

思路是：先找出最多元素的个数是几个，比如n个，然后在列表中找哪些元素的个数是n个。

def find_max_count(lst):if lst is None or len(lst) == 0:return Nonemax_freq_element = max(lst, key=lambda x: lst.count(x))max_freq = lst.count(max_freq_element)li = []for l in lst:if lst.count(l) == max_freq and l not in li:li.append(l)return liif __name__ == '__main__':my_list = [1, -2, 3, 2, 4, 1, 2]my_list2 = []print(find_max_count(my_list))print(find_max_count(my_list2))