元组

1.什么是元组

使用()将多个元素括起来，多个元素之间用逗号隔开
a.
容器，可以同时存储多个数据，不可变的，有序的
不可变 --> 不能增改
有序 --> 可以通过下标获取元素

b.
元素,可以是任何类型的数据

tuple1 = (1, 'abc', True, [1, 2], lambda s:s*2)
print(tuple1)

注意：
1.如果元组的元素只有一个的时候，必须在元素的括号后面加逗号

tuple2 = (1, )
print(type(tuple2))

2.多个数据直接用逗号隔开，表示的也是一个元组

tuple3 = 10, 20, 'abc'
print(tuple3,type(tuple3))

2.元素的增删改

元组的元素不支持增删改
列表获取元素的方式，元组都支持：元组[下标]，元组[:]，元组[::]

tuple2 = ('星期一', '星期二', '星期三', '星期四', )
print(tuple2[1])
print(tuple2[2:4])
print(tuple2[::-1])

for item in tuple2:
    print(item)

index = 0
while index < len(tuple2):
    print(tuple2[index])
    index += 1

补充：获取部分元素

x, y = (10, 20)
print(x, y)

x, y, z = (10, 20, 30)

1.应用：交换两个数的值

a = 10
b = 20

方法1

t = a
a = b
b = a

方法2

a, b = b, a  # a,b = (b,a) = (20,10)

可以通过在变量前加*来获取部分的元素(适用于列表）

tuple2 = ('小明', 90, 85, 98, 100)
name, *score = tuple2
print(name, score)

tuple2 = (90, 85, 98, 100, '小明')
*score, name = tuple2
print(score, name)

可以通过在列表或者元组前面加*，来展开列表中的元素

tuple3 = (1, 2, 3, 4)
print(*tuple3)

list1 = ['abc', 10, 20]
print(*list1)

3.元组的运算

+,*,==,is,in,not in

print((1, 2, 3) + ('a','b'))
print((1, 2) * 2)
print((1, 2, 3) == (1, 2, 3))
print((1, 2, 3) is (1, 2, 3))
print(1 in (1, 2, 3))

4.len(),max(),min()

tuple3 = 10, 20, 100, 50, 48
print(len(tuple3))
print(max(tuple3))
print(min(tuple3))

5.tuple()

所有的序列都可以转换为元组，注意：字典只能将key值作为元组元素

print(tuple('aabbccc'))
print(tuple([1, 2, 3]))
print(tuple(range(5)))
print(tuple({'a': 100, 'b': 200}))

7.sorted()

可以通过sorted（）方法，对元组进行排序，产生一个新的列表

tuple3 = 10, 20, 100, 50, 48
new = sorted(tuple3)
print(new, tuple3)

认识字典

"""
什么时候用容器类型的数据？ --> 需要同时保存多个数据的时候
什么时候用列表？ --> 保存的多个数据是同一类的数据（不需要区分）
什么时候用字典？ --> 保存的多个数据是不同类型的数据（需要区分）
"""

1.什么是字典

字典是一个容器的数据类型，可以用来存储多个数据（以键值对的形式存储）。可变的，无序的
{key1 : value1, key2 : value2...}
可变的 -->可以增删改
无序 --> 不能通过下标获取

键（key）：用来定位值。要求只能是不可变的数据类型（数字，字符串，元组）
值（value）：存储的数据。可以是任何类型的数据

person1 = ['Yuting', 18, 90, 100, '1564484654']
person2 = {'name': 'Yuting', 'age': 18, 'face': 90, 'score': 100, 'tel': '196265531'}
dict1 = {10: 665, 'abc': 100, (1, 2): 'abc'}

dict1 = {}
print(dict1)

字典的增删改查

1.查（获取键值对的value）

获取字典的值，必须通过key来获取

a.字典[key] ---> 获取key对应的值
注意：key值必须是存在的，否则会报错KeyError

student = {'name': '小明', 'age': 30, 'stu_id': 'py001', 'sex': 'boy'}
print(student['name'])

b. 字典.get(key) ---> 通过key获取值
注意:key值不存在的时候不会报错，结果是None

print(student.get('age'), student.get('stu_id'))
print(student.get('score'))

确定key一定存在就使用[]语法，key可能不存在的时候使用get语法

c.遍历字典
通过for-in遍历字典拿到的是key值

for x in student:
    print(x, student[x])

d.其他的遍历方式
直接遍历拿到值

for value in student.values():
    print(value)

直接拿到key和value

for key,value in student.items():
    print(key, value)

2.增（添加键值对）

字典[key] = 值（key不存在）

car = {}
car['color'] = 'yellow'
print(car)

car['price'] = 300000
print(car)

3.修改（修改值）

字典[key] = 新值（key存在）

car['color'] = 'red'
print(car)

4.删（删除键值对）

a.del 字典[key] --> 通过key删除键值对

student = {'name': '小明', 'age': 30, 'stu_id': 'py001', 'sex': 'boy'}
del student['age']
print(student)

b.字典.pop(key) --> 取出key对应的值（实质还是删除key对应的键值对）

name = student.pop('name')
print(student, name)

字典的相关操作

1.字典相关运算

==：判断两个字典的值是否相等
is：判断两个字典的地址是否相等

in 和 not in：key in 字典/key not in 字典 --> 判断key是否存在

print({'a': 100, 'b': 200} == {'b': 200, 'a': 100})
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100})
print('abc' in {'b': 200, 'a': 100})

