GIL（全局解释器锁）
面试题：
描述Python GIL的概念， 以及它对python多线程的影响？编写一个多线程抓取网页的程序，并阐明多线程抓取程序是否可比单线程性能有提升，并解释原因。
参考答案：
Python语言和GIL没有半毛钱关系。仅仅是由于历史原因在Cpython虚拟机(解释器)，难以移除GIL。
GIL：全局解释器锁。每个线程在执行的过程都需要先获取GIL，保证同一时刻只有一个线程可以执行代码。
线程释放GIL锁的情况： 在IO操作等可能会引起阻塞的system call之前,可以暂时释放GIL,但在执行完毕后,必须重新获取GIL Python 3.x使用计时器（执行时间达到阈值后，当前线程释放GIL）或Python 2.x，tickets计数达到100
Python使用多进程是可以利用多核的CPU资源的。
多线程爬取比单线程性能有提升，因为遇到IO阻塞会自动释放GIL锁
解决方案法：
（1）更换解释器比如使用jpython（java实现的python解释器）（jython xxx.py）
（2）使用其他语言（C语言）编写程序
（3）使用多进程完成多任务的处理
使用c语言编写程序
用C语言编写一个死循环程序：
void DeadLoop()
{
while(1)
{
;
}
}
把一个ｃ语言文件编译成一个动态库的命令（linux平台下）：gcc xxx.c -shared -o libxxxx.so
gcc loop.c -shared -o libdead_loop.so
用python 语言调用 C语言 程序：
from ctypes import *
from threading import Thread
#加载动态库
lib = cdll.LoadLibrary("./libdead_loop.so")
#创建一个子线程，让其执行ｃ语言编写的函数，此函数是一个死循环
t = Thread(target=lib.DeadLoop)
t.start()
#主线程
while True:
pass
私有化
# coding=utf-8
class Xinglu(object):
def __init__(self, name, age, taste):
print("------xinglu 初始化方法开始------")
self.name = name
self._age = age
self.__taste = taste
def show_xinglu(self):
print("------xinglu show方法开始------")
print(self.name)
print(self._age)
print(self.__taste)
def do_work(self):
self._work()
self.__away()
def _work(self):
print("------xinglu _work方法开始------")
print("my _work")
def __away(self):
print("------xinglu __away方法开始------")
print("my __away")
class Student(Xinglu):
def construction(self, name, age, taste):
print("------student construction方法开始------")
self.name = name
self._age = age
self.__taste = taste
def show_student(self):
print("------student show_student方法开始------")
print(self.name)
print(self._age)
print(self.__taste)
@staticmethod
def test_bug():
_Bug.show_bug()
# 模块内可以访问，当from cur_module import *时，不导入
class _Bug(object):
@staticmethod
def show_bug():
print("show_bug")
s1 = Student('jack', 25, 'football')
s1.show_xinglu()
print('*' * 20)
# 无法访问__taste（私有属性不能被子类继承）,导致报错
# s1.show_student()
s1.construction('rose', 30, 'basketball')
s1.show_xinglu()
print('*' * 20)
s1.show_student()
print('*' * 20)
Student.test_bug()
浅拷贝、深拷贝
浅拷贝：只分配变量地址，里面的内容是引用指向
深拷贝：全部分配新的，包括里面的内容
import copy
a = [11, 22]
b = [33, 44]
print("-----------浅拷贝和深拷贝对比---------")
c = [a, b]
d = copy.copy(c)
print("c的地址为：", id(c))
print("浅拷贝d的地址为：", id(d))
print("c[0]的地址为：", id(c[0]))
print("浅拷贝d[0]的地址为：", id(d[0]))
e = copy.deepcopy(c)
print("c的地址为：", id(c))
print("深拷贝e的地址为：", id(e))
print("c[0]的地址为：", id(c[0]))
print("深拷贝e[0]的地址为：", id(e[0]))
print("---浅拷贝和深拷贝对不可变类型数据操作的对比---")
c = (a, b)
d = copy.copy(c)
print("c的地址为：", id(c))
print("浅拷贝d的地址为：", id(d))
e = copy.deepcopy(c)
print("c的地址为：", id(c))
print("深拷贝e的地址为：", id(e))
a = (11, 22)
b = (33, 44)
c = (a, b)
d = copy.copy(c)
e = copy.deepcopy(c)
print("c的地址为：", id(c))
print("浅拷贝d的地址为：", id(d))
print("c的地址为：", id(c))
print("深拷贝e的地址为：", id(e))
print("---参数传递是浅拷贝---")
def test_nums(temp):
temp.append(33)
nums = [11, 22]
print("原本的列表：", nums)
test_nums(nums)
print("调用方法直接传递参数的列表：", nums)
nums = [11, 22]
print("原本的列表：", nums)
test_nums(copy.deepcopy(nums))
print("调用方法深拷贝传递参数的列表：", nums)
-----------浅拷贝和深拷贝对比---------
c的地址为： 139697894495232
浅拷贝d的地址为： 139697894494592 #说明为d新分配了内存空间
c[0]的地址为： 139697894324544
浅拷贝d[0]的地址为： 139697894324544 #说明并没有拷贝内容，相同的引用指向
c的地址为： 139697894495232
深拷贝e的地址为： 139697894494336 #说明为e新分配了内存空间
c[0]的地址为： 139697894324544
深拷贝e[0]的地址为： 139697894495296 #说明内容的地址也不一样了
---浅拷贝和深拷贝对不可变类型数据操作的对比---
c的地址为： 139697894285248
浅拷贝d的地址为： 139697894285248 #说明没有为d分配新的内存空间，因为c是不可变类型
c的地址为： 139697894285248
深拷贝e的地址为： 139697894324736 #说明为e分配新的内存空间，因为a和b是可变类型
c的地址为： 139907158474560
浅拷贝d的地址为： 139907158474560 #说明没有为d分配新的内存空间，因为c是不可变类型
c的地址为： 139907158474560
深拷贝e的地址为： 139907158474560 #说明没有为d分配新的内存空间，因为a和b也是不可变类型
---参数传递是浅拷贝---
原本的列表： [11, 22]
调用方法直接传递参数的列表： [11, 22, 33] #说明直接传递参数为浅拷贝
原本的列表： [11, 22]
调用方法深拷贝传递参数的列表： [11, 22] #说明深拷贝内容完全是新的一份
如果用copy.copy、copy.deepcopy对一个全部都是不可变类型的数据进行拷贝，那么他们的结果相同，透视引用指向
如果copy.copy、copy.deepcopy对一个拥有可变类型的数据，及时元组是对顶层（不可变），那么deepcopy依然是深拷贝，而copy.copy还是指向
多继承以及MRO顺序
1.单独调用父类的方法
print("******多继承使用类名.__init__ 发生的状态******")
class Parent(object):
def __init__(self, name):
print('parent的init开始被调用')
self.name = name
print('parent的init结束被调用')
class Son1(Parent):
def __init__(self, name, age):
print('Son1的init开始被调用')
self.age = age
Parent.__init__(self, name)
print('Son1的init结束被调用')
class Son2(Parent):
def __init__(self, name, gender):
print('Son2的init开始被调用')
self.gender = gender
Parent.__init__(self, name)
print('Son2的init结束被调用')
class Grandson(Son1, Son2):
def __init__(self, name, age, gender):
print('Grandson的init开始被调用')
Son1.__init__(self, name, age) # 单独调用父类的初始化方法
Son2.__init__(self, name, gender)
print('Grandson的init结束被调用')
gs = Grandson('xinglu', 22, '女')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)
print("******多继承使用类名.__init__ 发生的状态******\n\n")
运行结果：
[root@ww-master ~]# python3 test.py
******多继承使用类名.__init__ 发生的状态******
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Grandson的init结束被调用
姓名： xinglu
年龄： 22
性别： 女
******多继承使用类名.__init__ 发生的状态******
2.多继承中super调用有所父类的被重写的方法
print("******多继承使用super().__init__ 发生的状态******")
class Parent(object):
def __init__(self, name, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print('parent的init开始被调用')
self.name = name
print('parent的init结束被调用')
class Son1(Parent):
def __init__(self, name, age, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print('Son1的init开始被调用')
self.age = age
super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数
print('Son1的init结束被调用')
class Son2(Parent):
def __init__(self, name, gender, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print('Son2的init开始被调用')
self.gender = gender
super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数
print('Son2的init结束被调用')
class Grandson(Son1, Son2):
def __init__(self, name, age, gender):
print('Grandson的init开始被调用')
# 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍
# 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
# super(Grandson, self).__init__(name, age, gender)
super().__init__(name, age, gender)
print('Grandson的init结束被调用')
print(Grandson.__mro__)
gs = Grandson('xinglu', 22, '女')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)
print("******多继承使用super().__init__ 发生的状态******\n\n")
运行结果：
[root@ww-master ~]# python3 test.py
******多继承使用super().__init__ 发生的状态******
(<class '__main__.Grandson'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Parent'>, <class 'object'>)
Grandson的init开始被调用
Son1的init开始被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Son1的init结束被调用
Grandson的init结束被调用
姓名： xinglu
年龄： 22
性别： 女
******多继承使用super().__init__ 发生的状态******
注意：
- 以上2个代码执行的结果不同
- 如果2个子类中都继承了父类，当在子类中通过父类名调用时，parent被执行了2次
- 如果2个子类中都继承了父类，当在子类中通过super调用时，parent被执行了1次
（重点）※args、※※kwargs的另外用处：拆包
def test2(a, b, *args, **kwargs):
print("-" * 50)
print(a)
print(b)
print(args)
print(kwargs)
def test1(a, b, *args, **kwargs):
print(a)
print(b)
print(args)
print(kwargs)
# test2(a, b, args, kwargs) # 相当于test2(11, 22, (33, 44, 55, 66), {"name":"xinglu", "age":18})
# test2(a, b, *args, kwargs) # 相当于test2(11, 22, 33, 44, 55, 66, {"name":"xinglu", "age":18})
test2(a, b, *args, **kwargs) # 相当于test2(11, 22, 33, 44, 55, 66, name="xinglu", age=18)
test1(11, 22, 33, 44, 55, 66, name="xinglu", age=22)
运行结果
11
22
(33, 44, 55, 66)
{'name': 'xinglu', 'age': 22}
--------------------------------------------------
11
22
(33, 44, 55, 66)
{'name': 'xinglu', 'age': 22}
单继承中super
print("******单继承使用super().__init__ 发生的状态******")
class Parent(object):
def __init__(self, name):
print('parent的init开始被调用')
self.name = name
print('parent的init结束被调用')
class Son1(Parent):
def __init__(self, name, age):
print('Son1的init开始被调用')
self.age = age
super().__init__(name) # 单继承不能提供全部参数
print('Son1的init结束被调用')
class Grandson(Son1):
def __init__(self, name, age, gender):
print('Grandson的init开始被调用')
super().__init__(name, age) # 单继承不能提供全部参数
print('Grandson的init结束被调用')
gs = Grandson('xinglu', 22, '女')
print('姓名：', gs.name)
print('年龄：', gs.age)
# print('性别：', gs.gender)
print("******单继承使用super().__init__ 发生的状态******\n\n")
运行结果：
******单继承使用super().__init__ 发生的状态******
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Grandson的init结束被调用
姓名： xinglu
年龄： 22
******单继承使用super().__init__ 发生的状态******
总结
super().__init__相对于类名.__init__，在单继承上用法基本无差
但在多继承上有区别，super方法能保证每个父类的方法只会执行一次，而使用类名的方法会导致方法被执行多次，具体看前面的输出结果
多继承时，使用super方法，对父类的传参数，应该是由于python中super的算法导致的原因，必须把参数全部传递，否则会报错
单继承时，使用super方法，则不能全部传递，只能传父类方法所需的参数，否则会报错
多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍, 而使用super方法，只需写一句话便执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
example
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
运行结果：
1 1 1
1 2 1
3 2 3
实例方法、静态方法和类方法
class Foo(object):
def __init__(self, name):
self.name = name
def ord_func(self):
""" 定义实例方法，至少有一个self参数 """
# print(self.name)
print("实例方法")
@classmethod
def class_func(cls):
""" 定义类方法，至少有一个cls参数 """
print("类方法")
@staticmethod
def static_func():
""" 定义静态方法 ，无默认参数"""
print("静态方法")
f = Foo("LU")
# 调用实例方法
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
对比：
- 相同点：对于所有的方法而言，均属于类，所以在内存中也只保存一份
- 不同点：方法调用者不同、调用方法时自动传入的参数不同。
property属性
什么是property属性
一种用起来像是使用实例属性一样的特殊属性，可以对应于某个方法
# ############### 定义 ###############
class Foo:
def func(self):
pass
# 定义property属性
@property
def prop(self):
pass
# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func() # 调用实例方法
foo_obj.prop # 调用property属性
property属性的定义和调用要注意一下几点：
定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数
调用时，无需括号
方法：foo_obj.func() property属性：foo_obj.prop
简单的实例
对于京东商城中显示电脑主机的列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据，这个分页的功能包括：
根据用户请求的当前页和总数据条数计算出 m 和 n
根据m 和 n 去数据库中请求数据
# ############### 定义 ###############
class Pager:
def __init__(self, current_page):
# 用户当前请求的页码（第一页、第二页...）
self.current_page = current_page
# 每页默认显示10条数据
self.per_items = 10
@property
def start(self):
val = (self.current_page - 1) * self.per_items
return val
@property
def end(self):
val = self.current_page * self.per_items
return val
# ############### 调用 ###############
p = Pager(1)
p.start # 就是起始值，即：m
p.end # 就是结束值，即：n
从上述可见：
Python的property属性的功能是：property属性内部进行一系列的逻辑计算，最终将计算结果返回。
property属性有两种方式
- 装饰器 即：在方法上应用装饰器
- 类属性 即：在类中定义值为property对象的类属性
装饰器方式
在类的实例方法上应用@property装饰器
Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）
1> 经典类，具有一种@property装饰器
# ############### 定义 ###############
class Goods:
@property
def price(self):
return "xinglu"
# ############### 调用 ###############
obj = Goods()
result = obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
print(result)
2> 新式类，具有三种@property装饰器
# coding=utf-8
# ############### 定义 ###############
class Goods:
"""python3中默认继承object类
以python2、3执行此程序的结果不同，因为只有在python3中才有@xxx.setter @xxx.deleter
"""
@property
def price(self):
print('@property')
@price.setter
def price(self, value):
print('@price.setter')
@price.deleter
def price(self):
print('@price.deleter')
# ############### 调用 ###############
obj = Goods()
obj.price # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法，并将 123 赋值给方法的参数
del obj.price # 自动执行 @price.deleter 修饰的 price 方法
注意：
- 经典类中的属性只有一种访问方式，其对应为 @property 修饰的方法
- 新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
由于新式类中具有三种访问方式，我们可以根据它们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
@property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deleter
def price(self):
del self.original_price
obj = Goods()
p = obj.price # 获取商品价格
print(p) # 80.0
obj.price = 200 # 修改商品原价
p = obj.price # 获取商品价格
print(p) # 160.0
del obj.price # 删除商品原价
类属性方式，创建值为property对象的类属性
注意：当使用类属性的方式创建property属性时，经典类和新式类无区别
class Foo:
def get_bar(self):
return 'xinglu'
BAR = property(get_bar)
obj = Foo()
reuslt = obj.BAR # 自动调用get_bar方法，并获取方法的返回值
print(reuslt)
property方法中有个四个参数
第一个参数是方法名，调用 对象.属性 时自动触发执行方法
第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数是字符串，调用 对象.属性.doc ，此参数是该属性的描述信息
# coding=utf-8
class Foo(object):
def get_bar(self):
print("getter...")
return 'xinglu'
def set_bar(self, value):
"""必须两个参数"""
print("setter...")
return 'set value' + value
def del_bar(self):
print("deleter...")
return 'xinglu'
BAR = property(get_bar, set_bar, del_bar, "description...")
obj = Foo()
obj.BAR # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
desc = Foo.BAR.__doc__ # 自动获取第四个参数中设置的值：description...
print(desc)
del obj.BAR # 自动调用第三个参数中定义的方法：del_bar方法
由于类属性方式创建property属性具有3种访问方式，我们可以根据它们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除
class Goods(object):
def __init__(self):
self.original_price = 100 # 原价
self.discount = 0.8 # 折扣
def get_price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
def set_price(self, value):
self.original_price = value
def del_price(self):
del self.original_price
PRICE = property(get_price, set_price, del_price, '价格属性描述...')
obj = Goods()
p = obj.PRICE # 获取商品价格
print(p) # 80.0
obj.PRICE = 200 # 修改商品原价
p = obj.PRICE # 获取商品价格
print(p) # 160.0
del obj.PRICE # 删除商品原价
综上所述：
- 定义property属性共有两种方式，分别是【装饰器】和【类属性】，而【装饰器】方式针对经典类和新式类又有所不同。
- 通过使用property属性，能够简化调用者在获取数据的流程
property属性-应用
私有属性添加getter和setter方法
class Xinglu(object):
def __init__(self):
self.__xinglu = 0
def getXinglu(self):
return self.__xinglu
def setXinglu(self, value):
if isinstance(value, int):
self.__xinglu = value
else:
print("error:不是整型数字")
使用property升级getter和setter方法
class Xinglu(object):
def __init__(self):
self.__xinglu = 0
def getXinglu(self):
return self.__xinglu
def setXinglu(self, value):
if isinstance(value, int):
self.__xinglu = value
else:
print("error:不是整型数字")
# 定义一个属性，当对这个xinglu设置值时调用setXinglu,当获取值时调用getXinglu
xinglu = property(getXinglu, setXinglu)
a = Xinglu()
a.xinglu = 100 # 调用setXinglu方法
print(a.xinglu) # 调用getXinglu方法 # 100
使用property取代getter和setter方法
重新实现一个属性的设置和读取方法，可做边界判定
class Xinglu(object):
def __init__(self):
self.__xinglu = 0
# 使用装饰器对xinglu进行装饰，那么会自动添加一个叫xinglu的属性，当调用获取xinglu的值时，调用装饰的方法
@property
def xinglu(self):
return self.__xinglu
# 使用装饰器对xinglu进行装饰，当对xinglu设置值时，调用装饰的方法
@xinglu.setter
def xinglu(self, value):
if isinstance(value, int):
self.__xinglu = value
else:
print("error:不是整型数字")
a = Xinglu()
a.xinglu = 100
print(a.xinglu)
魔法属性
__doc__
表示类的描述信息
class Foo:
""" 描述类信息，这是用于看片的神器 """
def func(self):
pass
print(Foo.__doc__) # 输出：类的描述信息
__module__ 和 __class__
- module 表示当前操作的对象在那个模块
- class 表示当前操作的对象的类是什么
test.py
# -*- coding:utf-8 -*-
class Xinglu(object):
def __init__(self):
self.name = 'xinglu'
main.py
from test import Xinglu
obj = Xinglu()
print(obj.__module__) # 输出 test 即：输出模块
print(obj.__class__) # 输出 test.Xinglu 即：输出类
__init__
初始化方法，通过类创建对象时，自动触发执行
此方法不能成为构造方法，此方法加上__new__方法才是构造方法
class Xinglu:
def __init__(self, name):
self.name = name
self.age = 18
obj = Xinglu('xinglu') # 自动执行类中的 __init__ 方法
__del__
当对象在内存中被释放时，自动触发执行
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，del的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:
def __del__(self):
pass
__call__
对象后面加括号，触发执行
注：init方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
__dict__
类或对象中的所有属性
类的实例属性属于对象；类中的类属性和方法等属于类，即：
class Xinglu(object):
country = 'Cuicuisha'
def __init__(self, name, count):
self.name = name
self.count = count
def func(self, *args, **kwargs):
print('func')
# 获取类的属性，即：类属性、方法、
print(Xinglu.__dict__)
# 输出：{'__dict__': <attribute '__dict__' of 'Xinglu' objects>, '__module__': '__main__', 'country': 'Cuicuisha', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Xinglu' objects>, 'func': <function Xinglu.func at 0x101897950>, '__init__': <function Xinglu.__init__ at 0x1018978c8>}
obj1 = Xinglu('奶牛', 10000)
print(obj1.__dict__)
# 获取 对象obj1 的属性
# 输出：{'count': 10000, 'name': '奶牛'}
obj2 = Xinglu('牛奶', 20000)
print(obj2.__dict__)
# 获取 对象obj1 的属性
# 输出：{'count': 20000, 'name': '牛奶'}
__str__
class Foo:
def __str__(self):
return 'xinglu'
obj = Foo()
print(obj) # 输出：xinglu
__getitem__ __setitem__ __delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
# -*- coding:utf-8 -*-
class Foo(object):
def __getitem__(self, key):
print('__getitem__', key)
def __setitem__(self, key, value):
print('__setitem__', key, value)
def __delitem__(self, key):
print('__delitem__', key)
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'xinglu' # 自动触发执行 __setitem__
del obj['k1'] # 自动触发执行 __delitem__
__getslice__ __setslice__ __delslice__
该三个方法用于分片操作，如：列表
# -*- coding:utf-8 -*-
class Foo(object):
def __getslice__(self, i, j):
print('__getslice__', i, j)
def __setslice__(self, i, j, sequence):
print('__setslice__', i, j)
def __delslice__(self, i, j):
print('__delslice__', i, j)
obj = Foo()
obj[-1:1] # 自动触发执行 __getslice__
obj[0:1] = [11, 22, 33, 44] # 自动触发执行 __setslice__
del obj[0:2] # 自动触发执行 __delslice__
with与”上下文管理器“
如果你有阅读源码的习惯，可能会看到一些优秀的代码经常出现带有 “with” 关键字的语句，它通常用在什么场景呢？
今对于系统资源如文件、数据库连接、socket 而言，应用程序打开这些资源并执行完业务逻辑之后，必须做的一件事就是要关闭（断开）该资源。
比如 Python 程序打开一个文件，往文件中写内容，写完之后，就要关闭该文件，否则会出现什么情况呢？极端情况下会出现 "Too many open files" 的错误，因为系统允许你打开的最大文件数量是有限的。
同样，对于数据库，如果连接数过多而没有及时关闭的话，就可能会出现 "Can not connect to MySQL server Too many connections"，因为数据库连接是一种非常昂贵的资源，不可能无限制的被创建。
来看看如何正确关闭一个文件。
普通版：
def m1():
f = open("output.txt", "w")
f.write("xinglu is my girl")
f.close()
这样写有一个潜在的问题，如果在调用 write 的过程中，出现了异常进而导致后续代码无法继续执行，close 方法无法被正常调用，因此资源就会一直被该程序占用者释放。那么该如何改进代码呢？
进阶版：
def m2():
f = open("output.txt", "w")
try:
f.write("xinglu is my girl")
except IOError:
print("xinglu unhappy")
finally:
f.close()
改良版本的程序是对可能发生异常的代码处进行 try 捕获，使用 try/finally 语句，该语句表示如果在 try 代码块中程序出现了异常，后续代码就不再执行，而直接跳转到 except 代码块。而无论如何，finally 块的代码最终都会被执行。因此，只要把 close 放在 finally 代码中，文件就一定会关闭。
高级版：
def m3():
with open("output.txt", "r") as f:
f.write("xinglu is my girl")
一种更加简洁、优雅的方式就是用 with 关键字。open 方法的返回值赋值给变量 f，当离开 with 代码块的时候，系统会自动调用 f.close() 方法， with 的作用和使用 try/finally 语句是一样的。
那么它的实现原理是什么？在讲 with 的原理前要涉及到另外一个概念，就是上下文管理器（Context Manager）。
上下文管理器
任何实现了 enter() 和 exit() 方法的对象都可称之为上下文管理器，上下文管理器对象可以使用 with 关键字。显然，文件（file）对象也实现了上下文管理器。
那么文件对象是如何实现这两个方法的呢？我们可以模拟实现一个自己的文件类，让该类实现 enter() 和 exit() 方法。
class File():
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
def __enter__(self):
print("entering")
self.f = open(self.filename, self.mode)
return self.f
def __exit__(self, *args):
print("will exit")
self.f.close()
enter_() 方法返回资源对象，这里就是你将要打开的那个文件对象，exit() 方法处理一些清除工作。
因为 File 类实现了上下文管理器，现在就可以使用 with 语句了。
with File('out.txt', 'w') as f:
print("writing")
f.write('xinglu is my girl')
这样，你就无需显示地调用 close 方法了，由系统自动去调用，哪怕中间遇到异常 close 方法也会被调用。
实现上下文管理器的另外方式
Python 还提供了一个 contextmanager 的装饰器，更进一步简化了上下文管理器的实现方式。通过 yield 将函数分割成两部分，yield 之前的语句在 enter 方法中执行，yield 之后的语句在 exit 方法中执行。紧跟在 yield 后面的值是函数的返回值。
from contextlib import contextmanager
@contextmanager
def my_open(path, mode):
f = open(path, mode)
yield f
f.close()
调用
with my_open('out.txt', 'w') as f:
f.write("xinglu is my girl")
网友评论