第四章 深入类和对象

4.1 鸭子类型和多态

class Cat(object):
    def say(self):
        print("i am a cat")

class Dog(object):
    def say(self):
        print("i am a fish")

class Duck(object):
    def say(self):
        print("i am a duck")
    
animal = Cat
animal().say

上面三个类都有一个函数say()。现在定义一个对象animal，有可能是Cat、Dog或者Duck（多态）。

animal_list = [Cat, Dog, Duck]
for animal in animal_list:
    animal().say()

i am a cat
i am a fish
i am a duck

上面分别打印出三个类的say方法。

类只要定义同一个方法（鸭子类型），就可以实现多态。

类中的鸭子类型：只要类里面有同样的方法，在特定功能上就看成同一种类。

a = ["bobby1", "bobby2"]
b = ["bobby2", "bobby"]
name_tuple = ("bobby3", "bobby4")
name_set = set()
name_set.add("bobby5")
name_set.add("bobby6")
a.extend(b)
print(a)
a.extend(name_tuple)
print(a)
a.extend(name_set)
print(a)

['bobby1', 'bobby2', 'bobby2', 'bobby']
['bobby1', 'bobby2', 'bobby2', 'bobby', 'bobby3', 'bobby4']
['bobby1', 'bobby2', 'bobby2', 'bobby', 'bobby3', 'bobby4', 'bobby5', 'bobby6']

extend()有个参数Iterable(可迭代对象)，list、tuple、set都是可迭代对象。可迭代对象也是鸭子类型，里面实现了迭代器（比如__iter__魔法函数，或者是__getitem__），魔法函数充分利用了鸭子类型，只要实现了某种魔法函数，就可以看做某种类型。

python中有很多方法，只要求参数是某种类型，不指定具体是哪种结构。

4.2-4.3 抽象基类(abc模块)

python是动态语言，没有变量类型，变量只是一个符号，可以指向任何类型的对象，因此天然支持多态。由于是动态语言，不需要指定变量类型，因此少了一个编译时检查错误的环境。在python中写错代码，事先是很难知道的，只有在运行时才会发现错误，即无法做类型检查。

python的类不需要继承，只要实现了某些魔法函数，就会拥有某些类型的特性（协议）。

抽象基类的意思是：

  1. 在基类中设定好一些方法，所以继承基类的类都必须复写这些方法
  2. 抽象基类无法实例化

为什么会有抽象基类这个概念，Python是基于鸭子类型的，在类中直接实现某些方法不就行了吗？

两种应用场景来说明：

检查某个类是否有某种方法

class Company(object):
    """
    检查Company类是否可以计算长度
    """
    def __init__(self, employee_list):
        self.employee = employee_list

    def __len__(self):
        return len(self.employee)


com = Company(["bobby1","bobby2"])
print(len(com))
print(hasattr(com, "__len__")) # 在类中，函数也是一种属性

2
True

在某些情况之下判定某个对象的类型

如果没有抽象基类，必须使用hasattr，但isinstance这种用法更好，collections.abc模块中有Sized抽象基类，有抽象方法__len__，com实现了__len__方法。

from collections.abc import Sized
isinstance(com, Sized)

强制某个子类必须实现某些方法

假如实现一个web框架，要集成缓存cache，以后也希望可以用redis、cache、memorychache替换。那么一开始就需要设计一个抽象基类，指定子类必须实现某些方法。

class CacheBase(metaclass=abc.ABCMeta):
    # 从缓存中获取数据，必须用户自己实现
    @abc.abstractmethod
    def get(self, key):
        pass
    # 添加数据，必须用户自己实现
    @abc.abstractmethod
    def set(self, key, value):
        pass

上面相当于一个缓存组件，用户在使用的时候，可以使用redis、cache、或者memorychache来进行缓存，但是自己写缓存子类的时候，必须实现get、set方法。

模拟一个抽象基类：

class CacheBase():
	def get(self, key):
		raise NotImplementedError
	def set(self, key, value):
		raise NotImplementedError

定义一个子类继承抽象基类，不重写方法：

class RedisCache(CacheBase):
	pass
redis_cache = RedisCache()
redis_cache.set("key", "value")	

