python学习笔记4（对象／引用；多范式; 上下文管理器）

### Python的强大很大一部分原因在于，它提供有很多已经写好的，可以现成用的对象

21. 动态类型：对象/引用

对象和引用：

对象是储存在内存中的实体，对象名只是指向这一对象的引用(reference)。

对象和引用相分离是动态类型的核心。（Python会自动将没有引用指向的对象销毁(destruct)，释放相应内存。）

可变数据对象/不可变数据对象：

列表list可以通过引用其元素，改变对象自身(in-place change)，称为可变数据对象(mutable object)，词典也是。

而像数字和字符串，不能改变对象本身，只能改变引用，称为不可变数据对象(immutable object)。

元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也是immutable object.

从动态类型看参数传递：

例子：

def f(x):                        def f(x):
x = 100                          x[0]=100
print x                          print x

a = 1                            a=[1,2,3]
f(a)                             f(a)
print a                          print a

输出：

100 [100，2，3]

1 [100，2，3]

区别及原因：

如果参数是不可变对象，a和x引用之间相互独立。对参数x的操作不会影响引用a。如果传递的是可变对象，那么改变函数参数，有可能改变原对象。

22. 多范式语言 multi－paradigm

程序不仅可以用面向对象的方式编写，也可以是面向过程。多范式依赖于特殊方法，也叫魔法方法（可见笔记9）。

Python的许多语法都是基于其面向对象模型的封装，对象模型是Python的骨架，功能完备。但是Python 也有更简洁的语法，从而必要时隐藏一些面向对象的接口。

运算符

可以简化书写，它们是通过特殊方法实现的。

所以在Python中，两个对象是否能够进行 比如 ＋ 运算，首先要看对应的对象是否有__add__()方法。

'ABC' + 'abc' #连接字符串

'ABC'.__add__('abc') #两个是等价的

选择用面向对象的方法如 __add__() 或者＋符号，取决于编程习惯。

内置函数

许多内置函数也都是对象的特殊方法。

比如len([1,2,3]) 其实也就是 ［1,2,3].__len__()

表引用（list）

a=[1,2,3,4,5]

比如

print(li[3]) 其实也就是调用了__getitem__()方法，a.__getitem__(2)

函数

任何一个具有 __call__()特殊方法的对象都可以当作是函数。

如：

class SampleMore(object):
def __call__(self, a):
return a + 5

add = SampleMore()              # add是一个对象，也是一个 function object
print(add(2))
print(map(add, [2, 4, 5]))      # add  也可以作为函数对象传递给map函数

23. 标准库的itertools包

提供了更加灵活的生成循环器的工具，大都可以自行实现，只是更为高效和标准。

# import the tools
from itertools import *  # 或 import itertools

25. 上下文管理器

用于规定某个对象的使用范围，可以自动的关闭文件（根据程序块，也就是缩进）。

语法是 with ... as ...

# without context manager
f = open("new.txt", "a")
print(f.closed)               # the file is open
f.write("Hello World!")
f.close()                     # need to close after end
print(f.closed)               # the file is closed

以及：

# with context manager
with open("new.txt", "a") as f:   # with ... as ... open
print(f.closed)               # in, so open
f.write("Hello World!")
print(f.closed)                   # with ... as ... package end, so closed.

上下管理器，实际上是调用了文件对象的__enter__() 和 __exit__() 方法。在 __exit__()方法中，有self.close() ,就可以

自动关闭文件了。

自定义：

任何定义了__enter__() 和 __exit__()方法的对象，都可以用于上下文管理器。文件是内置对象，并不需要自定义。

class VOW(object):
def __init__(self, text):
self.text = text
def __enter__(self):
self.text = "I say: " + self.text    # add prefix
return self                          # note: return an object
def __exit__(self,exc_type,exc_value,traceback):
self.text = self.text + "!"          # add suffix

with VOW("I'm fine") as myvow:
print(myvow.text)

print(myvow.text)

在进入上下文和离开上下文时，对象的text属性发生了改变:

最初是 I'm fine --> I say: I'm fine(进入上下文时，前加 I say:) --> I say: I'm fine!(离开上下文时，后加！)

__exit__()中有4个参数，其中 exc_type,exc_value,traceback 3个参数用于描述异常，可以根据它们进行相应的处理。

如果程序正常结束，这三个参数为None.