函数的返回值
1.函数的返回值：
a.就是函数返回给调用者值
b.就是return关键字后面的表达式的值
c.就是函数调用表达式的值
python中每个函数都是有返回值的，返回值就是return后面的值。如果函数中没有return，那么函数的返回值就是None
**函数的调用：
a.先回到函数调用的位置
b.用实参给形参赋值（传参）
c.执行函数体
d.执行完函数体，将返回值返回给函数表达式
e.回到函数调用的位置
**函数的函数体只有在调用后才会执行
2.return关键字
a.将return后面的值，返回给函数调用表达式
b.结束函数
3.函数调用表达式
python中每个函数调用表达式的都是有值
def func1():
print('aaa')
a = func1() # 函数调用表达式
print(a, func1())
# aaa
# aaa
# None None
def my_sum(x, y):
# x=10, y=20
print(x+y) # 30
print(my_sum(10, 20)) # None
def my_sum(x, y):
# x=10, y=20
return x+y # return 30
print(my_sum(10, 20)) # 30
练习：写一个函数，判断指定的年龄是否属于成年人（返回结果）
def is_adult(age):
if age >= 18:
return True
else:
return False
if is_adult(10):
print('可以进网吧')
else:
print('未成年禁止进入')
person = {'name': '陈酌', 'is_adult':is_adult(18)}
print(person)
结果
{'name': '陈酌', 'is_adult': True}
4.函数的结束：
a.函数体执行完成
b.遇到return
def func2():
print('123') # 123
return 10 # 返回10
print('321')
print(func2()) # 10
练习：写一个函数，求1+2+3+...,和不能大于10000
def my_sum2():
sum1 = 0
number = 1
while True:
if sum1 + number >= 10000:
return sum1,number-1 # python中函数可以有多个返回值，在return后面返回多个值，每个值是一个元祖。
sum1 += number
number += 1
print(my_sum2()) # (9870, 140)
作用域
作用域：一个变量可以使用的范围，就是这个变量的作用域（函数和类可影响变量的作用域）
全局变量：从声明开始，到文件结束都可以使用
局部变量：在函数（类）中声明的变量是局部变量。作用域是从声明开始到函数结束
1.全局变量
a = 10 # 这是一个全局变量
print(a) # 10
for x in range(2):
b = 100 # 这个变量是全局变量
print(b)
print(a)
#100
#10
#100
#10
def func2():
print(b) # 100
func2()
2.局部变量
def func3():
aaa = 10 #局部变量，作用域是函数
print(aaa) # 10
func3()
# print(aaa) # 报错：NameError:mame 'aaa' is not defind
3.global和nonlocal
global:在函数中声明一个全局变量
格式：
global 变量名
变量名 = 值
abc = 'abc' # 全局变量
bcd = 'bcd'
def func4():
abc = 'aaa' # 局部变量，如果全局变量名和局部变量名相同，在函数中使用的是局部变量
print(abc) # aaa
global bcd # 说明bcd是一个全局变量
bcd = 200
print(bcd) # 200
func4()
print(abc) # abc
print(bcd) # 200
练习：声明一个变量，统计一个函数调用的次数
count = 0
def my_func():
global count
count += 1
print('=====')
my_func()
my_func()
print('=====')
my_func()
print(count)
结果
=====
=====
=====
=====
3
nonlocal:在函数中声明函数的时候，才需要使用
def func11():
a_11 = 10
print('外部',a_11)
# python中函数里面可以声明函数
def func12():
nonlocal a_11 # 使用nonlocal修饰后的变量还是局部变量
a_11 = 100
print('内部',a_11)
print('内部函数')
func12()
print('外部', a_11)
func11()
# print(a_11) 这是个局部变量，在外部不能打印。
结果
外部 10
内部 100
内部函数
外部 100
匿名函数
匿名函数：本质还是函数，以另外一种简单的方式来声明的
匿名函数的声明：
函数名 = lambda 参数列表:返回值 ---> 结果是一个函数变量
lambda：声明匿名函数的关键字
写一个函数计算两个数的和
def my_sum1(x,y):
return x+y
print(my_sum1(10, 20)) # 30
匿名函数
my_sum2 = lambda x,y:x+y
print(my_sum2(10, 20)) # 30
funcs = []
for i in range(5):
funcs.append(lambda x:x*i)
"""
i = (0, 1, 2, 3, 4)
i = 0
[lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i]
"""
# lambda 2:2*4
print(funcs[2](2)) # 8
print(funcs[3](2)) # 8
print(i) # 4
函数作为变量
1.声明一个函数就是在声明一个变量，函数名可以当成变量来使用。类型：function
可以打印、赋值、产看类型、作为函数参数、作为函数的返回值
函数名func1可以当成变量使用
def func1(a):
print(a)
return 10
print(func1, type(func1))
结果
将函数func1赋给变量a，这个时候a就是一个函数
a = func1
b = func1(10) + 100
a('aaa')
结果
10
aaa
将函数func1作为列表的元素
functions = [func1, func1(10)]
functions[0]('abc')
结果
10
abc
2.将函数作为参数
def my_sum(*numbers):
"""numbers =((10, 20, 30))"""
sum1 = 0
for item in numbers:
sum1 += item
return sum1
def my_mul(*numbers):
sum1 = 1
for item in numbers:
sum1 *= item
return sum1
def operation(method, *numbers):
"""
method = my_sum
numbers = (10, 20, 30)
return my_sum((10, 20, 30))
"""
return method(*numbers)
# 求10和20的和
result = operation(my_sum, 10, 20)
# 求10*20
result2 = operation(my_mul, 10, 20)
# 判断10是否大于20
result3 = operation(lambda x, y: x < y, 10, 20)
# 找出两个数中额定最大值
result4 = operation(lambda x,y:x if x>y else y,10, 20)
print(result, result2, result3,result4)
结果
30 200 True 20
python中三目运算符
值1 if 表达式 else 值2 ---> 判断表达式是否为True,为True整个表达式的结果是“值1”，否则是“值2”
a = 10 if 10 > 20 else 20
print(a) # 20
3.将函数作为函数的返回值
写一个函数有一个参数，要求传入一个运算符号（+，-，*，>，<），返回符号对应的功能
def get_method(char):
if char == '+':
return lambda x,y:x+y
elif char == '-':
def func(m, n):
return m - n
return func
elif char == '*':
return lambda x,y:x*y
elif char =='>':
def func(x, y):
return x>y
return func
elif char =='<':
return lambda x, y: x递归函数
1.什么是递归
递归函数：在函数的函数体中调用函数本身
循环能做的事情，递归函数都可以做
对递归的要求：能不用就不用
函数调用的过程是一个压栈的过程（每调用一次函数，系统都要为其分配内存空间，
用来存储函数中声明变量和参数等，这个内存在函数调用结束后会自动销毁）
# 这个函数就是递归函数
def fun1():
print('===')
fun1()
2.怎么写一个递归函数
a.找临界值（跳出循环 -> return）
b.找关系：假设当前函数对应的功能已经实现，找到f(n)和f(n-1)的关系
c.使用f(n-1)与前面找到关系去实现f(n)的功能
写一个递归函数实现：1+2+3+...+n
def my_sum(n):
sum1 = 0
for x in range(1, n+1):
sum1 += x
return sum1
print(my_sum(5))
结果
15
递归函数
def my_sum2(n):
# 1.找到临界值
if n == 1:
return 1
# 2.找my_sum2(n)和my_sum2(n-1)的关系：
"""
my_sum2(n):1+2+3+...+n-1+n
my_sum2(n-1):1+2+3+...+n-1+n
关系：my_sum2(n) = my_sum2(n-1)+n
"""
# 3.使用my_sum2(n-1)去实现my_sum2(n)的功能
return my_sum2(n-1)+n
print(my_sum2(5))
"""
my_sum2(5)
my_sum2(5) n = 5 return my_sum2(4)+5 1+2+3+4+5
my_sum2(4) n = 4 return my_sum2(3)+4 1+2+3+4
my_sum2(3) n = 3 return my_sum2(2)+3 1+2+3
my_sum2(2) n = 2 return my_sum2(1)+2 1+2
my_sum2(1) n = 1 return 1
"""
结果
15
用递归求2 * 4 * 6... n(n是偶数)
def my_mul(n):
# 1.找到临界值
if n % 2:
print('参数有误')
return None
if n == 2:
return 2
# 2.找关系
"""
f(x) = f(x-2)*x
"""
return my_mul(n-2)*n
print(my_mul(7))
print(my_mul(8))
结果
参数有误
None
384
n = 3
(*****
(**
(*
n = 4
（****
（***
（**
（*
def prin_star(n):
# 1.找临界值
if n == 1:
print('*')
return
# 2.找关系
"""
关系：先打印n个*，然后f(n-1)
"""
print('*'*n)
prin_star(n-1)
prin_star(7)
结果
*******
******
*****
****
***
**
*
n = 4
(*
(**
(***
(****
def prin_star(n):
# 1.找临界值
if n == 1:
print('*')
return
# 2.找关系
prin_star(n - 1)
print('*'*n)
prin_star(7)
结果
*
**
***
****
*****
******
*******