Traceback (most recent call last):
  File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 61, in <module>
    redis_cache.set("key", "value")
  File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 53, in set
    raise NotImplementedError
NotImplementedError

会抛出NotImplementedError 异常

模拟的方法会有一个不好的地方，在调用set函数的时候才会抛出异常。我们希望在初始化的时候（实例化的时候）就能够抛出异常，这需要用到abc 模块。

import abc

class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractmethod # 抽象方法，就不用raise异常
    def get(self, key):
        pass
    @abc.abstractmethod
    def set(self, key, value):
        pass

关于abc的模块，python中有两个地方，一个就是abc（全局），另外一个是collections.abc。

这时候再调用：

class RedisCache(CacheBase):
	pass
redis_cache = RedisCache()
redis_cache.set("key", "value")

Traceback (most recent call last):
  File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 60, in <module>
    redis_cache = RedisCache()
TypeError: Can't instantiate abstract class RedisCache with abstract methods get, set

抛出异常，我们必须重新定义get、set方法。

我们重新定义set方法：

class RedisCache(CacheBase):
    def set(self, key, value):
        pass
redis_cache = RedisCache()
redis_cache.set("key", "value")

Traceback (most recent call last):
  File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 59, in <module>
    redis_cache = RedisCache()
TypeError: Can't instantiate abstract class RedisCache with abstract methods get

异常只告诉我们要重载get，已经没有set的异常了。

采用abc模块后，在实例化的时候就抛出异常了，可以强制子类实现某些方法。

在python中已经实现了通用了抽象基类，放在collections.abc模块中，点进去看：

__all__ = ["Awaitable", "Coroutine",
           "AsyncIterable", "AsyncIterator", "AsyncGenerator",
           "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
           "Sized", "Container", "Callable", "Collection",
           "Set", "MutableSet",
           "Mapping", "MutableMapping",
           "MappingView", "KeysView", "ItemsView", "ValuesView",
           "Sequence", "MutableSequence",
           "ByteString",
           ]

列表里的都是抽象基类，点进抽象基类里：

