面向对象编程¶

>>> class Example:
...     class_attribute = '类属性'
...     __private = '私有 类属性'
...     _private = '惯用私有 类属性'
...     def __init__(self):
...         self.instance_attribute_in_method = '实例属性'
...     @property
...     def property_attribute(self):
...         return 'property装饰的类属性'

>>> dir(Example)
[ '_Example__private', '__class__', '__delattr__', 
  '__dict__', '__dir__', '__doc__', '__eq__', 
  '__format__', '__ge__', '__getattribute__', 
  '__getstate__', '__gt__', '__hash__', 
  '__init__', '__init_subclass__', '__le__', 
  '__lt__', '__module__', '__ne__', '__new__', 
  '__reduce__', '__reduce_ex__', '__repr__', 
  '__setattr__', '__sizeof__', '__str__', 
  '__subclasshook__', '__weakref__', 
  '_private', 'class_attribute', 'property_attribute']
>>> e = Example() 
>>> e.__dir__()
[ '_Example__private', '__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__',
  '_private', 'class_attribute', 
  'instance_attribute_in_method', 'property_attribute']
>>> e.__dict__
{'instance_attribute_in_method': '实例属性'}

>>> e.class_attribute
'类属性'
>>> try:
...     print(e.__private)
... except AttributeError as error:
...     print(error)
'Example' object has no attribute '__private'
>>> e.instance_attribute_in_method
'实例属性'
>>> e.property_attribute
'property装饰的类属性'
>>> e._Example__private
'私有 类属性'
>>> e._private
'惯用私有 类属性'

>>> class Warehouse:
...    purpose = 'storage'
...    region = 'west'
...
>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
storage east

class A:
    __match_args__ = ('a','b')
    def __init__(self, x, y, z):
        self.a = x
        self.b = y
        self.c = z

obj = A(2,2,3)

match obj:
    case A(2,2):
        print(2,2) # this case matched
    case A(1,1):
        print(1,1)

class A:
  __slots__  = ['data']
  pass

>>> class Example:
...     def f(s):
...         print(s)

>>> Example.f('asd')
asd

>>> e = Example()
>>> e.f()
<__main__.Example object at 0x102c437d0>

>>> e.f('asd')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Example.f() takes 1 positional argument but 2 were given

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

>>> class Person:
...     def __init__(self, name):
...         self.name = name
...     def hello(self):
...         print(f"I am {self.name}")
...
>>> class Doctor(Person):
...     def hello(self):
...         print(f"I am Dr.{self.name}")
...
>>> alice = Person('Alice')
>>> alice.hello()
I am Alice
>>> galler = Doctor('Galler')
>>> galler.hello()
I am Dr.Galler

class A:
  def __hash__(self):
    print('__hash__() is called')
    return super().__hash__(self) # 父类的hash函数

from os.path import join

class FileObject:
    '''文件对象的装饰类，用来保证文件被删除时能够正确关闭。'''

    def __init__(self, filepath='~', filename='sample.txt'):
        # 使用读写模式打开filepath中的filename文件
        self.file = open(join(filepath, filename), 'r+')

    def __del__(self):
        self.file.close()
        del self.file

>>> class Vector:
...     def __init__(self, *data):
...       self.data = data
...     def __repr__(self):
...       return 'vec(%s)' % (','.join(map(str,self.data)))
>>> v = Vector(1,2,3)
>>> print(v)
vec(1,2,3)

class A:

    def __init__(self, x):
        self.x = x

    def __getattribute__(self, name):
        return super().__getattribute__(name)

    def __getattr__(self, name):
        return None

a = A(1)
print(a.x) # print 1
print(a.data) # print None

class Range:
    """Range(n) is a iterator from 1 to n"""
    def __init__(self, n) -> None:
        self.max = n
        self.now = 0
        self.inc = 1 # 增量，顺序为1，逆序为-1

    def __next__(self):
        while self.now != self.max:
            self.now += self.inc
            return self.now
        else:
            raise StopIteration

    def __iter__(self):
        # 顺序迭代
        return self

    def __reversed__(self):
        # 逆序迭代
        self.inc = -1
        self.max, self.now = self.now+1, self.max+1
        return self

for i in Range(3): 
    # 输出 1 2 3
    print(i)

for j in reversed(Range(3)):
    # 输出 3 2 1
    print(j)

import os

class DirectorySize:
    """描述器"""
    def __get__(self, obj, objtype=None):
        return len(os.listdir(obj.dirname))

class Directory:
    size = DirectorySize() # Descriptor instance           
    def __init__(self, dirname):
        self.dirname = dirname  # Regular instance attribute

with ContextManager() as c:
    # with 语句会首先调用__enter__，把返回值赋值给as后的变量
    pass
# 语句结束后运行__exit__
# 如果没有异常，三个参数都是None

class Hello:
    def __init__(self, name) -> None:
        self.name = name

    def __call__(self):
        print(f'Hello {self.name}.')

h = Hello('python')
h() # print Hello python.

class entryExit(object):
    def __init__(self, f):
        self.f = f
    def __call__(self):
        print("Entering", self.f.__name__)
        self.f()
        print("Exited", self.f.__name__)

@entryExit
def func():
    print("inside func()")

func()

Entering func
inside func()
Exited func

class Reader:
    async def readline(self):
        ...

    def __aiter__(self):
        return self

    async def __anext__(self):
        val = await self.readline()
        if val == b'':
            raise StopAsyncIteration
        return val

class AsyncContextManager:
    async def __aenter__(self):
        await log('entering context')

    async def __aexit__(self, exc_type, exc, tb):
        await log('exiting context')

class A:
    pass

A = type("A", (), {})

class Philosopher:
    def __init_subclass__(cls, /, default_name, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.default_name = default_name

class AustralianPhilosopher(Philosopher, default_name="Bruce"):
    pass

class Meta(type):
    def __new__(cls, name, bases, dict):
        flag = all(name==name.lower() for name in dict)
        assert flag, "CapitalName"
        return type.__new__(cls, name, bases, dict)

    def __init__(self, name, bases, dict):
        return type.__init__(self, name, bases, dict)

    def __call__(cls, *args, **kwds):
        print("meta_called")
        return type.__call__(cls, *args, **kwds)

class MyClass(metaclass=Meta):

    def Apple(self):
        pass

Traceback (most recent call last):
  File "/Users/yang/Desktop/example.py", line 12, in <module>
    class MyClass(metaclass=Meta):
  File "/Users/yang/Desktop/example.py", line 3, in __new__
    assert all(name==name.lower() for name in dict), "CapitalName"
AssertionError: CapitalName

class MyClass(metaclass=Meta):

    def apple(self):
        pass

    def __call__(cls):
        print("subclass_called")
        pass

obj = MyClass()

obj() 
# print meta_called then print subclass_called