入门 N day
元组
元组是容器型数据类型，将()作为容器的标志，
不可变的(不支持增、删、改)
里面多个元素用逗号隔开：(元素1,元素2,元素3…)
元素可以是任何类型的数据，并且可以重复
t1 = (10, 11, 12, '123', 'abc')
print(type(t1), t1)
只有一个元素的元组(元素，)
如果一个元组中有且只有一个元素，那么唯一的元素后面必须加逗号
t2 = (1)
t3 = (1,)
print(t2, type(t2)) # 1 <class 'int'> 不是元组类型
print(t3, type(t3)) # (1,) <class 'tuple'> 元组类型
空元组
t4 = ()
print(t4, type(t4)) # () <class 'tuple'>
省略括号
在没有歧义的情况下，可以省略元组的(),直接将多个元素将逗号隔开来表示一个元组
t5 = 1, 3, 5, 1, 5
print(t5, type(t5)) # (1, 3, 5, 1, 5) <class 'tuple'>
# 获取元素:列表获取元素的方法元组都支持
#例如遍历和切片：
```python
t6 = (1, 3, 5, 4)
for i in t6:
print(i)
print(t6[-1], t6[2])
print(t6[:])
让变量的个数和元组中元素的个数保持一致，来获取元组中所有元素的值
变量1，变量2，变量3…=元组
t7 = (1, 2, 3, 4, 5, 6)
a, b, c, d, e, f = t7
print(a, b, c, d, e, f) # 1 2 3 4 5 6
'''
a, b, c, d=t7
print(a, b, c, d) #ValueError: too many values to unpack (expected 4)
a, b, c, d, e, f,g = t7
print(a, b, c, d, e, f,g) # ValueError: not enough values
to unpack (expected 7, got 6)
同时用多个变量获取元组元素的时候，变量的个数可以比元组中元素的个数少
但是必须有且只有一个变量前有*
nums = (1, 3, 5, 7, 6, 5)
a, b, c, *d = nums
print(a, b, c, *d) # 1 3 5 7 6 5
print(*d) # 7 6 5
*a, b, c = nums
print(*a) # 1 3 5 7
print(b) # 6
print(c) # 5
a, *b, c = nums
print(a) # 1
print(*b) # 3 5 7 6
print(c) # 5
'''
# 多个变量前面有*会报错
*a,*b,c,d=nums
print(*a,*b,c,d) # TypeError: print() argument after * must
be an iterable, not int
对元组排序过后产生的是一个新列表
nums2 = (1, 3, 5, 7, 1, 3, 5)
new_nums2 = sorted(nums2)
print(new_nums2) # [1, 1, 3, 3, 5, 5, 7]
list1=[1, 1, 3, 3, 5, 5, 7]
print(tuple(list1)) # (1, 1, 3, 3, 5, 5, 7)
print(tuple('abc')) # ('a', 'b', 'c')
print(tuple(range(1, 5))) # (1, 2, 3, 4)
字典
‘’’
作用：用来保存多个意义不同的数据就使用字典
字典是容器型数据类型，将{}作为容器的标志，里面多个元素用逗号隔开（元素必须是键值对）
{键1:值1,键2:值2,…}
特点：可变的，支持增删改查（不支持下标操作）
字典的是无序的
元素：必须是键值对
键：必须是不可变的数据（数字，字符串，元组）一般使用字符串、
键是用来进行区分和描述的，唯一的
值：没有要求
stu = {
"姓名": "小明", '成绩': 15, '性别': '男', '年龄': 15}
print(stu['成绩']) # 15
print(stu)
空字典
d1 = {
}
print(type(d1)) # <class 'dict'>
键是不可变的
d1 = {
10: 10, 'x': 11, (1, 2): 15}
print(d1)
d1 = {
10: 10, 'x': 11, [1, 2]: 15} TypeError: unhashable type: 'list'
键是唯一的
d1 = {
10: 10, 'x': 11, (1, 2): 15, 10: 1}
print(d1) # 出现多个相同的键，打印结果只会显示其中一个 {10: 1, 'x': 11, (1, 2): 15}
判断是否有序
print({
10: 10, 'x': 11} == {
'x': 11, 10: 10}) # 字典 True 无序的
print([10, 'x', 11] == ['x', 11, 10]) # 列表为False有序的
字典的增删改查
‘’’
查：获取单个值
字典[key] 获取指定key对应的值 如果获取的值不存在则会报错
字典.get(key) 获取指定key对应的值 如果获取的值不存在则会返回None
字典.get(key,value) 获取指定key对应的值 ,如果获取的值不存在则会返回value
dog = {
'name': '旺财', 'age': '2', 'sex': '母狗', 'breed': '土狗'}
print(dog['age'], dog['name']) # 2 旺财
print(dog.get('age')) # 2
print(dog.get('weight')) # None
print(dog.get('weight', 'gong')) # gong
遍历 键值对离开了字典无效
dog = {
'name': '旺财', 'age': '2', 'sex': '母', 'breed': '土狗'}
for i in dog:
print(i) # 'name' 'age' 'sex' 'breed'
print(dog[i]) # 旺财 2 母 土狗
增和改
‘’’
字典[key]= 值 当key存在就是修改指定key对应的值：当key不存在就是添加键值对
‘’’
dog = {
'name': '旺财', 'age': '2', 'sex': '母', 'breed': '土狗'}
dog['name'] = '小黑' # 修改‘name’的值
dog['weight'] = '12' # 增加‘weight’：‘12’
print(dog) # {'name': '小黑', 'age': '2', 'sex': '母',
# 'breed': '土狗', 'weight': '12'}
删
‘’’
del 字典[key] 删除指定key对应的键值对
字典.pop(key) 取出指定key对应的值
‘’’
dog = {
'name': '旺财', 'age': '2', 'sex': '母', 'breed': '土狗'}
del dog['breed']
del_name = dog.pop('name')
print(dog) # {'age': '2', 'sex': '母'}
print(del_name) # 旺财
定义一个变量保存一个班级的信息，班级信息主要包含：班主任，讲师，班级名称，
位置，容量，所有学生
class_python = {
'class_name': "python_2004", '位置': "肖家河", "容量": '42',
'班主任': {
"姓名": '张老师', '性别': '女', 'age': '18', '电话': '123456',
'qq': '123456'},
'讲师': {
"姓名": '余老师', '性别': '女', 'age': '18', '电话': '123456',
'qq': '123456', '级别': 'x'},
'学生':
{
'学生1': {
'性别': '男', '年龄': 24, "学历": '大专', "专业": '计算机',
'电话': '123456'},
'学生2': {
'性别': '男', '年龄': 23, "学历": '大专', "专业": '计算机',
'电话': '123456'},
'学生3': {
'性别': '男', '年龄': 24, "学历": '大专', "专业": '计算机',
'电话': '123456'},
'学生4': {
'性别': '男', '年龄': 21, "学历": '大专', "专业": '计算机',
'电话': '123456'},
'学生5': {
'性别': '男', '年龄': 20, "学历": '大专', "专业": '计算机',
'电话': '123456'}}
}
print(class_python)
# 获取班主任的名字
t_name = class_python['班主任']["姓名"]
print(t_name)
字典不支持加法、乘法运算，也不支持比较大小
‘’’
in 和 not in 判断字典中是否存在指定的key
key in 字典 判断字典中是否存在指定的键
‘’’
d1 = {
'a': 10, 'b': 12, 'c': 30}
print(10 in d1) # False
print('a' in d1) # True
# 相关函数：len
print(len(d1)) # 获取长度 3
字典的类型转换
dict(数据) :将指定数据转换成字典
要求：
数据本身是序列，序列中的元素必须是长度为2的小序列
小序列中的第一个元素是不可变的数据
list(字典) 将指定字典转换成列表(将字典的key作为列表的元素)
list1 = [(1, 2), [3, 4], 'ab']
print(dict(list1)) # {1: 2, 3: 4, 'a': 'b'}
dict1 = {
1: 1, 2: 3, 4: 5}
print(list(dict1)) # [1, 2, 4]
相关方法
‘’’
字典.clear()
‘’’
d1 = {
'a': 10, 'b': 20, 'c': 30}
d1.clear()
print(d1) # {} 清空
赋值空字典 效率很低不建议使用
d2 = {
'a': 10, 'b': 20, 'c': 30}
d2 = {
}
print(d2) # {}
字典.copy() 复制字典产生一个一模一样的新字典并且返回
d1 = {
'a': 10, 'b': 20, 'c': 30}
d2 = d1
print(d2) # {'a': 10, 'b': 20, 'c': 30},将d1赋值给d2,如果修改d2，会影响d1
print(id(d1), id(d2)) # 4728616 4728616 地址相同
d3 = d1.copy()
print(d3) # {'a': 10, 'b': 20, 'c': 30} 复制一个d3,修改d3不会影响d1
print(id(d1), id(d3)) # 5777192 5778232 地址不同
dict.fromkeys(序列) 创建一个新的字典，键是序列中的每一个元素，值都是None
print(dict.fromkeys('addada')) # {'a': None, 'd': None}
去除重复元素
nums = [1, 1, 1, 2, 3, 5, 5, 5, 3]
nums2 =list(dict.fromkeys(nums))
print(nums2) # [1, 2, 3, 5 ]
print(dict.fromkeys('ab', 1)) # {'a': 1, 'b': 1}
print(dict.fromkeys('ab', [1, 2, 2])) # {'a': [1, 2, 2], 'b': [1, 2, 2]
字典.keys() 获取字典所有的key（返回值是序列，但不是列表）
字典.values() 获取字典所有的值（返回值是序列，但不是列表）
d1={
'a': 1, 'b': 1}
print(d1.keys()) # dict_keys(['a', 'b'])
print(d1.values()) # dict_values([1, 1])
print(d1.items()) # dict_items([('a', 1), ('b', 1)])
字典.setdefault(键，值) 在字典中添加键值对（只添加不修改）
d1={
'a': 1, 'b': 1}
d1.setdefault('c',1)
print(d1) # {'a': 1, 'b': 1, 'c': 1}
d1.setdefault('c',3)
print(d1) # {'a': 1, 'b': 1, 'c': 1}
字典1.update(字典2) 将字典2 中所有的键值对都添加到字典1中
字典2不一定是字典，也可以是能转化成字典的序列
d1={
'a': 1, 'b': 1}
d2={
'c': 1, 'd': 1}
d1.update(d2)
print(d1) # {'a': 1, 'b': 1, 'c': 1, 'd': 1}