小甲鱼python--------函数二

20 作用域问题

①全局变量的优先级>局部变量②外部函数里变量的优先级>内部函数里变量的优先级

通俗地讲，如果一个变量在外面进行了声明和定义，就不能在里面进行修改，修改结果只作用于内部，在外部进行调用时变量值不改变，内部（也就是函数），相当于一个小世界，有自己的一套规则，却改变不了外部的规则。

>>> x=6
>>> def fun():
	x=10
	print(x)

>>> print(x)
6

几个基础定义：

1、内嵌函数：函数内部新创建另一个函数（内嵌函数也相当于一个小世界）

2、闭包：函数式编程的重要语法，如果在一个内部函数里，对外部作用域（但不是在全局作用域的变量）进行引用，那么内部函数就会被认为是闭包。（注意：不能越过外部函数调用内部函数，也不能通过改变内部变量去改变同名的外部函数变量）

3、nonlocal：用于声明局部变量

用来应对以下情形：其中用申明函数变量不是局部变量是一种方法，改编成列表也是种方法

4、global#类似于define，强行声明，使在在小世界里也可以通过改变同一个名字的变量来外面世界变量的好方法）

>>> x=6
>>> def fun():
	global x
	x=10
	print(x)

>>> print(x)
6
>>> fun()
10
>>> print(x)
10
>>> 

--------------------------------------------------测试----------------------------------------------------------------------------------------------------

测试题

0. 如果希望在函数中修改全局变量的值，应该使用什么关键字？

global 

 

1. 在嵌套的函数中，如果希望在内部函数修改外部函数的局部变量，应该使用什么关键字？

 nonlocal

 

2.Python的函数可以嵌套，但要注意访问的作用域问题哦，请问以下代码存在什么问题呢？

def outside():
    print('I am outside!')
    def inside():
        print('I am inside!')
inside()

inside()是内部函数，不能在外部调用
使用嵌套函数要注意一点就是作用域问题，inside()函数是内嵌在outside()函数中的，所以inside()是人妻，除了身为老公的outside()可以碰（调用），在外边或者别的函数体里是无法对其进行调用的。

3. 请问为什么代码A没有报错，但代码B却报错了？应该如何修改？
代码A：

def outside():
    var = 5
    def inside():
        var = 3
        print(var)
    inside()
outside()

代码B：

def outside():
    var = 5
    def inside():
        print(var)
        var = 3
    inside()
outside()

这里outside()函数里有一个var变量，但要注意的是，内嵌函数inside()也有一个同名的变量，Python为了保护变量的作用域，故将outside()的var变量屏蔽起来，因此此时是无法访问到外层的var变量的。

应该修改为：

def outside():
    var = 5
    def inside():
        nonlocal var
        print(var)
        var = 8
    inside()
outside()

注意比较3种情况：

>>> def outside():
    var = 5
    def inside():
        nonlocal var
        print(var)
        var = 8
    inside()

>>> outside()
5

>>> def outside():
    var = 5
    def inside():
        var = 3
        print(var)
    inside()

>>> outside()
3

>>> def outside():
    var = 5
    def inside():
        print(var)
        var = 3
    inside()

>>> outside()
Traceback (most recent call last):
  File "<pyshell#86>", line 1, in <module>
    outside()
  File "<pyshell#85>", line 6, in outside
    inside()
  File "<pyshell#85>", line 4, in inside
    print(var)
UnboundLocalError: local variable 'var' referenced before assignment

4. 请问如何访问funIn()呢？

def funOut():
    def funIn():
        print('宾果！你成功访问到我啦！')
    return funIn()

funOut()

5. 请问如何访问funIn()呢？

def funOut():
    def funIn():
        print('宾果！你成功访问到我啦！')
    return funIn

funOut()()

6. 以下是“闭包”的一个例子，请你目测下会打印什么内容？

def funX():
    x = 5
    def funY():
        nonlocal x
        x += 1
        return x
    return funY
a = funX()
print(a())
print(a())
print(a())

6
7
8
有些鱼油可能会比较疑惑，这……怎么跟全局变量一样了？局部变量x不是应该在每次调用的时候都重新初始化了吗？！

其实大家仔细看看就明白了，当a = funX()的时候，只要a变量没有被重新赋值，funX()就没有被释放，也就是说局部变量x就没有被重新初始化。

所以当全局变量不适用的时候，可以考虑使用闭包更稳定和安全

 

20函数名=lambda 参数：表达式#类似于matlab里的句柄，，function

>>> g=lambda x,y:x+y
>>> g(6,7)
13

lambda表达式的作用：

1）Python写一些执行脚本时，使用lambda就可以省下定义函数的过程，比如说我们只是需要写一个简单的脚本来管理服务器时间，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简。

2）对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候我们个函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名问题。

3）简化代码的可读性，由于普通的函数阅读经常要跳到开头def定义部分，使用lambda函数可以省去这样的步骤。

filter(function or None,iterable)：两个参数为函数和可迭代的序列（列表），函数定义了过滤的规则，默认过滤出真的部分。

>>> list(filter(None,[1,0,False,True]))
[1, True]
>>> list(filter(lambda x:x%2,range(10)))
[1, 3, 5, 7, 9]

2）map(function or None,iterable)：同filter()的两个参数相同，这个内置函数的作用是：将序列的每一个元素作为函数的参数进行运算加工，直到可迭代序列的每个元素都加工完毕，返回所有加工后的元素构成的新序列

>>> list(map(lambda x:x**2,range(10)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

----------------------------------------------测试题-------------------------------------------------------------------------------------

0.  请使用lambda表达式将下边函数转变为匿名函数？

def fun_A(x,y=3): return x*y result=lambda x,y=3 : x*y

 

1.  请将下边的匿名函数转变为普通的屌丝函数？

lambda x:x if x%2 else None

自己写的：

def add(x):

　　 if x%2:

　　　　 print(x)

　　else:

　　　　print('None') a = int(input('输入整数') ) 　　

print(add(a))

 

2.  感受一下使用匿名函数后给你的编程生活带来的变化？

1）Python写一些执行脚本时，使用lambda就可以省下定义函数的过程，比如说我们只是需要写一个简单的脚本来管理服务器时间，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简。

2）对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候我们个函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名问题。 3）简化代码的可读性，由于普通的函数阅读经常要跳到开头def定义部分，使用lambda函数可以省去这样的步骤。

 

3.  你可以利用filter()和lambda表达式快速求出100以内所有3的倍数吗？

print(list(filter(lambda x:x%3==0,range(1,100))))

 

4.  还记得列表推导式吗？完全可以使用列表推导式代替filter()和lambda组合，你可以做到吗？

[x for x in range(1,100)if x%3==0]

 

5.  还记得zip吗？使用zip会将两数以元祖的形式绑定在一块，例如：

>>> list(zip([1,3,5,7,9],[2,4,6,8,10]))

[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

但如果我希望打包的形式是灵活多变的列表而不是元祖（希望是[[1,  2],  [3,  4],  [5,  6],  [7,  8],  [9,  10]]这种形式），你能做到吗？

list(map(lambda x,y : [x,y],[1,3,5,7,9],[2,4,6,8,10]))

 

6.  请目测以下表达式会打印什么？

def make_repeat(n):

　　 return lambda s : s*n

double = make_repeat(2)

print(double(8))

print(double('FishC'))

 

 

16 FishCFishC