今日内容概要
- 利用列表实现队列与堆栈的特征
- 字典内置方法
- 元组及元组内置方法
- 集合及集合内置方法
今日内容详细
利用列表实现队列与堆栈的特征
队列
先进先出
堆栈
先进后出
需求:使用列表模拟出上述两个概念的特征
# 队列 先进先出
'''先进去的元素 先出来'''
l = []
# 添加元素
l.append(111) # l = [111,]
l.append(222) # l = [111, 222]
l.append(333) # l = [111, 222, 333]
print(l) # [111, 222, 333]
# 取出元素
print(l.pop(0)) # 111 l = [222, 333]
print(l.pop(0)) # 222 l = [333,]
print(l.pop(0)) # 333 l = []
print(l) # []
# 堆栈 先进后出
'''先进去元素 后出来'''
l = []
# 添加元素
l.append(111)
l.append(222)
l.append(333) # l = [111, 222, 333]
print(l) # [111, 222, 333]
# 取值
print(l.pop()) # 333 l = [111, 222]
print(l.pop()) # 222 l = [111,]
print(l.pop()) # 111 l = []
print(l) # []
字典内置方法
-
定义
#定义：key必须是不可变类型，value可以是任意类型 #作用：存多个值,key-value存取，取值速度快 """ 大括号括起来 内部可以存放多个元素 元素的表现形式是以K:V键值对形式 K是对V的描述性信息,一般都是字符串 K是不可变类型 整型 浮点型 字符串 V可以是任意类型 """ d1 = { 'username':'jason', 'password':123, 'hobby':['read', 'run'] } print(d1,type(d1)) d2 = { 1:'jason', 2:'egon', 3:'kevin' } print(d2,type(d2)) d3 = { 1.1:'jason', 2.2:'egon', 3.3:'kevin' } print(d3,type(d3)) # k值只要是不可变类型即可 同一个字典内可以混用 d4 = { 'username':'jason', 1:'egon', 1.1:'kevin' } print(d4,type(d4)) #几种创建字典的方式 #第一种 d2 = {'k1':'v1','k2':'v2'} # dict({'k1':'v1','k2':'v2'}) #第二种 res = dict(name='jason',pwd=123,hobby=['read','run']) print(res) # {'name': 'jason', 'pwd': 123, 'hobby': ['read', 'run']} #第三种 l = [ ['username','jason'], ['password',123], ['hobby',['read','run']] ] #(1) d = {} for i in l: # ['username','jason'] ['password',123] ['hobby',['read','run']] d[i[0]] = i[1] # d['username'] = 'jason' print(d) #(2) d = {} for k,v in l: # ['username','jason'] ['password',123] ['hobby',['read','run']] d[k] = v print(d) #(3) res = dict(l) print(res) # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run']} -
类型转换
# 转换1: info=dict([['name','tony'],('age',18)]) print(info) # {'name': 'tony', 'age': 18} # 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中 info={}.fromkeys(('name','age','sex'),None) print(info) # {'name': None, 'age': None, 'sex': None} -
优先掌握的操作
#1、按key存取值：可存可取 d1 = { 'username':'jason', 'password':123, 'hobby':['read', 'run'] } print(d1['username']) # jason print(id(d1)) # 对于赋值操作，如果key原先存在于字典，则会修改对应value的值 d1['username'] = 'tony' print(id(d1)) # {'username': 'tony', 'password': 123, 'hobby': ['read', 'run']} # 字典是可变类型 # 对于赋值操作，如果key原先不存在于字典，则会新增key:value print(d1['age']) # 键不存在 直接报错!!! d1['age'] = 18 # 键存在则修改 不存在则新建 print(d1) # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run'], 'age': 18} #2、长度len 统计字典中键值对的个数 print(len(d1)) # 3 #3、成员运算in和not in print('jason' in d1) # False 字典默认只暴露key,value不暴露,如果想取 一般只能通过key print('username' in d1) # True #4、删除 del d1['password'] # 通过指定字典的key来删除字典的键值对 print(d1) # {'username': 'jason', 'hobby': ['read', 'run']} '''字典不能使用索引!!!''' res = d1.pop('password') print(d1) # {'username': 'jason', 'hobby': ['read', 'run']} print(res) # 123 #5、键keys()，值values()，键值对items() # 将keys()的结果可以直接看成是列表 print(d1.keys()) # 获取字典中所有的key dict_keys(['username', 'password', 'hobby']) 老母猪 for k in d1.keys(): print(k) """ python2与python3对比 python3 keys() dict_keys(['username', 'password', 'hobby']) 老母猪 python2 keys() ['username', 'password', 'hobby'] """ # 将values()的结果可以直接看成是列表 # 获取字典所有的value print(d1.values()) # dict_values(['jason', 123, ['read', 'run']]) 老母猪 """ python2与python3对比 python3 values() dict_keys(['jason', 123, ['read', 'run']]) 老母猪 python2 values() ['jason', 123, ['read', 'run']] """ # 将items()的结果可以直接看成是列表[]套小列表() print(d1.items()) # 获取字典所有的键值对 for k,v in d1.items(): # 解压赋值 结合 for循环 print(k,v) """ python2与python3对比 python3 items() dict_keys([('username', 'jason'), ('password', 123), ('hobby', ['read', 'run'])]) 老母猪 python2 items() [('username', 'jason'), ('password', 123), ('hobby', ['read', 'run'])] """ #6、循环 '''字典for循环只能获取到key''' for i in d1: print(i) # 只遍历key for i in d1.keys(): print(i) # 只遍历value for i in d1.values(): print(i) # 遍历key与value for i in d1.items(): print(i) #7、get() # dict.get() # 使用频率最为广泛 通过字典的key获取字典的value print(d1.get('username')) # jason print(d1['username']) # jason # key不存在 print(d1['age']) # 直接报错 print(d1.get('age')) # get方法键不存在也不会报错 返回None(什么都没有) print(d1.get('username','嘿嘿嘿')) # jason print(d1.get('age','嘿嘿嘿')) # 嘿嘿嘿 '''get方法还可以给第二个参数 键存在则不使用 键不存在则返回第二个参数 不写默认返回None''' #8、clear() # dict.clear() 清空 d1.clear() print(d1) #9、fromkeys() dict.fromkeys() 快速先生成一个字典 l = ['username','pwd','hobby'] res = dict.fromkeys(l,None) print(res) #10、popitem() dict.popitem() res = d1.popitem() # 随机弹出一组键值对 print(d1) print(res) # ('hobby', ['read', 'run']) #11、setdefault() # dict.setdefault() 重点 dd = {'name':'jason','pwd':123} dd.setdefault('age',18) # key不存在则新增键值对,并将新增的value返回 res = dd.setdefault('name','egonSBSBSB') # key存在则不做任何修改, 而是获取到键对应的值 print(dd,res) # {'name': 'jason', 'pwd': 123, 'age': 18} jason #12、update() # dict.update() # 用新字典更新旧字典，有则修改，无则添加 dd = {'name':'jason','pwd':123} dd.update({'age':18}) # 键不存在 则新建 dd.update({'name':'EGONDSB'}) # 键存在则修改 print(dd) # 还不如使用下列方式 dd['age'] = 18 dd['name'] = 'jason'
元组
-
定义
#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读 #定义：与列表类型比，只不过[]换成() """ 小括号括起来 括号内可以存放多个元素 元素与元素之间逗号隔开 元素可以是任意类型 元组也可以简单的理解为是列表 元组属于不可变类型 """ t1 = (1,2,3,4,5,6) print(type(t1)) # tuple # 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组,只要是容器类型,无论内部有几个元素,都必须要有逗号 # (1,)[1,]{'username':'jason',} -
类型转换
# 类型转换 与list一致 支持for循环的都可以 t1 = (1) print(type(t1)) # int t2 = ('a') print(type(t2)) # str l1 = [1] print(type(l1)) # list # tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中 -
优先掌握的操作
#1、按索引取值(正向取+反向取)：只能取，不能改否则报错！ t1 = (11,22,33) t1[0] = 666 # 报错：TypeError: print(t1) """ 笔试题 元组内元素的内存地址不能修改 但是如果元素是可变类型 那么元素值可以改 """ t2 = (11,22,[11,22]) t2[2].append(33) # 问:上述代码执行的结果是什么 print(t2) # (11, 22, [11, 22, 33]) #2、切片(顾头不顾尾，步长) # 与字符串 列表一致 print(t1[0:2]) # (11, 22) #3、长度 # len() print(len(t1)) # 3 #4、成员运算in和not in # 与列表一致 print(11 in t1) # True #5、循环 for i in (11,22,33): print(i)
集合
-
定义
#作用：集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算 """ 定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点： 1：每个元素必须是不可变类型 2：集合内没有重复的元素 3：集合内元素无序 """ s = {1,2,3,4} # 本质 s = set({1,2,3,4}) # 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。 # 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者? d = {} # 默认是空字典 s = set() # 这才是定义空集合 se = {1,2,3,4,5} # set(1,2,3,4,5) print(type(se)) # set d1 = {} s1 = {} print(type(d1),type(s1)) # <class 'dict'> <class 'dict'> """定义空集合 需要使用关键字set""" ss = set() print(ss,type(ss)) # set s = {11,1.1,'hello',(1,2,3)} -
类型转换
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型 s = set([1,2,3,4]) s1 = set((1,2,3,4)) s2 = set({'name':'jason',}) s3 = set('egon') print(s,s1,s2,s3) # {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'} -
使用
''' 只有两种情况才会考虑使用集合 1.关系运算 两个群体之间判断 交叉并集 共同好友 共同关注 共同点赞... 2.去重操作 去除重复的元素 ''' # 1、关系运算 f1 = {'jason','egon','kevin','tony'} f2 = {'jason','jack','oscar','kevin'} # 交集(&):共同好友 print(f1 & f2) # {'jason', 'kevin'} # 差集(-):f1独有的好友 print(f1 - f2) # {'tony', 'egon'} # 差集(-):f2独有的好友 print(f2 - f1) # {'oscar', 'jack'} # 合集/并集(|):所有的好友 print(f1 | f2) # {'jason', 'oscar', 'egon', 'tony', 'kevin', 'jack'} # 对称差集(^):求各自好友 不包含共有的 print(f1 ^ f2) # {'jack', 'oscar', 'tony', 'egon'} #值是否相等(==) print(f1 == f2) # False # 父集:一个集合是否包含另外一个集合 子集:一个集合是否被包含在另外一个集合里 """ 父级:A包含B 那么A就是B的父级 子级:A包含B 那么B就是A的子级 包含则返回True，不存在包含关系，则返回False """ s1 = {1,2,3,4,5} s2 = {1,2,3} print(s1 > s2) # True print(s1 < s2) # False # 2.去重操作 #集合去重复有局限性，1. 只能针对不可变类型，2. 集合本身是无序的，去重之后无法保留原来的顺序 l = [11,22,33,22,11,44,33,22,55,66,66,66] # for循环一个个元素 判断当前元素是否已存在，保证顺序 new_l = [] for i in l: if i not in new_l: new_l.append(i) print(new_l) # [11, 22, 33, 44, 55, 66] # 将列表转换成集合，无法保证顺序 res = set(l) print(res) # {33, 66, 11, 44, 22, 55} '''集合内默认不能出现重复的元素 如果出现了会自动去重''' r1 = {11,22,22,22,11,44,44,44} print(r1) # {11, 44, 22} # 3、长度 print(len(l)) # 12 # 4.成员运算 print(11 in l) # True # 5.循环 for i in l: print(i)
浙公网安备 33010602011771号