# 列表的常用方法
# 列表可以存多个值，是可变类型，不可hash，有序，有索引
# count() 功能是计算括号内的字符在列表中出现的次数，返回字符串出现的次数
# l= [1,2,3,4,5,6,6,6,6,6,7]
# res = l.count(6)
# print(res) # 结果是 5
#clear() 清空列表
# l= [1,2,3,4,5,6,6,6,6,6,7]
# print(id(l)) # 结果为2194323517960
# res = l.clear()
# print(res) # 结果为None clear没有返回值，清空就清空了
# print(id(l))
# # 结果为2194323517960 跟清空前一样，说明列表是可变类型
# # 列表指向的内存中的地址里的值可以修改，值变了id不变
# # reverse() 反转列表 无返回值，直接操作原列表
# l= [1,2,3,4,5,6,6,6,6,6,7]
# print(id(l)) # 结果为2426713518600
# l.reverse()
# print(l.reverse()) # 结果为 None
# print(l) # 结果为[7, 6, 6, 6, 6, 6, 5, 4, 3, 2, 1]
# print(id(l)) # 结果为2426713518600 跟反转前一样，说明列表是可变类型
# # sort()排序 按数字大小排序,从小到大排序,直接修改自己，不输出
# l = [45,6,32,78,77,24,88]
# l.sort() # 从小到大排序 （升序）
# print(l) # 结果为[6, 24, 32, 45, 77, 78, 88]
# l.sort(reverse = True) # 从小到大排序然后反转 （降序）
# print(l) # 结果为[88, 78, 77, 45, 32, 24, 6]
# 队列和堆栈的概念
# # 队列的概念 先进先出
# ll = [] # 先定义一个空列表
# print(ll) # 打印空列表
# # 先进
# ll.append('first') # 调用append方法，往里加字符串
# ll.append('second') # append后面括号里写引号引起来的字符串
# ll.append('third') # append后面括号里写要添加的内容
# print(ll) # 打印添加了数据的列表
# # 先出
# print(ll.pop(0)) # 调用pop方法，从索引为0的第一个，一个一个弹出
# print(ll.pop(0)) # pop后面括号里不写，默认是从最后开始弹出
# print(ll.pop(0)) # pop后面括号里可以写索引，按索引弹出
# 堆栈的概念 先进后出
# ll = [] # 先定义一个空列表
# print(ll) # 打印空列表
# ll.append('first') # 调用append方法，往里加字符串
# ll.append('second') # append后面括号里写引号引起来的字符串
# ll.append('third') # append后面括号里写要添加的内容
# print(ll) # 打印添加了数据的列表
# # 先出
# print(ll.pop()) # 调用pop方法，从后开始一个一个弹出
# print(ll.pop()) # pop后面括号里不写，默认是从最后开始弹出
# print(ll.pop()) # pop后面括号里可以写索引，按索引弹出
# 数据类型 ： 元组
# 作用：能够存储多个元素，元素与元素之间用逗号隔开，外面用小括号括起来
# 元素可以是任意类型，元组不能被修改
# 定义 ： 与列表类型比，只不过[] 换成 ()
# age = (11,22,33,44,55)
# 本质为 age = tuple((11,22,33,44,55))
# 可以存多个值，有索引，有序，不可变类型，可hash
#元组是不可变类型，元组中元素有列表时
# 元组中的列表是可变，但不影响元组不可变
# 元组中的列表中的元素，不属于，元组，成员判定为False
# # t = (1,2,3,[1,2])
# # t[-1] = 'hahaha' # 会报错，元组不支持更改
# # 会报错 TypeError: 'tuple' object does not support item assignment
# # print(t) # 会报错，元组不支持更改
# t = (1,2,3,[1,2])
# print(id(t)) # 2285209545208
# t[-1].append(666)
# t[-1][0] = 'hahaha' # 可以改元组中的列表中的值，不算改元组
# print(t) # (1, 2, 3, ['hahaha', 2, 666])
# print(666 in t) # False
# print(id(t)) # 2285209545208
# 需要掌握的操作
# # 1 切片
# t = (1,2,3,4,5)
# print(t[2:4:1]) # 结果为 (3, 4)
# # 切片的结果也是一个元组，2表示从索引为2开始切，即第一个元素为3
# # 4表示到索引4为止，索引4 不取，即元素5 不取，切片取值步长为1，挨个取
# # 2 按索引取值
# t = (1,2,3,4,5)
# print(t[2]) # 结果为 3 ，取到索引为2 的值，是 3
# # t[2] = 'xxx' # 会报错，元组是不可变类型，只能取值，不可修改
# # 报错 ：TypeError: 'tuple' object does not support item assignment
# # 长度 len() 返回值为 元组长度
# t = (1,2,3,4,5) #定义一个元组
# l = len(t) # 用len()求元组长度，将长度赋值给变量
# print(len(t) ) # 返回值为 元组长度
# print(l) # 打印元组长度 结果为5
# # 成员运算 in 与 not in
# t = (1,2,3,'a',5)
# #定义一个元组，元组中的字符串要用引号引起来，否则就是变量
# print(1 in t) # 结果为 True
# print('a' in t)
# # 结果为 True 元组中的字符串要用引号引起来，否则就是变量
# print(5 not in t) # 结果为 False
# print('x' not in t) # 结果为 True
# # for循环取值
# t = (1,2,3,'a',5)
# for i in t:
# print(i,end='')
# # 结果为123a5,
# # 隔开的end=''，表示以空格结尾，print自带换行，让打印在一行
# # 注意 元组定义时，括号内的语法书写
# t = (1,2,3,'a','b',[1,2,3])
# tuple((1,2,3,'a','b',[1,2,3])) # 正确的定义方式
# print(type(t)) # 结果为 <class 'tuple'>
# # t1 = tuple(1) # 报错 TypeError: 'int' object is not iterable
# # 1不打引号为 整型，整型不可被转换成元组
# t2 = tuple('1') # 1打引号为字符串，字符换可以被定义为元组，
# print(t2) # 结果为 ('1',)，定义为元组内一个元素
# # 定义元组，元组中只有一个元素时，后面习惯性跟一个英文逗号
# n1 = ('1') # <class 'str'>
# n2 = (1) # <class 'int'>
# print(type(n1),type(n2)) # 结果为 <class 'str'> <class 'int'>
# #书写时候一定要注意整型和字符串的书写格式，字符串要加引号
# print(type((1))) # <class 'int'>
# print(type((1,))) # <class 'tuple'>
# print(type(('1'))) # <class 'str'>
# print(type(('1',))) # <class 'tuple'>
# print(type([1])) # <class 'list'>
# print(type(['1'])) # <class 'list'>
# print(type(['1',])) # <class 'list'>
# print(type({1})) # <class 'set'>
# print(type({1,})) # <class 'set'>
# print(type({'1'})) # <class 'set'>
# print(type({'1',})) # <class 'set'>
# print(type({})) # <class 'dict'>
# # 删除 del
# t = (1, 2, 3, 'a', 'b', [1, 2, 3])
# del t[0] # TypeError: 'tuple' object doesn't support item deletion
# print(t)
# # # 元组中的元素不支持删除，元组为不可变类型，所以不支持删除
# # count() 返回 该字符出现的个数
# t = (1, 1, 3, 'a', 'b', [1, 1, 3])
# print(t.count(1))
# # 结果为2 出现了两次，元组中的列表中的不统计，不属于元组
# print(t.count('1'))
# # 结果为0， 元组中的1为int整型，查找的count中的'1'为字符串，所以为0
# # index() 返回 索引值
# t = (1, 1, 3, 'a', 'b', [1, 1, 3])
# print(t.index([1,1,3])) # 结果为 索引是 5
# print(t.index(1)) # 结果为 索引是 0
# print(t.index('1'))
# # 元组中的1为整型，index()查找索引的函数中的'1',为字符串
# # 所以报错找不到： ValueError: tuple.index(x): x not in tuple
# # 数据类型 ： 字典
# # 作用：能存储多组 key:value键值对，key是对value的描述
# # key通常情况下都是字符串，key是用户获取value的唯一方式
# # 其实这个key只能是不可变类型,value可以是任意数据类型
# d = {[1,2]:'name'}
# print(d) # 结果会报错 TypeError: unhashable type: 'list'
# # 字典中的key必须是可has不可变类型的值
# # 可以存多个值，无序，无索引，可变
# # 定义： d = {'name':'xiao','password':123}
# # # d = dict( {'name':'xiao','password':123})
# # 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)]) # 字符串
# # 字典中的key是不可以重复的，要唯一标识一条数据value
# d = {'name':'1','name':'2','name':'3','pwd':123}
# print(d) # 结果为 {'name': '3', 'pwd': 123}
# # 如果key重复了，只会按照最后一组重复的键值对存储
# print(len(d)) # 结果为2
# 定义字典的三种方式
# # 第一种
# d1 = {'name':'xiao','pwd':123}
# print(d1) # 结果为 {'name': 'xiao', 'pwd': 123}
# #这种方法就是按照字典的格式来定义，直接写键值对定义，实质为
# d1 = dict({'name':'xiao','pwd':123})
# print(d1)
# # 第二种
# d2 = dict(name = 'xiao',pwd = 123,age = 18)
# print(d2,type(d2))
# # 结果为{'name': 'xiao', 'pwd': 123, 'age': 18} <class 'dict'>
# # 以多组 变量 = 变量值 ，来定义字典
# 第三种
# l = [['name','xiao'],['age',18],['pwd','hahaha']]
# # 定义一个列表，列表中元素是小列表，每个小列表中是一对值
# d3 = {} # 定义一个空字典
# for k,v in l:
# # 循环大列表取值，解压赋值小列表
# # 第一次从第一个小列表中取出两个值，解压赋值给k,v
# d3[k] = v
# # 用字典key值取value的方式，定义字典d3中的key=k,value=v
# print(d3) # 打印字典d3
# # 结果为 {'name': 'xiao', 'age': 18, 'pwd': 'hahaha'}
# l = [['name','xiao'],['age',18],['pwd','hahaha']]
# # 定义一个列表，列表中元素是小列表，每个小列表中是一对值
# d3 = {} # 定义一个空字典
# for i in l:
# # 从列表l中循环取值
# d3[i[0]] = i[1]
# #定义 d3字典中，key=i[0],value=i[1]
# #即 key为 从l大列表中循环取值出小列表的索引值为0的值
# #即 value为 从l大列表中循环取值出小列表的索引值为1的值
# print(d3) # 打印字典d3
# # 结果为 {'name': 'xiao', 'age': 18, 'pwd': 'hahaha'}
# 优先掌握的操作
# # 按key存取值： 字典按key可存可取value
# # （元组按索引：不可存可取 列表按索引，可存可取）
# d = {'name':'xiao','pwd':'123'}
# print(id(d)) # 结果为 1423053053456
# print(d['pwd']) # 结果为 123
# d['pwd'] = 456
# print(d,id(d)) # 结果为 {'name': 'xiao', 'pwd': 456} 1423053053456
# # 根据key修改value,但是id没有变，说明字典是可变类型
# d['age'] = 18
# print(d) # 结果为 {'name': 'xiao', 'pwd': 456, 'age': 18}
# # 赋值语句当key不存在的情况下，会自动新增一个键值对
# # 长度 len() 返回一个长度值，字典中元素的个数
# d = {'name': 'xiao', 'pwd': 456, 'age': 18}
# l = len(d)
# print(l) # 结果为3
# print(len(d)) # 结果为3
# #len统计的是字典中的键值对的个数
# # 成员运算 in 与 not in
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# print(123 in d) # 结果为 False
# print('name' in d) # 结果为True
# # 字典成员运算，只认为key在字典中，value不在字典中，key是唯一可以获取value的方式
# # 删除
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# del d['age']
# print(d) # 结果为 {'name': 'xiao', 'pwd': 123}
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# res1 = d.pop('age') # 结果为18
# res2 = d.pop('name') # 结果为xiao
# print(res1,res2) # 结果为 18 xiao，调用pop弹出key，给的返回值为value
# print(d) # 结果为{'pwd': 123}
# d.clear() # 清空字典
# print(d) # 结果为 {}
# # 键keys() 值value() 键值对items() 返回值分别为 key组成的列表，value组成的列表 键值对元组组成的列表
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# print(d.keys()) # 结果为 dict_keys(['name', 'pwd', 'age']) 结果为一个列表
# for k in d.keys():
# print(k,end=' ') # 结果为 name pwd age end=后面有个空格
# print(d.values()) # 结果为 dict_values(['xiao', 123, 18]) 结果为value组成的一个列表
# print(d.items()) # 结果为 dict_items([('name', 'xiao'), ('pwd', 123), ('age', 18)])
# # 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value
# # get() 根据key获取value 这个很重要 返回一个value 或者 返回一个自己指定的value
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# print(d['name']) # 用print来操作key取value 结果是 xiao
# print(d.get('name','haha')) # 返回xiao，字典中这个key，则返回对应的value
# res = d.get('xxx') # 返回 None 当字典的key不存在的情况，后面没有指定返回，返回当None
# print(res)
# print(d.get('hobby','haha')) # 返回haha，字典中没有这个key，则返回括号里第二个字符串
# print(d) # 字典中没有这个key，则返回括号里第二个字符串，不会在原字典中加入
# # dict.fromkeys() 快速的创建一个字典 返回一个字典
# l = [11,22,33]
# print(dict.fromkeys(l,'aa'))
# # 返回结果 {11: 'aa', 22: 'aa', 33: 'aa'}
# # dict.fromkeys(列表，'字典中的value')
# # dict.popitem() 返回值弹出的键值对
# d = {11: 'aa', 22: 'aa', 33: 'aa'}
# print(d.popitem()) # 结果为 (33, 'aa')
# # 从尾部开始以元组的形式弹出键值对
# # dict.setdefault() 返回值为 value 或着 自己指定的value
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# res1 = d.setdefault('pwd','xxoo')
# print(res1) # 返回结果为： 123
# print(d.setdefault('pwd','xxoo')) # 返回结果为： 123
# print(d) # 返回结果为：{'name': 'xiao', 'pwd': 123, 'age': 18}
# # 如果有这个键，则返回相应的value，如果没有这个键，则再原列表中添加这个键，value为后面所指定的
# res2 = d.setdefault('hobby','haha')
# print(res2) # 返回结果为： haha
# print(d.setdefault('hobby','haha')) # 返回结果为： haha
# print(d) # 返回结果为：{'name': 'xiao', 'pwd': 123, 'age': 18, 'hobby': 'haha'}
# # dict.update() 没有返回值
# d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# d1 ={'hobby':'haha'}
# print(d.update(d1)) # None没有返回值
# d.update(d1)
# print(d) # ：结果为{'name': 'xiao', 'pwd': 123, 'age': 18, 'hobby': 'haha'}
# # 字典.update(字典) 结果为两个字典合并
# d['age'] = 666
# print(d) # ：结果为{'name': 'xiao', 'pwd': 123, 'age': 666, 'hobby': 'haha'}
# d.update(age=30)
# print(d) # ：结果为{'name': 'xiao', 'pwd': 123, 'age': 30, 'hobby': 'haha'}
# # 循环取值
# # d = {'name': 'xiao', 'pwd': 123, 'age': 18}
# # for v in d:
# # print(v,end=' ') # 结果为 name pwd age
# # 数据类型 集合
# l1 = [11,22,33,44,55,66]
# l2 = [33,44,55,66,77,88]
# for i in l1:
# if i in l2:
# print(i,end=' ')
# # 结果为33 44 55 66 可以求交集
# 集合的作用 ： 关系运算 & 去重
# # 定义：
# s = {1,2,3,4,5}
# print(type(s)) # 结果为 <class 'set'> 实质为;
# s = set({1,2,3,4,5})
# print(type(s)) # 结果为 <class 'set'>
# # 定义空集合只能用关键字set() 否则直接大括号{}出来是 字典
# s1 = set({}) # <class 'set'>
# s2 = {} # <class 'dict'>
# print(type(s1),type(s2))
# t = () # <class 'tuple'>
# print(type(t))
# # 集合的元素遵循三个原则：
# # 1：每个元素必须是不可变类型 不能是 list 或者 dict
# # 可变:不可hash
# # 不可变:可hash
# s1 = {1,2,3,4,5,6,'a',(1,2),[1,2]} # 报错 TypeError: unhashable type: 'list'
# print(s1)
# s2 = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}} # 报错 TypeError: unhashable type: 'dict'
# print(s2)
# # 2: 没有重复的元素
# s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
# print(s) # 自动将重复的元素 去除 结果为 {1, 2, 3, 4, 5}
# # 3：无序
# s = {1, 2, 3, 4, 5, 6}
# print(s[1])
# # 报错 TypeError: 'set' object does not support indexing 不支持索引，即无序
# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
# 优先掌握的操作
# # len() 长度 返回长度
# s = {1, 2, 3, 4, 5, 6 }
# print(len(s)) # 结果为6 计算集合的长度，元素的个数
# # 成员运算 in 与 not in 返回布尔值
# s = {1, 2, 3, 4, 5, 6,'a' }
# print(1 in s) # 结果为True
# print('a' in s) # 结果为True
# # 合集 | 返回合集
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# print(s1 | s2) # 结果为{1, 2, 3, 4, 5, 6, 7} 合集
#
# # 交集 & 返回交集
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# print(s1 & s2) # 结果为 {3, 4, 5}
#
# # 差集 - 返回差集
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# print(s1 - s2) # 结果为 {1, 2}
#
# # 对称差集 ^ 返回对称差集
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# print(s1 ^ s2) # 结果为 {1, 2, 6, 7}
#
# # ==
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# s3 = {1,2,3,4,5}
# print(s1 == s2) # 结果为False
# print(s1 == s3) # 结果为True
#
# # 父集 > >= .issuperset 返回布尔值
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# s3 = {1,2,3}
# s4 = {1,2,3,4,5}
# print(s1 > s2) # 结果为False s1是否包含s2 否
# print(s1.issuperset(s2)) # 结果为False s1是否包含s2 否
# print(s3 >= s2) # 结果为False s3是否包含s2 否
# print(s3.issuperset(s2)) # 结果为False s3是否包含s2 否
# print(s1 > s3) # 结果为True s1是否包含s3 是
# print(s1.issuperset(s3)) # 结果为True s1是否包含s3 是
# print(s4 >= s1) # 结果为True s4是否包含s1 是
# print(s4.issuperset(s1)) # 结果为True s4是否包含s1 是
# #
# # 子集 < <= .issubset 返回布尔值
# s1 = {1,2,3,4,5}
# s2 = {3,4,5,6,7}
# s3 = {1,2,3}
# s4 = {1,2,3,4,5}
# print(s3 < s1) # 结果为True s3是否包含s1 是
# print(s3.issubset(s1)) # 结果为True s3是否包含s1 是
# print(s1 <= s4) # 结果为True s1是否包含s4 是
# print(s1.issubset(s4)) # 结果为True s1是否包含s4 是
# print(s3 < s2) # 结果为False s3是否包含s2 否
# print(s3.issubset(s2)) # 结果为False s3是否包含s2 否
# print(s1 <= s2) # 结果为False s1是否包含s2 否
# print(s1.issubset(s2)) # 结果为False s1是否包含s2 否
# # add() 将容器或这个一个别的数据类型当成 一个元素 传入集合 返回None 没有返回值
# s = {1,2,3,4,5}
# s.add(666)
# print(s)
# print(s.add(666)) # 返回None
# # 结果为 {1, 2, 3, 4, 5, 666} 添加一个666
# s.add((1,2,3))
# print(s)
# # 结果为 {1, 2, 3, 4, 5, (1, 2, 3), 666} 添加一个元组，因为集合无序，所以随机位置添加
# s = {1,2,3,4,5}
# s.add(('a'))
# print(s)
# # 结果为 {1, 2, 3, 4, 5, 'a'} 括号内加引号引起来 是字符串，添加一个字符串
# s = {1,2,3,4,5}
# s.add(('a',))
# print(s)
# # 结果为 {1, 2, 3, 4, 5, ('a',)} 括号加引号引起来，引号之后加一个英文逗号，添加一个元组
# # remove() 没有返回值
# s = {'a',2,3,4,5}
# print(s.remove('a')) # 结果为 None
# s.remove(2)
# print(s) # 结果为 { 3, 4, 5}
# # 从原列表中移除某一个元素
# print(s.remove('2'))
# # 如果没有这个元素 会报错 KeyError: '2' 查找字符串'2'，原集合中是整型 数字 int 2
# # dicard() 没有返回值
# s = {'a',2,3,4,5}
# print(s.discard('a')) # 没有返回值，但是移除了 字符串'a'
# print(s) # 结果为 {2, 3, 4, 5}
# print(s.discard('2'))
# # 如果没有这个元素 返回None 不会报错 KeyError: '2' 查找字符串'2'，原集合中是整型 数字 int 2
浙公网安备 33010602011771号