python元组总结

1.什么是元组

元组就是不可变的列表

元组是容器型数据类型，将()作为容器的标志，里面多个元素用逗号隔开：（元素1，元素2，元素3…）

元组不可变（不支持元素的增删改查）：元组是有序的（支持下标操作）

元素：任何类型的数据，并且可以重复

t1 = (18, 23, 98, 10)
print(type(t1[1]), type(t1))

可以有空元组

t2 = ()

只有一个元素的元组:(元素)

如果一个元素中有且只有一个元素，那么唯一的元素后面必须加逗号。

t3 = (45,)

list1 = [23]
print(list1,type(list1))

t3 = (23)
print(t3, type(t3))

t4 = (23,)
print(t4, type(t4))

省略括号

#在没有歧义的情况下，可以省略元组的(),直接将多个元组用逗号各种来表示一个元组。

t5 = 'abc', 10, 100, True
print(type(t5), t5)
t6 = 10, 20, 30*2
print(t6)

获取元素

列表获取元素的方法元组都支持

song = ('葫芦娃', '海阔天空', '霸王别姬', '夜曲', '稻香')

for x in song:
    print('x', x)

for index, item in enumerate(song):
    print(index, item)

for index in range(len(song)):
    print(song[index])

让变量的个数和元组中元素的个数保持一致来获取元组所有元素的值

变量1,变量2,变量3,… = 元组

t7 = (10, 102, 32)
x, y, z = t7
print(x, y, z)   # 10 102 32

相当与

x, y, z = 10, 102, 32

m, n = t7 # ValueError: too many values to unpack (expected 2)

l, m, n, o = t7 # ValueError: not enough values to unpack (expected 4, got 3)

同时用多个变量获取元组元素的时候，变量的个数可以比元组中元素的个数要少，但是必须有且只有一个元素前面有*。

stu = ('小明', '男', 30, 50, 10, 180)

m1, m2, *m3 = stu
print(m1, m2, m3)

m1, *m2, m3 = stu
print(m1, m2, m3)

*m1, m2, m3 = stu
print(m1, m2, m3)

元组的函数操作和列表一模一样

定义一个变量保存一个学生的信息：姓名，性别，年龄，身高，体重，成绩

stu = ['小明', '男', '30', '177', '80', '78']
print(stu[0], stu[-1])

stu = {'姓名': '小明', "性别": '男', "age": '30', "身高": '177', "体重": '80', "成绩": '78'}
print(stu['姓名'])

1.什么使用字典?

同时保存多个意义不同的数据就使用字典

2.什么是字典(dict)?

字典是容器型数据类型，将{}作为容器的标志，里面多个元素用逗号隔开(元素必须是键值对):{键1:值1, 键2:值2, 键三:值3}

字典是可变的(支持增删改);字典是无序的(不支持下标操作)

元素:必须是键值对:

​ 键 - 必须是不可变的数据(数字，字符串，元组)，一般使用字符串；键是用来对值进行描述和区分的唯一的。

​ 值 - 没有要求

空字典

d1 = {}
print(type(d1))  # <class 'dict'>

键是不可变的

d2 = {'姓名': '小明', "性别": '男', (1, 2): 200}
print(d2)  #

报错：列表不能作为键 d3 = {‘姓名’:‘小明’, “性别”: ‘男’, [1, 2]: 200} # 列表可变，会报错。

键是唯一的

d3 = {‘姓名’: ‘小明’, “性别”: ‘男’, ‘姓名’: ‘小明’}
print(d3)

字典是无序的

证明；

print({'姓名': '小明', "性别": '男'} == {'性别': '男', "姓名": '小明'})
print((1, 1, 3) == (1, 3, 1))

=字典的增删改查=

查询

a.字典[key] - 获取指定key对应的值

b.字典。get(key) - 获取指定key对应的值

c.字典.get(key, 默认值) - 获取指定key对应的值(如果key不存在不会报错，返回指定的默认值)

dog = dict(name='菜菜', sex='母', age=8, bread='柯基')
print(dog['sex'])
print(dog.get('age'))
# print(dog['weight'])
print(dog.get('weight'))
print(dog.get('weight', '不存在'))

=遍历=

注意:变量依次取到的是字典key

for 变量 in 字典
pass

l1 = [1, 2, 3]
a = 1

键值对离开了字典无效 字典不能直接转换为列表

d1 = {'姓名': '小明', "性别": '男'}

b = '姓名' : '小明'

=增加,修改=

字典[key] = 值 - 当key存在就是修改指定key对应的值；当key不存在就是添加键值对

##### dog = dict(name='菜菜', sex='母', age=8, bread='柯基')

dog['name'] = '大黄'
dog['size'] = 'big'
print(dog)

\=删除=

del 字典[key] - 删除指定key对应的键值对

del dog['sex']
print(dog)
'''
dog.pop('name')
print(dog)
'''
del_name = dog.pop('name')
print(dog, del_name)

###### 练习：定义一个变量保存一个班级的信息，班级信息主要包含；班级名称，位置，班主任，讲师，所有学生

###### 班主任；姓名，性别，年龄，电话，qq

