目 录
一、列表收尾
二、元组
三、字典
四、集合
五、数据类型总结
一、列表其他内置方法
1、count()：计算列表中元素的个数
ss = [1,2,3,4,23,2,2,1] ss.count(2) 3
2、clear() : 清除容器内数据
ss = [1,2,3,4,23,2,2,1] ss.clear() ss []
3、reverse() 将列表反转
ss = [1,2,3,4,23,55,66] ss.reverse() ss [66, 55, 23, 4, 3, 2, 1]
4、sort() : 对列表内元素进行排序，默认是从小到大；
若添加参数 sort( reverse = True) 就变成从大到小。
ss = [23,34,12,24,76,53] ss.sort() # 默认从小到大 ss [12, 23, 24, 34, 53, 76] ss.sort(reverse=True) # 从大到小 ss [76, 53, 34, 24, 23, 12]
类型总结：
1、可存多值。
2、有序，可被索引
3、可变类型：列表是可变类型的原因及内部原理
练习:用列表实现队列，用列表实现堆栈。
#队列的特点是先进先出 li = [] li.append('egon') li.append('jason') li.append('sean') li.append('tank') print(li.pop(0)) print(li.pop(0)) print(li.pop(0)) print(li.pop(0))
#堆栈的特点是先进后出或后进先出 li = [] li.append('egon') li.append('jason') li.append('sean') li.append('tank') print(li.pop()) print(li.pop()) print(li.pop()) print(li.pop())
二、元组
基本用法：
1、作用：可以存储多个元素，元素与元素之间可以用逗号隔开，元素可以是各个类型，但是元组不能被修改
2、定义：与列表相似，只是把中括号[ ] 改成 小括号 ( )
优先掌握的操作：
1、按索引取值（正向取，反向取），只能取值不能改
ss = (23,34,12,24,76,53) ss[0:4:2] [23, 12]
注意：只能取不能改指的是，元组内部的元素不能改，但是当内部元素是可变类型容器时如列表、字典等，该元素可以修改
tuple = ('a','b','c',['jason','egon','tank','sean'])
tuple[3][0] = 'alex' # 将元组中第4个元素列表中的值改变
tuple
('a', 'b', 'c', ['alex', 'egon', 'tank', 'sean'])
注意：元组和列表一样只能添加容器类型
# t1 = tuple(1) # 报错 必须传容器类型
***** 注意：在定义容器类型时，哪怕其中只有一个元素也要用逗号分隔开
n1 = (1) # 没有加逗号分开，默认识别为整型 type(n1) <class 'int'> n2 = (1,) # 加了逗号，识别为元组类型 type(n2) <class 'tuple'>
2、切片（顾头不顾尾，步长） 如 1中所示
3、成员运算 in 和 not in
tuple = ('a','b','c',['jason','egon','tank','sean']) 'jason' in tuple False 'a' in tuple True
4、长度 len()
tuple = ('a','b','c',['jason','egon','tank','sean']) len(tuple) 4
5、循环
类型总结：
1、存多个值。
2、有序。
3、不可变类型。原因及原理结构如下图所示：
三、字典
基本用法：
1、作用：可存储多对 key:value 键值对，key是对value的描述，所以key多是字符串类型
强调：在字典中key值只能是不可变类型如int float str tuple ，value可以是任意类型
# d1 = {1:'1',0:'0',1.11:'1.11',(1,2):'到底能不能呢?'} # print(d1[1.11]) # print(type(d1)) # print(d1[(1,2)])
2、定义：大括号{ }，里面存键值对，并用逗号分隔开
注意：字典中的key值不能是重复的，只能唯一标识一条数据，如果存在多个重复的key，会被重复赋值，输出最后一个key
d2 = {'name':'jason','name':'tank','name':'nick','password':123}
d2['name'] # 多个‘name’，只输出最后一个name对应的键值‘nick’
'nick'
优先掌握的方法：
1、按key存取值，可存可取！
d2 = {'name':'nick','password':123}
d2['name'] = 'tank' # 直接根据key值重新赋值
d2
{'name': 'tank', 'password': 123}
******* 注意：赋值语句当key不存在的情况下，会自动添加一个新的键值对
d2 = {'name':'nick','password':123}
d2['age'] = 19
d2
{'name': 'nick', 'password': 123, 'age': 19}
2、长度 len()
3、成员运算 in 和 not in
4、删除操作
a、del (dict['key'])
b、pop() 弹出的是value值；当key不在是会报错
d2 = {'name':'nick','password':123}
d2.pop('password') # 弹出的是value值
123
d2.pop('age') # 当key值不存在时，会报错！
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'age'
5、定义字典的三种方式：
第一种：
# d1 = {'name':'jason','password':123}
第二种：*****
d2 = dict(name = 'jason',age = 13,paw = 123) d2 {'name': 'jason', 'age': 13, 'paw': 123}
第三种：了解即可
l = [ ['name','jason'], ['age',18], ['hobby','read'] ] # d = {} # # for i in l: # ['name','jason'],['age',18]... # for k,v in l: # ['name','jason'],['age',18]... # # d[i[0]] = i[1] # d[k] = v # print(d) # d3 = dict(l) # print(d3)
******* 6、三种方法： 键keys() ，值values() ,键值对items() -------- 引出Python2 和Python3 的区别
# d1 = {'name':'jason','password':123} # print(d1.keys()) # dict_keys(['name', 'password']) 老母猪 # print(d1.values()) # dict_values(['jason', 123]) 老母猪 现在就把它当成一个列表来看即可 # print(d1.items()) # dict_items([('name', 'jason'), ('password', 123)]) # 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value
******* 7、重要的方法： get() 根据key值获取value
d1 = {'name':'jason','pwd':123}
print(d1['name'])
print(d1['age'])
print(d1.get('name','你给我的name在字典的key中'))
res = d1.get('age') # 当字典的key不存在的情况 不报错 返回None
res1 = d1.get('xxx','你给我的age在字典的key中') # 当字典的key不存在的情况 不报错 返回None
# get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
其他4种用法：
1、dict.fromkeys() 快速创建一个字典
d2 = ['jason','tank','sean','egon'] dict.fromkeys(d2,123) {'jason': 123, 'tank': 123, 'sean': 123, 'egon': 123}
2、dict.popitem() 尾部以元组的形式弹出键值对
d3 = {'jason': 123, 'tank': 123, 'sean': 123, 'egon': 123}
d3.popitem() # 尾部弹出
('egon', 123)
3、dict.setdefault() 分两种情况，如下所示：
d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo') # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1,res1)
res2 = d1.setdefault('age',18) # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1,res2)
>>>:
{'name': 'jason', 'pwd': 123} jason
{'name': 'jason', 'pwd': 123, 'age': 18} 18
4、dict.update() 添加键值对，并以dict.update(键值对)的形式进行更新，示例如下：
d1 = {'name':'jason','pwd':123}
d2 = {"age":18}
d1.update(d2)
# d1['age'] = 18
# d1.update(age=666)
print(d1)
>>>:
{'name': 'jason', 'pwd': 123, 'age': 18}
注意：update()方法：当没有重复key的情况下就是添加键值对，但是当update()里面有重复key，会覆盖原有字典里面的key值
5、循环
类型总结：
1、可存多个值
2、无序
3、可变类型
四、集合
定义：可以包含多个元素，并用逗号隔开
# 定义： # s = {1,2,3,4,5,6} # <class 'set'> # s = set() # print(type(s)) # s1 = set() # print(type(s1)) # 注意在定义空集合的只能用关键字set # x = {} # <class 'dict'> 如果你仅仅只写了一个大括号 那么python默认将它当做字典类型
作用：1、去重 2、关系运算
集合的元素需要遵循的三个原则：
1、每个元素必须是不可变类型。
可变：不可hash
不可变：可hash
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()
2、成员运算：in 和not in
3、| 合集 &交集 — 差集 ^ 对称差集
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 既报名python也报名linux的学生姓名
print(pythons & linux) # 交集
# 只报名python的学生姓名
print(pythons - linux)
# 只报名linux的学生姓名
print(linux - pythons)
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux) # 对称差集
# 取出所有报了名的学生姓名
print(pythons | linux)
4、父集 > ,>= 子集 <,<=
s = {1,2,3,4,5}
s1 = {1,2}
s>s1 # 判断s是不是s1的父集
True
5、add() remove() discard()
ss = {1,2,3,4}
ss.add(('a','b')) # add()是添加“单个元素”，无论什么类型都当做一个元素
ss
{1, 2, 3, 4, ('a', 'b')}
remove 和 discard 的区别是：如果要删除的元素不在集合内，用remove会报错，用discard不会报错，会返回None
ss = {2,3,4,('a','b','d')}
ss.remove(2)
ss
{('a', 'b', 'd'), 3, 4}
ss = {2,3,4,('a','b','d')}
ss.discard(3)
ss
{('a', 'b', 'd'), 2, 4}
五、数据类型总结
1、8种数据类型---- int 、float、str、list、dict、tuple、set、bool
2、可变类型：list 、dict 、set
3、不可变类型：int 、float、str、tuple、