2021-01-29

第七讲

元组

元组是一个不可变的序列，（元组内的数据是不可变话的，不可更改的）， 不希望数据发生改变的时候我们就用元组，其余的情况都用列表
元组的表达形式 （） tuple
tuple1 = (1, 2, 3, 4, 5)
print(tuple1, type(tuple1))
print(tuple1[2])
print(tuple1[2::])

如果元组不是一个空元祖，那么它必须得有一个逗号
tuple2 = 10,
tuple3 = (10)
print(tuple2, type(tuple2))
print(tuple3, type(tuple3))

拆包

拆包的时候如果有*， 那么有且只能有一个*, *接受参数之后，结果是用一个列表来放置的
tuple4 = (1, 2, 3, 4)
a, *b, c = tuple4
print(a, b, c)

字符串的拆包

a = ‘abcde’
b, *c = a
print(b, c)

列表的拆包

list1 = [1, 2, 3, 4, 5]
a, *b = list1
print(a, b)

…

字典的简介.

字典：mapping 映射关系 key:value 一个字典中, 每一个key都是唯一的，我们只需要通过key就可以查找到我们需要的数据， key-value我们称之为键值对，也可以称呼它为一项item

字典的创建（空） dict 用的符号是{}
dict1 = {}
print(dict1, type(dict1))

当字典中的key有重复的时候，后面的key-value会替换前面的
dict2 = {
‘name’: ‘郭靖’,
‘age’: 18,
‘sex’: ‘男’,
‘name’: ‘欧阳锋’,
‘skill’: ‘蛤蟆功’
}
print(dict2, type(dict2))

获取value， 直接用 dict[key]
print(dict2[‘skill’])
…

字典的使用（创建）.py

1. {}

2. 使用dict类去创建字典
   dict1 = dict(name=‘郭靖’, age=18, sex=‘男’)
   print(dict1, type(dict1))

3. 使用dict去创建
   python2 有序字典 orderdict 无序字典
   需要dict（）括号里的数据是属于一种双值子序列的形式
   双值序列 [1, 2]
   子序列 （‘a’）
   双值子序列： [(1, 2), (3, 4)]
   dict2 = dict([(‘name’, ‘郭靖’), (‘age’, 18), (‘sex’, ‘男’)])
   print(dict2, type(dict2))
   …

字典的增删改查.py

len()
dict1 = dict(name=‘郭靖’, age=18, sex=‘男’)
print(len(dict1))
in not in 检测的是key
print(‘name’ in dict1)
print(18 in dict1)

获取值得方式

使用key获取value dict[key] 如果不存在key则会报错
dict.get(key) 不存在key不会报错
print(dict1.get(‘skill’))

修改字典

dict[key] = value
dict1[‘name’] = ‘欧阳锋’
print(dict1)

dict.setdefault(key, [default]) 向字典中添加key-value
如果这个key已经存在于字典中，则返回value，不会对字典有影响, 如果不存在，则向字典中添加这个key，并设置value
result = dict1.setdefault(‘name’, ‘欧阳锋’)
result = dict1.setdefault(‘skill’, ‘降龙十八掌’)
print(result)
print(dict1)

dict.update() 将其他字典中的key—value添加到当前字典中
d1 = {‘1’: 1}
d2 = {‘2’: 2}
d1.update(d2)
print(d1)

dict1 = dict(name=‘郭靖’, age=18, sex=‘男’)

删除

del 关键字删除
del dict1[‘name’]
print(dict1)

dict.popitem() 随机删除一个键值对，一般都会删除最后一个, 有一个返回值，就是你删除的对象，结果是一个元组
result = dict1.popitem()
print(result)
print(dict1)

dict.pop(key，[default]) 根据key来删除键值对, 返回值就是你删除key对应的value
result = dict1.pop(‘sex’)
result = dict1.pop(‘skill’, ‘你删除的这个不存在’)
print(result)
print(dict1)

dict.clear（） 清空字典
dict1.clear()
print(dict1)

list1 = [1, 2, 3, 4, 5]
list1.clear()
print(list1)
…
@File : 浅拷贝和深拷贝.py

import copy

浅拷贝

做拷贝的对象必须是可变类型

dict1 = {‘1’: 1, ‘2’: 2, ‘list1’: [1, 2, 3, {‘name’: [12, 23]}]}
dict2 = {‘1’: 1, ‘2’: 2}
dict2 = copy.copy(dict1)
dict2 = dict1.copy()
print(id(dict1), id(dict2))
print(id(dict1[‘list1’]), id(dict2[‘list1’]))

深拷贝

dict3 = copy.deepcopy(dict1)
print(id(dict1), id(dict3))
print(id(dict1[‘list1’]), id(dict3[‘list1’]))

浅拷贝只能对第一层的数据进行拷贝，如果，第一层的数据也是个可变类型，那么浅拷贝无法将这个数据重新拷贝一份形成新的id

深拷贝则可以对所有的数据全部进行拷贝，形成一个新的id

dict1 = {}
list1 = [{‘name’: a}, {‘name’: a}, {‘name’: a}]
def fun():
a = input()
dict1.setdefault(‘name’, a)
…

字典的遍历

for i in list:
pass

通过key来遍历 dict.keys()
dict1 = dict(name=‘郭靖’, age=18, sex=‘男’)
for k in dict1.keys():
print(dict1[k])

通过value来遍历 dict.values()

for v in dict1.values():
print(v)

通过一项来进行遍历 dict.items()

for k, v in dict1.items():
print(k, ‘=’, v)

…

作业讲解.py

1. 现在有 a = [1,2,3,4,5,6] 用多种方式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程

切片的逆序

reverse（）
sort（）

2. 给 用户9次机会 猜1 - 10 个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对

创建一个1-10的列表
用户输入一个数字，你就删除一个数字，同时告诉他你猜错了，请重新输入，如果有输入的同样的数字，做判断
将删除9次的列表直接取值第一个，就是正确的数字
list1 = list(range(1, 11))
i = 1
while i < 10:
num = int(input(‘请输入1-10的数字：’))
print(‘对不起，您猜错了，请继续’)
list1.remove(num)
i += 1
print(‘正确答案是%s’ % list1[0])

创建一个空的列表，进行添加，最后在和1-10的列表进行比较，没有的那个就是正确答案

3. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素

for i in lst1:
if i in lst2:
print(i)

4. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中

1. 可以随机老师
2. 随机办公室
   创建一个列表装老师
   创建一个列表里面嵌套三个空列表，表示三个空的办公室
   遍历老师
   随机办公室
   讲遍历出来的老师添加到办公室中
3. 两个都随机
   import random
   teachers = [1, 2, 3, 4, 5, 6, 7, 8]
   offices = [[], [], []]
   for teacher in teachers:
   num = random.randint(0, 2)
   offices[num].append(teacher)

else:
print(offices)
…