列表
1.count
统计字符出现的次数
l = [1,2,2,4,5,6] l2 = l.count(2) print(l2)
2.clear
清空列表中的数据
l = [1,2,2,4,5,6] l1 = l.clear() print(l) print(l1)
3.reverse
l = [1,2,2,4,5,6] l.reverse() print(l)
4.sort
把列表中的数据按照从小到大的顺序排序（升序）
l = [1,5,7,6,2,4,3] l.sort() print(l)
也可以通过指定的参数来达到从大到小排序（降序）
l = [1,5,7,6,2,4,3] l.sort(reverse = True) print(l)
5.队列和堆栈的概念
队列：类似于排队，先排的先出来，列表中相当于先放的数据先拿出来
l = [] l.append(1) l.append(2) l.append(3) print(l) print(l.pop(0)) print(l.pop(0)) print(l.pop(0))
堆栈：类似于放一个书堆，先放的数要最后才能拿出来，列表中相当于先放的数据后拿出来
l = [] l.append(1) l.append(2) l.append(3) print(l) print(l.pop()) print(l.pop()) print(l.pop())
所以列表的特性就是：
能存多个值，是有序的（可以用索引取值），是可变的（列表中的数据发生改变，列表的id不变）
元组
作用：能够存储多个数据，数据与数据之间用逗号隔开，数据可以是任意类型，元组本身不能被修改（但是元组中的某个数据如果是一个可变类型的数据，那么该数据是可以修改的，比如元组中的列表和字典）
t = (1,[1,2]) # t[0] = 2 # 会报错 t[1][0] = 0 print(t)
定义：与列表类型相比，只不过是[ ]换成了( )
本质：t = (1,2,3,4,5) # t = tuple((1,2,3,4,5))
1.按索引取值（正向取，反向取），只能取值，不能存
t = (1,2,3,4,5) print(t[0]) print(t[-1])
2.切片
特点和字符串、列表切片一样，顾头不顾尾，参照字符串、列表切片方法。
3.长度
len：也和字符串、列表方法一样，得到的是元组中有多少个数据
4.成员运算
in 和 not in：也和字符串、列表方法一样
5.循环
for 变量名 in 元组：和字符串、列表方法一样
t = (1,'h',[1,'w'],{'name':'Francis'},(1,5,'g')) for i in t: print(i)
6.cound
统计元组中数据出现的次数
t = (1,2,2,4,5,6) t1 = t.count(2) print(t1)
7.index
返回的是数据在元组中第一次出现的索引
t = [1,2,2,4,5,6] t1 = t.index(2) print(t1)
所以元组的特性就是：
能存多个数据，是有序的（可以用索引取值），是不可变的。
额外重点：在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开，区分一下！
t1 = tuple((1,)) # 定义t1 = tuple((1))会报错 必须传容器类型 n = (1,) n1 = (1) print(type(t1),type(n),type(n1)) # <class 'tuple'> <class 'tuple'> <class 'int'>
字典
作用：能够存储多组 key:value 键值对， key是对value的描述。
key通常情况下都是字符串形式，key只能是不可变类型，value可以是任意数据类型。字典的key要有意义。
定义：内部原理d = {'name': 'Francis','password': 23} # d = dict( {'name':'Francis','password':23})
字典的key要取的有意义，而且字典的key是不能重复的，要唯一对应一条数据，如果重复了，只会按照最后一组重复的键值对存储。
d = {'name':'Francis','name':'jason','name':'egon','password':123}
print(len(d))
print(d)
1.按key存取值：可存可取
取值：用key取值
d = {'name':'francis','age':23}
print(d['name'])
存值：用key存值
d = {'name':'francis','age':23}
d['name'] = 'jason' # 赋值语句
print(d)
d['password'] = 123 # 赋值语句当key不存在的情况下，会自动新增一个键值对
print(d)
2.长度
len：方法与字符串、列表一样，不过返回的是字典中的 key：value键值对的个数
3.成员运算
in 和 not in：方法与字符串、列表一样，但是只能判断字典的key在不在字典里
d = {'name':'francis','age':23}
print('name' in d)
print('francis' in d)
4.删除
1.del：直接删除，没有值返回
d = {'name':'francis','age':23}
del d['name']
print(d)
2.pop：弹出，会有值返回，但是返回的仅仅只是value
d = {'name':'francis','age':23}
res = d.pop('name') # 弹出仅仅是value，当key不存在的时候会直接报错
print(res)
print(d)
3.clear：清空字典，没有值返回
d = {'name':'francis','age':23}
print(d.clear())
print(d)
5.定义字典的三种方式
1.第一种
d = {'name':'francis','age':23}
2.第二种
d = dict(name='francis',password=123,age=23) print(d,type(d))
3.第三种
l = [['name','francis'],['password',123],['age',23]] d = {} for k,v in l: # ['name','francis'],['password',123],['age','23'] d[k] = v # key:value print(d) d1 = dict(l) # 第三种方法 print(d1)
6.键keys，值value，键值对items
1.键keys：返回的是一个“老母猪”，可以把其当为一个列表来看
d ={'name': 'francis', 'password': 123, 'age': 23}
print(d.keys())
2.值value：返回的是一个“老母猪”，可以把其当为一个列表来看
d ={'name': 'francis', 'password': 123, 'age': 23}
print(d.values())
3.键值对items：返回的也是一个“老母猪”，可以把其看成是一个列表套元组，元组的第一个元素是字典的key，第二个元素是字典的value
7.get
根据key获取value
d ={'name': 'francis', 'password': 123, 'age': 23}
print(d['name'])
print(d.get('name'))
# print(d['xxx']) # 没有这个key的时候会报错
print(d.get('xxx')) # 没有这个key的时候会返回None
print(d.get('xxx','没有xxx')) # 第二个参数不写的话，没有这个key默认返回的是None，写了就返回写的内容
8.dict.fromkeys
快速创建一个字典
l = ['name','age','password','hobby'] print(dict.fromkeys(l,'francis')) # 'francis'是自己输入的value的值
9.popitem
尾部以元组的形式弹出键值对
d ={'name': 'francis', 'password': 123, 'age': 23}
print(d.popitem()) # 尾部以元组的形式弹出键值对
print(d.popitem())
print(d)
10.setdefault
d = {'name': 'francis','password': 123,'age': 23}
print(d.setdefault('name',18)) # 当key存在的情况下,不修改value,并且将原先key对应的value返回给你
print(d.setdefault('hobby', 'read')) # 当key不存在的情况下，新增一个键值对，并且将新增的键值对的value返回给你
print(d)
11.update
更新字典，就相当于添加键值对
d = {'name': 'francis','password': 123}
d1 = {'age': 23}
d.update(d1) # 给字典添加更新新的键值对
print(d)
d.update(hobby = 'read') # 也可以key=value的形式
print(d)
12.循环
for 变量名 in 字典：和字符串、列表方法一样
d = {'name': 'francis', 'password': 123, 'age': 23}
for i in d:
print(i)
所以字典的特性就是：
能存多个值（键值对），是无序的（无法用索引取值），是可变的（字典中的数据发生改变，字典的id不变）
集合
作用：1.去重，2.关系运算
定义：内部原理就是s = {1,2,3,4,5,6} # s = set({1,2,3,4,5,6})。可以包含多个元素，用逗号分割。
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
1.集合的元素遵循三个原则
1.每个元素必须是不可变类型
s = {1,'a',(1,2)}
s1 = {1,'a',(1,2),[1,2]} # 报错
s2 = {1,'a',(1,2),{'name':'francis'}} # 报错
print(type(s))
2.集合中没有重复，集合会自动将重复的元素去除
s = {1,2,2,3,3,4,4,5}
print(s) #自动将重复的元素去除
3.无序
集合无法用索引取值
2.注意：
定义空集合只能用关键字set({ }),如果你仅仅只写了一个大括号{ },那么python默认将它当做字典类型
d = {} s = set({}) print(type(d)) # <class 'dict'> print(type(s)) # <class 'set'>
3.长度
len：方法与字符串、列表一样，返回的是集合中元素的个数
4.成员运算
in 和 not in：方法与字符串、列表一样，判断元素在不在集合中。
5.交集，差集，对称差集，合集
即数学意义上的求两个几个集合中数据的交集，差集，对称差集，合集
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'} # 报名python课程的人
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'} # 报名linux课程的人
# 既报名python也报名linux的学生姓名
print(pythons & linux) # 交集
# 只报名python的学生姓名 # 差集
print(pythons - linux)
# 只报名linux的学生姓名 # 差集
print(linux - pythons)
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux) # 对称差集
# 取出所有报了名的学生姓名
print(pythons | linux) #合集
6.求两个集合的元素是否一致
==：
s = {1,2,3}
s1 = {3,1,2}
print(s == s1) # True
7.父集，子集
父集：>，>=
子集：<，<=
s = {1,2,3,4,5}
s1 = {1,2,3,4,5}
s2 = {1,2,3}
print(s > s1) # False
print(s >= s1) # True
print(s2 < s) #True
8.添加元素
add：
s = {1,2,3,4,5}
s.add(6) # 往集合中添加元素
print(s)
s.add((1,2,3,4)) # 将容器类型也当成一个元素传入
print(s)
9.删除元素
1.remove：从集合中删除指定的元素，集合中没有指定的元素就会报错
s = {1,2,3,4,5}
print(s.remove(3))
print(s)
print(s.remove(8)) # 集合中没有这个元素就会报错
print(s)
2.discard：从集合中删除指定的元素，集合中没有指定的元素就会返回None，不会报错
s = {1,2,3,4,5}
print(s.discard(3))
print(s)
print(s.discard(8)) # 集合中没有这个元素就会返回None，不会报错
print(s)
3.清空集合，删除所有元素
s = {1,2,3,4,5}
print(s.clear())
print(s)