python命名空间和闭包_python命名空间&闭包&上下文管理器&鸭子类型

函数与命名空间

函数的全局命名空间始终是定义该函数的模块，而不是调用该函数的命名空间。

函数及其全局命名空间决定了函数中引用全局变量的值

因此，在函数中引用的全局变量始终是定义该函数模块中的全局变量

闭包及其应用(嵌套函数)

闭包：将组成函数的语句和这些语句的执行环境打包到一起所得到的对象。当使用嵌套函数时，闭包将捕获内部函数执行所需的整个环境。

嵌套的函数可以使用被嵌套函数中的任何变量，就像普通函数可以引用全局变量一样，而不需要通过参数引入。

闭包的应用是根据嵌套函数持有定义环境变量的特性来完成功能的

闭包：

def foo():

x=3

def bar():

print('x is %d'%x)

bar()

闭包与延迟求值：闭包可以实现先将参数传递给一个函数，而并不立即运行，以达到延迟求值的目的。

所谓延迟求值，就是函数返回的是一个函数，而真正需要运行函数中的代码时，其本质还是函数调用。

例：

def delay_fun(x,y):

def calculator():

return x+y

return calculator

if __name__=='__main__':

print('返回一个求和的函数，并不求和。')

msum=delay_fun(3,4)

print()

print('调用并求和：')

print(msum())

闭包与泛型函数

例：实现所有类型的一次函数的求值

def line(a,b):

def aline(x):

return a*x+b

return aline

if __name__=='__main__':

line23=line(2,3)

line50=line(5,0)

print(line23(4))

print(line50(2))

上下文管理器:实现上下文管理协议方法的对象,方便资源管理的一种语法形式。

上下文协议方法：

__enter__(self)          #该方法是进入上下文时调用的，它创建并返回一个可以引用的资源对象，供with语句块中的程序使用

__exit__(self,type,value,tb)   #该方法是推出上下文时调用的，主要用来安全地释放资源对象。参数type、value、tb用于跟踪退出错误时发生的错误类型、值和跟踪信息。

使用上下文管理器的with语句的形式为：

with context as var:

pass

变量var将取得上下文管理器的__enter__()方法所返回的资源引用，供with后的代码块中使用

例：

class FileMgr:

def __init__(self,filename):

self.filename=filename

self.f=None

def __enter__(self):

self.f=open(self.filename,encoding='utf-8')

return self.f

def __exit__(self,t,v,tb):

if self.f:

self.f.close()

if __name__=='__main__':

with FileMgr('10-4.py') as f:

for line in f.readlines():

print(lines,end='')

使用这个管理文件的上下文管理器后，在每次使用文件资源时都不用写打开关闭文件的代码，就像操作一般变量一样操作就行了。

contextmanager——将生成器转变为上下文管理器的装饰器

例：

import contextlib   #内置的上下文管理器的模块

@contextlib.contextmanager

def my_mgr(s,e):

print(s)

yield s+' '+e

print(e)

if __name__=='__main__':

with my_mgr('start','end') as val:

print(val)

重写类的特殊方法：

__init__  构造函数，生成对象时调用

__del__ 析构函数，释放对象时调用

__add__ 加运算

__mul__ 乘运算

__cmp__ 比较

__repr__  打印，转换

__setitem__  按照索引赋值

__getitem__   按照索引获取值

__len__       获得长度

__call__      函数调用

鸭子类型与多态：

鸭子类型(duck typing)是动态类型的一种风格，在这种风格中，一个对象有效的语义不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定

“当看到一只鸟走起来像鸭子、游泳起来像鸭子，叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。

在鸭子类型的语言中，编写一个函数可以接受一个任意类型的对象，并调用它的走和叫的方法。任何拥有这样的正确的走和叫方法的对象都可被函数接受。

例：

class Duck:

def __init__(self,name='duck'):

self.name=name

def quack(self):

print("gagaga....")

class Cat:

def __init__(self,name='cat')

self.name=name

def quack(self):

print("miaomiaomiao....")

class Tree:

def __init__(self,name='tree')

self.name=name

def duck_demo(obj):

obj.quack()

if __name__=='__main__':

duck=Duck()

cat=Cat()

tree=Tree()

duck_demo(duck)

duck_demo(cat)

duck_demo(tree)  #报错