Day 07 字典、元组及集合的内置方法

今日内容概要

• 利用列表实现队列与堆栈的特征
• 字典内置方法
• 元组及元组内置方法
• 集合及集合内置方法
• 作业

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

队列

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

eg.

list = []
# 添加元素
list.append(111) 
print(list)
>>>[111]
list.append(222)  
print(list)
>>>[111, 222]
list.append(333)
print(list)
>>>[111, 222, 333]
# 取出元素
print(list.pop(0), list)  #按索引0弹出
>>>111 [222, 333]
print(list.pop(0), list)
>>>222 [333]
print(list.pop(0), list) 
>>>333 []

堆栈

先进后出，先进去的元素后出来

eg.

list = []
# 添加元素
list.append(111)  
print(list)
>>>[111]
list.append(222) 
print(list)
>>>[111, 222]
list.append(333)
print(list)
>>>[111, 222, 333]
# 取出元素
print(list.pop(), list)  # 尾部弹出
>>>333 [111, 222]
print(list.pop(), list) 
>>>222 [111]
print(list.pop(), list)
>>>111 []

字典内置方法

概念

大括号括起来，内部可以存放多个元素

元素的表现形式是以K:V键值对形式

K是对V的描述性信息，一般都是字符串

定义

在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型

eg.

info={'name':'koala,'age':18,'gender':'female'}  # 本质上等于info=dict(name='koala',age=18,gender='female')

类型转换

eg.

# 列表
info=dict([['name','koala'],('age',18)])
print(info)
>>>{'name': 'koala', 'age': 18}
# fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
info = {}
print({}.fromkeys(('name','age','gender'),None))
>>>{'name': None, 'age': None, 'gender': None}

操作方法

1. 按key取值

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
print(d1['name'])  # 按key取值
>>>koala
d1['name'] = 'yugali'  # key存在会修改
print(d1['name'])
>>>yugali
print(d1['gender'])  # key不存在就报错
>>>报错
d1['gender'] = 'female'  # key存在则修改 不存在则新建
print(d1)
>>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee'], 'gender': 'female'}

2. len 统计字典中键值对的个数

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}  
print(len(d1))
>>>3

3. 成员运算in和not in

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}  
print('koala' in d1)  # 字典默认只暴露key value不暴露 如果想取 一般只能通过key
>>>False
print('name' in d1)
>>>True

4. 删除

eg.1 del

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
del d1['age']
print(d1)
>>>{'name': 'koala', 'hobbies': ['shopping', 'coffee']}

eg.2 pop

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
res = d1.pop('age')
print(d1)  
>>>{'name': 'koala', 'hobbies': ['shopping', 'coffee']}
print(res)
>>>18

字典不能使用索引

5.键keys()，值values()，键值对items()

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
print(d1.keys())
>>>dict_keys(['name', 'age', 'hobbies'])  # 获取字典的key，将keys()的结果可以直接看成是列表
print(d1.values())
>>>dict_values(['koala', 18, ['shopping', 'coffee']])  # 获取字典里的值，将values()的结果可以直接看成是列表
print(d1.items())
>>>dict_items([('name', 'koala'), ('age', 18), ('hobbies', ['shopping', 'coffee'])])  # 将items()的结果可以直接看成是列表[]套小列表()

6. for 循环

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
for i in d1:
    print(i)  # 字典for循环只能获取到key
>>>name
   age
   hobbies

7. get

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
# dict.get()  # 使用频率最为广泛   通过字典的key获取字典的value
print(d1.get('name'))
>>>koala
print(d1['name'])  # 也可以，但是low
>>>koala
print(d1['gender'])  # key 不存在就报错
>>>报错
print(d1.get('gender')) # get方法key不存在也不会报错 返回None(什么都没有)
>>>None
print(d1.get('name','yugali'))  # key存在则取值，不会修改
>>>koala
print(d1.get('gender','female'))  # key不存在则取给的值，但不会添加进字典
>>>female

8. clear 清空

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
d1.clear()
print(d1)
>>>{}

9. **dict.fromkeys() ** 快速生成一个列表

   eg.

   l = ['name','age','hobby']
   res = dict.fromkeys(l,None)
   print(res)
   >>>{'name': None, 'age': None, 'hobby': None}
   

10. popitem() 随机弹出一组键值对

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
res = d1.popitem() 
print(d1)
>>>{'name': 'koala', 'age': 18}
print(res)
>>>('hobbies', ['shopping', 'coffee'])

