day15-函数进阶

1、函数嵌套

多个函数嵌套在一起即为函数嵌套

在调用函数时，函数需在调用之前定义，如果函数在调用之后才定义，则不能被成功调用。
当定义多个函数时，函数名称不能相同，否则后定义的函数会将之前的函数覆盖，即之前的函数失效。

 #定义一个函数，划一条横线
 def printLine():
         print('-'*30)

 #定义一个函数，调用上一个函数，并按用户输入的值划出指定条数的横线
 def stringPrint(index):
         i = 0
         while i<index:
                 printLine()
                 i+=1

 indexNum = int(input('请输入横线的行数：'))
 stringPrint(indexNum)

注意：
最初需求为划一条横线，当需要变更为按用户需求划出n条横线时，不要直接更改原有的函数代码，因为原函数可能在其他地方也被调用，而应该重新定义一个函数来实现新的功能，当需要重复执行原函数的功能时，可以直接调用原函数，而不要重复编写原函数的代码。

求3个数的和、3个数的平均值

 #定义一个函数，求3个数的和：
 def sum3Num(a,b,c):
         sum = a+b+c
         return sum

 #定义一个函数，求3个数的平均值
 def ava3Num(a,b,c):
         sum = sum3Num(a,b,c)
         ava = sum/3
         return ava

 a = int(input('请输入第一个数：'))
 b = int(input('请输入第二个数：'))
 c = int(input('请输入第三个数：'))

 result = sum3Num(a,b,c)
 ava = ava3Num(a,b,c)
 print('和为%d'%result)
 print('平均值为%d'%ava)

2、高阶函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
一个最简单的高阶函数：

1 def add(x, y, f):
2     return f(x) + f(y)

当我们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs
add(-5, 6, abs)
11

编写高阶函数，就是让函数的参数能够接收别的函数。

有两种情况属于高阶函数：
1、把一个函数的内存地址当作参数传给另外一个函数
2、一个函数把另外一个函数当作返回值返回

例子
编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。

 def calc_prod(lst):
     def lazy_prod():
         def f(x, y):
             return x * y
         return reduce(f, lst, 1)
     return lazy_prod
 f = calc_prod([1, 2, 3, 4])
 print f()

在函数calc_proc内部返回了内部函数的值，但是没有调用内部函数，所以在全局命名变量f时不会调用函数lazy_prod()

当f()时才会调用，可以选择在需要的时候通过f()进行调用，也称为延迟调用。

如果函数calc_proc内部返回了lazy_prod()的话就会在全局定义变量f时就会调用内部函数。

3、递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

python默认递归函数最多能有999层，也可以改默认值

import sys
sys.setrecursionlimit(10000)
def func(x):
    print(x)
    x +=1
    func(x)
func(1)

将递归函数默认限制层数改成10000，实际执行测试时可以执行8000多次，要看PC性能了。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

于是，fact(n)用递归的方式写出来就是：

 def fact(num):
     if num == 1:
         return 1
     return num*fact(num-1)

 result = fact(5)
 print('fact=%d'%result)

或者

 def fact(num):
     if num>1:
         return num*fact(num-1)
     return 1

计算10的阶乘也可以使用reduce

 from functools import reduce
 def fact(n):
     return reduce(lambda x,y:x*y, range(1,n+1) )
 print(fact(10))

 或者直接输出：
 print(reduce(lambad x,y:x*y, range(1,11)))

也可以使用for循环相乘

 def cal(n):
     result = 1
     for i in range(1,n+1):
         result *=i
     print(result)
 cal(4)

或倒序

 def cal(n):
     for i in range(n-1,0,-1):
         n*=i
     return n
 print(cal(4))

或

 def cal(n):
     result = 1
     for i in range(n,0,-1):
         result*=i
     return result
 print(cal(4))

 例子：生成一个斐波那契数列

def fib(max):
    a = 0
    b = 1
    n = 0
    while n<max:
        print(b)
        a, b = b, a+b
        n+=1
fib(8)

结果：

1
1
2
3
5
8
13
21

输出斐波那契数列中指定下标的数字

def fib2(n):
    if n == 1 or n == 2:
        return 1
    elif n > 2:
        return fib2(n-2) + fib2(n-1)
print(fib2(5))

结果：5

例子：将列表中的3变成字符串‘101’

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 创建一个列表循环函数，如果元素还是列表，就再调用列表循环函数，直到元素不是列表类型了，再判断元素如果等于3就换成'101'

 def change(li, old, new):
     for i in range(len(li)):
         if isinstance(li[i], list):
             change(li[i],old,new)
         if li[i] == old:
             li[i] = new
 change(lis, 3, '')
 print(lis)

4、二分查找

li = [1,2,3,5,6,8,10,12,15,16,17,18,20]
#li_1 = list(range(1,10000000))#试验了查了22次能查1000万，查1亿需要25次，电脑快死机了不知道为什么

 def find(find_str, lst, count):
     mid = len(lst) // 2
     if len(lst) == 1:
         if find_str == lst[0]:
             count +=1
             print('找了' + str(count) + '次就找到了')
     elif mid > 0:
         if lst[mid] == find_str:
             count += 1
             print('找了' + str(count) + '次就找到了')
         elif lst[mid] > find_str:
             find(find_str, lst[:mid], count + 1)
         else:
             find(find_str, lst[mid + 1:], count + 1)
     else:
         print('找了' + str(count) + '次也没找到')
 find(200,li, 0)

