七、Python基础之元组、字典

一、元组 tuple

1.1 元组基本定义

  • 特点：元组是要给不可变序列，一旦数据定义好之后，数据就不能更改了。
  • 注意：元组是不可变序列，而列表是一个可变序列。
  • 使用场景:
    通常我们不希望数据被修改时，固定格式，被经常使用的数据时使用元组。

1.2元组的使用：

tuple1 = (1,2,3,4,5,True)
print(tuple1,type(tuple1))
----------输出----------
(1, 2, 4, 5, True) <class 'tuple'>

1.3 元组的特性

1） 元组本身数据时不可变的，但是我们可以 通过切片来取值。其数据结构依然没有发生改变。

tuple4 = (1, 2, 5, 'a', 'b', 'c', 'd')
list4 = [1, 2, 5, 'a', 'b', 'c', 'd']
print(list4[1:3])
print(tuple4[1:3])   #切片取值，左闭右开区间，取值不包含结束位置的值
print(tuple4)
------------输出-------------
[2, 5]
(2, 5)
(1, 2, 5, 'a', 'b', 'c', 'd')

2）空元组

tuple2 = ()
print(type(tuple2))
<class 'tuple'>

3）如果创建的不是一个空元组，里面至少包含一个","(逗号); 且当元组中只有一个变量赋值时，括号可以省略。

tuple3 = (10,)
tuple4 = 10,
tuple5 = 10, 20  # 一个变量赋值
print(tuple3,tuple4, tuple5)
print(type(tuple4))
print(type(tuple5))
-----------输出----------
(10,) (10,) (10, 20)
<class 'tuple'>
<class 'tuple'>

如果元组是多个变量赋值呢 ？括号还可以省略吗 ？

tuple5, tuple6 = 10, 20
print(type(tuple5),type(tuple6))
----------输出-------------
<class 'int'> <class 'int'>

所以：多次变量赋值时，类型变成了 int 了，这个时候括号是不可以省略的。因为做多个变量的赋值时，涉及到元组拆包的概念。

1.4 元组的拆包

1.赋值要和元组内的数据一一对应

tuple5 = (1, 3, 5, 7)
a, b = tuple5
a,b,c,d = tuple5
print(a,b)
print(a,b,c,d)
------------输出----------
a,b = tuple5 报错：ValueError: too many values to unpack (expected 2)
a,b,c,d = tuple5 : 1 3 4 5

2.元组中有多个数据时，我们可以使用 * 号匹配，但是不能同时出现2个或2个以上的 * 号

tuple5 = (1, 3, 5, 7)
a, *b = tuple5
a, b, *c = tuple5
*a, *b, c = tuple5  # 同时出现2个*  报错
print(a,b)
-----------输出-----------
1 [3, 4, 5]
1 3 [4, 5]

总结: 元组最大的特点是不可变序列，因此没有多少增删改等操作。

二、 字典 dict <重点>

2.1 字典的基本介绍

  • 字典属于一种新的数据结构称为映射，mapping。
  • 采用键值对 key: value 存储形式。
  • 字典同列表的作用类似，都是存储对象的容器。
  • 字典中每一个元素都有一个唯一名字，通过这个唯一名字可以找到指定的元素。
  • 每个字典都可以有多个键值对，而每一个键值对我们称为是一个 item ，项。
  • 使用 {} 大括号创建字典，{key: value} ,多个键值对之间使用 逗号分隔。

2.2 创建字典

1.空字典

dict1 = {}
print(type(dict1))
-----------输出-----------
<class 'dict'>

2.创建字典

方式一：
dict2 = {"ci": "jenkins", "cd": "k8s"}
方式二：
dict3 = dict(ci='jenkins', cd='k8s')  # dict 类转换
方式三：
dict4 = dict([('ci', 'jenkins'), ('cd','k8s')]) # dict类转换，列表包裹元组的方式。
print(dict2, dict3, dict4)
-----------输出-----------
{'ci': 'jenkins', 'cd': 'k8s'} {'ci': 'jenkins', 'cd': 'k8s'} {'ci': 'jenkins', 'cd': 'k8s'}

3.当有相同的key 名称是，后面的键值对会把前面的覆盖掉。

dict4 = {"ci": "jenkins", "cd": "k8s", "ci": "gitlab-ci"}
print(dict4)
-----------输出-----------
{'ci': 'gitlab-ci', 'cd': 'k8s'}

4.通常我们使用更容易理解的格式来展示数据

dict6 = {
    "name": "晓鸥",
    "age": 18,
    "gender": "男",
    "hobby": "足球",
    "school": "星洲二小"
}

2.3 使用字典

1.字典取值

dict2 = {"ci": "jenkins", "cd": "k8s"}
print(dict2['ci'])
----------输出----------
jenkins