class Awaitable(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __await__(self):
        yield

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Awaitable:
            return _check_methods(C, "__await__")
        return NotImplemented

有个很重要的魔法函数 __subclasshook__

看上面的例子

class Company(object):
	def __init__(self, employee_list):
		self.employee = employee_list
	def __len__(self):
		return len(self.employee)

com = Company(["bobby1","bobby2"])

from collections.abc import Sized
print(isinstance(com, Sized))

com并没有继承Sized，但却可以判断出com是Sized类型，为什么能判断出来，点进去看Sized：

class Sized(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod
    def __len__(self):
        return 0

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            return _check_methods(C, "__len__")
        return NotImplemented

这里面也有个魔法函数 __subclasshook__，这个函数首先判断传递进来的对象C有没有__len__方法，有则返回True。

所以例子里面就是利用了Sized的魔法函数__subclasshook__，如果com有__len__方法，则判断com是Sized类型。

当然isinstance的功能并没有看起来这么简单，它内部会做很多的步骤，比如：

我们实现

class A:
    pass

class B(A):
    pass

b = B()
print(isinstance(b, A))

True

所以isinstance不只是去找__subclasshook__，还会去找继承链。

综上，抽象基类有两个用途，一是调用isinstance，二是可以做接口的强制规定。

可以看到Python在尽量使用鸭子类型，抽象基类也不推荐使用，抽象基类在设计的时候容易设计过度，反而不容易理解。

4.4 isinstance和type的区别

为什么尽量使用isinstance而少使用type

举个例子说明：

class A:
    pass

class B(A):
    pass

b = B()
print(isinstance(b, B))
print(isinstance(b, A))

True
True

B是A的子类，所以b也是A类。

使用type时：

print(type(b))
print(type(b) is B)
print(type(b) is A)

<class '__main__.B'>
True
False

可以看到b是B类，type(b)指向B，虽然B继承A，但A和B是两个不同的对象，但是isinstance会找继承链。

这里有个知识点is和==的区别，is在判断两个对象的id是否相同：

print(id(B))
print(id(type(b)))

2158572618624
2158572618624

==是在判断值是否相同

4.5 类变量和实例变量

class A:
    aa = 1
    def __init__(self, x, y):
        self.x = x
        self.y = y
a = A(2,3)

print(a.x, a.y, a.aa)
print(A.aa)
print(A.x)

2 3 1
1
    print(A.x)
AttributeError: type object 'A' has no attribute 'x'

aa是类变量，__init__中的self是实例，所以self.x，self.y是实例变量。

实例化后(a)，a.aa先在实例变量中查找，没有再向上从类变量中查找。

类没有办法向下查找变量，因为实例变量是绑定在具体实例中的，如果在类变量中没有找到，则抛出异常。

A.aa = 11
print(a.x, a.y, a.aa)

a.aa = 100
print(a.x, a.y, a.aa)

b = A(3,5)
print(b.aa)

2 3 11
2 3 100
11

image-20200718102748463

修改类中的aa变量后，已经实例化的aa变量也会改变（实例aa变量指向类aa变量指向的对象）。

修改实例aa变量后，a.aa指向100，但A.aa仍然指向11，先查找实例中的aa变量，找到不会再向上查找类的aa变量。

4.7 类属性和实例属性以及查找顺序

class A：
    name = 'A'

a = A()
print(a.name)

A

实例是有自己的属性的，可以在类里面初始化

class A：
    name = 'A'
    def __init__(self):
        self.name = "obj"

a = A()
print(a.name)

obj

a.name的查找顺序是由下而上的，所以首先查找实例的name，如果查不到再向上查找类的name。

在多继承里，查找循序会变得复杂。

首先看下一种继承关系，python比较早的继承算法：MRO算法

image-20200718124156736

DFS：深度优先搜索

属性查找顺序是A、B、D、C、E，比如A中有个方法，在B中没有，那么则会去D中查找。

这种查找顺序其实是合理的，A从B、C继承，先搜索B的那个继承链。

但如果换一种继承方式，这种逻辑就不合理

image-20200718124646730

A继承于B、C，B、C继承于D（菱形继承），这种情况下使用DFS的逻辑就不合适。如果使用的是C中继承的方法，那么从B、D、C的顺序就不合理，这样相当于C永远无法覆盖D中的方法。

image-20200718132028033

这种情况下改为广度优先算法BFS。

但这种方法又会出现问题

image-20200718132148352

如上图，如果D和C中有同名的方法，那在搜索的时候，在B中没找到，就会去C中找。但此时B继承于D，而C继承于A，此时D、B应该看成一个整体，所以B后应该是D。所以广度优先算法BFS在这种情况下又不合适了。

Python3中的继承算法是C3算法，可以克服上述两个方法的缺点。

来看一下查找的例子：

#新式类
class D:
    pass

class E:
    pass

class C(E):
    pass

class B(D):
    pass

class A(B, C):
    pass

print(A.__mro__)

(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)

可以看到继承的顺序。

4.6 静态方法、类方法以及实例方法和参数

class Date:
    #构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    def __str__(self):
        return "{year}/{month}/{day}".format(year=self.year, 
                                             month=self.month, day=self.day)
    
new_day = Date(2018, 12, 10)
print（new_day）

2018/12/10

def __str__(self)是实例方法，普通情况下类中定义的方法都是实例方法

class Date:
    #构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1
        
    def __str__(self):
        return "{year}/{month}/{day}".format(year=self.year, 
                                             month=self.month, day=self.day)
new_day = Date(2018, 12, 10)
new_day.tomorrow()
print(new_day)

2018/12/11

new_day.tomorrow()，没有传入参数，python解释器会自动变成tomorrow(new_day)。

上面就是实例方法的使用。

接下来讲解静态方法：

class Date:
    #构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    def __str__(self):
        return "{year}/{month}/{day}".format(year=self.year, 
                                             month=self.month, day=self.day)
date_str = "2018-12-31"
year, month, day = tuple(date_str.split("-"))
new_day = Date(int(year), int(month), int(day))
print (new_day)

2018/12/10

用.split先对字符串切片，然后实例化Date。这组方法有个缺陷，就是每次对Date实例化时，都需要先对字符串切片。

我们可以把处理date的逻辑拿到类中，就是定义一个静态方法。

class Date:
    #构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1
	
    # 静态方法不需要self参数，也不需要cls对象
    @staticmethod
    def parse_from_string(date_str):
        year, month, day = tuple(date_str.split("-"))
        return Date(int(year), int(month), int(day))
    
date_str = "2018-12-10"
new_day = Date.parse_from_string(date_str)
print(new_day)

2018/12/31

这样我们使用时，代码变精简了，不需要每次都写代码处理一次date。

但是静态方法不好的地方是，在return的时候采用硬编码方式（Date()），如果改一下类名称为MyDate，那么我们也要改掉return的Date为MyDate。

所以有了一个python中常用的方法，@classmethod

class Date:
    #构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    @staticmethod
    def parse_from_string(date_str):
        year, month, day = tuple(date_str.split("-"))
        return Date(int(year), int(month), int(day))
	
    # 要传递cls，代表类本身
    @classmethod
    def from_string(cls, date_str):
        year, month, day = tuple(date_str.split("-"))
        return cls(int(year), int(month), int(day)) # 直接返回cls,不是硬编码

    def __str__(self):
        return "{year}/{month}/{day}".format(year=self.year, 
                                             month=self.month, day=self.day)
    
date_str = "2018-12-10"    
new_day = Date.from_string(date_str)
print(new_day)

2018/12/10

@classmethod方法里不是采用硬编码，传递cls参数。

classmethod貌似可以完全替代staticmethod，那么staticmethod的作用是什么？

假设在另外一种场景，要判断字符串是不是合法的：

class Date:
    #构造函数
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):
        self.day += 1

    @staticmethod
    def parse_from_string(date_str):
        year, month, day = tuple(date_str.split("-"))
        return Date(int(year), int(month), int(day))

    @staticmethod
    def valid_str(date_str):
        year, month, day = tuple(date_str.split("-"))
        if int(year)>0 and (int(month) >0 and 
                            int(month)<=12) and (int(day) >0 and int(day)<=31):
            return True
        else:
            return False

    @classmethod
    def from_string(cls, date_str):
        year, month, day = tuple(date_str.split("-"))
        return cls(int(year), int(month), int(day))

    def __str__(self):
        return "{year}/{month}/{day}".format(year=self.year, 
                                             month=self.month, day=self.day)
    
print(Date.valid_str("2018-12-32"))

1990/2/1
28

在判断字符串时，不需要返回对象，只有判断（True or False），这时候就没有必要传递cls参数进去。

静态方法，类方法必须加装饰器，实例方法就是普通的函数。

4.8 数据封装和私有属性

from  class_method import Date
class User:
    def __init__(self, birthday):
        self.__birthday = birthday

    def get_age(self):
        #返回年龄
        return 2018 - self.__birthday.year
    
user = User(Date(1990,2,1))
print(user.birthday)
print(user.get_age())

1990/2/1
28

输出了birthday和年龄，但一般我们希望将birthday隐藏掉，不希望用户直接看到。

在python中是没有private的，做法是添加双下划线。

from  class_method import Date
class User:
    def __init__(self, birthday):
        self.__birthday = birthday

    def get_age(self):
        #返回年龄
        return 2018 - self.__birthday.year

user = User(Date(1990,2,1))
print(user.__birthday)
print(user.get_age())

    print(user.__birthday)
AttributeError: 'User' object has no attribute '__birthday'

告诉我们没有这个__birthday，这样就相当于私有属性的封装。

私有属性是无法通过实例.__birthday来访问的，只能通过公共方法get_age间接获取__birthday。

当然，函数方法上也可以加双划线变为私有属性。

实际上，python封装私有属性，是对原有属性做变形，把名字改掉。

打印_classname__attr：

print(user._User__birthday)

1990/2/1

所以加双下划线不是从语言层面上来解决私有性，只是加了一些小技巧。把birthday变形成了_User__birthday。

4.9 python 的自省机制

自省是通过一定的机制查询到对象的内部结构

from class_method import Date
class Person:
    """
    人
    """
    name = "user"
    
class Student(Person):
    def __init__(self, school_name):
        self.school_name = school_name
        
user = Student("慕课网")
#通过__dict__查询属性
print(user.__dict__)
print(user.name)

{'scool_name': '慕课网'}
user

dict在python中是c语言实现的，所以效率很高，还有很多优化，这是个性能很高的数据结构。

我们理清关系，user是Student的实例，Student是Person的子类。

看两个输出，既然__dict__打印的是实例属性，为什么user.name打印出来的user没有进入dict呢？

因为name属于Person，是Person类属性，是Person对象空间里的值，并不是Student的属性，没有在Student的对象空间里。用.name这种方法，其实是会向上查找的。

print(Person.__dict__)

{'__module__': '__main__', '__doc__': '\n    人\n    ', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}

再用Person.__dict__的时候，里面是有“name”的。

如果对user的属性添加值：

user.__dict__["school_addr"] = "北京市"
print(user.school_addr)

北京市

所以__dict__我们可以取出来，也可以添加值，可以完成动态操纵user对象。

print(dir(user))

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'scool_name']