11. setdefault()

    eg.

    d1 = {
        'name': 'koala',
        'age': 18,
        'hobbies': ['shopping', 'coffee']
    }
    d1.setdefault('gender','female')  # 键不存在 则新建
    print(d1)
    >>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee'], 'gender': 'female'}
    res = d1.setdefault('name','yugali')  # 键存在不修改 而是获取到键对应的值
    print(d1,res) 
    >>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee']}   koala
    

12. update()

eg.

d1 = {
    'name': 'koala',
    'age': 18,
    'hobbies': ['shopping', 'coffee']
}
d1.update({'gender':'female'})  # 键不存在 则新建
print(d1)
>>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee'], 'gender': 'female'}
d1.update({'name':'yugali'})  # 键存在则修改
print(d1)
>>>{'name': 'yugali', 'age': 18, 'hobbies': ['shopping', 'coffee']}

这种方式一般不用

字典的三种创建方式

直接写

eg.

d2 = {'k1':'v1','k2':'v2'}  # 等价于 dict({'k1':'v1','k2':'v2'}）

指名道姓的方式，key = value, 关键字的方式

eg.

res = dict(name='koala',age=123,hobbies=['shopping', 'coffee'])
print(res) 
>>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee']}

eg.

K:V 赋值的方法

# 将l1转为字典
l = [
    ['name','koala'],
    ['age',18],
    ['hobbies',['shopping', 'coffee']]
]
d = {}
for k,v in l: 
    d[k] = v  # key存在，则修改，不存在则新建
print(d)
>>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee']}
# 等价于以下方式
res = dict(l)
print(res)
>>>{'name': 'koala', 'age': 18, 'hobbies': ['shopping', 'coffee']}

元组 tuple

概念

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

元组是不可变的列表

定义

eg.

t1 = (1,2,3,4,5,6)
print(type(t1)) 
>>>tuple

类型转换

eg.

# 元组当内部只有一个元素的时候 逗号不能省略
t1 = (1,)
print(type(t1))   
<class 'tuple'>
t2 = ('a',)
print(type(t2))  
<class 'tuple'>
l1 = [1,]
print(type(l1)
<class 'list'>    

类型转换 与list一致 支持for循环的都可以

以后只要是容器类型 无论内部有几个元素 都必须要有逗号，尤其是只有一个元素的情况下

操作方法

1. 按索引取值(正向取+反向取)

eg.

t1 = (11,22,33)
print(t1[0])  # 按索引取值
>>>11
t1[0] = 44  # 只能取不能改
print(t1)
>>>报错

2. 切片

t1 = (11, 22, 33)
print(t1[0: 2])
>>>(11, 22)

4. 长度 len

t1 = (11,22,33)
print(len(t1))
>>>3

与列表一致

5.成员运算in和not in

t1 = (11,22,33)
print(11 in t1)
>>>True
print(11 not in t1)
>>>False

6.循环

for i in (11,22,33):
    print(i)
>>> 11
    22
    33

集合

概念

大括号括起来 内部可以存放多个元素，元素与元素之间逗号隔开(不是k:v键值对) 元素只能是不可变类型(整型 浮点型 字符串 元组)

定义

定义空集合 需要使用关键字set

1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

类型转换

但凡能被for循环的遍历的数据类型都可以传给set()转换成集合类型

遍历出的每一个值都必须为不可变类型

eg.

s = set([1,2,3,4])
print(s,type(s))
>>>{1, 2, 3, 4} <class 'set'>
s1 = set((1,2,3,4))
print(s1,type(s1))
>>>{1, 2, 3, 4} <class 'set'>
s2 = set({'name':'koala',})
print(s2,type(s2))
>>>{'name'} <class 'set'>
s3 = set('yugali')
print(s3,type(s3))
>>>{'g', 'a', 'l', 'u', 'y', 'i'} <class 'set'>

内置方法

1. 关系运算

eg.

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

2. 去重操作

   只能针对不可变类型

   集合本身是无序的，去重之后无法保留原来的顺序

eg.

l = [11,22,33,22,11,44,33,22,55,66,66,66]
# 将列表转换成集合
res = set(l)
print(res)
>>>{33, 66, 11, 44, 22, 55}  #集合内默认不能出现重复的元素 如果出现了会自动去重

3. len 长度

eg.

s = {1, 2, 3, 4, 5, 6}
print(len(s))
>>>6

4. 成员运算in & not in

eg.

s = {1, 2, 3, 4, 5, 6}
print(2 in s)
>>>Ture
print(2 not in s)
>>>False

eg. for 循环

s = {1, 2, 3, 4, 5, 6}
for item in s:
    print(item)
>>>1 2 3 4 5 6