函数的声明
def 函数名(参数1:类型名1，参数2:类型名2)-->返回值类型
函数体的描述信息
函数体
补充：参数列表中，可以通过'参数名：类型名'来指定参数类型，也可以通过设置默认值来说明参数类型
说明的好处：a.传什么类型的值一目了然
b.实现函数体的时候，可以有相关提示
声明函数的时候不会执行函数体
2.函数的调用
函数名（实参列表）
调用过程
第一步：回到函数声明的位置
第二步：实参给形参赋值 --->传参(每个参数都有值)
第三步：执行函数体
第四步：返回值 -->将函数调用表达式设置为返回值
第五步：回到函数调用的位置，接着往后执行
3.函数的参数
位置参数
关键字参数
参数的默认值 -->有默认值的参数要放在没有默认值的参数的后面
不定长参数
*参数名：将位置参数作为元祖的元素。参数就是一个元祖
def func1(*args):
print(args)
func1(1,2,3)
#(1, 2, 3)
**参数名：将关键字参数，一参数名为key，实参为值组合成键值对，作为字典的元素，参数是一个字典
def func2(**kwargs):
print(kwargs)
func2(a=1,b=2,小=3)
#{'a': 1, 'b': 2, '小': 3}
注意：args，kwargs经常一起组合使用，要放在**前面
def func2(*args,**kwargs):
print(args,kwargs)
func2(10,20,a=1,b=2,小=3)
sum1 = lambda num1,num2: num1 + num2
print(sum1(10,20))
#(10, 20) {'a': 1, 'b': 2, '小': 3}
*返回值
所有函数都有返回值。如果遇到return,函数的返回值就是return后面的值，没有遇到返回值就返回None
返回值就是调用表达式的值。
调用函数的目的：a.执行函数体 b.获取返回值(函数中遇到return函数就结束)
def func2(*args,**kwargs):
print(args,kwargs)
func2(10,20,a=1,b=2,小=3)
#(10, 20) {'a': 1, 'b': 2, '小': 3}
匿名函数
函数名 = lambda 参数列表：返回值
说明：
函数名 -> 变量名
lambda -> 关键字
参数列表 ->参数名1，参数名2.....（必须要有值）
：->固定的
返回值 -> 相当于只有一个return语句的函数体
匿名函数的调用和普通函数一样：函数名(实参列表)
sum1 = lambda num1,num2: num1 + num2
print(sum1(10,20))
#30
#求1+2+3+4....+n的和
sum2 = lambda num1:sum(range(num1+1))
print(sum2(100))
#5050
练习：读函数
funcs = []
for item in range(1,5):
funcs.append(lambda x: x*item)
print(funcs[0](2)) #8
print(funcs[1](2)) #8
print(funcs[2](2))#8
'''
item = 1 ~ 4
item = 1 [lambda x: x*item]
item = 2 [lambda x: x*item, lambda x: x*item]
item = 3 [lambda x: x*item, lambda x: x*item, lambda x: x*item]
item = 4 [lambda x: x*item, lambda x: x*item, lambda x: x*item, lambda x: x*item]
'''
变量的作用域
变量的作用域指的是变量能够使用的范围
全局变量和局部变量
全局变量：什么在函数和类的外面都是全局变量，作用域是从声明开始到整个py文件结束
# a 是全局变量
a = 10
# x和b都是全局变量
for x in range(5):
b = 10
print(x)
# c是全局变量
for x in range(5):
for y in range(4):
c = 100
print(c)
局部变量：声明在函数和类中的变量都是局部变量。声明在函数的局部变量，作用域是从声明开始到整个函数结束
# 全局变量
a1 = 100
def fun1():
# 局部变量
aa = 100
print(aa, a1)
for xx in range(5):
print(aa+xx)
fun1()
# print(aa) # NameError: name 'aa' is not defined
global关键字
在函数中说明一个变量是全局变量
#没有global
name = 'abc' #全局变量
def fun2():
name = 'aaa' #局部变量也叫name
print(name) #打印局部变量name
fun2()
print(name) #打印全局name变量
#aaa
#abc
#有global
name = 'abc' #全局变量
def fun2():
global name #说明是全局变量name
name = 'aaa' #修改全区变量name
print(name)
fun2()
print(name) #打印全局name变量
#aaa
#aaa
#还可以这样用
def fun3():
global age #说明局部变量 可以作为全局变量
age = 18
fun3()
age = 17 #在外面修改局部变量age
print(age) #在函数外面也可以打印函数里的age
#17
nonlocal关键字
def fun3():
abc = 100 # fun3现在是100
def fun4():
nonlocal abc #说明fun3 .abc是局部的abc
abc = 200# 现在fun3度abc被修改成200
print('f4:',abc)打印fun4点abc,200
fun4()
print('f3:',abc)
fun3()
f4: 200
f3: 200
函数作为变量
声明函数就是声明一个类型是function的变量，函数名实质就是变量名。
# 声明一个变量func1,类型是function
def func1():
print('我是函数')
# 用一个函数给变量赋值
a = func1
# 现在a就相当于函数，调用函数
a()
#我是函数
函数作为列表的元素
def fun1(n):
return n
print([1, fun1(5), fun1, fun1(10)])
#[1, 5, , 10]
将函数作为参数
a = 10
list1 = [1, a]
print(list1, list1[1]+100)
def func22():
print('我又是函数')
return 10
list2 = [1, func22, func22()]
print(list2)
#我又是函数
#[1, , 10]
# list2[1]取到一个函数, 通过后面加()调用函数
print(list2[1]())
#我又是函数
#10
# list2[2]取到的是整数10
print(list2[2]+100) #110
函数的调用
2.函数的调用过程是一个压栈的过程
每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数执行过程中产生数据(函数中声明的变量)。
当函数调用完成后，这块内存会自动销毁。
递归函数
2.怎么写递归函数
第一步：确定临界值（循环结束的条件），让函数结束
第二步：找关系，假设函数的功能已经实现，找f(n)和f(n-1)的关系
第三步：根据关系，用f(n-1)实现f(n)的功能
"""
yt_sum(5) n=5 5!=1 return yt_sum(4)+5
yt_sum(4) n=4 4!=1 return yt_sum(3) + 4
yt_sum(3) n=3 3!=1 return yt_sum(2) + 3
yt_sum(2) n=2 2!=1 return yt_sum(1) + 2
yt_sum(1) n=1 1==1 return 1
"""
# 写一个递归函数，实现：1+2+3+...n
def yt_sum(n):
# 1.找临界值
if n == 1:
return 1
# 2.找关系
"""
yt_sum(n) = 1+2+3+...+n
yt_sum(n-1) = 1+2+3+...+n-1
yt_sum(n) = yt_sum(n-1)+n
"""
# 3.用f(n-1)实现f(n)的功能
return yt_sum(n-1) + n
print(yt_sum(5))
# 用递归实现以下功能
"""
n = 3
***
**
*
n = 4
****
***
**
*
f(n)和f(n-1)的关系：
先打印n颗星
f(n-1)
"""
def print_star(n):
if n == 1:
print('*')
return
print('*'*n)
print_star(n-1)
print_star(5)
"""
n = 3
*
**
***
n=4
*
**
***
****
"""
# 总结：递归，能不用就不用！！