dir会列出对象中所有的属性，比__dict__功能更加强大，但只有属性名称，没有属性值。

4.10 super真的是调用父类吗

class A:
    def __init__(self):
        print ("A")
        
class B(A):
    def __init__(self):
        print ("B")
        
b = B()

B

这个打印逻辑很简单，但某种情况下，我们希望再调用父类的init方法。

class A:
    def __init__(self):
        print ("A")

class B(A):
    def __init__(self):
        print ("B")
        super().__init__()
        
b = B()

B
A

添加super函数，获取父类的init方法。

这里会有两个疑问：

  1. 既然B重写了A的构造函数（不一定要是init），为什么还要调用super？
  2. super的执行顺序是什么样的？

第一个问题回答：

在某些情况下，比如多线程的时候：

from threading import Thread
class MyThread(Thread):
    def __init__(self, name, user):
        self.user = user
        # self.name = name 实际上不用做这一步
        super().__init__(name=name) # 不用自己再写处理逻辑

定义自己的MyThread类，继承于Thread，定义初始化方法时，可以使用父类的方法。

class Thread:
    _initialized = False

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None):

Thread类中初始化方法有个参数name，Thread有很多处理的逻辑，那我们可以直接调用父类，好处是可以重用代码。

第二个问题回答：

不要认为super是调用父类方法，执行顺序涉及到mro算法。