2.查询 dict.get()
当使用get 查询不存在的key 的时候，不会报错，会返回一个None。

print(dict6.get('age'))
18
print(dict6.sex('sex'))  # 查询不存在的key 时，返回None
None
print(dict6['sex'])    # 这种方式查询不存在的key 时，直接报错
    print(dict7['sex'])
KeyError: 'sex'

3.修改

直接修改方式：
dict6['name'] = '萧何'
print(dict6['name'])
----------输出----------
萧何

添加的方式：
dict6.setdefault('home', '滨江')
print(dict6)
{'name': '萧何', 'age': 18, 'gender': '男', 'hobby': '足球', 'school': '星洲二小', 'home': '滨江'}

4.更新操作 update()
将其他字段的 key-value添加到当前字典中

dict7 = {"code": 98}
dict6.update(dict7)
print(dict6)
{'name': '萧何', 'age': 18, 'gender': '男', 'hobby': '足球', 'school': '星洲二小', 'home': '滨江', '成绩': 98}

5.del : 删除字典中的 key-value

del dict6['school']
print(dict6)
{'name': '萧何', 'age': 18, 'gender': '男', 'hobby': '足球', 'home': '滨江', '成绩': 98}

6.dict.popitem()
删除字典中的最后一个key-value ，并返回删除的这个值

res = dict6.popitem()
print(res)
('成绩', 98)
  1. pop(key,[default])
    根据key 删除相应的value，当删除的key 不存在时，可以自定义返回值
res = dict6.pop(2, '删除的值不存在')
print(res)
删除的值不存在

8.dict.clear() 清空字典

dict6.clear()
print(dict6)
{}

三、练习

** a = {“name”:“123”, “data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到 python1/python2/python3
分析：逐步拆分，整体上看是一个字典，但是中间嵌套有列表。因此可以取出列表后，索引取值，再依次取出src 的值。**

a = {"name":"123", "data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
i = 0
while  i < 3:
    print((a['data']['result'])[i]['src'])
    i += 1
python1
python2
python3

有如下值列表 [11,22,33,44,55,66,77,88,99,90], 将多有大于66 的值保存至字典的第一个key 的值中，将小于66 值保存至第二个key 中的值。
思路：
a. 首先可以用for 循环加 if 判断，i >66 和 i < 66 两种情况；
b. 大于小小于66的数都有多个，因此 字典里面的2个 value 肯定是一个 列表最好。
c. 通过判断取值后，使用 list.append() 列表追加方式更新列表
d. 最后分别将2个列表的值 替换字典中的 value.

list = [11,22,33,44,55,66,77,88,99,90]
dict1 = {"big":[],"small":[]}
list2 = []
list3 = []
for i in list:
    if i > 66:
        list2.append(i)
        # print(list2)
        dict1["big"] = list2
        # print(dict1)
    elif i < 66:
        list3.append(i)
        dict1["small"] = list3
print(dict1)
-------------输出---------------
{'big': [77, 88, 99, 90], 'small': [11, 22, 33, 44, 55]}

给 用户9次机会猜1-10 个数字，随机来猜测数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误，最终结果要求用户怎么也猜不对。永远都猜不到，都更抽奖类似。
思路1：定义一个1-10 元素的列表，用户猜出一个数字，从列表中删除这个元素，猜完9次后，剩下一个数字即为答案。
思路2: 定义一个 [] ， 利用 list.append()，用户猜出一个数字，就往里面添加一个数字。当猜完9次后，对比1-10 ，最后哪一个没有猜出的就取出，告知答案。
方法一：

list1 = [1,2,3,4,5,6,7,8,9,10]
i = 1
while i < 10:
    num = int(input("请输入一个1-10的数字:"))
    print("对不起，输入错误")
    list1.remove(num)
    i += 1
print('正确答案是%s' % list1[0])

现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中。每个办公室至少有一位老师。

import random
classroom = [[],[],[]]
# teachers = random.randint(1,9)
teachers = list(range(1, 9))
for i in teachers:
    index = random.randint(0,2) # 随机函数生成办公室的索引下标
    classroom[index].append(i)  # 通过append()追加方式将老师分配到办公室列表中
print(classroom)

# 定义3个办公室的编号 j
# 定义分配后的每个办公室的老师 t
j = 0
for t in  classroom:
    j += 1
    print('第%d个办公室有%d个人,分别是：' % (j, len(t)), end=' ')
    for k in t:
        print(k, end='\t')
    print('\n')
------------------------演示结果-------------------------
第1个办公室有5个人,分别是： 2   3   4   7   8   

第2个办公室有2个人,分别是： 1   5   

第3个办公室有1个人,分别是： 6