###### 讲师： 姓名，性别，年龄，电话，qq，级别

###### 所有学生：多个学生，每个学生：学号，姓名，性别，年龄，学历，专业，电话

dict_python = {
    '班级名称' : 'python2004',
    '位置' : '成都',
    'students':
        [
        {'name':'星', '性别':'男', '年龄':'20', '学历':'大学', '专业':'计算机', '电话':'123456'},
        {'name':'海', '性别':'女', '年龄':'18', '学历':'高中', '专业':'计算机', '电话':'123456'}
        ]}
print(dict_python['students'][1])

class1 = {
    'name': 'python2004',
    'location': '9教室',
    'capacity': 50,
    'class_teacher': {
        'name': '张老师',
        'gender': '女',
        'age': 30,
        'tel': '110',
        'qq': '7282233'
    },
    'teacher': {
        'name': '骆昊',
        'gender': '男',
        'age': 35,
        'tel': '172623283',
        'qq': '2828332',
        'rank': '特级讲师'
    },
    'students': [
        {'name': '小明', 'gender': '男', 'age': 19},
        {'name': '小花', 'gender': '女', 'age': 18},
        {'name': '张三', 'gender': '男', 'age': 23},
        {'name': 'Tom', 'gender': '男', 'age': 22},
        {'name': 'Bob', 'gender': '男', 'age': 30}
    ]
}

print

(class1)

获取班主任的名字

print(class1[‘class_teacher’][‘name’]) # 张老师

获取讲师的名字和级别

teacher = class1['teacher']
# print(teacher)
print(teacher['name'], teacher['rank'])

 计算班级所有学生的平均年龄

student_list = class1[‘students’]

print(student_list)

sum1 = 0
for x in student_list:

print(‘x:’, x)

###### print(x['age'])

​ sum1 += x[‘age’]
print(sum1/len(student_list)) # 22.4

2)字典的类型转换

dict(数据) - 将指定数据转换成字典，数据的要求：

​ a. 数据本身是序列

​ b. 序列中的每个元素必须是长度为2的小序列

​ c. 小序列中的第一个元素是不可变的数据

list(字典) - 将指定字典转换成列表(将字典的key作为列表的元素)

data = ['ab', (10, 20), ['abc', 123]]
print(dict(data))  # {'a': 'b', 10: 20, 'abc': 123}


d1 = {'a': 10, 'b': 20, 'c': 30}
print(list(d1))  # ['a', 'b', 'c']

3.相关方法

1)字典.clear() - 清空字典

d1 = {'a': 10, 'b': 20, 'c': 30}
d1.clear()
print(d1)

不建议使用：效率低

d1 = {'a': 10, 'b': 20, 'c': 30}
print(d1)
d1 = {}
print(d1

)

2)字典.copy() - 复制字典产生一个一模一样的新字典并返回

dict.fromkeys(序列) - 创建一个新的字典,键是序列中的每一个元素，值都是None

dict.fromkeys(序列, 值) - 创建一个新的字典,键是序列中的每一个元素，值是指定的值

print(dict.fromkeys(‘abc’)) # {‘a’: None, ‘b’: None, ‘c’: None}
print(dict.fromkeys([‘name’, ‘age’, ‘sex’])) # {‘name’: None, ‘age’: None, ‘sex’: None}

print(dict.fromkeys(‘abc’, 100)) # {‘a’: 100, ‘b’: 100, ‘c’: 100}
print(dict.fromkeys(‘abc’, [10, 20, 30])) # {‘a’: [10, 20, 30], ‘b’: [10, 20, 30], ‘c’: [10, 20, 30]}

keys、values、items

字典.keys() - 获取字典所有的key(返回值是序列但是不是列表)
字典.values() - 获取字典所有的值(返回值是序列但是不是列表)
字典.items() - 同时获取每个键值对的键和值(返回值是序列，序列中的元素是元组)

d1 = {'a': 10, 'b': 20, 'c': 30}
print(d1.keys())  # dict_keys(['a', 'b', 'c'])
print(d1.values())  # dict_values([10, 20, 30])
print(d1.items())  # dict_items([('a', 10), ('b', 20), ('c', 30)])

5）字典.setdefault(键, 值) - 在字典中添加键值对(只添加不修改)

d1.setdefault('name', '小明')
print(d1)  # {'a': 10, 'b': 20, 'c': 30, 'name': '小明'}

不会修改已经存在的键值对

d1.setdefault('a', 111)
print(d1)  # {'a': 10, 'b': 20, 'c': 30, 'name': '小明'}

字典1.update(字典2) - 将字典2中所有的键值对都添加到字典1中

注意：字典2不一定是字典，也可以是能转换成字典的序列

d1 = {'a': 10, 'b': 20, 'c': 30}
d1.update({'name': '张三', 'age': 20, 'a': 100})
print(d1)  # {'a': 100, 'b': 20, 'c': 30, 'name': '张三', 'age': 20}

d1.update(('nm', [10, 20]))
print(d1)  # {'a': 100, 'b': 20, 'c': 30, 'name': '张三', 'age': 20, 'n': 'm', 10: 20}