一、浅拷贝和深拷贝
import copy
copy.copy(对象)：浅拷贝
copy.deepcopy(对象)：深拷贝
拷贝：将变量中的值赋值一份，产生新的数据。然后将新的数据对应的地址返回。
浅拷贝：直接拷贝地址(切片和字典列表的copy方法都是浅拷贝)。
深拷贝：将地址对应的值拷贝，产生新的地址。
代码
import copy
# 浅拷贝
# list2 = copy.copy(list1)
a1 = [1,2]
a2 = [{'a': 10}]
list1 = [a1,a2]
print(list1)
list2 = list1.copy()
print(list2)
list2[0].append(100)
print(list1)
print(list2)
测试结果
代码
import copy
# 深拷贝
a1 = [1,2]
a2 = [{'a': 10}]
list1 = [a1,a2]
print(list1)
list2 = copy.deepcopy(list1)
print(list2)
list2[0].append(100)
print(list1)
print(list2)
测试结果
二、字典和列表的应用
列表的元素和字典的值可以是任何类型的数据
1.列表中有字典
代码
persons = [
{'name': '张三','age': 30,'sex': '男'},
{'name': '李四','age': 58,'sex': '女'},
{'name': '王五','age': 40,'sex': '男'}
]
print(persons)
print(persons[1]['name'])
测试结果
练习1：找出persons中年龄最大的人的名字。
代码
persons = [
{'name': '张三','age': 30,'sex': '男'},
{'name': '李四','age': 58,'sex': '女'},
{'name': '王五','age': 40,'sex': '男'}
]
max_age = 0
name = ''
for item in persons:
age = item['age']
if age > max_age:
max_age = item['age']
name = item['name']
print(name,max_age)
测试结果
2.字典中有列表
代码
# 写一个程序，保存一个班级的信息，包含班级名，位置，所有学生(学生中需要保存名字，年龄和学校)
my_class = {
'class_name': 'python1807','location': '18-6','all_students': [
{'name': '小花','age': 18,'school': '清华'},
{'name': '小红','age': 20,'school': '北大'},
{'name': '小明','age': 17,'school': '川大'},
]
}
print(my_class['all_students'][0]['school'])
测试结果
练习1：在班级中添加一个学生，姓名：老王，年龄：40，学校：北大青鸟。
代码
my_class = {
'class_name': 'python1807','location': '18-6','all_students': [
{'name': '小花','age': 18,'school': '清华'},
{'name': '小红','age': 20,'school': '北大'},
{'name': '小明','age': 17,'school': '川大'},
]
}
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_students = my_class['all_students']
for student in all_students[:]:
if student['age'] < 20:
all_students.remove(student)
print(my_class)
# index = 0
# while index < len(all_students):
# student = all_students[index]
# if student['age'] < 20:
# del all_students[index]
# continue
# index += 1
# print(my_class)
测试结果
三、为什么要使用函数
没有函数的时候的问题：
1.同样的代码需要重复很多遍。
2.功能发生改变时需要修改很多地方。
怎么解决：使用函数
四、函数的声明
函数就是对实现某一特定功能的代码段的封装。
分类：自定义函数(程序员自己声明实现其功能)和内置函数(系统已经声明实现完成)。
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(10, 20)
my_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 sum2(n):
sum1 = 0
for num in range(1,n+1):
sum1 += num
print(sum1)
sum2(100)
测试结果
五、函数的调用
1.格式
函数名(实参列表)
2.函数的调用(重点！！！)
第一步：回到函数声明的位置
第二步：用实参给形参赋值(传参：一定要保证每个参数都有值)
第三步：执行函数体
第四步：返回返回值 --> 返回给函数调用表达式
第五步：执行完函数体回到函数调用的位置，接着执行后面的代码
代码
def sum2(num1, num2):
# num1 = 10, num2 = 20
print(num1 + num2)
sum2(10, 20)
测试结果
六、函数的参数
1.位置参数和关键字参数
根据调用函数实参的书写方式：
位置参数：按照实参的顺序一一给形参赋值
关键字参数：按照关键字一一给形参赋值
代码
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, 98)
测试结果
七、函数的返回值
函数的返回值就是函数调用表达式的值，就是return关键字后面的表达式的值。
python中所有的函数都有返回值，返回值默认是None。
执行函数体没有遇到return，函数的返回值就是None；遇到了return函数的返回值是return后面的值。
函数调用表达式 --> 调用函数的语句(函数名(实参))。
return --> 关键字，只能写在函数体中。用来返回返回值和结束函数。
注意：看一个函数的返回值，只看有没有遇到return。只要没有遇到就是None，遇到return就是return后面的值。
代码
# 情况一：没有return
def func1():
print('hello python!')
# 将返回值赋给一个变量
re = func1()
print(re)
# 直接打印返回值
print(func1())
# 将返回值作为列表的元素
list1 = [func1(), 1]
print(list1)
测试结果
执行函数的时候，一旦遇到return，函数就直接结束。并且把return后面的结果作为返回值。
注意：并不是只要函数中有return，函数的返回值就是return后面的值。
代码
# 情况二：有return
def func2():
print('====')
print('!!!!!')
return 100
print('*****')
re = func2()
print(re)
def func3(n):
if n % 2:
return '是奇数'
print(func3(4)) # None
print(func3(3)) # 是奇数
测试结果
如果实现函数的功能会产生新的数据，就将新的数据返回。如果不会产生新的数据就不用返回值。
代码
# 写一个函数，功能是计算一个数的阶乘
def jie_cheng(num):
sum1 = 1
for x in range(1,num+1):
sum1 *= x
return sum1
re = jie_cheng(10)
print(re)
print('===%d===' % re)
list1 = [re, re]
print(list1)
# 写一个函数，打印问候语："吃饭了吗？"
def say_hello():
print('吃饭了吗？')
say_hello()
测试结果
八、作业
- 编写一个函数，求1+2+3+...+N。
代码
def sum1(n):
sum2 = 0
for num in range(1,n+1):
sum2 += num
return sum2
print('sum=',sum1(100), sep='')
测试结果
- 编写一个函数，求多个数中的最大值。
代码
def max1(*num):
return max(num)
print('max=',max1(100, 10, -20, 50,), sep='')
测试结果
- 编写一个函数，实现摇骰子的功能，打印n个骰子的点数和。
代码
def play_dice(n):
import random
sum1 = 0
for x in range(n):
num = random.randint(1, 6)
sum1 += num
print(num)
print(n, '个骰子的点数和=', sum1, sep='')
play_dice(5)
测试结果
- 编写一个函数，交换指定字典的key和value。
代码
def exchange_dict(dict1):
list1 = []
list2 = []
for student in dict1:
list1.append(student)
list2.append(dict1[student])
dict1.clear()
for index in range(len(list1)):
dict1[list2[index]] = list1[index]
return dict1
students = {'a': 1, 'b': 2, 'c': 3}
print(exchange_dict(students))
测试结果
- 编写一个函数，提取指定字符串中的所有的字母，然后拼接在一起后打印出来。
代码
def join_letter(str2):
str3 = ''
for index in range(len(str2)):
if (str2[index] >= 'a' and str2[index] <= 'z') or (str2[index] >= 'A' and str2[index] <= 'Z'):
str3 += str2[index]
print(str3)
str1 = '12a&bc12d--'
join_letter(str1)
测试结果
- 写一个函数，求多个数的平均值。
代码
def count_average(*nums):
average = 0
sum1 = 0
count = 0
for num in nums:
sum1 += num
count += 1
average = sum1 / count
return average
print('average=', count_average(1,2,3,4,5),sep='')
测试结果
- 写一个函数，默认求10的阶乘，也可以求其他数的阶乘。
代码
def count_factorial(n=10):
sum1 = 1
for num in range(1,n+1):
sum1 *= num
return sum1
print(count_factorial())
print(count_factorial(5))
测试结果
- 写一个函数，可以对多个数进行不同的运算。
代码
def operation(operator, *nums):
sum1 = nums[0]
if operator == '+':
for index in range(1, len(nums)):
sum1 += nums[index]
elif operator == '-':
for index in range(1, len(nums)):
sum1 -= nums[index]
elif operator == '*':
for index in range(1, len(nums)):
sum1 *= nums[index]
elif operator == '/':
for index in range(1, len(nums)):
sum1 /= nums[index]
return sum1
print(operation('+', 1, 2, 3))
print(operation('-', 10, 9))
print(operation('*', 2, 4, 8, 10))
print(operation('/', 10, 5, 2))
测试结果
9.写一个函数，求指定列表中，指定的元素的个数。
代码
def count_element(list2, element):
count = 0
for x in list2:
if x == element:
count += 1
return count
list1 = [1, 2, 3, 1, 5, 1, 6, 8, 1, 10, 1]
print(count_element(list1, 1))
测试结果
10.写一个函数，获取指定列表中指定元素对应的下标(如果有多个，一起返回)。
代码
def count_index(list2, element):
list3= []
for index in range(len(list2)):
if list2[index] == element:
list3.append(index)
return list3
list1 = [1, 2, 3, 1, 5, 1, 6, 8, 1, 10, 1]
print(count_index(list1, 1))
测试结果
