1.浅拷贝和深拷贝

import copy

copy.copy(对象)：浅拷贝
copy.deepcopy(对象)：深拷贝

a = 100
b = a
b = 200

a = [1, 2]
b = a.copy()
b.append(3)
print(a)
# [1, 2]

拷贝： 将变量中的值赋值一份，产生新的数据，然后将新的数据对应地址返回
浅拷贝：直接拷贝地址(切片和字典列表的copy方法都是浅拷贝)
深拷贝：将地址对应的值拷贝，产生新的地址

a1 = [1, 2]
a2 = {'a': 10}
list1 = [a1, a2]
# 浅拷贝
# list2 = list1.copy()
# 深拷贝
# list2 = copy.deepcopy(list1)

list2 = copy.deepcopy(list1)
list2.append(1)
print(list1)
print(list2)
# [[1, 2], {'a': 10}]
# [[1, 2], {'a': 10}, 1]

list2[0].append(100)
print(list1)
print(list2)
# [[1, 2], {'a': 10}]
# [[1, 2, 100], {'a': 10}, 1]

2.字典和列表的应用

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

1.列表当中有字典

persons = [
        {'name':'张三', 'age': 50, 'sex': '男'},
        {'name':'李四', 'age': 23, 'sex': '女'},
        {'name':'王五', 'age': 32, 'sex': '男'}
           ]
print(persons)
# [{'name': '张三', 'age': 50, 'sex': '男'}, {'name': '李四', 'age': 23, 'sex': '女'}, {'name': '王五', 'age': 32, 'sex': '男'}]

print(persons[1]['name'])
# 李四

找出persons中年龄最大的人的名字

max1 = 0   # 当前最大的年龄
name = '' # 当前最大年龄对应的名字
for x in persons[:]:
    age = x['age']
    if age > max1:
        max1 = age
        name = x['name']
    print(age)
print(max1, name)
# 50
# 23
# 32
# 50 张三

2.字典中有列表

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

my_class = {
    'class_name': 'python1807',
    'location': '18-6',
    'all_students':[
        {'name': '小花', 'age': 20, 'school': '清华'},
        {'name': '小红', 'age': 19, 'school': '北大'},
        {'name': '小名', 'age': 23, 'school': '川大'}
    ]
}
print(my_class['all_students'][0]['school'])
print(my_class)
# 清华
# {'class_name': 'python1807', 'location': '18-6', 'all_students': [{'name': '小花', 'age': 20, 'school': '清华'}, {'name': '小红', 'age': 19, 'school': '北大'}, {'name': '小名', 'age': 23, '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)
{'class_name': 'python1807', 'location': '18-6', 'all_students': [{'name': '小花', 'age': 20, 'school': '清华'}, {'name': '小名', 'age': 23, 'school': '川大'}]}

4.为什么使用函数

"""
没有函数的时候的问题：
1.同样的代码需要重复很多遍
2.功能发生改变需要改很多代码

怎么解决：使用函数

# 左移，右移
# 左移
print('看后视镜')
print('打左转向灯')
print('踩油门')
print('向左打方向盘')
print('回正方向盘')
# 看后视镜
# 打左转向灯
# 踩油门
# 向左打方向盘
# 回正方向盘

# 右移
print('看后视镜')
print('打右转向灯')
print('踩油门')
print('向右打方向盘')
print('回正方向盘')

# 看后视镜
# 打右转向灯
# 踩油门
# 向右打方向盘
# 回正方向盘

4.函数的声明

函数就是对实现某一特定功能的代码段的封装

分类： 自定义函数（程序员自己声明实现其功能）和内置函数（系统已经声明实现完成）

1.声明函数的语法
def 函数名（参数列表）：
函数体

说明：
a.def ---> python中声明函数的关键字
b.函数名 ---> 标识符，不是关键字。遵守PEP8命名规范（所有字母小写，多个单词之间使用下划线隔开）
见名知义（看见名字知道函数的功能）

c.() ---> 固定格式
d.参数列表 ----> 形参列表，参数名1，参数名2....
可以有多个参数，也可以没有
参数是用来从函数的外部给函数里面传值的
e.： ---> 固定格式
f.函数体 ---> 实现函数功能的代码段

2.初学者声明函数的步骤
a.确定函数的功能
b.根据功能确定函数名
c.确定参数：确定有没有，确定有几个（看实现函数的功能需不需要函数外面传值，需要传几个）
d.实现函数功能
e.确定返回值

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

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

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

# 写一个函数，打印两个数的和
def my_sum(num1, num2):
    print(num1 + num2)

my_sum(20,10)
my_sum(100,200)

# 写一个函数，打印五个'*'
def print_star():
    print('*'*5)

print_star()


# 写一个函数，打印n个'*'
def print_star2(n):
    print('*'*n)

print_star2(10)
print_star2(20)

# 练习：写一个函数，计算1+2+...+n的和
def print_sum(n):
    num = 0
    for x in range(n+1):
        num += x
    print(num)

print_sum(100)

30
300
*****
**********
********************
5050

5.函数的调用

"""
1.格式
函数名（实参列表）

