1.函数的返回值
a.就是函数返回给调用者的值
b.就是return关键字后面的表达式的值
c.就是函数调用表达式的值
python中每个函数都是有返回值的
1.2.关键字return
a.将return后面的值，返回给函数调用表达式
b.结束函数(函数执行过程中遇到return就结束)
1.3.函数调用表达式
python中每个函数调用表达式都是有值的，返回值就是return后面的值。如果函数中没有ruturn，那么函数的返回值就是None
1.4.函数的调用
a.回到函数声明的地方
b.将实参的值赋给形参
c.执行函数体
d.执行完函数体，将返回值返回给函数调用表达式
e.回到函数调用的位置
def func1():
print('aaa')
a = func1() # 函数调用表达式
print(a, func1())
def my_sum(x, y):
return x+y
print(my_sum(1, 2))
# 练习：写个函数，判断指定的年龄是否属于成年人（返回结果）
def is_adult(age):
if age >= 18:
return True
else:
return False
if is_adult(19):
print('可以进网吧')
else:
print('未成年人禁止进入')
1.5.函数的结束：
a.函数体执行完
b.遇到return
def func2():
print('123')
return 10
print('321')
print(func2())
"""
函数功能：下载指定地址对应的数据
def download(url):
判断有没有网
if 没有网:
return None
写网络请求
请求数据
保存数据
"""
# 练习：求1+2+3+...+N,和不能大于10000
def my_sum2():
sum1 = 0
number = 1
while True:
if sum1 + number >= 10000:
return sum1,number-1 # python中函数的return可以有多个值(用逗号隔开)，返回值是一个元祖
sum1 += number
number += 1
# sum1 += number
# if sum1 > 10000:
# return number-1
# number += 1
print(my_sum2())
2.作用域
一个变量可以使用的范围，就是这个变量的作用域（函数和类可以影响变量的作用域）
全局变量：从声明开始，到文件结束都可以使用
局部变量：在函数(类)中声明的变量。作用域是从声明开始到函数结束
2.1.全局变量
a = 10 # 全局变量
for x in range(10):
b = 100 # 全局变量
print(a)
print('==', b)
def func2():
print(b)
func2()
2.2.局部变量
def func3():
aaa = 100 # 局部变量，作用域是函数
print(aaa)
func3()
# print(aaa) # 报错：NameError
2.3.global和nonlocal
global:在函数中声明或修改一个全局变量
个数：
global 变量名
变量名 = 值
abc = 'abc' # 全局变量
bcd = 'bcd'
def func4():
abc = 'aaa' # 声明了一个局部变量，如果全局变量名和局部变量名相同，在函数中使用的是局部变量，
print(abc)
global bcd # 说明bcd是一个全局变量
bcd= 200
print(bcd)
func4()
print(abc)
print(bcd)
# 练习：声明一个变量，统计一个函数调用的次数
count = 0
def func_():
global count
count += 1
print('aaa')
func_()
func_()
func_()
print(count)
nonlocal：在函数中声明函数的时候，才可以使用
def func_11():
a_11 = 10
print('外部', a_11)
# python中函数里可以声明函数
def func_12():
nonlocal a_11 # 修改原有的，不是声明新的变量
a_11 = 100
print('内部', a_11)
print('内部函数')
func_12()
print('外部', a_11)
func_11()
3.匿名函数
匿名函数：以另外一种简单的方式来声明
匿名函数的声明：
函数名 = lambda 参数列表:返回值 --> 结果是一个函数变量
lambda:声明匿名函数的关键字
# 计算两个数的和
def my_sum1(x, y):
return x+y
print(my_sum1(10, 20))
# 匿名函数
my_sum2 = lambda x,y:x+y
print(my_sum2(1, 2))
#
funcs = []
for i in range(5):
funcs.append(lambda x: x*i)
"""
funcs = [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
列表中存放的是函数，只有在调用时函数才会执行
"""
print(i)
print(funcs[1])
print(funcs[2](2))
print(funcs[3])
print(funcs[4](2))
4.函数作为变量
声明一个函数就是在声明一个变量。函数名可以当成变量来说使用。类型是，function
可以打印，可以赋值，可以查看类型，可以作为函数的参数，可以作为函数的返回值
# 函数名func1可以当成变量使用
def func1(a):
print(a)
return 10
print(func1, type(func1))
# 将函数func1赋给变量a，这个时候a就是一个函数
a = func1
b = func1(10) + 100
a('aaa')
#将函数func1作为列表的元素
functions = [func1, func1(10)]
functions[0]('bbb')
4.1.将函数作为参数
def my_sum(*numbers):
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, a, b):
"""
method = my_sum
numbers = (1, 2, 3)
:return my_sum((1, 2, 3))
"""
return method(a, b)
# 求1+2的和
result1 = operation(my_sum, 1, 2)
# 求1*2的积
result2 = operation(my_mul, 1, 2)
# 判断1是否大于2
result3 = operation(lambda x, y: x > y, 1, 2)
# 找出两个数中的最大值
result4 = operation(lambda x, y: x if x > y else y, 1, 2)
print(result1, result2, result3, result4)
4.2.python中三目运算符
值1 if 表达式 else 值2 -->判断表达式是否为True，为True整个表达式的结果是'值1'，否则是'值2'
a = 1 if 1 < 2 else 2
print(a)
4.3.将函数作为函数的返回值
# 要求传入一个运算符（+，-，*，<, >）,返回符号对应的功能
# + --> 求和功能
# - --> 求差功能
# ....
func_a = lambda x, y: x + y
def func_b(x, y):
return x + y
def get_method(char):
if char == '+':
# return func_a
# return func_b
return lambda x, y: x + y
elif char == '-':
return lambda x, y: x - y
elif char == '*':
return lambda x, y: x * y
elif char == '>':
return lambda x, y: x > y
elif char == '<':
def func(x, y):
return x < y
return func
else:
def func(x, y):
return None
return func
print(get_method('+')(10, 20))
print(get_method('-')(10, 20))
print(get_method('*')(10, 20))
print(get_method('<')(10, 20))
print(get_method('>')(10, 20))
print(get_method('%')(10, 20))
5.递归函数
5.1.什么是递归
递归函数：在函数的函数体中调用函数本身
理论上循环能做的事情，递归都能做
对递归的要求：能不用就不用
函数调用的过程是一个压栈的过程(每调用一次函数，系统都要为其分配内存空间，
用来存储函数中声明变量和参数等，这内存在函数调用结束后会自动销毁)
# 递归函数
def fun1():
print('===')
fun1()
5.2.怎么写递归函数
a.找临界值(跳出循环 --> return)
b.找关系：假设当前函数对应的功能已经实现，找到f(n)-f(n-1)的关系
c.使用f(n-1)与前面（b）找到的关系去实现f(n)的功能
# 写一个递归函数实现：1+2+3+...+N
def my_sum1(n):
sum1 = 0
for x in range(1, n + 1):
sum1 += x
return sum1
print(my_sum1(3))
# 递归函数
def my_sum2(n):
# 1.找临界值
if n == 1:
return 1
# 2.找my_sum2(n)与my_sum2(n-1)的关系
"""
my_sum2(n):1+2+...+(n-1)+n
my_sum2(n-1):1+2+...+(n-1)
关系：my_sum2(n) = my_sum2(n-1) + n
"""
# 使用my_sum2(n-1)去实现my_sum2(n)的功能
return my_sum2(n-1) + n
print(my_sum2(3))
"""
my_sum2(3)
my_sum2(3) n = 3 return my_sum2(2)+3
my_sum2(2) n = 2 return my_sum2(1)+2
my_sum2(1) n = 1 return 1
"""
# 用递归求2*4*6*...*n(n是偶数)
def mul(n):
# 1.找临界值
if n % 2:
print('参数有误')
return None
if n == 2:
return 2
# 2.找关系
return mul(n-2)*n
print(mul(6))
def my_mul(n):
if n == 1:
return 2
return my_mul(n-1)*(2*n)
print(my_mul(3))
"""
n = 3
***
**
*
"""
def print_(n):
if n == 1:
print('*')
return
print('*'*n)
print_(n - 1)
print_(5)
def print_str(n):
if n == 1:
print('*')
else:
print_str(n-1)
print('*'*n)
print_str(3)
