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

1.队列(先进先出)
l = []

l.append(111)
l.append(222)
l.append(333)

print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

2.堆栈(先进后出)
l = []

l.append(111)
l.append(222)
l.append(333)

print(l.pop())
print(l.pop())
print(l.pop())

字典以及它的内置方法

大括号括起来，内部可以存放多个元素
元素的表现形式是以K:V键值对形式
    K是对V的描述性信息，一般都是字符串
    	K不可变类型，且不能重复
        	整型，浮点型，字符串
        V可以是任意类型

d1 = {
    'username':'jason',
    'password':123,
    'hobby':['read','run']
}

K只要是不可变类型即可，同一个字典内可以混用

1.按key存取值：可存可取
d1['username'] = 'tony'
print(d1['age'])  # 键不存在 直接报错！！！
d1['age'] = 18  # 键存在则修改 不存在则新建

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

3.成员运算in和not in
print('jason' in d1)  # Flase
字典默认只暴露key，value不暴露，如果想取，一般只能通过key

4.删除
del d1['password']  # 键值对一起删除
d1.pop('password')  # 字典不能用索引
res = d1.pop('password')  # 123  pop弹出value

5.键keys(),值values(),键值对items()
print(d1.keys())  # 获取字典中所有的key，输出的可以看成是列表
print(d1.values())  # 获取字典中所有的value，输出的可以看成是列表
print(d1.items())  # 将items()的结果可以直接看成列表[]套小列表()

for k,v in d1.items():  # 解压赋值，结合for循环
    print(k,v)
    
6.循环
'''字典for循环只能获取到key'''
for i in d1:
    print(i)

字典常用的操作方法

第一种创建字典的方式
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:  # for循环输出每个列表
    d[i[0]] = i[1]  # d['username'] = 'jason'
# 用 键存在则修改，键不存在则新建 的理论，直接全部套进字典

# 换一种用法
d = {}  
for k,v in l:  
    d[k] = v
    
# 再换一种 最精简方法
res = dict(l)



d1 = {
    'username':'jason',
    'password':123,
    'hobby':['read','run']
}

1.dict.get()  # 使用频率最为广泛
print(d1.get('key值'))  返回value值
# 好处：get方法不存在也不会报错 返回None(什么都没有)
print(d1.get('username','嘿嘿嘿'))  # 输出 jason
print(d1.get('age','嘿嘿嘿'))  # 输出 嘿嘿嘿
'''get方法还可以给第二个参数 键存在则不使用 键不存在则返回第二个参数'''

2.dict.clear()
d1.clear()  # 清空列表

3.dict.fromkeys()  # 快速生成一个字典
l = ['username', 'age', 'hobby']
res = dict.fromkeys(l,123)
print(res)  # 输出 {'username': 123, 'age': 123, 'hobby': 123}

4.dict.popitem()  # 弹出一组键值对
d1.popitem()
print(d1)  # 输出 {'username': 'jason', 'password': 123}

res = d1.popitem()
print(res)  # 输出 ('hobby', ['read', 'run'])

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

6.dict.update()  # 可有可无
dd = {'name': 'jason', 'pwd': 123}
dd.update({'age': 18})  # 键不存在，则新建
dd.update({'name': 'egon'})  # 键存在，则修改
print(dd)  # 输出 {'name': 'egon', 'pwd': 123, 'age': 18}

# 完全等于↓ 
dd['age'] = 18
dd['name'] = 'egon'

元组及元组内置方法

'''
元组  tuple
小括号括起来 括号内可以存放多个元素
元素与元素之间逗号隔开 元素可以是任意类型
	元组也可以简单地理解为是列表
	
	元组属于不可变类型
'''
# 类型转换与list一致，支持for循环的都可以

# 元组当内部只有一个元素的时候，逗号不能省略
t1 = (1)
print(type(t1))  # 输出 int
t2 = ('a')
print(type(t2))  # 输出 str

t1 = (1,)
print(type(t1))  # 输出 tuple
t2 = ('a',)
print(type(t2))  # 输出 tuple

元组优先要掌握的操作

1.按索引取值(正向取+反向取)：只能取
t1 = (11, 22, 33)
t1[0] = 666
print(t1)  # 报错，因为元组内存地址不能修改

t1 = (11, 22, [11, 22])
t1[2].append(33)
print(t1)  # 输出t1 = (11, 22, [11, 22, 33]) 
# 如果元素是可变类型，那么元素值可以改

2.切片(顾头不顾尾，步长)
# 与字符串，列表一致

3.长度
len()

4.成员运算in和not in
# 与列表一致

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

集合（用的不多）

'''
集合 set
大括号括起来，内部可以存放多个元素
元素与元素之间逗号隔开(不是k:v键值对)，元素只能是不可变类型

只有两种情况才会考虑使用集合，其他情况不要使用
	1.关系运算
		两个群体之间判断 交叉并集
	2.去重操作  # 集合天生去重，不保留顺序
		去除重复的元素
'''
# 定义空集合，需要使用关键字set
se = set()

集合操作方法

# 关系运算
a = {1,2,3,4,5,6,7,8}
b = {2,4,6,8,10}

如何求交集
>>> a.intersection(b)
>>> a & b  # a和b共同拥有的
如何求差集
>>> a.difference(b)
>>> a - b  # a相对b独有的
>>> b - a  # b相对a独有的
如何求并集
>>> a.union(b)
>>> a | b  # a和b所有拥有的
如何求对称差集
>>> a.symmetric.(b)
>>> a ^ b  # a和b都相对独有的

# 父集，子集
'''
a包含b
a是b的父集，b是a的子集
'''