2.函数的调用（重点）
第一步：回到函数声明的位置
第二步：用实参给形参赋值(传参：一定要保证每个参数都有值)
第三步：执行函数体
第四步：返回返回值 --> 返回给函数调用表达式
第五步：执行完函数体回到函数调用的位置，接着执行后面的代码

def sum2(num1,num2):
    # num1 = 10 , num2 = 20
    print(num1 + num2)

sum2(10,20)
print('----')
30
----

6.函数的参数

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

根据调用函数实参的书写方式
位置参数：按照实参的顺序--给形参赋值
关键字参数：形参1=值1，形参2=值2...

def kiki(a, b, c):
    print('a:', a,'b:', b, 'c:', c)
# 位置参数
kiki(10, 20, 30)
# 关键字参数
kiki(c=300, a=200, b=100)

2.默认参数

"""
函数声明的时候可以给参数设置默认值，但是：有默认值的参数，必须放在参数列表的最后

有默认值的时候，在调用时可以不传参数

def kiki2(a, c, b=0):
    # a =10 c =20
    print('a:', a,'b:', b, 'c:', c)

kiki2(10,20)
# a= 100 b= 300 c= 200
kiki2(100,200,300)

def kiki3(a=10, c=30, b=20):
    # a =10 c =20
    print('a:', a,'b:', b, 'c:', c)

kiki3(a=100,b=200)
kiki3(100,b=200)

a: 10 b: 20 c: 30
a: 200 b: 100 c: 300
a: 10 b: 0 c: 20
a: 100 b: 300 c: 200
a: 100 b: 200 c: 30
a: 100 b: 200 c: 30

3.不定长参数

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

# 写一个函数，计算多个数的和
def my_sum(*nums):
    print(sum(nums))

my_sum()
my_sum(1)
my_sum(1,2)
my_sum(1, 2, 3, 4)

def func4(name,age,*scores):
    print(scores, name, age)

func4('小花', 18, 90, 34, 324)

0
1
3
10
(90, 34, 324) 小花 18

7. 函数的返回值

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

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

注意：看一个函数的返回值，只看有没有遇到retutn。只要没有遇到None,遇到

# 情况1：没有return
def func1():
    print('hello python!')

# 将返回值赋值给一个变量
re = func1()
print(re)

# 直接打印返回值
print(func1())

# 将返回值作为列表的元素
list1 = [func1(), 1]
print(list1)

hello python!
None
hello python!
None
hello python!
[None, 1]

情况2：有return

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

def func2():
    print('====')
    print('@@@@@@')
    return 100
    print('1000')

func2()
re = func2()
print(re)

====
@@@@@@
====
@@@@@@
100

注意：并不是只要函数中有return，函数的返回值就是return后面的值

def func3(n):
    if n % 2:
        return '是奇数'

print(func3(4)) # None
print(func3(5)) # 是奇数

None
是奇数

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

# 写一个函数，功能是计算一个数的阶乘
def jie_ceng(num):
    sum1 = 1
    for x in range(1, num+1):
        sum1 *= x

    return sum1

re = jie_ceng(10)
print(re)

3628800