# 递归,简单来说就是自己引用自己，在函数中就是自己调用自己
# 求10的阶乘
def fn(num):
for x in range(1,num):
num *= x
return num
print(fn(10))
# 递归是解决问题的一种方式，类似于循环
# 递归函数的两个要件
# 基线条件：问题可以被分解为最小的问题，当满足基线条件时，递归就不在执行了
# 递归条件：将问题继续分解的条件
def factorial(n):
if n == 1:
return 1
else :
return n * factorial(n-1)
print(factorial(8))
# 求任意一个数的n次幂
def power(n,i):
if i == 1:
return n
else:
return n * power(n , i-1)
print(power(8,6))
# 检查一个字符串是否是回文
# abcddbca
def huiwen(s):
if len(s) < 2:
return True
elif s[0] != s[-1]:
return False
else :
return huiwen(s[1:-1])
print(huiwen('abcddcba'))
# 高阶函数：接受函数作为参数。
l = [1,2,3,4,5,6,7,8,9]
# 定义一个函数，将制定列表中的所有偶数保存到新列表返回
def fn1(func,lst):
new_list = []
for x in lst:
# if x % 2 == 0:
if func(x):
new_list.append(x)
return new_list
def fn2(n):
if n % 2 != 0:
return True
return False
def fn3(n):
if n > 4:
return True
return False
print(fn1(fn3,l))
# filter(),可以从序列中过滤出符合条件的元素保存到新的序列中
# 参数：
# 函数，根据该函数过滤序列
# 需要过滤的序列
# 返回值：
# 过滤后的新序列
print(list(filter(fn2,l)))
# 匿名函数lambda表达式,一般作为参数使用
# 专门用来创建一些简单的函数，
fn4 = lambda a,b : a + b
print(fn4(10,12))
res = filter(lambda i : i > 5 ,l)
print(list(res))
# map() 函数可以对可迭代对象中所有元素做指定操作，并添加到新对象中返回。
res = map(lambda i : i ** 2, l)
print(list(res))
# sort() 用来对列表中的元素进行排序，默认是直接比较列表中元素大小
# 该函数可以接收一个关键字参数，key,
# key需要一个函数作为参数，当设置了函数作为参数，每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素大小
l = ['aaa','ffas','ffqwe','fgf','jack','mark']
l.sort()
print(l)
# sorted() 该函数和sort()函数用法基本一致，但是sorted()可以对任意的序列进行排序
# 并且使用该函数不会对原来的对象产生影响，会返回一个新的对象
l = ['1',9,'2',3,'7',4,'5',5]
l = '12896425'
print(sorted(l,key=int))
# 将函数作为返回值的函数。
# 这种函数也称为闭包，通过闭包可以创建一些只有当前函数能访问的变量。
# 可以将私有的数据放在闭包中。
def fn():
a = 10
def inner():
print('inn')
return inner
fn()()
# 闭包的要件
# 函数嵌套
# 将内部函数作为返回值返回
# 内部函数必须要使用外部函数的变量
def make_averager():
nums = []
def averager(n):
nums.append(n)
return sum(nums) / len(nums)
return averager
averager = make_averager()
print(averager(10))
print(averager(20))
print(averager(30))
