字典、元组、集合内置方法

今日内容概要

• 队列与堆栈的特征
• 字典及字典内置方法
• 元组及字典内置方法
• 集合及集合内置方法

今日内容详细

利用列表实现队列与堆栈的特征

队列
    先进先出
堆栈
    先进后出
需求:使用列表模拟出上述两个概念的特征


# 队列 先进先出
'''先进去的元素 先出来'''
# # 添加元素
l = []
l.append(111)
l.append(222)
l.append(333)
# # 取出元素
print(l.pop(0))  # 111
print(l.pop(0))  # 222
print(l.pop(0))  # 333

# 堆栈 先进后出
'''先进去的元素 先出来'''
l = []
l.append(111)
l.append(222)
l.append(333)
# # 取出元素
print(l.pop())  # 333
print(l.pop())  # 222
print(l.pop())  # 111

字典内置方法

"""
大括号括起来 内部可以存放多个元素
元素的表现形式是以K:V键值对形式
    K 是不可变类型
          整型 浮点型 字符串 
    V 可以是任意类型
"""
"""
d1 = {
      'username':'wuxie',
      'password':123,
      'hobby':['read','run']
}
print(d1,type(d1))
d2 = {
     1:'wuxie'
     2:'xiesj'
     3:'cym'
}
print(d2,type(d2))
d3 = {
    1.1:'wuxie'
    2.2:'cym'
    3.3:'tinatian'
}
print(d3,type(d3))
d4 = {
      'username':'chengyumeng'
      1:'wuxie'
      1.1:'kevin'
}
print(d4,type(d4))
# 作用:存多个值,key-value存取,取值速度快

# 定义:key必须是不可变类型,value可以是任意类型

# 1. 按key存取值:可存可取
d1 = {
      'username':'wuxie',
      'password':123
      'hobby':['read','run']
}
print(d1['username'])
d1['username'] = 'tony'
print(d1)  # {'username': 'tony', 'password': 123, 'hobby': ['read', 'run']}
# 字典是可变类型
print(d1['age']) # 键不存在 直接报错
d1['age'] = 18 # 键存在则修改 不存在则新建

# 2. 长度len 统计字典键值对的个数
print(len(d1)) 

# 3.成员运算in和not in 
print('tony' in d1) # False 字典默认只暴露key value不暴露 如果想去一般只能通过key
print('username' in d1) # True 
# 4.删除
del d1['password']
print(d1) 
'''字典不能使用索引!!!'''
# 使用pop 也可以实现删除
res = d1.pop('password')
print(d1)
print(res) # pop 删除可以返回值,返回值为value

# 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() ['uesrname','password','hobby'] # 以列表的形式贮存,需要更大的内存空间
# 将values()的结果可以直接看成是列表
# print(d1.values()) # dict_values(['jason',123,['read','run']] 

# 将items()的结果可以直接看成列表[]套小列表()
print(d1.items()) # dict_items([('username', 'wuxie'), ('password', 123), ('hobby', ['read', 'run'])])

for k,v in d1.items():
    print(k,v)
# username wuxie
  password 123
  hobby ['read', 'run']

# 6. 循环
'''字典for循环只能获取key'''
for i in d1:
    print(i)
# 7. get方法
  dict.get() # 使用频率最为广泛 通过字典的key获取字典的value
  print(d1.get('username')) # wuxie
  print(d1['username']) # wuxie
# get 的优势
 当key不存在:
  print(d1['age']) # 直接报错
  print(d1['age']) # get方法键不存在也不会报错 返回None(什么都没有)
'''get方法还可以给第二个参数 键存在则不使用 键不在则返回第二个参数 不写默认返回None'''

# 第一种创建字典的方式
# d2 = {'k1':'v1','k2':'v2'} # dict({'k1':'v1','k2':'v2'})
#第二种创建方式 
res = dict(name='wuxie',pwd=123,hobby=['read','run'])
print(res) # {'name': 'wuxie', 'pwd': 123, 'hobby': ['read', 'run']}
# 第三种创建方法
l = [
    ['uesrname','wuxie'],
    ['password',123],
    ['hobby',['read','run']
]
d = {}
for i in l :
    d[i[0]] = i[1] # d['username'] = 'wuxie'
print(d)
# {'username': 'wuxie', 'password': 123, 'hobby': ['read', 'run']}    
#######
d ={}
for k,v in l:
    d[k]=v
print(d)
# { 'username': 'wuxie', 'password': 123, 'hobby': ['read', 'run']}
#######
res = dict(l)
print(res)

# {'username': 'wuxie', 'password': 123, 'hobby': ['read', 'run']}

# 8. 清空
  dict.clear()
  d1.clear()
  print(d1)
# 9. 快速生成一个字典
dict.fromkeys()
l = ['username','pwd','hobby']
res = dict.fromkeys(l,None) # None 对应的value的值,先默认,后修改
print(res)
# 10.随机弹出一组键值对
dict.popitem()
res = d1.popitem() 
print(d1)
print(res) # ('hobby',['read','run']))
# 11. setdefault()函数
# setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
dd = {'name':'wuxie','pwd':123}
dd.setdefault('age',18) # 键不存在 则新建
res = dd.setdefault('name','cym') # 键存在不修改 而是获取到键对应的值
print(dd,res) # {'name': 'wuxie', 'pwd': 123, 'age': 18} wuxie
# 12. update() 方法
# update() 函数把字典dict的键/值对更新到dict里
dd = {'name':'wuxie','pwd':123} 
dd.update({'age':18}) # 键不存在 则新建
dd.update({'name':'cym'}) # 键存在 则修改值
print(dd)

元组

"""
小括号括起来 括号内可以存放多个元素
元素与元素之间逗号隔开 元素可以是任意类型
     元组也可以简单的理解为是列表
     元组属于不可变类型
