一、列表的常用操作及内置方法

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() # {}

该类型总结：

存多个值，无序，可变类型