Python全栈自动化测试--Python基础04--可变数据类型

一、list列表类型：

一种有序集合，里面有多个数据用逗号隔开，可以对数据进行增删改；使用[]标识，可以包含任意数据类型

a = [1,’2’,(3, ‘4’)] 
print(type(a)) 
#>>> <class 'list'>

1、list内修改元素：

a[0]=0
通过索引的方式给需要修改的元素直接赋值，将列表a内的某个元素改为0

a = [1,2,3,4] a[3]=0 
print(a) 
#>>> [1, 2, 3, 0]

2、list末尾增加元素：

.append(x)，.extend(x)，.inster (1,x)

2.1）append方法

用于将一个对象内的元素作为一个整体在列表末尾追加

a = [1,2,3,4]
b = ['张三']
a.append(b)
print(a)
#>>>[1, 2, 3, 4, ['张三']]

2.2）extend方法

用于将一个对象内的元素作为单个元素在列表末尾追加

a = [1,2,3,4]
b = ['张三']
a.extend(b)
print(a)
#>>>[1, 2, 3, 4, '张三']

2.3）inster方法

用于将一个对象内的元素作为一个整体在列表内指定位置添加（将对象x添加到列表内第一和第二个元素之间）

a = [1,2,3,4]
b = ['张三']
a.insert(1,b)
print(a)
#>>>[1, ['张三'], 2, 3, 4]

3、list内删除元素：

.pop()，.remove(x)，del[]

3.1）pop方法

默认删除列表内最后一个元素，还可指定索引删除.pop(2)

a = [1,2,3,4]
a.pop(1)
print(a)
#>>>[1, 3, 4] 

3.2）remove方法

删除list内指定的元素

a = [1,2,3,4,'张三']
a.remove('张三')
print(a)
#>>>[1, 2, 3, 4] 

3.3）del方法

根据指定的索引删除list 内的指定元素

a = [1,2,3,4,'张三']
del a[4]
print(a)
# >>>[1, 2, 3, 4] 

4、list内元素翻转：

x.reverse()
将列表的的元素进行翻转 注：此方法只适用于list，其他类型需要先转格式，.reverse()本身并没有返回值，所以直接打印的是none，翻转后直接打印需要翻转的变量即可输出翻转后的值

b = ['李四', '张三', '王二', '赵一' ]
b.reverse()
print(b)
#>>>['赵一', '王二', '张三', '李四'] 

5、list内的元素排序：

x.sort()升序排序；x.sort(reverse=True)降序排序

a = [4,2,1,3]
a.sort()
print(a)
#>>>[1, 2, 3, 4]
a.sort(reverse=True)
print(a)
#>>>[4, 3, 2, 1] 

6、list的切片：

列表的切片：分割一个列表，只提取其中某一个片段出来
语法规则：
列表的变量名[start: end: step]；start: 从哪里开始，end: 到哪里结束，step: 步长，每几个元素获取一次值 – 默认为1，可以省略；左闭右开（取头不取尾）

lst3 = [100, 3.14, True, "python", [1, 2, 3, 4]]
print(lst3[0])

#切片：
print(lst3[0:2])
#>>>>>>>> [100, 3.14]
print(lst3[0:4])
#>>>>>>>> [100, 3.14, True, 'python']
print(lst3[2:4])
#>>>>>>>> [True, 'python']
print(lst3[0:])
#>>>>>>>> [100, 3.14, True, "python", [1, 2, 3, 4]] end可以省略，默认取到最后
print(lst3[:4]) 
#>>>>>>>> [100, 3.14, True, 'python'] start可以省略，默认从0开始
print(lst3[0::2])
#>>>>>>>> [100, True, [1, 2, 3, 4]] 从0开始，步长为2

7、list的元素统计：

统计元素的个数：count() – 判断这个元素在列表中有几个

lst3 = [100, 3.14, True, "python", [1, 2, 3, 4, "python", "python"]]
print(lst3.count("python"))
#>>>>>>>>> 1 count将列表内元素作为参数，返回列表内该元素出现的次数
print(lst3[4].count("python"))
#>>>>>>>>> 2

二、dict字典类型：

用于存储关联关系的数据，标识{键:值, key:value}键值对之间用逗号隔开 字典中key值具有唯一性，不能重复

a = {'x': 10, 'y': 20}
print(a, type(a))
#>>>{'x': 10, 'y': 20} <class 'dict'> 

1、dict内访问键值对：

print(a[‘key’])
通过字典内的key可直接获取value

a = {'x': 10, 'y': 20}
print(a['x'])
#>>>10 

2、dict内修改键值对：

x[‘key’]=‘zz’
通过获取value的方式，将新的值赋值给value

a = {'x': 10, 'y': 20}
a['x'] = 15
print(a)
#>>>{'x': 15, 'y': 20} 

3、dict内增加键值对：

x[‘key’]=‘yy’
通过修改不存在的键值对方式，直接将不存在的键值对添加至字典内

a = {'x': 10, 'y': 20}
a['z'] = '张三'
print(a)
#>>>{'x': 10, 'y': 20, 'z': '张三'} 

4、dict内删除键值对：

del x[‘key’]，.pop (‘key’)

4.1）del方法

与修改方式相同，通过获取value的方式，删除key的键值对

