01.recode
1.字典
增：字典[key] = 值；字典.setdefault(key, 值)； 字典.update（字典1）
删：del 字典[key]；字典.pop（key）
改：字典[key] = 值
2.集合 - 无序，可变
查 - 遍历
增 - 集合.add（元素）；集合.update（序列）
删 - 集合.remove（元素）
数学集合运算：包含（>=, <=）、并集（|）、交集（&）、差集（-）、补集（^)
3.函数：就是实现某一特定功能代码度段的封装
a.函数的声明
def 函数名（形参列表）
函数体
b.函数的调用
函数名（实参列表）
02.函数的调用
函数在声明的时候不会执行函数体，只有在调用函数的时候才会执行
def say_hello(name):
print(name, 'hello')
1.函数的调用过程（重点！）
a.物理过程
第一步：回到函数声明的位置
第二步：用实参给形参赋值（传参）
传参一定要保证每个形参都有值
第三步：执行函数体
第四步：获取返回值
第五步：回到函数调用的位置，接着往后执行
b.函数调用的过程是一个压栈的过程
当函数调用的时候，系统会自动的在内存中栈区间开辟空间，存储函数调用过程中产生的数据
（这儿的数据包括参数和在函数的声明的变量）。当函数调用完成后，对应的内存空间会自动销毁。
say_hello('小美')
say_hello('娜美')
小美 hello
娜美 hello
a = 10
b = 20
def change(a, b):
a, b = b, a
print('函数中：', a, b)
change(a, b)
print('函数外：', a, b)
函数中： 20 10
函数外： 10 20
03.函数的参数
1.根据实参分为位置参数和关键字参数
a.位置参数
让实参的位置和形参的位置一一对应
def func1(a, b, c):
# a = 10, b=20, c=100
print('a:%d b:%d c:%d' % (a, b, c))
func1(10, 20, 100)
a:10 b:20 c:100
b.关键字参数
实参以"形参名=值"的形式来传参
func1(c=100, b=20, a=10)
a:10 b:20 c:100
c.位置参数和关键字参数混合使用
前提：a.保证每个参数都有值; b.位置参数要在关键字参数的前面
func1(100, c=300, b=200)
func1(100, 200, c=300)
a:100 b:200 c:300
a:100 b:200 c:300
2.从函数声明的角度又有：参数默认值，不定长参数，参数类型说明
a.参数默认值
声明函数的时候可以给参数设置默认值, 语法：参数名 = 默认值
注意：设置默认值除了可以给参数一个默认的值，也可以对参数的类型进行说明
#声明函数，并且给每个参数设置默认值
def func2(a=1, b=2, c=3):
print('a:%d b:%d c:%d' % (a, b, c))
# 如果函数声明的时候参数有默认值，调用函数的时候，有默认值的参数可以不用赋值
func2()
func2(b=20)
func2(10, 20)
func2(10, 20, 30)
a:1 b:2 c:3
a:1 b:20 c:3
a:10 b:20 c:3
a:10 b:20 c:30
# 如果有的参数有默认值，有的参数没有默认值；有默认值的参数一定要放在没有默认值参数的后面
def func3(a, b, c=3):
print('a:%d b:%d c:%d' % (a, b, c))
func3(10, 20)
func3(10, 20, 30)
func3(b=200, a=100)
func3(b=200, a=100, c=300)
func3(11, b=22)
a:10 b:20 c:3
a:10 b:20 c:30
a:100 b:200 c:3
a:100 b:200 c:300
a:11 b:22 c:3
3.不定长参数
不定长参数：声明函数的时候，函数的参数不确定
a.在声明函数的时候，参数名前加一个*,会将这个参数变成元祖，来获取多个实参的值(通过位置参数调用)
# 声明一个函数，功能是求多个数的和
def my_sum(*num):
print(num)
print('和：',sum(num))
# 调用参数是不定长参数的函数的时候，不定长参数对应的位置，可以传任意个实参
my_sum(10, 20, 9, 89, 38, 100)
my_sum(10, 20)
my_sum(10)
my_sum()
(10, 20, 9, 89, 38, 100)
和： 266
(10, 20)
和： 30
(10,)
和： 10
()
和： 0
def func4(name, *scores):
print(name, scores)
func4('小明', 19, 98, 82, 78, 192)
小明 (19, 98, 82, 78, 192)
b.在声明函数的时候，参数名前加两个*,会将这个参数变成字典，来获取多个实参的值（必须使用关键字参数）
def func5(**num):
print(num)
# 如果是调用不定长关键字参数(参数名前加了两颗*)，调用的时候关键字可以随便命名
func5(a=1, b=2, c=3)
func5(aa=11, bb=22)
func5()
{'a': 1, 'b': 2, 'c': 3}
{'aa': 11, 'bb': 22}
{}
def func6(a, **b):
print(a, b)
func6('abc', x=10, y=20)
abc {'x': 10, 'y': 20}
c.一颗和两颗一起使用 - 用来表示不定长参数，调用的时候更灵活，可以用位置参数传参，也可以用关键字参数传参，也可以两个一起用
要求，一颗的参数要放在两颗参数的前面
def func7(*args, **kwargs):
print(args, kwargs)
func7()
func7(8, 9, 10, 29)
func7(a=10, b=20, c=30)
func7(1, 2, 3, x=11, y=22)
() {}
(8, 9, 10, 29) {}
() {'a': 10, 'b': 20, 'c': 30}
(1, 2, 3) {'x': 11, 'y': 22}
# 练习：求多个数的和，要求调用函数的时候可以多样性(位置，关键字)
def my_sum2(*args, **kwargs):
sum1 = 0
# 获取所有的位置参数
for item in args:
sum1 += item
# 获取所有的关键字参数
for key in kwargs:
sum1 += kwargs[key]
print(sum1)
my_sum2(10, 20, 30)
my_sum2(n1=11, n2=22)
my_sum2(10, 20, 30, n1=11, n2=22)
60
33
93
4.参数类型说明
参数类型说明，只是对参数类型进行提示，不能限制参数的类型
a.设置默认值
b.参数名:类型名
注意：类型说明除了说明类型以外，还可以做相应类型对应的语法提示
def func8(a1: list, a: int, b=''):
a1.append('aa')
print(a, b)
# func8(10, 'abc')
# func8([1,2], 'hello')
func8([10], 23, 'abc')
23 abc
04.函数的返回值
1.返回值
a.函数的返回值就是return关键字后面表达式的值，就是函数调用表达式的值。
b.python中所有的函数都有返回值，默认是None
return - 关键字；返回返回值；结束函数(当函数在执行的过程中遇到了return，函数直接结束)如果函数体中没有return，函数会在函数体执行完成后将None作为返回值
函数调用表达式 - 调用函数的语句;当函数调用完成后，函数调用表达式的结果就是函数的返回值
def func1(m, n):
print(m,n)
# 将100作为函数func1的返回值
return 100 # return-关键字 100 - 返回值
def func2(m, n):
return m+n # m+n的结果就是返回值
def func3(m, n):
#return None # None作为返回值， 在这儿结束函数。函数体后面的其他语句不会执行
print(m, n)
def func4(m):
if m % 2 == 0:
return '偶数'
str1 = func4(10) # func4(10) == '偶数'
print(str1, func4(10), len(func4(10)))
print(func4(11))
偶数 偶数 2
None
# 看一个函数的返回值，永远只看是否遇到return,遇到了就是return后面的值，遇不到就是None
def func5():
print('hello')
func5()
print(func5())
hello
hello
None
返回值的作用：就是将在函数内部产生的数据，传递到函数的外面。防止在函数调用完成后被销毁
什么时候使用返回值：如果实现函数的功能会产生新的数据，一般都会将这个数据返回
def func6(n):
sum1 = sum(range(n+1))
# print(sum1)
return sum1
num = func6(10)
print(num)
list1 = [num]
print(list1)
55
[55]
2.同时返回多个值
python的函数支持返回多个值
return 返回值1,返回值2,返回值3... - 实质是以元祖的形式返回
# 写一个函数，求多个数的和以及平均值
def operation(*nums):
sum1 = sum(nums)
aver = sum1 / len(nums)
return sum1, aver
print(operation(1, 2, 3, 4, 5)) # (15, 3.0)
x, y = operation(1, 2, 3, 4, 5, 6, 7)
print(x, y)
(15, 3.0)
28 4.0
05.返回值的应用
返回值能做的事情，函数调用表达式都可以做
# 1.用函数调用表达式给变量赋值
def func1():
return 'hello'
# str1 = 'hello'
str1 = func1()
print(str1)
hello
# 2.通过函数调用表达式使用相应的方法
def func2():
return [1, 2]
# print([1, 2][0])
item = func2()[0]
print(item)
1
item = func2().append(3) # item获取的是append函数的返回值，append函数没有返回值
print(item)
list1 = func2()
list1.append(3)
print(list1)
None
[1, 2, 3]
# 3.将函数调用表达式作为容器的元素，函数的参数，函数的返回值
def func3():
print('hello')
return 100
# 作为值参与运算
print(func3() + 3) # print(100 + 3)
hello
103
# 作为列表元素
list2 = [func3(), 'abc']
print('list2:',list2) # [100, 'abc']
hello
list2: [100, 'abc']
# 作为字典的key和value
dict1 = {func3(): func3()} # {100:100}
print(dict1)
hello
hello
{100: 100}
# 作为函数的返回值
def func4(m):
print(m)
return func3()
hello
100
# 作为函数的实参
re = func4(func3()) # func4(100)
print(re) # 100
hello
100
06.匿名函数
匿名函数还是函数，除了声明的语法以外，函数其他的语法匿名函数都支持
1.匿名函数的声明
a.语法:
函数名 = lambda 参数列表:返回值
b.说明:
函数名 - 变量名
lambda - 关键字
参数列表 - 和普通函数的参数列表的作用和要求一样
返回值 - 相当于普通函数retrun关键字后面的表达式
注意：匿名函数中冒号后面的语句属于函数体。在声明的时候不会执行
匿名函数的调用和普通函数一模一样
# 用匿名函数求两个数的和
def my_sum(num1, num2=0):
return num1 + num2
print(my_sum(10, 20))
print(my_sum(num1=1, num2=2))
30
3
my_sum1 = lambda num1, num2=0: num1+num2
print(my_sum1(100, 200))
print(my_sum1(num1=11, num2=22))
300
33
# 练习：写一个匿名函数，求两个数的最大值
my_max = lambda x, y: max(x, y)
print(my_max(100, 200))
200
补充：python中的三目运算符
a.
C中的三目运算符： 条件语句?值1:值2 - 条件语句为True,整个表达式的结果是值1，否则是值2
int x = 10, y = 20;
max = x>y?x:y;
b.
python中的三目运算符：值1 if 条件语句 else 值2 - 条件语句为True,整个表达式的结果是值1，否则是值2
x = 10
y = 20
max1 = x if x > y else y
x = 100
y = 20
max1 = x if x > y else y
print(max1)
my_max2 = lambda num1, num2: num1 if num1 > num2 else num2
print(my_max2(20, 89))
print(my_max2(200, 89))
200
100
89
200
#练习：写一个匿名函数，获取字典中指定的key对应的值
get_value = lambda dict1, key: dict1.get(key)
print(get_value({'a': 100, 'b': 200}, 'a'))
100
list1 = [
{'name': '张三', 'age': 20},
{'name': '李四', 'age': 10},
{'name': '王五', 'age': 30}
]
def func1(item: dict):
return item['age']
list1.sort(key=func1)
list1.sort(key=lambda item: item['age'])
print(list1)
[10, 20, 30]