2.字典相关的函数和方法

1.
len(字典) --> 获取键值对的个数

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(len(dict1))

2.字典.clear（） --> 清空字典

dict1.clear()
print(dict1)

3.字典.copy() --> 将字典中的键值对复制一份产生一个新的字典

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict2 = dict1.copy()
print(dict2, dict1 is dict2)

4.dict.fromkeys(序列，值)

dict3 = dict.fromkeys('xyz', 100)
print(dict3)
dict3 = dict.fromkeys(['a', 'b', 'c'], 100)
print(dict3)
dict3 = dict.fromkeys(['a', 'b', 'c'], (1, 2))
print(dict3)

5.

字典.get(key) --> key不存在取None
字典.get(key,默认值) -->key不存在取默认值

student = {}
print(student.get('name'))
print(student.get('name', '没有'))

字典.values() -->返回所有值对应的序列
字典.keys() -->返回所有键对应的值
字典.items() -->将键值对转换成元组，作为一个序列的元素
注意:返回的都不是列表，是其他类型的序列

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
items = list(dict1.items())
print(items, type(items))
print(dict1.items(), type(dict1.items()))

7.
字典.setdefault(key) --> 添加键值对，键是key，值是None
字典.setdefault(key,值) --> 添加的是键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作（不会修改key对应的值）

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict1.setdefault('aaa')
print(dict1)

8.字典1.update(字典2) --> 使用字典2中键值对去更新字典1(已经存在的key就更新，不存在就添加)

dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 5, 'b': 6, 'c': 3, 'd': 4}
dict1.update(dict2)
print(dict1)

集合

1.什么是集合（set）

容器，可以同时存储多个数据，可变的，无序的,元素是唯一的
可变 --> 增删改
无序 --> 不能通过下标获取元素
唯一 --> 自带去重的功能
{元素1，元素2...}
元素：只能是不可变的数据

set1 = {10, 20, 'abc', (1, 2)}
set2 = {}  # 这是空的字典

2.集合的增删改查

a.查（获取元素）

集合不能单独的获取一个元素，也不能切片，只能通过for-in循环来遍历

for x in set1:
    print(x)

b.增

集合.add(集合) --> 在集合中添加一个元素

set1 = {1, 2, 3}
set1.add(4)
print(set1)

集合1.update(集合2) --> 将集合2中的元素添加到集合1中

set1.update({'a', 'b'})
print(set1)

set1.update('5587')
print(set1)

set1.update(['a1', 'a2'])
print(set1)

set1.update({'name': 'hehe', 'age': 25})
print(set1)

3.删（删除元素）

集合.remove(元素) -->删除指定的元素

set1.remove(1)
print(set1)

4.改（集合不能改）

集合相关的数学运算

集合相关的运算：是否包含，交集、并集、差集、补集

1.包含

集合1 >= 集合2 --> 判断集合1之中是否包含集合2
集合2 <= 集合1 --> 判断集合2之中是否包含集合1

set1 = {1, 2, 3, 4, 5, 6}
set2 = {5, 6}
print(set1 >= set2)

2、交集

