复习：
1.列表(list)
"""
1.一个列表可以保存多个数据。容器类型，有序的(下标)、可变的(增删改)
[元素, 元素] ---> 元素可以是任意类型的数据
2.声明列表
3.元素的增删改查
4.遍历列表
5.列表的存储（存地址）
6.列表相关的方法
7.元祖（元祖是不可变的列表）
(元素，元素) ---> (元素,)
查找单个、切片、遍历、in/not in、+、、len()
颜色值(255,0,0),(0,255,0)、坐标(100, 200)
"""

1.字典(dict)：

1.字典是容器类型(序列)，以键值对作为元素（字典里面存的数据全是以键值对的形式出现的）
{key1:value1, key2:value2...}
2.键值对： 键:值(key:value)
键(key): 要唯一，不可变的(数字、布尔、字符串和元祖，推荐使用字符串)
值(value):可以不唯一，可以任何类型的数据

3.字典是可变(增删改) --- 可指的是字典中的键值对的值和个数可变

1.声明字典

dict1 = {10: 100, 'a': 97, True: 100, (10, 10): 'start', 'a': [1, 2]}
print(dict1)

person1 = ['酒坛坛儿', 20, 5, 90]

声明一个字典，有三个键值对儿，key分别是:name， age和work_age
person2 = {'name': '酒坛坛儿', 'age': 20, 'work_age': 5}

dict2 = {} # 空的字典
print(type(dict2))

2.查(获取值)
获取字典的元素对应的值（字典存数据，实质还是存的value, key是获取value的手段）
a.字典[key] --- 通过key获取值
print(person2['name'], person2['age'])

通过字典[key]获取value的时候,如果key不存在会发生KeyError异常

 print(person2['sex'])    # KeyError: 'sex'

b.字典.get(key)
print(person2.get('age'))
字典.get(key),如果key不存在不会报错，返回None
print(person2.get('sex')) # None -- python中的特殊值，代表没有

 print(person2.get('name2'))

总结: 确定key肯定存在的时候用[]语法获取value。
key值可能不存在，不存的时候不希望报错，而是想要自己对它进行特殊处理的时候使用get获取value
person = {'name': '叶玉', 'age': 17, 'grade': 90, 'sex': 'girl'}
想要获取性别sex，如果没有就默认为'男'

if person.get('sex') != None:
    print(person['sex'])
else:
    print('男')

c. 遍历字典
dog = {'name': '旺财', 'color': 'yellow', 'age': 3}
遍历字典直接取到是字典的所有的key值

for key in dog:
     打印key
    print(key)
    print(dog[key])

3.改(修改key对应的value)
字典[key] = 新值 （key是本来就存在）

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

4.增(添加键值对)
字典[key] = 值 （key本来不存在）

dog['type'] = '土狗'
print(dog)

5.删(删除键值对)
a.del 字典[key]

del dog['age']
print(dog)

b.字典.pop(key)

color = dog.pop('color')
new_dict = {'a': color}
print(color, dog)
print(new_dict)

2.字典不支持'+'和'*':

2. in 和 not in : 是判断key是否存在

computer = {'brand': '联想', 'color': 'black'}
print('color' in computer)

3.len()

print(len(computer))

4.字典.clear()
删除字典中所有的元素(键值对)

computer.clear()
print(computer)

5.字典.copy()
拷贝字典中的所有的元素，放到一个新的字典中
dict1 = {'a': 1, 'b': 2}
dict2 = dict1 # 将dict1中的地址赋给dict2，两个变量指向同一块内存区域
dict3 = dict1.copy() # 将dict1中的内存复制到一个新的内存区域中，然后将新的地址给dict3

dict1['a'] = 100
print(dict2)   # {'a': 100, 'b': 2}
print(dict3)   # {'a': 1, 'b': 2}

6.dict.fromkeys(序列,默认值=None)
将序列中的每个值作为key,默认值为value创建一个新的字典。
注意：默认值可以不写，写的话只能写一个值

