1. 函数返回值
1）函数的返回值：
a.就是函数返回给调用者值
b就是return关键字后面的表达式的值
c.就是函数调用表达式的值
函数的调用：
a.先回到函数调用的位置
b.用实参给形参赋值（传参）
c.执行函数体
d.执行完函数体，将返回值返回给函数调用表达式
e.回到函数调用的位置
python中每个函数都是有返回值的，返回值就是return后面的值，如果函数中没有return，那么函数的返回值就是None
2）return关键字
a.将return后面的值，返回给函数调用表达式
b.结束函数（）
3）函数结束
a.函数体执行完
b.遇到return
4）函数调用表达式
python每个函数调用表达式的都是有值
5）python中可以有多个返回值，这时候返回值是一个元组
2. 作用域
全局变量：从声明开始，到文件结束都可以使用
局部变量: 在函数中使用的变量
goloal
nonlocal：在函数中声明函数才需要使用
3. 匿名函数
匿名函数：本质函数函数，以另外一种简单的方式来声明
匿名函数的声明：
函数名 = lambda 参数列表:返回值 ---> 结果是一个函数变量
lambda：声明匿名函数的关键字
def my_sum1(x,y):
return x+y
print（my_sum1(10,20）)
#匿名函数
my_sum2 = lambda x,y:x+y
funcs = []
for i in range(5):
funcs.append(lambda x ： x*i）
print(funcs[2](2)) >>> 8
print(funcs[4](2)) >>> 8
print(i)
4.函数作为变量
1.声明一个函数就是在声明一个变量。函数名可以当成变量来使用。类型是：function
可以打印，可以赋值，可以查看类型，可以作为函数的参数，可以作为函数的返回值
a = 10
a = 'a'
print(a)
函数名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]('abc')
1.将函数作为参数
def my_sum(*numbers):
""" numbers = (10, 20) """
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)
return my_sum((10, 20, 30))
"""
a = ('1', 100, 'c')
print(*a)
print(*numbers)
return method(*numbers)
求10和20的和
print('+++++')
result = operation(my_sum, 10, 20)
# 求10*20
result2 = operation(my_mul, 10, 20)
# 判断10是否大于20
reslut3 = operation(lambda x,y:xy else y,10, 20)
"""
python中三目运算符(?:)
值1 if 表达式 else 值2 ---> 判断表达式是否为True,为True整个表达式的结果是'值1'，否则是'值2'
"""
a = 10 if 10 > 20 else 20
print(result, result2, reslut3, result4)
3.将函数作为函数的返回值
写一个函数有个参数，要求传入一个运算符号(+,-,*,>,<),返回符号对应的功能
- ——-> 求和功能
- --->求差功能
....
funca = lambda x,y:x+y
def funb(x, y):
return x+y
def get_method(char):
""" char='-' """
if char == '+':
return funb
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 < y
else:
def func(x, y):
return None
return func
print(get_method('+')(10, 20))
print(get_method('-')(10, 20))
print(get_method('%')(10, 20))
递归函数
递归函数:在函数的函数体中调用函数本身
理论上循环能做的事情，递归都可以
对递归的要求: 能不用就不用
函数调用的过程是一个压栈的过程(没调用一次函数，系统都要为其分配内存空间，
用来存储函数中声明变量和参数等，这个内存在函数调用结束后会自动销毁)
# 这个函数就是递归函数
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))
递归函数：
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
关系: 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 1+2+3+4+5
my_sum2(4) n = 4 return 1+2+3+4
my_sum2(3) n = 3 return 1+2+3
my_sum2(2) n = 2 return 1+2
my_sum2(1) n = 1 return 1
"""
用递归求246...n(n是偶数)
def mul(x):
# 1.找临界值
if x == 2:
return 2
# 2.找关系
"""
f(x) = f(x-2)*x
"""
return mul(x-2)*x
#print(mul(6))
用递归函数实现以下功能
n = 3
***
**
*
n = 4
****
***
**
*
def prin_star(n):
# 1.找临界值
if n == 1:
print('*')
return
# 2.找关系
"""
f(n)
****
***
**
*
f(n-1)
***
**
*
关系：先打印n个*,然后f(n-1)
"""
print('*'*n)
prin_star(n - 1)
#prin_star(6)
print(prin_star(3))
prin_star(3) n = 3 None print('*'*3)
prin_star(2) n = 2 None print('*'*2)
prin_star(1) n = 1 print(*)
"""
n = 4
*
**
***
****
n=3
*
**
***
"""
def prin_star2(n):
# 1.找临界值
if n == 1:
print('*')
return
prin_star2(n-1)
print('*' * n)
prin_star2(6)
1.写⼀个函数将⼀个指定的列表中的元素逆序(例如[1, 2, 3] -> [3, 2, 1])
(注意：不要使⽤列表⾃带的逆序函数)
def ni_xu():
list1 = [1,2,3,4,5,6]
list2 = []
for i in list1[::-1]:
list2.append(i)
list1 = list2
return list1
#print(ni_xu())
#2)
def ni_xu2():
list1 = [1,2,3,4,5,6]
list2 = []
j =len(list1)
for _ in range(0,j):
list2.append(list1[j-1])
j -= 1
list1 = list2
return list1
#print(ni_xu2())
2.写⼀个函数，提取出字符串中所有奇数位上的字符
str = 'adbfeff123'
def ti_qu():
for index in range(0,len(str),2):
print(str[index],end='')
#ti_qu()
3.写⼀个匿名函数判断指定的年是否是闰年
is_leap_year = lambda year(year % 400 ==0) or(year %100 != 0 and year % 4 ==0)
print(is_leap_year(2013)
4.使⽤递归打印：
"""
n = 3的时候
@
@@@
@@@@@
n = 4的时候:
@
@@@
@@@@@
@@@@@@@
"""
def print_star(row, space=0):
if row>1:
print_star(row - 1, space + 1)
print(' ' * space, end='')
print('*' * (2 * row - 1))
else:
print(' '*space+'*')
return
print_star(5)
"""
n = 4 prin_a(3) print 0个空格，7个@
n = 3 prin_a(2) print 1个空格，5个@
n = 2 prin_a(1) print 2个空格，3个@
n = 1 print 3个空格，1个@
"""
5.写函数，检查传⼊列表的⻓度，如果⼤于2，那么仅保留前两个⻓度的内容，并将新内容返回给调⽤者。
def check():
str = [1, 2, 3, 4, 5, 6, 7]
if len(str)>2:
str1 = str[0:2]
print(str1)
return check
#check()
6.写函数，利⽤递归获取斐波那契数列中的第 10 个数，并将该值返回给调⽤者。
list = [1,2,3,5,8,13,21,]
# for循环版本
def get_value(n):
a = 1
b = 1
for i in range(n-1):
a,b = b,a+b
return b
# 递归版本
def recur_fibo(n):
"""递归函数
输出斐波那契数列"""
if n ==1 or n==2:
return 1
return(recur_fibo(n-1) + recur_fibo(n-2))
print(recur_fibo(8))
7.写⼀个函数获取列表中的成绩的平均值和最⾼分
def get_info():
list1 = [1,3,4,5,6,8,10]
ave1 = sum(list1)/len(list1)
max1 = max(list1)
return ave1,max1
#print(get_info())
8.写函数，检查获取传⼊列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者
list1 = [1,2,3,4,5,6,7]
def ti_qu():
list2 = []
for index in range(0,len(list1),2):
list2.append(list1[index])
return list2
#print(ti_qu())