& -> 求两个集合公共的部分

set1 = {1, 2, 3, 4, 5, 6}
set2 = {5, 6, 10, 20}
print(set1 & set2)

3.求并集

| --> 求两个集合的和

set1 = {1, 2, 3, 4, 5, 6}
set2 = {5, 6, 10, 20}
print(set1 | set2)

4.求差集

集合1-集合2 -->求集合1中除了集合2的部分

print(set1 - set2)

5.求补集

^ --> 求两个集合除了公共以外的部分

print(set1 ^ set2)

类型转换

1.整型

int()
浮点数、布尔、部分字符串可以转换成整型
只有去掉引号后本身就是一个整数的字符串才能转换成整型

print(int(35.5))
# print(int('35.5'))

2.浮点数

整数，布尔，部分字符串可以转换成浮点数
去掉引号，本身就是一个数字的字符串才能转换成浮点数

print(float(100))
print(float(True))
print(float('25.36'))
print(float('100'))

3.布尔

所有的数据都可以转换成布尔值
为空的值转换成False，其他的数据都转换成True

print(bool('abc'))
print(bool('False'))
print(bool(''))
print(bool(0.00))
print(bool(None))

4.字符串

str()
所有的数据都可以转换成字符串
数据转换成字符串，就是在数据的最外面加引号

print([str(100)])
print([str(True)])
print(str({'a': 1, 'b': 2}))
print([str(lambda x: x*2)])

5.列表

list()
序列才能转换成列表
将序列中的元素作为列表的元素

print(list('sdff'))
print(list((12, 34, 56)))
print(list({'a': 1, 'b': 2}))
print(list({'a': 1, 'b': 2}.items()))

6.元组

tuple()
只能将序列转换成元组

print(tuple('afgr'))
print(tuple({'a': 1, 'b': 2}))

7.字典

dict()
序列的每个元素有两个元素的数据才能转换成字典

list1 = [(1, 2), ['a', 10]]
tuple1 = ((2, 3), {'a', 'b'})
print(list1)
print(tuple1)

8.集合

序列可以转换成集合，有去重的功能

print(set([1, 2, 3, 3, 10]))

作业

(学生管理系统简易版)
用一个变量来保存一个班级的学生信息，学生信息包括:姓名、学号、成绩(英语、体育、美术、数学)、年龄
b.给这个班级添加学生
c.根据姓名查看班级里的某个学生的信息
d.根据姓名删除一个指定的学生信息
e.查看班级的所有的学生信息
f.求指定的学生平均成绩
提示：用一个列表来存整个班级的学生信息；列表的每个元素是字典，来存储每个学生的信息

grade = []

# 添加信息
print('添加3个学生的成绩：')
for x in range(3):
    score = {'english': None, 'PE': None, 'painting': None, 'math': None}
    student = {'name': None, 'stu_id': None, 'score': score, 'age': None}
    name = input('姓名：')
    student['name'] = name
    stu_id = input('学号：')
    student['stu_id'] = stu_id
    english = int(input('英语成绩：'))
    score['english'] = english
    PE = int(input('体育成绩：'))
    score['PE'] = PE
    painting = int(input('美术成绩：'))
    score['painting'] = painting
    math = int(input('数学成绩：'))
    score['math'] = math
    student['score'] = score
    age = int(input('年龄：'))
    student['age'] = age
    grade.append(student)
print(grade)

# 根据姓名查找
name = input('输入要查找的姓名：')
count = 0
for index in range(len(grade)):
    stu = grade[index]
    if name == stu['name']:
        print(stu)
        count += 1
    elif count == 0 and index == len(grade) - 1:
        print('没有你要找的人')


# 根据姓名删除
name = input('输入要删除的学生姓名：')
for x in range(len(grade)):
    stu = grade[x]
    if name == stu['name']:
        del grade[x]
        break
print(grade)


# 查看所有信息
print('全部学生信息：')
for grade_all in grade:
    print(grade_all)


# 指定学生的平均成绩
name = input('输入要查询成绩的学生姓名：')
sum1 = 0
for grade_all in grade:
    if name == grade_all['name']:
        score = grade_all['score']
        for index in list(score):
            sum1 += score[index]
        print('姓名：', name, '平均分:', sum1 / 4)

结果：

1.JPG