print(dict.fromkeys('abc', 0))  # {'a': 0, 'b': 0, 'c': 0}
print(dict.fromkeys(['name', 'age', 'sex'], [1, 2]))

7.字典.keys()(了解)
获取字典中所有的key，以dict_keys的形式返回

all_key = dict1.keys()
for key in all_key:
    print(key)

8.字典.values()(了解)
获取字典中所有的value

print(dict1)
all_value = dict1.values()
print(all_value)

9.字典.items()
print(dict1.items())
这种方式不推荐使用

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

10.字典.setdefault(key, 默认值=None)
给字典添加键值对。如果key本身就存在，这个方法无作为

dict1.setdefault('ab', 'abc')
dict1.setdefault('dd')
print(dict1)

11.字典1.update(字典2)
将字典2中的键值对更新到字典1中
更新方式: 如果字典2的key,在字典1中是存在的，就字典2中的值去更新字典1中的值。不存在就添加到字典1中

dict1 = {'aa': 1, 'bb': 'abc', 'cc': True}
dict1.update({'aa': 99, 'dd': '你好'})
print(dict1)

"""author = 余婷"""

4.学生管理系统

1.一个系统可以存储多个学生
系统应该是一个容器：列表、字典
2.一个学生可以存储：姓名，电话，籍贯，专业，学号等等
3.添加学生
4.删除学生
5.修改学生的信息
.....

什么使用列表？ 什么时候使用字典？
1.保存的多个数据的类型是同一个类型时候，用列表
例如：声明一个变量保存所有的数学成绩， 声明一个变量保存所有的学生信息

2.保存的多个数据的类型不同，就使用字典
声明一个变量保存一个学生的信息

1.列表中有字典

student_system = [
    {'name': 'stu1', 'age': 18, 'tel': 110, 'native_place': '四川.成都'},
    {'name': 'stu2', 'age': 20, 'tel': 120, 'native_place': '重庆'}
]

取出第一个学生的籍贯

print(student_system[0]['native_place'])

2.字典中有列表

py_class = {
    'class_name': 'python1806',
    'students': [
        {'name': 'studen1', 'age': 20, 'id': '001'},
        {'name': 'studen2', 'age': 30, 'id': '002'},
        {'name': 'studen3', 'age': 18, 'id': '003'}
    ]
}

取班级名

print(py_class['class_name'])

取第三个学生的名字

print(py_class['students'][2]['name'])

练习1：在班级python1806中添加一个学生,学生的信息自己输入，名字、年龄和id

name1 = input('姓名:')
age1 = int(input('年龄:'))
id1 = input('id:')

一个学生对应一个字典

student = {'name': name1, 'age': age1, 'id': id1}

将学生对应的字典添加到列表中

py_class['students'].append(student)
print(py_class)

练习2：输入一个学生的姓名，根据姓名去删除对应的学生

del_name = input('请输入需要删除的学生姓名:')

获取班级所有的学生

all_student = py_class['students']

遍历取出每个学生对应的字典

for student_dict in all_student[:]:

判断name对应的值是否和输入的要删除的姓名相同

    if student_dict['name'] == del_name:
        all_student.remove(student_dict)

print(py_class)

5.集合(set)
集合是python中一种容器类型; 无序的，可变的, 值唯一
和数学中的集合差不多
除了可变的类型，其他的基本都行，数字、布尔和字符串是可以的（和字典的key的要求一样）

1.声明一个集合

set1 = {1, 'abc', 100, 100}
print(set1, type(set1))

将其他的序列转换成集合，自带一个去重的功能

set2 = set('name name')
print(set2)

set3 = {10, 4.14, True, 'abc'}
print(set3)

2.查(获取集合中元素)
集合是不能单独获取其中的某一个元素的
遍历获取每一个元素

for item in set3:
    print(item)

3.增(添加元素)
a. 集合.add(元素)

set3.add('good')
print(set3)

