day7

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

队列
	先进先出
堆栈
	先进后出
    
需求:使用列表模拟出上述两个概念的特征
    
    
# 队列  先进先出
'''先进去的元素 先出来'''
# l = []
# # 添加元素
# l.append(111)  # l = [111,]
# l.append(222)  # l = [111, 222]
# l.append(333)  # 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 = []

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

2字典内置方法

"""
大括号括起来 内部可以存放多个元素
元素的表现形式是以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(d2,type(d2))
# # k值只要是不可变类型即可 同一个字典内可以混用
# d4 = {
#     'username':'jason',
#     1:'egon',
#     1.1:'kevin'
# }
# print(d4,type(d4))

#作用：存多个值,key-value存取，取值速度快

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


#优先掌握的操作：
#1、按key存取值：可存可取
d1 = {
    'username':'jason',
    'password':123,
    'hobby':['read', 'run']
}
# print(d1['username'])  # jason
# print(id(d1))
# d1['username'] = 'tony'
# print(id(d1))  # {'username': 'tony', 'password': 123, 'hobby': ['read', 'run']}
# 字典是可变类型
# 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']
# 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()的结果可以直接看成是列表
# 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)


# 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'''

# 第一种创建字典的方式
# 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']]
# ]
# # d = {}
# # for i in l:  # ['username','jason']     ['password',123]   ['hobby',['read','run']]
# #     d[i[0]] = i[1]  # d['username'] = 'jason'
# # print(d)
#
# # d = {}
# # for k,v in l:  # ['username','jason']     ['password',123]   ['hobby',['read','run']]
# #     d[k] = v
# # print(d)
# res = dict(l)
# print(res)  # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run']}


# dict.clear()  清空
# d1.clear()
# print(d1)


# dict.fromkeys()  快速先生成一个字典
# l = ['username','pwd','hobby']
# res = dict.fromkeys(l,None)
# print(res)

# dict.popitem()
# res = d1.popitem()  # 随机弹出一组键值对
# print(d1)
# print(res)  # ('hobby', ['read', 'run'])

# dict.setdefault()  重点
# dd = {'name':'jason','pwd':123}
# dd.setdefault('age',18)  # 键不存在 则新建
# res = dd.setdefault('name','egonSBSBSB')  # 键存在不修改 而是获取到键对应的值
# print(dd,res)  # {'name': 'jason', 'pwd': 123, 'age': 18} jason

# dict.update()
# dd = {'name':'jason','pwd':123}
# dd.update({'age':18})  # 键不存在 则新建
# dd.update({'name':'EGONDSB'})  # 键存在则修改
# print(dd)
# # 还不如使用下列方式
# dd['age'] = 18
# dd['name'] = 'jason'

3元组

小括号括起来 括号内可以存放多个元素
元素与元素之间逗号隔开 元素可以是任意类型
    元组也可以简单的理解为是列表

    元组属于不可变类型
"""
# 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)
# # 问:上述代码执行的结果是什么
# print(t2)  # (11, 22, [11, 22, 33])
#2、切片(顾头不顾尾，步长)
# 与字符串 列表一致
#3、长度
# len()
#4、成员运算in和not in
# 与列表一致

#5、循环
# for i in (11,22,33):
#     print(i)

4集合

"""
大括号括起来 内部可以存放多个元素
元素与元素之间逗号隔开(不是k:v键值对)  元素只能是不可变类型(整型 浮点型 字符串 元组)
    s = {1,2,3,4}

    只有两种情况才会考虑使用集合
        1.关系运算
            两个群体之间判断 交叉并集
                共同好友 共同关注 共同点赞...
        2.去重操作
            去除重复的元素
"""
# 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)}
# 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)
# '''集合内默认不能出现重复的元素 如果出现了会自动去重'''
# r1 = {11,22,22,22,11,44,44,44}
# print(r1)

5关系运算

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'}

# 父集 子集
"""
父级: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

6作业

1.整理今日内容至自己博客
2.字典练习题
    1.将列表中大于等于66的元素放入字典k1键对应的列表中
    	将列表中小于66的元素放入字典k2键对应的列表中
        nums=[11,22,33,44,55,66,77,88,99,90]
        dic={
            'k1':[],
            'k2':[]
        }
    2.s='hello jason jason say hello sb sb sb'
		统计字符串中每个单词出现的次数
        	{'jason':2,...}

7.集合练习题

　一.关系运算
      有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
      pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
      linuxs={'wupeiqi','oldboy','gangdan'}
      1. 求出即报名python又报名linux课程的学员名字集合
      2. 求出所有报名的学生名字集合
      3. 求出只报名python课程的学员名字
      4. 求出没有同时这两门课程的学员名字集合
      二 去重并且保留原来的顺序
    	l = [11,22,33,22,22,33,11,22,55,66,66,77,77]
        1.去重不保留顺序
        2.去重并且保留顺序