class A:
    def __init__(self):
        print ("A")

class B(A):
    def __init__(self):
        print ("B")
        super().__init__()

class C(A):
    def __init__(self):
        print ("C")
        super().__init__()
        
class D(B, C):
    def __init__(self):
        print ("D")
        super(D, self).__init__()

print(D.__mro__)
d = D()

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
D
B
C
A

可以看到顺序是D、B、C、A，如果是调用父类方法这种逻辑，那么打印应该是D、B、A、C。

4.11 mixin继承案例

python是支持多继承的，但是也不推荐编码使用多继承，设计不好很容易造成关系混乱，mro算法也可能造成预料不到的问题。python中推荐的做法是mixin（混合模式）的模式。

class GoodListViewSet(CacheResponseMixin,mixins.ListModelMixin,
mixins.RetrieveModelMixin,viewsets.GenericViewSet):
    """
    商品列表页，分页，搜索，过滤，排序
    """

只写一个类，就能完成商品列表页，分页，搜索，过滤，排序，实际就是集成了多个mixin，这些mixin只写了一个方法。

image-20200719094606815

ListModelMixin也是一个类，但只有一个方法（获取商品的列表）。

image-20200719094655348

RetrieveModelMixin也只有一个函数，返回商品详情。

所以mixin模式，就是自己写一个mixin类，这个类只有一个方法（干一件事情）。

  1. mixin功能单一，只提供一个方法
  2. mixin不和基类关联，GenericViewSet才是真正的基类，mixin可以和任何基类组合，基类不和mixin关联也能初始化
  3. 在mixin中不要使用super

4.12 python中的with语句

首先介绍下try，except，finally

try:
    print ("code started")
    raise KeyError
except KeyError as e:
    print ("key error")

code started
key error

如果改为IndexError

try:
    print ("code started")
    raise IndexError
