定义
列表(list)是Python中使用最频繁的数据类型,在其他语言中通常叫做数组,专门用来存储一组数据。
#第一种方式
name_list = [] OR name_list = ['tom','jack']
#第二种方式
data_list = list()
1
2
3
4
ps: 相当于C语言中的数组 只不过C语言的数组存的是同一类型的数据
count
data_list = ['python', 'java', 'python', 'php']
print(data_list.count("python")) #2
1
2
索引[] 列表可以用索引来用数据
name_list = ['张三', '李四']
print(name_list[0]) # 张三
print(name_list[1]) # 李四
1
2
3
append(数据) 在末尾插入数据
val_list = ["Web自动化", "UI自动化", "接口自动化"]
val_list.append("APP自动化")
print(val_list)
# ['Web自动化', 'UI自动化', '接口自动化', 'APP自动化']
ps:
可以插入的各种不同类型的数据 比如数字 字典 元组
1
2
3
4
5
6
extend()
使用新的序列来扩展当前序列,需要一个序列作为参数,它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精']) 相当于
stus += ['唐僧','白骨精']
1
2
clear()
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.clear() #清空序列 []
1
2
insert(位置,数据)
abc = [‘yinsheng’, ‘jiayou’, 1111, (11, 22, 33), {‘abc’: 456}]
abc.insert(0,{“key”:1})
print(abc)
#[{‘key’: 1}, ‘yinsheng’, ‘jiayou’, 1111, (11, 22, 33), {‘abc’: 456}]
remove()
# 删除指定值得元素,如果相同值得元素有多个,只会删除第一个
stus = ['孙悟空','猪八戒','沙和尚','唐僧','猪八戒']
stus.remove('猪八戒')
print(stus) #['孙悟空','沙和尚','唐僧','猪八戒']
1
2
3
4
pop (列表索引号) 删除某个数据
val_list = ["Web自动化", "UI自动化", "接口自动化"]
val = val_list.pop(0)
print(val, val_list)
# web自动化,['UI自动化', '接口自动化']
ps:
不指定位置号 那么默认删除最后一个
1
2
3
4
5
6
排序
reverse() 反转列表
my_list = [10,1,20,3,4,5,0,-2]
print('修改前',my_list) #[10,1,20,3,4,5,0,-2]
my_list.reverse()
print('修改后',my_list) #[-2, 0, 5, 4, 3, 20, 1, 10]
1
2
3
4
sort() 默认reverse=false
sort(reverse=true) #降序
sort(reverse=false) #升序
val_list = [8, 100, 30, 10, 40, 2]
val_list.sort(reverse=True)
print(val_list) # [100, 40, 30, 10, 8, 2]
val_list.sort()
print(val_list) #[2, 8, 10, 30, 40, 100]
1
2
3
4
5
sorted() 临时排序
val_list = [8, 100, 30, 10, 40, 2]
b= sorted(val_list)
print(val_list) #[8, 100, 30, 10, 40, 2]
print(b) #[2, 8, 10, 30, 40, 100]
1
2
3
4
5
嵌套
student_list = [["张三", "18", "功能测试"], {"key":1,"key1":2},(11,222,333)]
print(student_list[1]["key1"]) #2
print(student_list[0][1]) # 18
print(student_list[2][1]) #222
1
2
3
4
元组
ps: 和列表list 几乎差不多 只是不可以修改 但是这个不可以修改指的是指向永远不变
for example
t = ('a', 'b', ['A', 'B'],111,(2,3,4),{"key":1})
t[2][0] = 'x'
t[2][1] = 'y'
t[5]["key"]=2
print(t)
#('a', 'b', ['x', 'y'], 111, (2, 3, 4), {'key': 2})
1
2
3
4
5
6
定义
元组和列表一样,都可用于存储多个数据,不同之处在于元组的元素不能修改
#第一种方式
user_info = () OR name_list = ('zhangsan',18,1.75)
#第二种方式
info_tuple = tuple()
ps:元组中只包含一个元素时,需要在元素后面添加逗号
如 data=(1,)
1
2
3
4
5
6
查(by索引)
tuple1 = (1, 2, 3)
print(tuple1[1]) # 2
1
2
count
tuple1 = (1, 2, 3)
print(tuple1.count(3)) # 1
1
2
解包
元组的特殊用法: 交换两个变量的值
num1 = 100
num2 = 200
num2,num1 = num1,num2
print(num1) #200
print(num2) #100
ps:
1.在Python中可以使用对应数据个数的变量,获取对应元组数据中的每一个元素
2.在Python中定义多个元素的元组数据时,小括号可以省略
3.借助以上两个特性,可以通过元组快速实现交换两个变量的值
1
2
3
4
5
6
7
8
9
10
解包
my_tuple = 10 , 20 , 30 , 40
a , b , *c = my_tuple
print(a,b,c) #10 20 [30, 40]
a , *b , c = my_tuple
print(a,b,c) #10 [20, 30] 40
*a , b , c = my_tuple
print(a,b,c) #[10, 20] 30 40
1
2
3
4
5
6
7
注意
ps:
# 当元组不是空元组时,括号可以省略
# 如果元组不是空元组,它里边至少要有一个,
1
2
3
字典
定义
test = dict()
test2 = {}
d = dict(name1='孙悟空',age1=18,gender1='男')
print(d) #{'name1': '孙悟空', 'age1': 18, 'gender1': '男'}
#利用双值子序列
d = dict([('name','孙悟饭'),('age',18)])
print(d) #{'name': '孙悟饭', 'age': 18}
1
2
3
4
5
6
7
8
9
增加和修改 字典[键]=值
info = {
"name": "tom",
"age": 18
}
info["salary"] = 100000
print(info) # {'name': 'tom', 'age': 18, 'salary': 100000}
1
2
3
4
5
6
pop(键) 删除
info = {
"name": "tom",
"age": 18,
"gender": "男" }
info.pop("gender")
print(info) # {'name': 'tom', 'age': 18}
1
2
3
4
5
6
get(键) 查询
info = {
"name": "tom",
"age": 18,
"gender": "男" }
print(info.get("name")) # tom
print(info.get("abc")) # None
1
2
3
4
5
6
for key in 字典.keys()
#遍历得到所有键名
info = {
"name": "tom",
"age": 18,
"gender": "男" }
for key in info.keys():
print(key)
1
2
3
4
5
6
7
for value in 字典.values():
#遍历得到所有的键对应的值
info = {
"name": "tom",
"age": 18,
"gender": "男" }
for value in info.values():
print(value)
1
2
3
4
5
6
7
for k, v in 字典.items():
#遍历得到所有的键和值
info = {
"name": "tom",
"age": 18,
"gender": "男" }
for k, v in info.items():
print(f"key={k} value={v}")
1
2
3
4
5
6
7
一些常用方法
setdefault(key, default]) 可以用来向字典中添加key-value
#如果key已经存在于字典中,则返回key对应的value值,不会对字典做任何操作
#如果key不存在,则向字典中添加这个key,并设置value
d = dict([('name','孙悟饭'),('age',18)])
result = d.setdefault('name1','猪八戒')
result2 = d.setdefault('name','11111')
print(result) #猪八戒
print(result2) #孙悟饭
print(d) #{'name': '孙悟饭', 'age': 18, 'name1': '猪八戒'}
1
2
3
4
5
6
7
8
update()
#将其他的字典中的key-value添加到当前字典中
#如果有重复的key,则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)
print(d) #{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
1
2
3
4
5
6
del
d = {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d['a']
print(d) #{'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d['e']
print(d) #{'b': 2, 'c': 3, 'd': 4, 'f': 6}
1
2
3
4
5
popitem()
#随机删除字典中的一个键值对,一般都会删除最后一个键值对
#删除之后,它会将删除的key-value作为返回值返回
#返回的是一个元组,元组中有两个元素,第一个元素是删除的key,第二个是删除的value
#当使用popitem()删除一个空字典时,会抛出异常 KeyError
d = {'b': 2, 'c': 3, 'd': 4, 'f': 6}
result = d.popitem()
print(result) # ('f', 6)
print(d) # {'b': 2, 'c': 3, 'd': 4}
1
2
3
4
5
6
7
8
copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象,和原对象是独立,修改一个不会影响另一个
# 注意,浅复制会简单复制对象内部的值,如果值也是一个可变对象,这个可变对象不会被复制 意味着修改了这个可变对象的值之后 两个地方的值均变化 因为它不独立
1
2
3
d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy()
print(d2) # {'a': {'name': '孙悟空', 'age': 18}, 'b': 2, 'c': 3}
d2['a']['name'] = '测试一想'
d2['b']=6
print(d2) # {'a': {'name': '测试一想', 'age': 18}, 'b': 6, 'c': 3}
print('d = ',d , id(d)) #d = {'a': {'name': '测试一想', 'age': 18}, 'b': 2, 'c': 3} 2363954785808
print('d2 = ',d2 , id(d2)) #d2 = {'a': {'name': '测试一想', 'age': 18}, 'b': 6, 'c': 3} 2363954786168
1
2
3
4
5
6
7
8
clear()
d = {'b': 2, 'c': 3, 'd': 4}
d.clear() #{}
1
2
in not in
注意
字典的值可以是任意对象
字典的键可以是任意的不可变对象(int、str、bool、tuple ...),但是一般我们都会使用str
字典的键是不能重复的,如果出现重复的后边的会替换到前边的
1
2
3
集合
定义
a = set()
print(type(a))
a = {1,3,4}
print(type(a))
1
2
3
4
将列表 字符串 字典 元组转化为集合
s = set([1,2,3,4,5,1,1,2,3,4,5])
print(s) # {1, 2, 3, 4, 5}
s = set('hello')
print(s) # {'l', 'o', 'e', 'h'}
s = set({'a':1,'b':2,'c':3})
print(s) # {'a', 'b', 'c'}
s = (1,2,3,4)
print(set(s)) # {1, 2, 3, 4}
1
2
3
4
5
6
7
8
9
10
11
常用方法
in not in
使用in和not in来检查集合中的元素
s = {'a' , 'b' , 1 , 2 , 3 , 1}
print('c' not in s) #True
print('a' in s) #True
1
2
3
add()
s = {'a' , 'b' , 1 , 2 , 3 , 1}
s.add(10)
print(s) #{1, 2, 3, 'a', 10, 'b'}
1
2
3
update()
update() 将一个集合中的元素添加到当前集合中
update()可以传递序列或字典作为参数,字典只会使用键
s = {'a' , 'b' , 1 , 2 , 3 , 1}
s2 = set('hello')
s.update(s2)
print(s) #{1, 2, 3, 'o', 'e', 'a', 'h', 'b', 'l'}
s.update((10,20,30,40,50))
print(s) #{1, 2, 3, 'o', 40, 10, 'e', 'a', 'h', 50, 20, 30, 'b', 'l'}
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})
print(s) #{1, 2, 3, 100, 'o', 40, 10, 'e', 1000, 'a', 'h', 50, 20, 30, 'b', 'l'}
1
2
3
4
5
6
7
8
9
pop()
pop()随机删除并返回一个集合中的元素
s = {'a' , 'b' , 1 , 2 , 3 , 1}
result = s.pop()
print(result) #1
print(s) #{2, 3, 'a', 'b'}
1
2
3
4
remove()
s = {'a' , 'b' , 100 , 2 , 3 , 100}
s.remove(100)
print(s) # {2, 3, 'b', 'a'}
1
2
3
clear()
copy() #对集合进行浅复制
集合的运算
————————————————
版权声明:本文为CSDN博主「BRAVE_Fighting」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/shijianzhihai/article/details/126682302