# 递归,简单来说就是自己引用自己，在函数中就是自己调用自己
# 	求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))