5、函数返回值

Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！

例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

def f():
    print 'call f()...'
    def g():
        print 'call g()...'
    return g

仔细观察上面的函数定义，我们在函数f内部又定义了一个函数g。由于函数g也是一个对象，函数名g就是指向函数g的变量，所以，最外层函数f可以返回变量g，也就是函数g本身。

调用函数 f，我们会得到 f 返回的一个函数：
>>> x = f()   #调用f()
call f()...
>>> x 　　 #变量x是f()返回的函数：
<function g at 0x1037bf320>
>>> x()       #x指向函数，因此可以调用
call g()...     #调用x()就是执行g()函数定义的代码

请注意区分返回函数和返回值：

def myabs():
　　return abs # 返回函数
def myabs2(x):
　　return abs(x) # 返回函数调用的结果，返回值是一个数值

返回函数可以把一些计算延迟执行。例如，如果定义一个普通的求和函数：

def calc_sum(lst):
　　return sum(lst)

调用calc_sum()函数时，将立刻计算并得到结果：
>>> calc_sum([1, 2, 3, 4])
10

但是，如果返回一个函数，就可以“延迟计算”：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum    

# 调用calc_sum()并没有计算出结果，而是返回函数:
>>> f = calc_sum([1, 2, 3, 4])
>>> f
<function lazy_sum at 0x1037bfaa0>

# 对返回的函数进行调用时，才计算出结果:
>>> f()
10

由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

例子：
编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。

from functools import reduce
def calc_prod(lst):
    def lazy_prod():
        def f(x, y):
            return x * y
        return reduce(f, lst, 1)
    return lazy_prod
a = calc_prod([1, 2, 3, 4])
print(a())

结果：24

6、闭包

在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：

def g():
　　print 'g()...'

def f():
　　print 'f()...'
　　return g

将 g 的定义移入函数 f 内部，防止其他代码调用 g：

def f():
　　print 'f()...'
　　def g():
　　　　print 'g()...'
　　return g

但是，例如下面定义的 calc_sum 函数：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。

像这种内层函数引用了外层函数的变量（参数也算变量，并且是非全局变量），然后逐层返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：
# 希望一次返回3个函数，分别计算1x1,2x2,3x3:

def count():
　　fs = []
　　for i in range(1, 4):
　　　　def f():
　　　　　　return i*i
　　　　fs.append(f)
　　return fs

f1, f2, f3 = count()
print(f1(),f2(),f3())

你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（可以验证）。
原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：
>>> f1()
9 # 因为f1现在才计算i*i，但现在i的值已经变为3
因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。

def f(j):
    def g():
        return j*j
    return g

它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。

在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print(f1(), f2(), f3())

或

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            return j*j
        fs.append(f(i))
    return fs

f1,f2,f3=count()
print(f1,f2,f3)

结果为1，4，9

例子2

li = []
for i in range(10):
    def func():
        return i
    li.append(func)

for j in li:
    print(j())

结果全是9，因为在循环时添加到列表中的只是函数名或者叫函数内存地址，而并没有调用函数，因为i的值并没有添加到列表中 #而当循环列表中的函数，再挨个调用时才传入i的值，这时i为9

print(li)

可以看到列表中只是函数内存地址 [<function func at 0x02781A50>, <function func at 0x027818A0>, <function func at 0x02781A98>, <function func at 0x02781B28>,
<function func at 0x02781B70>, <function func at 0x02781BB8>, <function func at 0x02781C00>, <function func at 0x02781C48>,
<function func at 0x02781C90>, <function func at 0x02781CD8>]

li = []
for i in range(10):
    def func():
        return i
    li.append(func())
print(li)

结果： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

这次是在循环时就调用了函数func()，所以结果是将i的值循环加入了列表

l1 = [lambda x:x+i for i in range(10)]
for j in l1:
    print(j(1))

#结果全是10，因为列表中是10个函数内存地址，在调用j()时才将最终的i=9传入函数

print(l1)

#[<function <listcomp>.<lambda> at 0x02151A98>, <function <listcomp>.<lambda> at 0x02151AE0>, <function <listcomp>.<lambda> at 0x02151A50>,
<function <listcomp>.<lambda> at 0x021518A0>, <function <listcomp>.<lambda> at 0x02151BB8>, <function <listcomp>.<lambda> at 0x02151C00>,
<function <listcomp>.<lambda> at 0x02151C48>, <function <listcomp>.<lambda> at 0x02151C90>, <function <listcomp>.<lambda> at 0x02151CD8>,
<function <listcomp>.<lambda> at 0x02151D20>]

l2 = (lambda x:x+i for i in range(10))
for j in l2:
    print(j(1))

#结果是1-10，因为用()时是生成了一个生成器表达式，只有被调用时才返回值

print(l2)

#<generator object <genexpr> at 0x0215EB70>

例子3

Python遇到闭包，空间不会随着函数的执行结束而消失，保存闭包数据不会销毁

def wrapper(x):
    n = 1
    def inner():
        nonlocal n
        n += x
        print(n)
    return inner

ret = wrapper(5)
ret()
ret()
ret()
ret()

6
11
16
21

判断闭包函数的方法__closure__

#输出的__closure__有cell元素 ：是闭包函数
def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()

#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()

from urllib.request import urlopen

def index():
    url = "http://www.xiaohua100.cn/index.html"
    def get():
        return urlopen(url).read()
    return get

xiaohua = index()
content = xiaohua()
print(content)