一、列表常用方法
1.count():统计列表中元素的个数
l = [1,2,3,4,5,6,7] res = l.count(3) # 统计列表中元素的个数 print(res)
2.clear():清除列表中所有的元素
l = [1,2,3,4,5,6,7] print(l) res = l.clear() # 清除列表中所有的元素 print(l) print(res) # None
3.reverse():将列表中的元素反转
l = [1,2,3,4,5,6,7] print(id(l)) # 1997351167048 l.reverse() # 将列表反转 print(id(l)) # 1997351167048 print(l) # [7, 6, 5, 4, 3, 2, 1]
4.sort():排序 默认情况下是从小到大（升序）
l = [1,2,3,4,5,6,7] l.sort() # 排序 默认情况下是从小到大(升序) l1 = [43,6,1,7,99] l1.sort(reverse=True) # 可以通过指定参数来修改默认的排序规则(降序) print(l1) # [99, 43, 7, 6, 1]
能存多个值、有序、可变类型
队列：遵循先进先出
l1 = [] # 先进 l1.append(\'first\') l1.append(\'second\') l1.append(\'third\') # 先出 print(l1.pop(0)) print(l1.pop(0)) print(l1.pop(0))
堆栈：遵循先进后出
l1 = [] # 先出 l1.append(\'first\') l1.append(\'second\') l1.append(\'third\') # 后出 print(l1.pop()) print(l1.pop()) print(l1.pop())
二、元组
1.作用：能够存储多个元素，元素与元素之间逗号隔开 元素可以是任意类型，元祖本身不能被修改
2.定义：在（）内用逗号分隔开多个任意类型的值
age=(11,22,33,44,55) # age=tuple((11,22,33,44,55))
3.常用操作
（1）按索引取值（正向取+反向取）：只能取
t = (1, 2, 3, \'a\', \'b\', [1, 2, 3]) print(t[0]) # 1 t[-1][0] = \'我改了\' print(t) # (1, 2, 3, \'a\', \'b\', [\'我改了\', 2, 3])
（2）切片（顾头不顾尾，步长）
t = (1, 2, 3, \'a\', \'b\', [1, 2, 3]) print(t[::2]) # 从头到尾隔一个元素取值 (1, 3, \'b\')
（3）长度
t = (1, 2, 3, \'a\', \'b\', [1, 2, 3]) print(len(t)) # 统计元素个数
（4）成员运算in和not in
t = (1, 2, 3, \'a\', \'b\', [1, 2, 3]) print(\'a\' in t) # True
（5）循环
t = (1, 2, 3, \'a\', \'b\', [1, 2, 3]) for i in t: print(i)
t = (1, 2, 3, \'a\', \'b\', [1, 2, 3]) print(t.count(\'a\')) # 统计元素在元祖中的个数 print(t.index(\'xxx\')) # 不存在这个值时报错
能存多个值、有序、不可变类型
t2 = (1,2,3,4,[1,2]) print(id(t2)) # 1770637668776 t2[-1].append(666) print(t2) # (1, 2, 3, 4, [1, 2, 666]) print(id(t2)) # 1770637668776
三、字典
1.作用：能存储多组数据 key:value键值对 key是对value的描述 key通常情况下都是字符串
其实这个key只能是不可变类型，value可以是任意数据类型
2.定义（三种方式）：
d = {\'name\':\'jason\',\'password\':123} # d = dict( {\'name\':\'jason\',\'password\':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)
字典的key是不能重复的，要唯一标识一条数据
如果重复了，只会按照最后一组重复的键值对存储
d1 = {1:\'1\',0:\'0\',1.11:\'1.11\',(1,2):\'到底能不能呢?\'}
print(d1[1.11]) # 1.11
print(type(d1)) # <class \'dict\'>
print(d1[(1,2)]) # 到底能不能呢?
d2 = {\'name\':\'jason\',\'name\':\'tank\',\'name\':\'nick\',\'password\':123}
print(len(d2)) # 2
print(d2) # {\'name\': \'nick\', \'password\': 123}
3.常用操作
（1）按key存取值：可存可取
d3 = {\'name\':\'jason\',\'password\':\'123\'}
print(id(d3)) # 1790997716568
print(d3[\'name\']) # jason
d3[\'name\'] = \'egon\'
d3[\'age\'] = 18 # 赋值语句当key不存在的情况下，会自动新增一个键值对(******)
print(d3,id(d3)) # {\'name\': \'ooo\', \'password\': \'123\', \'age\': 18} 1790997716568
（2）长度len：统计键值对个数
（3）成员运算in和not in（对于字典来说只能判断key值）
d3 = {\'name\':\'jason\',\'password\':\'123\'}
print(\'123\' in d3) # False
print(\'name\' in d3) # True
（4）删除
d3 = {\'name\':\'jason\',\'password\':\'123\'}
del d3[\'name\']
print(d3) # {\'password\': \'123\'}
res = d3.pop(\'name\') # 弹出仅仅是value jason
res = d3.pop(\'age\') # 当键不存在的时候直接报错
print(res)
print(d3) # {\'password\': \'123\'}
d3.clear()
print(d3) # {}
（5）键keys()，值values()，键值对items()
d1 = {\'name\':\'jason\',\'password\':123}
print(d1.keys()) # dict_keys([\'name\', \'password\']) 老母猪
for k in d1.keys():
print(k)
print(d1.values()) # dict_values([\'jason\', 123]) 老母猪 现在就把它当成一个列表来看即可
print(d1.items()) # dict_items([(\'name\', \'jason\'), (\'password\', 123)])
把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value
get():根据key获取value
d1 = {\'name\':\'jason\',\'pwd\':123}
print(d1[\'name\'])
# print(d1[\'age\'])
print(d1.get(\'name\',\'你给我的name在字典的key中\')) # jason
res = d1.get(\'age\') # 当字典的key不存在的情况 不报错 返回None
res1 = d1.get(\'xxx\',\'你给我的age在字典的key中\') # 当字典的key不存在的情况 不报错 返回None
# get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
print(res1)
print(d1.get(\'xxx\',\'asdsad\'))
# 第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容
fromkeys():快速创建一个字典
l1 = [\'name\',\'password\',\'age\',\'hobby\'] print(dict.fromkeys(l1,123)) # {\'name\': 123, \'password\': 123, \'age\': 123, \'hobby\': 123}
popitem():尾部以元祖的形式弹出键值对
d1 = {\'name\':\'jason\',\'pwd\':123}
print(d1.popitem()) # (\'pwd\', 123)
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
update():
d1 = {\'name\':\'jason\',\'pwd\':123}
d2 = {"age":18}
# d1.update(d2) # 无
# d1[\'age\'] = 18 # 无
d1.update(age=18)
print(d1) # {\'name\': \'jason\', \'pwd\': 123, \'age\': 666}
（6）循环
d1 = {\'name\':\'jason\',\'password\':123}
for i in d1:
print(i)
存多个值，无序，可变类型
四、集合
1.作用：去重，关系运算
2.定义：
s = {1,2,3,4,5,6} # <class \'set\'> # s = set()
注意：在定义空集合的只能用关键字set
如果仅仅只写了一个大括号，那么python默认将它当做字典类型
x = {} # <class \'dict\'>
t = () # <class \'tuple\'>
3.定义集合（可以包含多个元素，用逗号隔开）
集合元素遵循三个原则：
（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]) # 报错
注意：集合的目的是将不同的值存放到一起，不同的集合间
用来做关系运算，无需纠结于集合中单个值
4.优先掌握的操作：
（1）长度len
s = {1,2,3,4}
print(len(s)) # 4
（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）是否相等
s1={1,2,3}
s2={3,1,2}
print(s1 == s2) # True
（5）父集：一个集合是包含另一个集合
s1={1,2,3}
s2={1,2}
print(s1 >= s2) # True
print(s1.issuperset(s2)) # True
（6）子集
s1={1,2,3}
s2={1,2}
print(s2 <= s1) # True
print(s2.issubset(s1)) # True
5.需要掌握的：
（1）update()
s1={1,2,3}
s1.update({3,4,5})
print(s1) # {1, 2, 3, 4, 5}
（2）pop()
s1={1,2,3}
res=s1.pop()
print(res) # 1
（3）remove()
s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1) # {1, 2}
（4）add()
s1={1,2,3}
s1.add(4)
print(s1) # {1, 2, 3, 4}
存多个值、无序、set可变
局限性：
1、无法保证原数据类型的顺序
2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
五、数据类型总结
1.按存储空间的占用分（从低到高）
数字<字符串<集合<元组<列表<字典
2.按存值个数区分
标量/原子类型：数字、字符串
容器类型：列表、元组、字典
3.按可变不可变区分
可变：列表、字典
不可变：数字、字符串、元组
4.按访问顺序区分
直接访问：数字
顺序访问（序列类型）：字符串、列表、元组
key值访问（映射类型）：字典