函数
1.函数的定义
- a.定义函数就是实现某一某一特定功能的代码段的封装。
- b.分类
函数可以分为内置函数和自定义函数
内置函数：python已经声明好了，程序员直接调用的函数，print，input
（相当于已经造好的机器，程序员只需要知道机器的功能和使用方法。）
自定义函数：程序员自己用，程序员直接调用的函数，可以提供给别人用
2.函数的声明
语法：
def 函数名（形象列表）
函数说明文档
函数体
说明：
def - python中声明函数的关键字
函数名 - 自己命名，要求规范，标识符，不能是关键字
pep8。名字中字母小写，多个单词之间用下划线隔开、
见名知意（看到函数，大概知道函数的功能）
（） - 固定写法
形参列表 - 形象名1，形象名2 ，，（可以有一个参数，也可以由多个参数，uekeyi没有）
形参的作用：从函数外部，向函数内部传递数据
：- 固定写法
函数说明文档 - 用来对函数功能进行说明的注释。这个注释需要使用三个双引号引起来。
函数体 - 实现函数功能的代码段。
c.初学者函数声明的过程
第一步：确定函数功能
第二部：根据函数功能确定函数名。
第三部：确定参数列表，需不需要传递额外的数据
第四部：实现函数的功能
第五步：确定返回值
def save_sum(a,b):
sum_ab = a+b
print(sum_ab)
save_sum(10,20)
save_sum(100,200)
def dayin_xing(n):
print("*"*n)
dayin_xing(10)
# 声明一个函数求1+2+3+...n
def sum_n(n):
sum1 = 0
for i in range(n+1):
sum1 += i
print(sum1)
sum_n(3)
3.函数的调用
（重点）函数在声明的时候，不会执行函数体，只有在调用的时候才会执行。
a.语法：
函数名（实参列表）
b.说明：
函数名 - 已经声明过的函数。先声明才能调用。
（） - 固定写法。
实参列表 - 实参就是给形参赋值，传递给函数内部的数据
目前来说 形参有多少，实参有多少。
4.函数的调用过程
- a.物理过程
第一步、回到函数声明的位置
第二部、用实参给形参赋值（传参）
目的：传参保证每个形参都有值
第三部、执行函数体
第四部、获取返回值
第五步、回到函数调用的位置、接着往后执行
- b.压栈过程
b.函数调用的过程是一个压栈的过程
当函数调用的时候，系统会自动的在内存中栈区间开辟空间，存储函数调用过程中的数据
（数据包括参数和在函数的声明的变量）当函数调用完成后，对应的内存空间会自动销毁
say_hello("lorry")
a = 10;b = 20
def change(a,b):
a,b = b,a
print("函数中：",a,b)
change(a,b)
print("函数外：",a,b)
5.参数部分
- 1.根据实参分为位置参数和关键字参数
- a.位置参数
实参的位置和形参的位置一一对应
- a.位置参数
def func1(a,b,c):
print("a:%d b:%d c:%d"%(a,b,c))
func1(10,20,200)
- b.关键字参数.
实参以“形参名 = 值”的形式来传参
def func1(c=100,b=500,a=20):
return a+b+c
- c.关键字参数和位置参数可以混合使用
前提：保证每个参数都有值,位置参数在关键字参数前面。
def func1(100,c=300,b=636):
def func1(100,300,c=636):
- 2.从函数声明的角度又有：参数默认值，不定长参数，参数类型说明.
- a.参数默认值
声明函数的时候可以给参数设置默认值，语法：参数名 = 默认值。
有默认值的参数写在有默认值参数的后面。
如果函数声明有默认值，调用函数的时候，有默认值的参数可以不赋值
注意：设置默认值，除了给参数设置默认值。也可以对参数的类型进行说明。
- a.参数默认值
def func1(a=10,b=20,c=50):
print("a:%d b:%d c:%d"%(a,b,c))
func1(20,86,500) #传参重新复制
func1() #不赋值也是对的
func1(1000,2000)
func1(a=10000)
#注意：有默认值的参数写在有默认值参数的后面。有默认值的参数还是可以重新赋值
def func3(a,b,c=50):
print("a:%d b:%d c:%d"%(a,b,c))
func3(20,86,500)
func3(20,b = 200,c = 300)
- b不定长参数。
不定长参数：声明函数的时候，函数的参数不确定
a.在声明函数的时候，参数名前加一个，会将这个参数变成元组，来获取多个实参的值。（位置参数调用实参）*
练习：#声明一个函数，功能求多个数的和,调用参数是不定长参数的函数的时候，不定长参数对应的位置，可以传任意个实参
def my_sum(*num):
print(num)
print(sum(num))
my_sum(1,2,3,4,5,6)
my_sum()
def func4(name,*scores):
print(name,*scores)
func4("小明",10,20,90,60)
- b.在声明函数的时候，参数名前加两个个**，会将这个参数变成字典，来获取多个实参的值。
（必须使用关键字参数）
def func5(**kwargs):
print(kwargs)
# 如果调用不定长关键字参数（**），调用的关键字可以随便命名。
func5(name= "lorry",a = 20,b = 30)
func5(c = 50,a = 20,b = 30)
func5()
def func6(a,**kwargs):
print(a,kwargs)
func6("lorry",age = 23,xuehao = 2056,hobby = "girls")
- c.一颗星和两颗星一起使用，用来表示不定长参数，调用的时候比较灵活。可以用位置，关键字参数，也可以混合传参。
要求：一颗星的参数要放在两颗星的前面。
def func7(*args,**kwargs):
print(args,kwargs)
func7(1,2,3)
func7(name = "lorry",age = 23,hobby = "girls")
func7(1,2,3,name = "lorry",age = 23,hobby = "girls")
练习：求多个数的和,要求调用函数的时候可以多样性
def my_sum(*args,**kwargs):
sum1 = sum(args)
sum2 = 0
for key in kwargs:
sum2 += int(kwargs[key])
sum3 = sum1 + sum2
print(sum3)
my_sum(10,20,a = 10,b = 20)
my_sum(a = 10,b = 20)
my_sum(10,20)
6.类型说明
参数类型说明只是对参数类型进行提示，不能限制参数的类型
a.设置默认值
b.参数名后面加冒号：类型名
注意：类型说明除了说明类型意外，还可以做相应类型的语法提示。
def func8(a:int,b=""):
print(a,b)
func8(1.2,20) #会有颜色提醒
func8([1,2],"lorry") #会有颜色提醒
func8(1,b = "lorry")
def func8(a1:list,a:int,b=""):
a1.append()
print(a1,a,b)
func8(10,10,20)
7.函数 的返回值
1.返回值
- a.函数的返回值就是return关键字后面表达式的值，就是函数调用表达式的值。
- b.python中所有的函数都有返回值，默认的返回值是None
return - 关键字 只能写到函数体里面。返回返回值；结束函数
如果函数体重没有return，函数的返回值是none、，函数会在执行完函数体后将none作为函数的返回值
函数调用表达式 - 调用函数的语句；当函数调用完成后，函数调用表达式的结果就是函数的返回值
函数返回值，永远只是看return，遇到就是return后面的值，没有遇到就是none。 - c.返回值的作用：就是将在函数内部产生的数据传递到函数的外部。防止在函数调用完成后被销毁。
- d.什么时候使用返回值，如果实现函数的功能会产生新的数据，一般都会讲这个数据返回。
def func1(m, n):
print(m, n)
return 100 # 关键字,将100作为函数的返回值
func1(10, 20)
def func1(m, n):
return m + n # 关键字,将m+n作为函数的返回值
func1(10, 20)
def func1(m, n):
return 100 # 直接结束
print(m, n)
func1(10, 20)
def func1(m, n):
return None # 关键字,将None作为函数的返回值，结束函数
func1(10, 20)
def func4(m):
if m % 2 == 0:
return "偶数" # 关键字,将None作为函数的返回值，结束函数
func4(2) # 当函数调用完成时 此时的func4(2)就是返回值“偶数”，他就可以做任何事情
print(func4(2))
func4(11)
print(func4(11))
2.返回多个返回值（支持元组的语言）
:return 返回值1，返回值2，返回值3
练习，功能求多个数的和以及平均值
def ave_and_sum(*args, **kwargs):
sum1 = 0
sum2 = sum(args)
for key in kwargs:
sum1 += kwargs[key]
sum3 = sum1 + sum2
ave = sum3 / (len(args) + len(kwargs))
return sum3, ave
sum3, ave = ave_and_sum(10, 20, a = 10, b = 20)
print(sum3, ave) # 实质就是一个元组
单独将 敲黑板
返回值能做的事情，函数调用表达式都可以做
1.用函数调用表达式给变量赋值
def func1():
return "hello"
a = func1()
print(a)
print(len(a))
print(a+"lory")
for x in a:
print(x)
print(a.center(11,"*"))
两种对比：
def func1():
return "hello"
print(func1())
print(len(func1()))
print(func1()+"lory")
for x in func1():
print(x)
print(func1().center(11,"*"))
def func1():
return "hello"
aa = list(func1())
print(aa)
aa.append(100)
print("===============",aa)
2 .通过函数调用表达式使用相应的方法。
def func2():
return [1,2]
item = func2().append(3)
print(item) #item获取的是append的返回值，append是没有返回值的
print(func2())
def func2():
return [1,2]
func2().append(3)
print("************",func2())
a=[1,2]
a.append(3)
print(a)
3. 将函数调用表达式作为容器的元素，函数的参数，函数的返回值
def func3():
return 100
print(func3()+3)
list2 = [func3(),"abc"] #容器的元素
print("list2:",list2)
def func4(m):
print(m)
print(func4(func3())) #函数的参数
def func4(m):
return func3() #函数的返回值
print("==========**********",func4(func3())) #函数的参数
def func3():
print("*****")
return 100
dict1 = {func3():func3()} #容器的元素
print({func3():func3()})
print(dict1)
print([1,2,4].append(3)) #函数没有返回值
匿名函数
匿名函数的调用：和普通函数都是一样的。
1.####函数的声明
a.语法
函数名 = lambda 参数列表：返回值
b.说明：
函数名 - 变量名
lambda - 关键字
参数列表 - 和普通列表的参数和作用是一样的，还是从外部向内部赋值。
返回值 - 相同于的普通函数return关键字后面的表达式。
匿名函数中：后面的语句属于函数体，在声明的时候不会执行。
匿名函数求两个数的和
my_sum = lambda num1, num2: num1+num2
my_sum(10,20)
print(my_sum(10,20))
print(my_sum(num1=1,num2=2))
my_sum = lambda num1, num2=10: num1+num2
print(my_sum(10))
print(my_sum(10,20))
list1 = [{"name":"lorry","age":"23"},
{"name":"xiaohong","age":"36"},
{"name":"xiaomin","age":"11"}
]
def func1(item:dict):
return item["age"]
list1.sort(key=func1)
print(list1)
list2 = [{"name":"lorry","age":"23"},
{"name":"xiaohong","age":"36"},
{"name":"xiaomin","age":"11"}
]
list2.sort(key=lambda item:item["age"])
print(list2)
练习 ：写一个匿名函数，求两个数的最大值
max_num = lambda num1, num2 :max(num1,num2)
print(max_num(9,8))
my_max2 = lambda num1,num2:num1 if num1 > num2 else num2
print(my_max2(100,1000))
补充：
a.C中的三目运算符：条件语句？值1：值2 - 条件语句为True，整个表达式结果是值1，否则是值2
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 = 10
y = 20
max1 = x if x > y else y
print(max1)
练习，写一个匿名函数获取字典中对应的值
dict2 = {"name":"lorry","age":"23"}
my_key = lambda dict1,key:dict1.get(key)
print(my_key(dict2,"name"))
