长风破浪正其时，Python天堑变通途（8）（小螺丝：函数2：套娃玄学：递归）

1.global关键字：修改全局变量

>>> count = 5
>>> def function():
	count = 10 #此处的修改不会改到全局变量
	print(count)

>>> function()
10
>>> count
5

>>> count = 5
>>> def function():
	global count
	count = 10
	print(count)

>>> function()
10
>>> print(count)
10

2.内嵌函数：在函数内部创建另外一个函数

3.闭包：函数式编程：

>>> def fun1(x):
	def fun2(y):
		return x*y
	return fun2()

>>> temp = fun1(3)
>>> temp
<function fun1.<locals>.fun2 at 0x02BC3108>
>>> type(temp)
<class 'function'>
>>> temp(3)
9
>>> fun1(5)(7)
35

nonlocal：在内部函数修改外部函数的局部变量

>>> def fun1():
	x = 5
	def fun2():
		x *= x
		return x
	return fun2()

>>> fun1()
Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    fun1()
  File "<pyshell#42>", line 6, in fun1
    return fun2()
  File "<pyshell#42>", line 4, in fun2
    x *= x
UnboundLocalError: local variable 'x' referenced before assignment
>>> def fun1():
	x = 5
	def fun2():
		nonlocal x
		x *= x
		return x
	return fun2()

>>> fun1()
25

4.lambda表达式：匿名函数：不需要考虑命名，不需要再额外定义函数

>>> g = lambda x : 2*x + 1
>>> g(5)
11

#带if的格式：
funcb = lambda x:x+1 if x==1 else 0
funcb(1)
out:2
funcb(2)
out:0

lambda 并不会带来程序运行效率的提高，只会使代码更简洁。

　　如果可以使用for...in...if来完成的，坚决不用lambda。

　　如果使用lambda，lambda内不要包含循环，如果有，我宁愿定义函数来完成，使代码获得可重用性和更好的可读性。

　　总结：lambda 是为了减少单行函数的定义而存在的。

5.filter( 函数名， 可迭代对象 )：过滤器

>>> def zjy(x):
	shuchu = x%2
	return(shuchu)

>>> temp = range(10)
>>> output = filter(zjy,temp)
>>> output
<filter object at 0x02B5A370>
>>> output = list(filter(zjy,temp)) #不需要写括号，只要找到那个函数即可
>>> output
[1, 3, 5, 7, 9]

>>> output = list(filter(lambda x:x%2 , temp))
>>> output
[1, 3, 5, 7, 9]

#和lambda函数结合使用：筛选出符合前者表达式的数：
list2 = list(filter(lambda x:x<=4,[2,3,4,5]))
out:[2, 3, 4]

6.map():会把可迭代序列里的每一个元素代入到前面的函数表达式进行变形，返回执行后的值

>>> output = list(map(lambda x:x*2 , range(10)))
>>> output
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#和lambda结合使用：将前一个函数映射到后面的每一个范围内的数
list1 = list(map(lambda x: x**2,[1,2,3,4]))
out: [1, 4, 9, 16]

7.屌丝函数 ---------> lambda函数作业：

>>> list1 = list(filter(lambda x:x%3==0 , range(101)))
>>> list1
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

8.递归：定义简单，逻辑清晰

1.必须有一个明确的结束条件；
2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3.相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。
4.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

9.递归pow函数：

def power(x,y):#x*power(y-1)
    if y == 0:
        return 1 #乘1相当于没乘，到这里结束了
    else:
        return x * power(x,y-1)

print(power(2,10))

10.循环从左往右写，迭代从右往左写（从结果倒推）

11.分析递归问题的步骤：
a.递的问题：先把一个问题分割成若干不同的与原问题提问方式相同的小问题，而且可以用相同的思路去解答

b.归的问题：这些问题有一个明确的终点，从这个终点开始，原路返回到原点，问题解决

c、递归的三要素:

1、明确递归终止条件；

2、给出递归终止时的处理办法；

3、提取重复的逻辑，缩小问题规模。

1). 明确递归终止条件

　　 我们知道，递归就是有去有回，既然这样，那么必然应该有一个明确的临界点，程序一旦到达了这个临界点，就不用继续往下递去而是开始实实在在的归来。换句话说，该临界点就是一种简单情境，可以防止无限递归。

2). 给出递归终止时的处理办法

　　 我们刚刚说到，在递归的临界点存在一种简单情境，在这种简单情境下，我们应该直接给出问题的解决方案。一般地，在这种情境下，问题的解决方案是直观的、容易的。

3). 提取重复的逻辑，缩小问题规模

　　 我们在阐述递归思想内涵时谈到，递归问题必须可以分解为若干个规模较小、与原问题形式相同的子问题，这些子问题可以用相同的解题思路来解决。从程序实现的角度而言，我们需要抽象出一个干净利落的重复的逻辑，以便使用相同的方式解决子问题

12.递归练习（get_digits函数）：

我的：

#读取数
#终止条件：得到结果为0
#简单结果：输出return返回值为为余数
#重复逻辑：函数内调用的值是floor除法结果，floor除法之后，将结果贴到列表里
def get_digits(n):
    if n // 10 == 0:
        list1.append(n%10)
    else:
        get_digits(n//10)
        list1.append(n%10)

num = input('输入： ')
num = int(num)
list1 = []
get_digits(num)
print(list1)

范例：

def get_digits(n):
    result = ''
    if n:
        result = get_digits(n//10)
        result += str(n%10)
    return list(result)
num = int(input('请输入一个数：'))
print(get_digits(num))

12.递归回文练习：

我的：

def zhongjian(n):#取中间值
    if n%2 == 0:
        n = n//2
        return n
    else:
        n = (n//2 + 1)
        return n

def huiwenou(str1,n,zhongnum):
    if n == zhongnum:
        if str1[n-1] == str1[zhongnum*2-n]:
            print('是回文')
    else:
        if str1[n-1] == str1[zhongnum*2-n]:
            n -= 1
            huiwenou(str1,n,zhongnum)
        else:
            print('不是回文')

def huiwenji(str1,n,zhongnum):
    if n == zhongnum:
        print('是回文')
    else:
        if str1[n-1] == str1[zhongnum*2-n-1]:
            n -= 1
            huiwenji(str1,n,zhongnum)
        else:
            print('不是回文')



str1 = input('键入：')
n = len(str1)
zhongnum = zhongjian(n)

if n%2 == 0:
    huiwenou(str1,n,zhongnum)
else:
    huiwenji(str1,n,zhongnum)

范例： 

def Huiwen(temp,start,end):
    if start > end:
        return 1
    else:
        if temp[start]==temp[end]:
            return Huiwen(temp,start+1,end-1)
        else:
            return 0
temp = input('请输入一段文字：')
length = len(temp)
end = len(temp)-1
if Huiwen(temp,0,end):
    if temp[0:length//2] == temp[length//2:length]:#解释如图所示
        print('%s不是一个回文字符串！'%temp)
    else:
        print('%s是一个回文字符串！'%temp)
else:
    print('%s不是一个回文字符串！'%temp)