一、列表的常用操作及内置方法
1、用途：按照索引存放多个任意类型的值，索引反映的是位置/顺序
2、定义方式：在[]内用逗号分割开多个任意类型的元素
ps：只要能被for循环的类型都能传成功list转成列表
#数据类型转换
res=list("hello")3['h', 'e', 'l', 'l', 'o'] # res=list({"k1":1,"k2":2,"k3":3})3['k1', 'k2', 'k3'] print(res)
3、常用操作+内置的方法
===============3.1 优先掌握的操作===============
1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值
2、切片(顾头不顾尾，步长)
2.1 浅copy：
l1 = [11,22,[66,77]] l2=l1.copy() print(id(l1[0]),id(l1[1]),id(l1[2])) print(id(l2[0]),id(l2[1]),id(l2[2]))#与上一横id相同
2.2 deepcopy:
l1 = [11,22,[66,77]] from copy import deepcopy#深拷贝要引用的模块 l3=deepcopy(l1) print(id(l3[0]),id(l3[1]),id(l3[2])) l1[2][0]=6666 print(l1) print(l3)
# 了解：
res=l1[-1:-4:-1] res=l1[::-1] print(res)#步长与切片方向都要一致
3、长度
l1 = [11,22,[66,77]] print(len(l1))
4、成员运算in和not in
l1 = [111,22,[66,77]] print([66,77] in l1)#[66,77]是个整体 print(66 in l1) print(66 not in l1)
5、追加append
l1=[11,222] l1.append(33) l1.append(44) l1.append([55,66]) print(l1)
6、insert插入
l1 = [111,22,[66,77]] l1.insert(1,"aaa")#在索引1的前面插入'aaa' print(l1)#[11, 'aaa', 22, [66, 77]]
7、删除
l1=[11,222,[1,2]] #6.1 万能删除，没有返回值，代表的是单纯的删除 # del l1[0] # print(l1) #6.2 指定元素删除,没有返回值，代表的是单纯的删除 # res=l1.remove([1,2]) # print(l1) # print(res) #6.3 指定索引删除，有返回值，代表的是取走操作 # res=l1.pop(1) # print(l1) # print(res)
8、循环
l1=[11,222,[1,2]] for x in l1: print(x)
===============3.2 需要掌握的操作===============
1、clear
l1.clear()
2、append extend
extend内置for循环，而append没有
l2=[444,555] for item in l2: l1.append(item) print(l1)#[11, 22, 333, 333, 333, 444, 555] l1.extend(l2) print(l1)#[11, 22, 333, 333, 333, 444, 555, 444, 555] l1.extend("hello")#[11, 22, 333, 333, 333, 444, 555, 444, 555, 'h', 'e', 'l', 'l', 'o'] print(l1)
3、count
l1=[11,22,333,333,333,] print(l1.count(333333333))#0计数为0 print(l1.count(22)) #1计数为1
4、index
l1=[11,22,333,333,333,] # res=l1.index(333,0,2)#查找不到报错 # res=l1.index(444)#查找不到报错 print(res)
5、reverse 顺序反转：相当于切片再赋值
l1=[11,22,"aaa",'bbb'] l1.reverse() # l1=l1[::-1]#也可以反转 print(l1)#['bbb', 'aaa', 22, 11]
6、sort 排序，默认从小到大排，除非定义
l1 = [11, 22, "aaa", 'bbb'] l1 = [-3,99,12,-5,93] l1.sort(reverse=True) print(l1)
列表总结：
存多个值，有序，可变类型
二、元组的常用操作及内置方法
1、元组就是一个不可变的列表
2、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序
3、定义方式：在()内用逗号分隔开多个任意类下的值/元素
# 强调:当元组内只有一个元素时，必须加逗号
# 类型转换
tuple(所有可以被for循环遍历的类型)
#空元组 t=()
4、常用操作+内置的方法
=============优先掌握的操作=============
1、按索引取值(正向取+反向取)：只能取
2、切片(顾头不顾尾，步长)
3、长度
4、成员运算in和not in
5、循环
============需要掌握的操作==============
1、index
2、count
元组总结：
存多个值，有序，不可变
三、字典的常用操作及内置方法
1、用途：按key:value的形式存放多个任意类型的value，key反映的是value的属性
2、定义方式：在{}内用逗号分隔开多个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常是字符串类型
# 若 key重复，只保留一个
# 空字典 d={}
#字典默认暴露给外界的可操作的只有字典的key
# 类型转换
转换方式一：
#列表转换为字典 l=[("name","egon"),("age",18),["gender","male"]] res=dict(l) print(res)#{'name': 'egon', 'age': 18, 'gender': 'male'}
#d1= dict([['username','password'],('egon',123)])
#print(d1) # {'username': 'password', 'egon': 123}
转换方式二：
d=dict(x=1,y=2,z=3) print(d)#{'x': 1, 'y': 2, 'z': 3}
dic1={}.fromkeys(["name",'age',"gender"],None)
print(dic1)#{'name': None, 'age': None, 'gender': None}
dic2={}.fromkeys("hello",None)
print(dic2)#{'h': None, 'e': None, 'l': None, 'o': None}
3、常用操作+内置的方法
============优先掌握的操作============
1、按key存取值：可存可取
d={'k1':111}#取
print(d['k1'])#111
d['k2']=222#存
print(d)#{'k1': 111, 'k2': 222}
2、长度len
d={'k1':111,'k2':222}
print(len(d))#2
3、成员运算in和not in ====》说的是key
d={'k1':111,'k2':222}
print('k1' in d)#True
print(111 in d)#False
4、推荐使用的取值方法
d = {'username': 'jason', 'password': 123}
print(d['username']) # 不推荐使用该方法
用 get方法：
res = d.get('username')
print(res) # jason
res = d.get('xxx')
print(res) # None 键不存在会返回None 不会报错
res = d.get('username', '你搞什么飞机 这个键不存在 去你妹啊')
print(res) # 键存在还是返回对应的值
res = d.get('xxx', '你搞什么飞机 这个键不存在 去你妹啊')
print(res) # 键不存在 返回get方法里面第二个参数
5、字典新增键值对
方式1 d['hobby'] = 'study' # 字典的key不存在新增 print(d) d['username'] = 'egon' print(d) # 字典的key存在则修改 方式2 d.update(username='jason') print(d) # 特点同上，key不存在新增，key存在则修改 方式3 #键如果存在的情况下 那么不做修改 而是将对应的value取出 #键如果不存在的情况下 那么就是新增 d.setdefault('xxx',123) print(d) # 键不存在是新增 res = d.setdefault('username',123) print(d) # {'username': 'jason', 'password': 123} print(res) # jason #键存在不做修改,而是将对应的value取出
6、快速构造字典******此处有道笔试题
#快速构造出一个字典 res = {}.fromkeys(['k1','k2','k3'],[]) print(res) # {'k1': [], 'k2': [], 'k3': []} res.get('k1').append(123) print(res) # {'k1': [123], 'k2': [123], 'k3': [123]}
7、删除
d={'k1':111,'k2':222}
#7.1 万能删除，没有返回值，代表的是单纯的删除
# del d['k1']
# print(d)
#7.2 随机删,有返回值，返回一个元组
# res=d.popitem() # 将弹出的键值对组织成元组的形式返回出去
# print(d，res)
#7.3 指定key删除，有返回值，代表的是取走操作
# res=d.pop('k1') # 将括号内指定的key对应的value弹出
# print(d,res)
8、键keys()，值values()，键值对items()
# 字典方法三剑客 # print(d.keys()) # 获取字典所有的key # print(d.values()) # 获取字典所有的value # print(d.items()) # 获取字典所有的key和value组织成小元组 """ 可以直接只看里面的数据结构 dict_keys(['username', 'password']) dict_values(['jason', 123]) dict_items([('username', 'jason'), ('password', 123)]) """ for key in d.keys(): print(key) for value in d.values(): print(value) for item in d.items(): print(item) for k, v in d.items(): print(k,v)
9、循环
d={'k1':111,'k2':222}
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items():
print(k,v)
keys=[]
for k in d:
keys.append(k)
print(keys)#['k1', 'k2']
print(d)#{'k1': 111, 'k2': 222}
10、将字典的key用列表打印出来
d={'k1':111,'k2':222}
keys=list(d.keys())
print(keys)#['k1', 'k2']
11、clear()
d = {'username': 'jason', 'password': 123}
d.clear() # {}
该类型总结：
存多个值，无序，可变类型