a = {'x': 10, 'y': 20}
del a['x']
print(a)
#>>>{'y': 20} 

4.2）pop方法

与del功能相同，此函数也可作为获取value来使用

a = {'x': 10, 'y': 20}
a.pop('x')
print(a)
# >>>{'y': 20} 

a = {'x': 10, 'y': 20}
b = a.pop('x')
print(b)
# >>>10 

5、list内的元素作为dict的key：

x.fromkeys(y,“none”)
fromkey方法，用于将列表内的元素作为字典的key来使用，注：需要先创建空字典，然后再将列表内的元素作为字典内的key

x = {}
y = ['name', 'age', 'sex']
dict1 = x.fromkeys(y, 'none')
print(dict1)
# >>>{'name': 'none', 'age': 'none', 'sex': 'none'}

6、dict内多个键值对进行更新：

a.update(b)
将b的键-值对更新到字典a中，b可以是字典、列表等；此函数亦可作修改字典使用（相同的key，不同的value） 注：此函数没有返回值

dict_ = {}  # 创建空字典
dict_.update({'x': 10, 'y': 20})  # 传字典
print(dict_)
#>>>{'x': 10, 'y': 20}
dict_.update([('j', 30), ('k', 40)])  # 传列表
print(dict_)
#>>>{'x': 10, 'y': 20, 'j': 30, 'k': 40}
dict_.update(e=50, f=60)  # 传关键字
print(dict_)
#>>>{'x': 10, 'y': 20, 'j': 30, 'k': 40, 'e': 50, 'f': 60}
dict_.update(x='张三', y='李四')  # 修改字典内容
print(dict_)
#>>>{'x': '张三', 'y': '李四', 'j': 30, 'k': 40, 'e': 50, 'f': 60} 

7、dict遍历：

items()
items() 方法把字典中每对 key 和 value 组成一个元组，并把这些元组放在列表中返回。

a = {'x': 10, 'y': 20}
print(a.items())
# >>>dict_items([('x', 10), ('y', 20)]) 

三、set集合类型：

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合。注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。创建非空集合只能使用{ }

1、创建集合:

set()

x = {'张三', '李四', '王二'}
y = set()
print(x, type(x), y, type(y))
# >>>{'张三', '王二', '李四'} <class 'set'> set() <class 'set'> 

2、set内不能含有重复的值，只会显示一个

x = {'张三', '李四', '王二', '张三'}
print(x)
# >>>{'张三', '王二', '李四'} 

3、添加元素：

.add()，.update()

3.1）add方法

将需要添加的元素当做一个整体，添加到集合中去

x = {1,2} x.add(‘python’) print(x)	# 添加字符串 
#>>>{1, 2, 'python'}  x = {1, 2}
y = ('python', 'java')
x.add(y)	# 添加元组
print(x)
#>>>{1, 2, ('python', 'java')} 

3.2）update方法

是把要传入的元素拆分，做为个体传入到集合中（如传入列表、集合、元组等，拆分后作为个体传入）

x = {1, 2}
y = ('python')
x.update(y)    # 添加字符串
print(x)
#>>>{'t', 1, 2, 'p', 'n', 'y', 'o', 'h'}  x = {1, 2}
y = ['python', 'java']
x.update(y)    # 添加元组
print(x)
#>>>{1, 2, 'python', 'java'} 

4、set删除元素：

.remove()，.discard()，.pop()，.difference_update()，.intersection_update()

4.1）remove 方法

如果元素不存在集合中，那么程序会报错。

x = {‘python’, ‘java’, ‘php’} x.remove(‘php’) 
print(x) 
#>>>{'python', 'java'} 

4.2）discard 方法

如果元素不存在集合中，那么程序不会报错。

x = {‘python’, ‘java’, ‘php’} x.discard(‘php’) 
print(x) 
#>>>{'python', 'java'} 

4.3）pop 方法

随机删除集合中的一个元素，并返回被删除的元素，如果集合为空，程序报错（有的版本讲是删除第一个元素，我安装的python3.9是随机删除的，应该是python版本不同的原因）

x = {'python', 'java', 'php'}
y = x.pop()
print(x,y)
# >>>{'java', 'python'} php 

4.4）difference_update方法

删除集合x与序列y的重复元素

x = {1, 2, 3}
y = [3, 4, 5]
x.difference_update(y)
print(x)
#>>>{1, 2} 

4.5）intersection_update方法

删除集合A中与序列B不重复的元素

x = {1, 2, 3}
y = [3, 4, 5]
x.intersection_update(y)
print(x)
#>>>{3} 

5、set集合：

x&y交集，x|y并集， x-y差集， x^y非交集

x = {'python', 'java'}
y = {'python', 'sql'}
print(x & y, x | y, x - y, x ^ y)
#>>> {'python'} {'sql', 'python', 'java'} {'java'} {'sql', 'java'} 

6、set内是否有重复：

.isdisjoint()
使用isdisjoint方法，用于判断两个集合是否不含相同的元素，如果不含返回 True，如果含有返回 False

x = {'python', 'java'}
y = {'python', 'sql'}
z = x.isdisjoint(y)
print(z)
#>>>False  x = {'python', 'java'}
y = {'php', 'sql'}
z = x.isdisjoint(y)
print(z)
#>>>True