"""
t1 = (1,2,3,4,5,6)
print(type(t1)) #tuple
类型转换 与list一致 支持for循环的都可以
t1 = (1)
print(type(t1))  # int
t2 = ('a')
print(type(t2))  # str
l1 = [1]
print(type(l1))  # list
"""
元组当内部只有一个元素的时候 逗号不能省略
以后只要是容器类型 无论内部有几个元素 都必须要有逗号
    尤其是只有一个元素的情况下
        (1,)
        [1,]
        {'username':'jason',}
"""
作用:存多个值,对比列表来说,元组不可变(是可以当做字典的key的) 主要用来读
定义:与列表类型相比,只不过[]换成()
# 1. 按照索引取值(正向取+反向取):只能取
t1 = (11,22,33)
t1[0] = 666
print(t1)
"""
"""
笔试题
t2 = (11,22,[11,22])
t2[2].append(33)
问:上述代码执行的结果是什么
"""
# 2. 切片(左闭右开)
与字符串 列表一致
# 3. 长度
len
# 4. 成员运算 in 和 not in 
与列表一致
#5. 循环
fr i in (22,33,11)
    print(i)

集合

"""
大括号括起来 内部可以存放多个元素
元素与元素之间逗号隔开(不是K:V键值对) 元素只能是不可变类型(整型 浮点型 字符串 元组)
 s = {1,2,3,4}
    只有两种情况下才会考虑使用集合
        1.关系元素
          两个群体之间判断 交叉并集
        2.去重操作
          去除重复的元素
"""
se = {1,2,3,4,6} 
print(type(se)) # set
如果{}里是空值 系统默认为字典类型
"""定义空集合 需要使用关键set"""
ss = set{}
print(ss,type(ss)) # set

# 1. 去重操作
l = [11,22,33,55,66,66,55,88,33,11,22]
for循环一个个元素 判断当前元素是否已存在
new_l = []
for i in l:
    if i not in new_l:
        new_l.append(i)
print(new_l)
####
直接将列表转换成集合
res = set(l)
print(res)
'''集合内默认不能出现重复的元素 如果出现了会自动去重'''
# 2. 关系运算
  f1 = {'wuxie','cym','tiantian','xiexie'}
  f2 = {'wuxie','cym','bochen','bohe'}
# 共同好友
print(f1 & f2)
# f1独有好友
print(f1 - f2)
#f2独有好友
print(f2 - f1)
#所有的好友
print(f1 | f2)
#各自好友 不包含共有的
print(f1 ^ f2)

# 父集 子集
"""
父集:A包含B 那么A就是B的父集
子集:A包含B 那么B就是A的子集
"""
s1 = {1,2,3,4,5}
s2 = {1,2,3}
print(s1 > s2) # True
print(s1 < s2) # False

总结

• 字典需要掌握 后期用到非常多
• 元组类型不可变
• 集合一般运用在关系运算