一、容器类型复习

列表，字典，元祖，集合

列表(list): []；可变，有序；元素是任何类型的数据
增：列表.append(一个元素) 在最后添加一个元素
列表.insert（下标，元素） 在指定下标前添加一个元素
列表.extend（序列） 将序列中的元素添加到列表中
删：del列表[下标], 列表.remove（元素）,
列表.pop[下标], clear（）
改：列表[下标] = 新值
查：列表[下标], 切片, 遍历

字典(dict): {}；可变，无序；元素是键值对，键是不可变的唯一的，值可以是任何类型的数据
增：字典[key] = 值,
setdefault(key,默认值)： 添加键值对，键是key，值是value 如果没有值，默认值为None
字典1.update(字典2）： 使用字典2中键值对去更新字典1
删：del 字典[key], 字典.pop[key], clear
改：字典[key] = 值
查：字典[key], 字典.get(key), 字典.get(key,默认值)，遍历

元祖(tuple): ()；不可变，有序；元素是任何类型的数据
查：和列表一样（元祖[下标], 切片, 遍历）

tuple1 = 2, 34, 90, 18, 90
tuple2 = ('abc',)
x,y = (10, 20)
x,y = 10, 20
*nums, x, y = tuple1
print(x,y,nums)
#18 90 [2, 34, 90]

集合(set): {}；可变，无序；元素是不可变的唯一的
增：集合.add（元素）,在集合中添加一个指定元素
集合. update（序列）：将序列中的元素添加到集合中
删：集合.remove（元素）：指定删除一个元素
查：遍历
集合运算：包含(>=, <=)，并集(|)、交集(&)、差集(-)、补集(^)

二、拷贝和深拷贝

拷贝：将变量中的值赋值一份，产生新的数据，然后将新的数据对应的地址返回。
浅拷贝：直接拷贝地址（切片和字典列表的
深拷贝：将地址对应值拷贝，产生新的地址（如果拷贝对象是地址，直到找到相应的值为止）

浅拷贝 深拷贝

# import copy
# copy.copy(对象)：浅拷贝
# copy.deepcopy(对象)：深拷贝
a=100
b=a
b=200
print(a)     #100         b没有改变a的值

a=[1,2]
b=a
b.append(3)
print(a)     #[1, 2, 3]    b改变a的值


list1=[a,b]
list1.append(4)
print(list1)      #[[1, 2, 3], [1, 2, 3], 4]
list2=list1.copy()
list2[0].append(100)
print(list1)     #[[1, 2, 3, 100], [1, 2, 3, 100], 4]
print(list2)     #[[1, 2, 3, 100], [1, 2, 3, 100], 4]

a=[1,2]
b=1
list1=[a,b]
import copy
list2=copy.deepcopy(list1)
list2[0].append(100)
print(list1, list2)  # [[1, 2], 1] [[1, 2, 100], 1]

三、字典和列表的应用

列表的元素和字典的值可以是任何类型的数据

1.列表中有字典

persons = [
    {'name': '张三', 'age': 30, 'sex': '男'},
    {'name': '李四', 'age': 58, 'sex': '女'},
    {'name': '王五', 'age': 40, 'sex': '男'}
]
# print(persons)
# print(persons[1])
# print(persons[1]['name'])
person = persons[1]
print(person)   #{'name': '李四', 'age': 58, 'sex': '女'}

name = person['name']
print(name)   #李四

找出persons中最大的年龄对应的名字

max1 = 0   # 当前最大的年龄
name = ''  # 当前最大年龄对应的名字
for item in persons:
    age = item['age']
    if age > max1:
        max1 = age
        name = item['name']

print(max1, name)     #58 李四

2.字典中有列表

写一个程序，保存一个班级的信息，包含班级名，位置，所有学生(学生中需要保存名字，年龄和学校)

my_class = {
    'class_name': 'python1807',
    'location': '18-6',
    'all_students': [
        {'name': '小花', 'age': 18, 'school': '清华'},
        {'name': '小红', 'age': 19, 'school': '北大'},
        {'name': '小明', 'age': 20, 'school': '川大'}
    ]
}
print(my_class['all_students'][0]['school'])   #清华

练习：在班级中添加一个学生，姓名：老王， 年龄: 40, 学校：北大青鸟

name = input('请输入名字:')
age = int(input('请输入年龄:'))
school = input('请输入学校:')
# 根据输入的信息创建对应的学生
student = {'name': name, 'age': age, 'school': school}
# 将学生添加到班级的所有学生中
my_class['all_students'].append(student)
print(my_class)

练习2：删除班级中年龄小于20岁的学生~

# 取出所有学生
all_student = my_class['all_students']
for student in all_student[:]:
    if student['age'] < 20:
        all_student.remove(student)
print(my_class)

index = 0
while index < len(all_student):
    student = all_student[index]
    if student['age'] < 20:
        del all_student[index]
        continue
    index += 1
print(my_class)

四、函数的声明

函数就是对实现某一特定功能的代码段的封装
分类：自定义函数（程序员自己声明实现其功能）
内置函数（系统已经声明实现完成）

1.声明函数的语法

def 函数名（参数列表）：
函数体
说明：
a.def --->python中声明函数的关键字
b.函数名-->与变量一样，标识符，不能是关键字。遵守PEP8命名规范（所有字母小写，多个单词之间使用下划线）
见名知义（看见名字知道函数的功能）
c.（）--->固定格式
d.参数列表-->形参列表 ，可以有多个参数，也可以没有，参数是用来从函数的外部给函数内部传值 （参数名1，参数名2....）
e.：-->固定格式
f：函数体-->就是实现函数功能的代码段

2.初学者声明函数的步骤

a.确定函数的功能
b.根据功能来确定函数名
c.确定参数：确定有没有，确定有几个（看实现函数的功能需不需要从函数外面传值，需要传几个）
d.实现函数功能
e.确定返回值

3.函数的调用

声明函数的时候不会执行函数体，函数体只有在函数调用的时候才会执行

语法：
函数名（实参列表）

说明：函数名--->必须是已经声明过的函数
（）--->固定的
实参列表---——>数据1，数据2...（用来给函数赋值）

def sum1(a,b):
    print(a+b)
sum1(1,3)   #4

def print_ster ( n ) :
    print('*'*n)
n=12
print_ster(n)   #************

def sum2(n):
    sum3=0
    for x in range(n+1):
        sum3+=x
    print(sum3)

sum2(3)  #6

五、函数的调用

1.格式

函数名（实参列表）

2.函数的调用过程（重点！！！）

第一步：回到函数声明的位置
第二步：用实参给形参赋值
第三步：执行函数体
第四步：返回返回值
第五步：回到函数调用的位置，接着执行后面的代码

六、函数的参数

1.位置参数和关键字参数

位置参数：按照位置给形参赋值
关键字参数：形参1=值1，形参2=值2....

def func1(a,b,c):
    print('a:',a,'b:',b,'c:',c)
func1(1,2,3)        #a: 1 b: 2 c: 3
func1(a=1,b=2,c=3)  #a: 1 b: 2 c: 3

2.默认参数
函数声明的时候可以给参数设置默认值,但是有默认值的参数必须放在参数列表的最后
有默认值的参数，在调用的时候可以不用传参

def func2(a,c,b=0):
    print('a:', a, 'b:', b, 'c:', c)
func2(1,2,b=3)    #a: 1 b: 3 c: 2
func2(1,2)        #a: 1 b: 0 c: 2
func2(1,2,3)      #a: 1 b: 3 c: 2
def func2(a=10,c=20,b=30):
    print('a:', a, 'b:', b, 'c:', c)
func2(a=100,b=200)     #a: 100 b: 200 c: 20   位置参数和关键字参数可以混用

3.不定长参数
参数的个数不确定的时候，可以在形参的前面加*，将这个形参变成一个元祖，用来接收多个参数
注意：如果函数有多个参数，那么不定长参数放在最后

# 写一个参数，计算多个数的和
def  my_num(*nums):
    print(nums)
    print(sum(nums))
my_num(1,2,3,4)   #(1, 2, 3, 4)      10

def func3(name,age,*score):
    print(score,name,age)
func3('小花',18,90,56,34)    #(90, 56, 34) 小花 18

七、函数的返回值

1.函数的返回值

函数的返回值就是函数调用表达式的值，就是return关键字后面的表达式的值
Python中所有的函数都有返回值，返回值默认就是None.
执行函数体没有遇到return，函数的返回值就是None；遇到了return函数的返回值是return后面的值。

函数调用表达式-->调用函数的语句（函数名（实参））
return -->关键字，只能写在函数体中。用来返回返回值和结束函数

注意：看一个函数的返回值，只看有没有遇到return，如果遇到就是None，遇到return就是return后面的值。

def fun1():
    print('hello  python')
re=fun1()  #将返回值赋给变量
print(re)
list=[fun1(),1]    #将返回值作为列表的元素
print(list)        #[None, 1]

情况2;有return
执行函数的时候，一旦遇到return，函数就直接结束，并且把return后面的结果作为返回值

def func2():
    print('*****')
    print('======')
    return 100
    print('.....')
re=func2()
print(re)    #100

def fun3(n):
    if n&1:
        return  '是奇数'
print(fun3(4))   #None
print(fun3(5))   #是奇数

如果实现函数的功能会产生新的数据，就将新的数据返回。如果不会产生新的数据就不用返回值

def  jie_ceng(num):
    sum1 = 1
    for x in range(1,num+1):
        sum1*=x
    return  sum1
re=jie_ceng(10)
print('===%d==='% re)   #===3628800===