1.列表内置方法
l=[1,2,3,4,5,6,7] res = l.clear() print(res)#None 因此.clear方法没有返回值 print(l)#[] 现在列表为空了
将列表反转reserse() l = [1,2,1,3,4,5,6,7] l.reverse() print(l)#[7, 6, 5, 4, 3, 1, 2, 1]
sort()排序
l1 = [43,6,1,7,99] l1.sort(reverse=False) # 可以通过指定参数来修改默认的拍讯规则(降序) print(l1)
总结：列表类型：能存多个值；有序的；可变类型
队列：先进先出
l=[] l.append('1') l.append('2') l.append('3') print(l) #['1', '2', '3'] print(l.pop(0)) print(l.pop(0)) print(l.pop(0)) #1,2,3
堆栈：先进后出
l.append('1') l.append('2') l.append('3') print(l) #['1', '2', '3'] print(l.pop()) print(l.pop()) print(l.pop()) #3,2,1
2.元祖
2.1作用：存储多个值，元素与元素之间逗号隔开，元素可以是任意类型，元祖不能被修改
2.2定义：与列表类型比，只不过将【】换成了（）
age = (1,3,4,5,6,67)本质上age = tuple((1,3,4,5,6,67))
元祖内必须传容器类型
a=(1,32,32,'sdf','fsd',[1,2,3])#tuple((1,32,32,'sdf','fsd',[1,2,3]))
print(type(a))
#<class 'tuple'>
tuple(1)
print(tuple(1))
#TypeError: 'int' object is not iterable.
#元祖内必须传容器类型
在定义容器类型的时候，哪怕只有一个元素，也必须加上逗号。否则识别为字符串。（***）
n=('a') print(n,type(n)) #a <class 'str'> n=('a',) print(n,type(n)) #('a',) <class 'tuple'>
2.3优先掌握的操作:
#优先掌握的操作： #1、按索引取值(正向取+反向取)：只能取 #2、切片(顾头不顾尾，步长) #3、长度 #4、成员运算in和not in #5、循环
1.按索引取值（正向取+反向取）：只能取
a=(1,32,23,4,'sd','fsd',[1,32,43]) print(a[0]) a[-1]='aaaaaaaa' #ypeError: 'tuple' object does not support item assignment a[-1][0]='改了元祖内列表中的值' print(a) #(1, 32, 23, 4, 'sd', 'fsd', ['改了元祖内列表中的值', 32, 43])
元祖内的值，不能修改
del a[0] print(a) #TypeError: 'tuple' object doesn't support item deletion
2.切片（还是顾头不顾尾）
连续两个：：，代表从开始取到最后一个值
a=(1,32,23,4,'sd','fsd',[1,32,43]) print(a[::2]) #(1, 23, 'sd', [1, 32, 43])
3.长度len
a=(1,32,23,4,'sd','fsd',[1,32,43]) print(len(a)) # 7
4.成员运算 in 和 not in
a=(1,32,23,4,'sd','fsd',[1,32,43]) print('d' in a) #False
5.循环for
a=(1,32,23,4,'sd','fsd',[1,32,43]) for i in a: print(i,end=' ') # 1 32 23 4 sd fsd [1, 32, 43]
总结：
能存多个值
有序
不可变
1.能存多个值。由于元祖是不可变类型。不能修改值，但是如果元祖里面有列表，可以先取出列表，再给修改。
比如在元祖内的列表中增加值.append
a=(1,32,23,4,'sd','fsd',[1,32,43])
print(id(a))
#6029824 a[-1].append(666) print(a,id(a))
#(1, 32, 23, 4, 'sd', 'fsd', [1, 32, 43, 666])
#6029824
3.字典及其内置方法
3.1作用：字典能存储多组（key：value）键值对。由于key是不可变类型，而value是任意类型
3.2定义;
c = {'name':'zdq','pwd':123,(1,3):'可不可行'}
print(c['name'])
print(type(c))
print(c[(1,3)])
# zdq
# <class 'dict'>
# 可不可行
3.3注意字典的Key是不能重复的。若重复，则存储最后一组键值对
f={'name':'wuxi','name':'zdq','name':'abd'}
print(f['name'])
#abd
3.4len
f={'name':'wuxi','name':'zdq','name':'abd'}
print(len(f))
print(f)
#1
#{'name': 'abd'}
优先掌握的操作：
1.key存取值：可存可取
正常取值
b={'name':123,'age':18}print(b['age'])
#18
对同一K赋多个值，则以最后一赋值为准 b['name']='789' b['name']='abc' print(b) # {'name': 'abc', 'age': 18} 34615232
赋值key。当要复制的key在字典中，会自动新增一个键值对（*****）
b={'name':123,'age':18}
#weight不在字典中
b['weight']='150'
print(b)
{'name': 'abc', 'age': 18, 'weight': '150'}
2.长度：len
统计字典的键值对个数
3.in 和not in。对于字典来说只能判断key值
d3 = {'name':'wuxi','password':'123'}
print('123' in d3)
print('name' in d3)
4.删除
1.del 删除
# d3 = {'name':'jason','password':'123'} # del d3['name'] # print(d3) 2.pop弹出值。注意弹出即有返回值，弹出的在返回值中 #d4 = {'name':'jason','password':'123'} # res = d3.pop('name') # 弹出仅仅是value
# print（res） #jason,弹出值 2.1当键不存在时，直接报错 # res = d3.pop('age') # print(res) 报错。弹出字典中不存在的内容 3.clear（）清除 # d3.clear() # print(d3) 全部清除，留下{}
定义字典的三种方式： 掌握d1 = {'name':'jason','password':123}
1.一般定义
d={‘name’:'jason','pwd':123}
2.掌握 d2 = dict(name='jason',password=123,age=18) # (******) print(d2,type(d2)) 3.列表转换字典（了解） l = [ ['name','jason'], ['age',18], ['hobby','read'] ]
5.键keys（），值values（），键值对items（）。这三个方法分别用来获取字典所有的的key，value和同事取到这两个值
# 获取k
# d1 = {'name':'jason','password':123}
# print(d1.keys()) # 结果是dict_keys(['name', 'password']) 老母猪，省内存和之前的一样。就把它当成一个列表来看即可
# for k in d1.keys():
# print(k)
# 获取value
# print(d1.values()) # dict_values(['jason', 123]) 老母猪 现在就把它当成一个列表来看即可
#
# 拿到k：v两个值
# print(d1.items()) # dict_items([('name', 'jason'), ('password', 123)])
# 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的valueeys(['name', 'password']) 老母猪占用空间小，要值就给几个，不要值就不给
6.for循环
e={‘name’：‘wuix’，‘aeg’：123}
for i in e：
print(i)
7.其他字典内置方法：
7.1 .get()字典获取值得推荐使用方法：取不到key值（当key值不在字典中）不会报错
#字典取值，取（value）的推荐使用方法
# get()根据key获取value（*******************************）与索引是有区别的
d1 = {'name':'jason','pwd':123}
1.一般方法：
# print(d1['name'])
2.get方法
print(d1.get('name'))
当输入内容不在字典中：
1.不在逗号后写任何内容，返回none
# res = d1.get('age') # 当字典的key不存在的情况 不报错 返回None
# print(res)#None
2.在逗号候写内容。返回内容
# res1 = d1.get('xxx','你输入的key值不存在') # get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
# print(res1)
总结：
# 第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容
总结：.get()括号内第二个参数不写，且key不存在，则返回None；
写了就返回，你指定的内容。
7.2 .fromkeys（）从‘列表’（或者其他容器）中快速的创建一个‘字典’
# dict.fromkeys() 快速的创建一个字典。
# 比如有一个列表
l1 = ['name','password','age','hobby']#。快速以这个4个为键快速建造一个字典
print(dict.fromkeys(l1,123))#.fromkeys(第一个，第二个)第一个写的是列表（容器），第二个为value值
#结果{'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
7.3
.popitem()
d1 = {'name':'jason','pwd':123}
print(d1.popitem()) # 把字典尾部键值对取出来，用（）就是写成元祖的形式
#('pwd', 123)
7.4 .setdefault()
d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo') # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1,res1)
#{'name': 'jason', 'pwd': 123} jason
res2 = d1.setdefault('age',18) # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1,res2)
#{'name': 'jason', 'pwd': 123, 'age': 18} 18
7.5 .update()
d1 = {'name':'jason','pwd':123}
d2 = {"age":18}
d1.update(d2)#d1中无d2内容，则新增
print（d1）
#结果{'name': 'jason', 'pwd': 123, 'age': 18}
d1.update(age=666)
# 相当于赋值：d1['age'] = 18
print(d1)#d1中有d2内容，则修改
#结果{'name': 'jason', 'pwd': 123, 'age': 666}
存多个值
无序
8.集合及内置方法
创建集合的目的：仅仅为了找一个容器存放值。因此，无序，不可索引
作用：关系运算、去重
定义：
s = {1,2,3,4,5,6}
print(type(s))# <class 'set'>
#
s1 = set()
print(type(s1)) # 注意在定义空集合的只能用关键字set
# x = {} # <class 'dict'>
如果你仅仅只写了一个大括号 那么python默认将它当做字典类型
定义集合：可以包含多个元素，用逗号分隔、
集合的元素规则：
1：每个元素必须是不可变类型
可变:不可hash
不可变:可hash
s = {1,2,3,4,5,6,'a',(1,2),[1,2]} # 报错
s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}} # 报错
2: 集合内没有重复的元素
s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
print(s) # 自动将重复的元素 去除
3：无序
s = {1, 2, 3, 4, 5, 6}
print(s[1])
不可以按索引取值
注意集合的目的是将不同的值存放到一起，两个集合之间用来做关系运算，无需纠结于集合中单个值
集合优先掌握的操作：
1、长度len
s = {1,2,3,4}
print(len(s))
2、成员运算in和not in
#
3、|合集
4、&交集
5、-差集
6、^对称差集
7、==
8、父集：》，》=
9、子集：<,<=
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
#交集
# 既报名python也报名linux的学生姓名
print(pythons & linux)
#差集
# 只报名python的学生姓名
print(pythons - linux)
#对称差集
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux)
#合集
# 取出所有报了名的学生姓名
print(pythons | linux)
#==判断两个集合是否相等.
s={1,2,4}
s1={4,1,2}
集合无序所以是相等的
8、父集：判断‘两个集合是否包含’
标识：>,>=
s = {1,2,3,4,55}
s2 = {1,2,666}
print(s >= s2) # s是否包含s2
"""
# issubset()
# issuperset()
"""
# 9、子集：<,<=
增加值add
s = {1,2,3,4,5} s.add(666) print(s) #{1, 2, 3, 4, 5, 666} s.add((1,2,3,4)) # 将容器类型也当成一个元素传入 print(s)
删除 #{1, 2, 3, 4, 5, (1, 2, 3, 4), 666} print(s.remove(1)) print(s) # remove()内若集合没有该值，则报错 print(s.discard(888888888)) print(s) # discard()内若集合没有该值，不会报错