浅拷贝和深拷贝

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

import copy
a = 100
b = a
b = 200

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

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

a1 = [1, 2]
a2 = {'a': 10}
list1 = [a1, a2]

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

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

字典和列表的应用

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

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)#李四

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

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'])#清华

#删除班级中年龄小于20岁的学生

# 取出所有学生
all_student = my_class['all_students']
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.传什么类型的值一目了然 b.实现函数体的时候，可以有相关提示 c.

  声明函数的时候不会执行函数体

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

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

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

• • 说明:
    函数名 --> 必须是已经声明过的函数
    () --> 固定的
    实参列表 --> 数据1,数据2...
    用来给形参赋值

# 写一个函数，打印两个数的和

def yt_sum(num1, num2):
    print(num1 + num2)
yt_sum(10, 20)
yt_sum(100, 200)

# 写一个函数，打印5个'*'

def print_star():
    print('*'*5)
print_star()

# 写一个函数，打印n个'*'

def print_star2(n):
    print('*'*n)


print_star2(10)
print_star2(20)

# 练习：写一个函数，计算1+2+...+n的和

def yt_sum2(n):
    sum1 = 0
    for x in range(1, n+1):
        sum1 += x
    print(sum1)
yt_sum2(100)

函数的调用

• 1.格式
  函数名(实参列表)

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

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

函数的参数

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

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

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

2.默认参数

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

def func2(a, c, b=0):

    print('a:', a, 'b:', b, 'c:', c)


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


def func3(a=10, c=30, b=20):

    print('a:', a, 'b:', b, 'c:', c)


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

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, 29, 89)

函数的返回值

• 函数的返回值就是函数调用表达式的值，就是return关键字后面的表达式的值。

• python中所有的函数都有返回值，返回值默认是None

• （执行函数体没有遇到return，函数的返回值就是None;遇到了return函数的返回值是return后面的值）

• 函数调用表达式 --> 调用函数的语句(函数名(实参))

• return --> 关键字，只能写在函数体中。用来返回返回值和结束函数

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

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

def func1():
    print('hello python!')
    print('abcc')
    for x in range(10):
        print(x)


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

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

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

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

def func2():
    print('=====')
    print('!!!!!')
    return 100
    print('*****')


re = func2()
print(re)

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

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


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

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

#写一个函数，功能是计算一个数的阶乘

def jie_ceng(num):
    sum1 = 1
    for x in range(1, num+1):
        sum1 *= x

    return sum1


re = jie_ceng(10)
print(re)
print('===%d===' % re)
list1 = [re, re]
print(list1)