python 函数作用域

python函数之作用域：

>>> def times(x,y):
		return x*y

>>> times(2,4)
8
>>> times(3.1,4)
12.4
>>> times('eop',4)
'eopeopeopeop'
>>> def inset(s1,s2):
        res=[]
        for x in s1:
            if x in s2:
                res.append(x)
        return res

>>> s1='jacck'
>>> s2='jimmk'
>>> inset(s1,s2)
['j', 'k']
>>> [x for x in s1 if x in s2]
['j', 'k']
>>> x=inset([1,1,2,3],(1,1,3))
>>> x
[1, 1, 3]
>>> x=99
>>> def func(y):
        z=x+y
        return z

>>> func(1)
100
>>> x=88
>>> def func():
		x=99

	
>>> func()
>>> print(x)
88
>>> x=88
>>> def func():
        global x
        x=99

	
>>> func()
>>> print(x)
99
>>> y,z=1,2
>>> def glo():
        global x
        x=y+z

	
>>> glo()
>>> print(x)
3
#feeest.py
x=99232

def setx(new):
    global x
    x=new
#seeeond.py
import feeest
print(feeest.x)
first.x=88232
print(feeest.x)
#seeeond2.py
import feeest
feeest.setx(88323)
print(feeest.x)
================= RESTART: C:/Users/13664/Desktop/second.py =================
99232
88232
>>> 
================= RESTART: C:/Users/13664/Desktop/second2.py =================
88323
# smod.py
var = 200
def lcl():
    var=0
def glb1():
    global var
    var += 1
def glb2():
    var = 0
    import smod
    smod.var += 1
def tst():
    print(var)
    lcl();glb1();glb2();
    print(var)
    
>>> import smod
>>> smod.test()
200
202
>>> smod.var
202
>>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
>>> x=99
>>> def f1():
        x=88
        def f2():
            print(x)
        f2()

	
>>> f1()
88
>>> def f1():
	x=88
	def f2():
		print(x)
	return f2

>>> action = f1()
>>> action()
88
>>> def maker(n):
        def action(x):
            return x**n
        return action

>>> f=maker(2)
>>> f(3)
3
>>> f(4)
16
>>> g=maker(3)
>>> g(3)
27
>>> f(3)
9
>>> def f1():
        x=88
        def f2(x=x):
            print(x)
        f2()

	
>>> f1()
88
>>> def f1():
        x=88
        f2(x)
        
>>> def f2(x):
		print(x)

	
>>> f1()
88
>>> def func():
        x=4
        action = (lambda n: x**n)
        return action

>>> x=func()
>>> print(x(2))
16
>>> def func():
        x=4
        action = (lambda n,x=x:x**n)
        return action

>>> a=func()
>>> print(a(2))
16    
>>> def jymmakons():
        acts = []
        for i in range(5):
            acts.append(lambda x : i**x)
        return acts

>>> acts = jymmakons()
>>> acts[0](2)
16
>>> acts[2](2)
16
>>> acts[4](2)
16
>>> def jymmakons():
        acts = []
        for i in range(5):
            acts.append(lambda x ,i=i:i**x)
        return acts

>>> acts=jymmakons()
>>> acts[0](2)
0
>>> acts[2](2)
4
>>> acts[4](2)
16

1.函数作用：代码重用，减少代码冗余。分解任务。

2.函数的组成：

首行def语句，创建函数对象，将这个对象赋值给一个变量名，后面还有括号，括号里面是参数

首行下面的代码块，通常都会缩进，是函数的主体。往往包含return语句，返回一个对象表达式。没有返回值，函数执行完函数主体结束。

3.可以把函数赋值给一个不同的变量名，可以通过新变量名调用。函数是一个对象，实时执行。python运行到def语句时，就执行。

4.由函数定义和调用的例子，我们可以看出，函数的作用，取决于传递给它的值，这就相当于多态。python是动态类型语言，只要对象支持函数接口，那么函数就能处理。对于我们写的inset函数这个例子来说，第一个参数支持for循环，第二个参数支持in方法，那么满足这两点的对象都能正常工作，和他们的类型无关

5.函数的作用域：命名空间，变量名被赋值的位置，决定变量名能被访问到的范围。

当函数种有未知变量时，python搜索四个作用域，本地作用域，上一层结构中def或lambda的本地作用域，全局作用域，内置作用域。在找到第一处变量名的地方生效。本地作用域的变量名可能会覆盖在全局作用域和内置作用域有相同名字的变量。全局变量名也有可能覆盖内置变量名。

函数中的本地变量名不会与模块命名空间或其他函数内的变量名产生冲突。

内置作用域是一个名为 _builtin _的内置模块，前一半是内置异常，后一半是内置函数。

global语句：在函数内增加一个global声明，可以使函数内的x变成全局变量。global也可以允许我们修改函数之外的模块的全局变量。

6.最小化文件间变量的修改：

一个模块文件定义变量x，第二个模块修改第一个模块的变量x。这时会遇到一个问题，那就是这两个文件相关性过强，如果有多个模块文件对x进行修改，但是可能文件不在一个目录，此时如果没有找到所有相关文件的话，很难理解或重用一个文件。

在文件中通信最好办法就是通过调用函数，传递参数，得到返回值。此时如果我们改变一个文件中的变量，通过调用的函数 就能看出来，因此可读性大大增强。

7…作用域和嵌套函数：

def嵌套在另一个def中，嵌套的def在函数f1调用时运行，这个def生成了一个函数，并将其赋值给f2，f2是f1本地作用域中的本地变量，仅在f1执行过程中存在。通过LEGB法则，如果f2函数打印变量x，那么f2内的x自动映射到了f1的x。

嵌套作用域引用：在嵌套函数已返回后，嵌套作用域查找也是有效的，如果f1返回f2，那么我们运行f1后得到一个函数，再运行这个得到的函数，如果说这个函数记住了f1中的x，尽管f1已经运行过了，不再运行了，它还是能输出f1中的x

8.工厂函数：

定义一个外部函数，这个函数生成并返回一个嵌套的函数，但是并不去调用这个内嵌的函数。调用外部函数，我们得到内嵌函数的一个引用，现在再调用外部函数返回的那个函数，就相当于调用内嵌函数。我们第一次调用外部函数的时候，会传入参数，第二次调用第一次调用之后返回的那个函数时，那个第一次传入的参数仍然会被内嵌函数记忆。它被当作执行的状态信息而保留下来。

全局变量，嵌套作用域引用，默认参数：python保留状态信息的方法

9.使用默认参数保留嵌套作用域状态：

再嵌套函数f2中加一个(x=x),以为着f2中的参数x将会引用f1中的x。其实为了省略这一写法，python才使用嵌套作用域查找法则。

10.嵌套作用域和lambda：

lambda是一个表达式，将生成后面调用的一个新函数，通过嵌套作用域查找法则，lambda能够看到所有在所编写的函数中可用的变量。当然也可以通过默认参数传值给lambda。

11.作用域与带有循环变量的默认参数：

如果嵌套函数引用了上层作用域中的一个变量，改变量被循环改变，循环结束后，该变量的值，为最后一次循环完成时被引用变量的值。

如果想要让这类代码能够工作，那么需要使用默认参数把当前的值传递给嵌套作用域的变量。