字典，元组，集合

今日内容详细
利用列表实现队列与堆栈的特征
队列
先进先出
堆栈
先进后出

需求:使用列表模拟出上述两个概念的特征

队列 先进先出

'''先进去的元素 先出来'''

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 = []
字典内置方法
"""
大括号括起来 内部可以存放多个元素
元素的表现形式是以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)) #

字典是可变类型

print(d1['age']) # 键不存在 直接报错!!!

d1['age'] = 18 # 键存在则修改 不存在则新建

print(d1) #

​

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

'''字典不能使用索引!!!'''

res = d1.pop('password')

print(d1) #

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

第三种创建方式

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

​
​

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 =

dd.setdefault('age',18) # 键不存在 则新建

res = dd.setdefault('name','egonSBSBSB') # 键存在不修改 而是获取到键对应的值

print(dd,res) # {'name': 'jason', 'pwd': 123, 'age': 18} jason

​

dict.update()

dd =

dd.update({'age':18}) # 键不存在 则新建

dd.update({'name':'EGONDSB'}) # 键存在则修改

print(dd)

# 还不如使用下列方式

dd['age'] = 18

dd['name'] = 'jason'

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

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)

​
集合
"""
大括号括起来 内部可以存放多个元素
元素与元素之间逗号隔开(不是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 =

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 =

print(r1)

​
​
​
​

关系运算

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