b.集合1.update(集合2) ： 将集合2中的元素，添加到集合1中

set3.update({1, 2, 3})
print(set3)

4.删
集合.remove(元素)

set3.remove('abc')
print(set3)

删除所有的元素

set3.clear()
print(set3)

5.改(改不了)

6.数学相关的集合运算
a. 判断包含情况：
集合1 >= 集合2 ： 判断集合1中是否包含集合2
集合1 <= 集合2 ： 判断集合2中是否包含集合1

print({1, 2, 3, 4, 5} >= {2, 3, 1, 10})   # False
print({2, 3, 1} <= {1, 2, 3, 4, 5})  # True

b.求并集： |
两个集合合并

set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 2, 3, 14, 15, 16}
print(set1 | set2)

c.求交集: &
求两个集合的公共部分

print(set1 & set2)

d.求差集: -

print(set1 - set2)

e.求补集：^
请两个集合中除了公共部分以外的部分

print(set1 ^ set2)

list1 = [1, 2, 2, 3, 4, 5, 6]
list2 = [5, 2, 100, 20, 56]
result = list(set(list1) & set(list2))
print(result)

6.已知一个列表，求列表中心元素:

numbers = [1, 2, 5, 3, 7, 8, 9]
length = len(numbers)

if length % 2:
如果是奇数个,中心元素的下标是长度//2

    print(numbers[length//2])
else:
     如果是偶数个，中心元素有两个
    print(numbers[length//2], numbers[length//2-1])

2.已知一个列表，求所有元素和

numbers = [1, 2, 5, 3, 7, 8, 9]
sum1 = 0
for item in numbers:
    sum1 += item
print(sum1)

3.已知一个列表，输出所有下标是奇数的元素

numbers = [1, 2, 5, 3, 7, 8, 9]

index 是下标

for index in range(len(numbers)):
    if index % 2:

     打印奇数下标对应的值

        print(numbers[index])
print('================================')

4.已知一个列表，输出所有元素中，值为奇数的元素。

numbers = [1, 2, 5, 3, 7, 8, 9]
for item in numbers:
    if item % 2:
        print(item, end=' ')

print('===============================')

5.已知一个列表，将所有的元素乘以2。

numbers = [1, 2, 5, 3, 7, 8, 9]

因为要修改每个元素的值，所以使用下标去遍历

for index in range(len(numbers)):
    numbers[index] *= 2  # numbers[index] = numbers[index]*2

print(numbers)

index = (0 ~ 6)
index = 0   numbers[0] = number[0]*2 = 1*2 = 2
index = 1   numbers[1] = number[1]*2 = 2*2 = 4
...
index = 6   numbers[6] = numbers[6]*2 = 9*2 = 18

6.已知一个列表，将所有元素加到第一个元素中。

numbers = [1, 2, 5, 7, 8, 9]
 numbers = [[1,2,5,3,7,8,9], 2, 5, 3, 7, 8, 9]
 numbers[0] = numbers[:]
 print(numbers)

sum(序列): python内置的求序列中元素的和的方法

numbers[0] = sum(numbers)
print(numbers)

7.已知一个列表A，将奇数位置元素存到B列表中，偶数元素存到C列表中。

A = [1, 2, 5, 7, 8, 9]
B = []
C = []
for index in range(len(A)):
    if index % 2:
        B.append(A[index])
    else:
        C.append(A[index])
print(B, C)

用切片做

B = A[1::2]
C = A[::2]
print(B, C)

9.有一个长度是10的列表，按递增排列，用户输入一个数，插入适当位置

numbers = [1, 2, 4, 5, 7, 8, 9, 18, 98, 100]
排序
 numbers.sort()
num = int(input('请输入一个数字:'))
for index in range(len(numbers)):

 找列表中第一个比输入的数大的位置，然后插入到它的前面

    if numbers[index] > num:
        numbers.insert(index, num)
        break
else:
     如果前面的数字都比输入的小，就添加到最后
    numbers.append(num)

print(numbers)