列表 list
list [ ] 多个元素,每个元素用逗号隔开
1.定义形式
#定义方式一 常用方式
list_1 = [1,2,'a','b','c',"asdasawsd",汉字,[12,'now',端午]] #[a]也是列表
#定义方式二
list_2 = list("ab13")
print(list_2) #底层使用的for循环 "ab13"为可迭代字符串类型
# 得到列表['a','b',1,3]
2.特点
可存储大量数据,字符串自能存储少量数据,列表中存储类型是多样的,任意数据类型都可存放.
有序 即可以索引和切片
可变的 对列表的操作可改变原列表,而字符串不可变
3 列表的索引 切片
列表内以逗号为区分为每一个元素,从左至右索引为0,1,2,3....,从右至左索引为-1,-2,-3,-4....
切片
L1 = [1,2,3,'a','b','edx']
print(L1[1:5:2]) #列表切片后还是列表,[1:5:2]第一个数位置为起始索引位置,第二个为终止索引位置,第三个为间隔
# 得到结果 [2, 'a']4 列表的增删改
增
1.append 追加 添加在末尾
L1 = [1,2,3,'a','b']
L1.append('c') #注意这里对L1的操作不会有返回值,只是改变的L1 因此直接print(L1.append('c'))是空值
print(L1)2.insert(,) 插入 括号前半部分为要插入位置的索引号 后边为插入内容
L1 = [1,2,3,'a','b']
L1.insert(2,'A') # 效率较低 插入索引为记号,插入的内容就位于记号索引位
print(L1)3.extend 扩展 迭代添加 可迭代对象都可加入
L1 = [1,2,3,'a','b']
L1.extend('cde') #迭代添加本质添加了如下过程: for i in 'cde'
print(L1) # L1.append(i)
#结果 [1, 2, 3, 'a', 'b', 'c', 'd', 'e']4.列表合并
L2 = [1,2,3]
L3 = ["a","b","c"]
L4 = L2+L3
print(L4)删
1.pop() 弹出 默认删除最后一个也可指定索引位 有返回值 返回被删除内容(对列表的操作唯一有返回值的)
li = [1,2,3,"abc",True]
print(li.pop(3)) # 输出 abc 返回值
print(li) # 输出 [1, 2, 3, True] 操作后li结果2.clear 清空
li = [1,2,3,"abc",True]
li.clear()
print(li)3.remove 按元素名删除
li = [1,2,3,"abc",True]
li.remove(2)
print(li) >>> [1, 3, 'abc', True] #按元素名从左到右删一个4.del
li = [1,2,3,"abc",True]
del li #删除整个列表
del li[2] #删除指定元素 按索引
del li[1:3] #删除区间
del li[1:5:2] #删除间隔的内容改
1.通过索引改
li = [1,2,3,"abc",True]
li[-1] = 'fg' # 换什么就是什么且位于输入的索引号位置2.通过切片改
li = [1,2,3,"abc",True]
li[1:3] = "qwo" ==>> #迭代 输出 [1, 'q', 'w', 'o', 'abc', True]
li[1:3] = "1" # [1, '1', 'abc', True]
li[1:3] = [] # 切片的时候可以多,可以少,可以指定空值3.通过间隔切片改
li = [1,2,3,"abc",True] #去几个放几个
li[1:4:2] = '今天' ==>> # 迭代
li[1:4:2] = 1,21 #可以自己指定,元素之间由逗号隔开查
索引,切片,for循环
a,b = [1,23],[3,45]
print(a,b) ==>>>[1, 23] [3, 45]
列表的嵌套
li = [1,2,3,"abc",True,[5,6,['ss'],7]]
print(li[5][2][0]) #嵌套下的查找"ss"元组 tuple
2.1 定义 ()内每个元素都已逗号隔开 tuple
tu = (1,2,34) # 元组类型
tu = () #元组类型
tu = (1) #括号中元素本身类型
tu = (1,) #元组类型特点
元组有序 可索引 可切片
元组不可改变数据类型,元组只能查看不能修改
可存储任意数据类型,一般存储一些不修改的数据,用于配置文件,防误修改等
查看
for循环也可查询
index 通过元素找索引,找到第一个符合值就返回结果,没有就报错.
tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白')) # 0 字典
列表的缺点:
1.列表可存储大量数据类型,但数据量大后查询慢
2.列表只能按顺序存储,数据之间关联性不强
为解决这些缺点,引入字典(dict)数据类型
不可变（可哈希）的数据类型：int，str，bool，tuple。
可变（不可哈希）的数据类型：list，dict，set。
字典是python中的映射类型,它以{}括起来,里边的内容以键值对形式存储.{"key":"value"} 即{"键":"值"}
key(键):不可变(可哈希)的数据类型.并且是唯一的,不重复的
value(值): 任意数据
字典特点:
无序的(在python3.5及之前版本,字典是无序的,随机显示.在3.6版本之后.字典会按初建字典时的顺序排列.
查询速度快,内存消耗大.
存储大量数据
能将数据关联
字典创建方式:
dic = dict((('one', 1),('two', 2),('three', 3)))
dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic) # {'one': 1, 'two': 2, 'three': 3}dic = dict(one=1,two=2,three=3)
print(dic) # {'one': 1, 'two': 2, 'three': 3}
dic = dict({'one':1,'two':2,'three':3})
print(dic) #{'one':1,'two':2,'three':3}字典的常用操作
增
1.通过键值直接增加 dic["键"] = "值"
dic = {'name': '太白', 'age': 18}
dic['weight'] = 108 #没有weight这个键,就增加键值 如有键则改值
print(dic) #{'name': '太白', 'age': 18, 'weight': 108}
2.setdefault(‘键‘,值)
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175) #没有键则添加,**有键则不变**
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
#它有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.setdefault('weight',108)
print(ret) # 108删
1.pop 通过key删除字典的键值对,有返回值,可设置返回值
dic = {'name': '太白', 'age': 18}
ret = dic.pop('name')
print(ret,dic) #太白 {'age':18}
ret = dic.pop('n',None) # None 为找不到键时的返回值
print(ret,dic) #None {'name': '太白', 'age': 18} 2.del
dic = {'name': '太白', 'age': 18}
del dic #删除整个字典
del dic['name'] #删除指定键值对
3.clear 清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}4.popitem 3.5版本及之前,popitem为随机删除,3.6及之后为删除最后一个,有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) #('age', 18) {'name': '太白'}改
1.通过键值改
dic = {'name': '太白', 'age': 18}
dic['name'] = '大木'
print(dic) # {'name': '大木', 'age': 18}2.update() (update括号里的字典级别高,会覆盖同键的)
dic = {'name': '太白', 'age': 18}
dic.update({'name':'大木','weight':108})
# dic.update(name='大木',weight=108) **注意此时的key不叫''
# dic.update([('name','大木'),('weight',108)])
print(dic) # {'name': '大木', 'age': 18, 'weight': 108}查
字典的查询只能通过键获取值,不能通过值获取键
1.通过键查看和通过get查看
dic = {1:2,"a":"a1"}
print(dic[1]) # 如果有键在就返回键对应的值,弱国不在就报错
print(dic.get(1,'没有此键')) #有键返回对应键值,没有返回指定内容,不会报错2.dic.setdefault(‘键‘) 也是通过键查看
其他
dic = {1:2,"a":"a1"}
for i in dic: # for循环字典的时候打印的时字典的键
print(i,dic[i],end=' ') # 1 2 a a1 dic = {1:2,"a":"a1",3:4,5:6}
key_list = dic.keys()
print(key_list) #dict_keys([1, 'a', 3, 5]) 一个高仿列表,存放的都是字典的key(键).它无序但可fo循环打印
print(list(key_list)) # 这个高仿列表可转换为列表 dic = {1:2,"a":"a1",3:4,5:6}
values_list = dic.values() #dict_values([2, 'a1', 4, 6]) 一个高仿列表,存放的都是字典的value(值).它无序但可fo循环打印
print(values_list)
print(list(values_list)) #可转换为列表dic = {1:2,"a":"a1",3:4,5:6}
key_volues_list = dic.items()
print(key_volues_list) # dict_items([(1, 2), ('a', 'a1'), (3, 4), (5, 6)])
# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值 无序可for循环打印
print(list(key_volues_list)) #并且这个高仿的列表可以转化成列表分别赋值 拆包
a,b = 1,2
print(a,b) #1 2
a,b = ('你好','世界') # 这个用专业名词就叫做元组的拆包
print(a,b) #你好 世界
a,b = ['你好','大飞哥']
print(a,b) # 你好 大飞哥
a,b = {'汪峰':'北京北京','王菲':'天后'}
print(a,b) # 汪峰 王菲
dic = {"1":1,"2":2,"3":3,"4":4}
for k,v in dic.items():
print(k,v) # 结果 1 1 2 2 3 3 4 4 解构
a = 1
b = 2
print("is a",id(a)) # 显示a在内存中的id
print("is b",id(b)) # 显示b在内存中的id
a,b = b,a
print("is a",id(a)) # 显示a在内存中的id
print("is b",id(b)) # 显示b在内存中的id
print(a,b) # 结果 2 1 通过观察变量id的变换可知转换本质时交换了内存地址的指向
a,_,c = '你好啊'
print(a,c) # 你 啊 字典嵌套
dic = {
'name':'汪峰',
'age':48,
'wife':[{'name':'国际章','age':38}],
'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}
name = dic['name']
print(name) #1. 获取汪峰的名字。
di = dic['wife'][0]['name']
print(di) #3. 获取汪峰妻子的名字。
name = dic['children']['girl_three']
print(name) #获取第三个孩子的名字.enumerate：
枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['name','李白','age',18,'sex','man']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name) 集合
set
集合特点:集合中的元素可哈希(不可变)且不重复的
? 集合本身时不可哈希的(可变),集合是无序的
?
集合常用于去重复,如把一个列表变为集合就自动去重了
li = [1,2,3,4,2,11,3,5,6,3,4,8,3,2,1,5,6]
l2 = list(set(li))
print(l2) # [1, 2, 3, 4, 5, 6, 8, 11]
集合的操作
增
update 迭代添加
s = {1,2,3,"123",False,(1,2,3,4)}
s.update('123')
print(s) #{False, 1, 2, 3, (1, 2, 3, 4), '123', '2', '3', '1'}add
s = {1,2,3,"123",False,(1,2,3,4)}
s.add("abc")
print(s) #{False, 1, 2, 3, (1, 2, 3, 4), '123', 'abc'}
删
remove 指定元素删除
s = {1,2,3,"123",False,(1,2,3,4)}
s.remove('123')
print(s) # {False, 1, 2, 3, (1, 2, 3, 4)}pop 随机删除一个
s = {1,2,3,"123",False,(1,2,3,4)}
s.pop()
print(s)clear 清空
s = {1,2,3,"123",False,(1,2,3,4)}
s.clear()
print(s) #set()del 删除集合
s = {1,2,3,"123",False,(1,2,3,4)}
del s # 直接删除集合其他操作
交集。（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}并集。（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>原文地址：https://www.cnblogs.com/banshannongchang/p/11006376.html
时间： 2024-10-08 18:50:56