except KeyError as e:
    print ("key error")

code started
Traceback (most recent call last):
  File "D:/py_tutrial/AdvancePython-master/chapter04/ttt.py", line 4, in <module>
    raise IndexError
IndexError

这样就没有捕获到error，如果我们知道错误类型，那可以该except语句里的代码，如果不知道错误类型，那么可以加else语句

try:
    print ("code started")
    # raise IndexError 
except KeyError as e:
    print ("key error")
else:
    print ("other error")

code started
other error

注意else是在没有抛异常时运行的，有异常且无法捕获时无法运行。

还可以加finally，finally后的语句不管前面有没有错误都会运行

try:
    print ("code started")
    raise KeyError
except KeyError as e:
    print ("key error")
else:
    print ("other error")
finally:
    print ("finally")

code started
key error
finally

finally 有什么用呢？

try:
    f_read = open("bobby.txt")
    print ("code started")
    raise KeyError as e：
    f_read.close()
except KeyError as e：
	print ("key error")
    f_read.close()

比如打开一个文件，如果没有异常，就要close关闭会话，如果有异常，就不会执行close，那么要在

except里写一个close。如果还有其它异常，都写close就很繁琐。close操作其实可以写在finally中。

try:
    f_read = open("bobby.txt")
    print ("code started")
    raise KeyError as e：
except KeyError as e：
	print ("key error")
finally：
	f_read.close()

所以finally一般是用来做资源释放的。

解下来讲一下try，finally执行过程：

def exe_try():
    try:
        print ("code started")
        raise KeyError
        return 1
    except KeyError as e:
        print ("key error")
        return 2
    else:
        print ("other error")
        return 3
    finally:
        print ("finally")
        return 4

result = exe_try()
print(result)

code started
key error
finally
4

加了return后返回4，正常逻辑是raise一个error，进入except return 2，那为什么最后是return 4？

因为先return 2，那么会把2要让栈里，然后return 4，再把4压入栈，最后结果就是栈顶4。

python的with语句（上下文管理器）就是简化try，except，finally 这种用法。

在魔法函数中讲过python的协议，类只要实现了某些魔法函数，就可以看做某种类型的协议。with上下文管理器协议涉及到了两个魔法函数__enter__，__exit__，上下文管理器协议就可以直接使用with语句。

#上下文管理器协议
class Sample:
    def __enter__(self):
        print ("enter")
        #获取资源
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        #释放资源
        print ("exit")
    def do_something(self):
        print ("doing something")
        
with Sample() as sample:
    sample.do_something()

enter
doing something
exit

实际上我们并没有调用enter、exit，with自动调用了这两个魔法函数。调用顺序是enter、do_something、exit，所以可以去enter里获取资源，去exit里释放资源。

4.13 contextlib简化上下文管理器

本来自己实现上下文管理器，要写一个class和对应的魔法函数。

为了简化实现，python内置了contextlib。

import contextlib

@contextlib.contextmanager # 装饰器可以把函数变为上下文管理器
def file_open(file_name):
    print ("file open") # 可以看成enter
    yield {} # 必须是一个生成器
    print ("file end") # 可以看成exit

with file_open("bobby.txt") as f_opened:
    print ("file processing")

file open
file processing
file end

posted @   yueqiudian  阅读(151)  评论(0)  编辑  收藏  举报
编辑推荐：
· 浏览器原生「磁吸」效果！Anchor Positioning 锚点定位神器解析
· 没有源码，如何修改代码逻辑？
· 一个奇形怪状的面试题：Bean中的CHM要不要加volatile？
· ［.NET］调用本地 Deepseek 模型
· 一个费力不讨好的项目，让我损失了近一半的绩效！
阅读排行：
· 全网最简单！3分钟用满血DeepSeek R1开发一款AI智能客服，零代码轻松接入微信、公众号、小程
· .NET 10 首个预览版发布，跨平台开发与性能全面提升
· 《HelloGitHub》第 107 期
· 全程使用 AI 从 0 到 1 写了个小工具
· 从文本到图像：SSE 如何助力 AI 内容实时呈现？（Typescript篇）
点击右上角即可分享
微信分享提示