面向对象进阶

目录

• 面向对象进阶
  • __new__，__init__
  • __call__
  • with和__enter__,__exit__
  • __len__
  • __hash__
  • __eq__

面向对象进阶

__new__，__init__

​ __new__负责对象的创建，__init__负责对象的初始化

​ Python2.x中类的定义分为新式定义和老式定义两种。老式类定义时不继承 object 基类，而新式类在定义时显示继承 object 类。

# Python2.x中的老式类定义
class A: 
    pass

# Python2.x中的新式类定义
class A(object):
    pass

​ 注意：实例化对象是object类底层实现，其他类继承了object的__new__才能够实例化对象。

​ Python3.x中没有新式类和老式类，它们都继承自 object 类。因此可以不用显示地指定其基类。

# 在Python3中，__init__方法是当对象创建后，实例化对象自动执行的一种方法，而__new__方法和__init__方法不同，可以通俗的理解__init__方法在__new__方法执行后再执行。
# __new__方法是用来创建对象的，__new__方法需要有一个返回值，这个返回值表示创建出来的对象的引用。__init__方法是刚刚创建出来的对象的应用。
class A:
    def __init__(self):
        self.x = 1
        print('__init__方法，执行了。')

    def __del__(self):
        print('__del__方法，执行了。')

    def __new__(cls, *args, **kwargs):
        print('__new__方法，执行了。')
        return object.__new__(A)

a = A()
# __new__方法，执行了。
# __init__方法，执行了。
# __del__方法，执行了。

__call__

​ 对象后面加括号，触发执行。

​ 注意：构造方法的执行时由创建对象触发的，即：对象 = 类名()；而对于__call__方法的执行是由对象后加括号触发的。即：对象()或类()()。

class A:
    def __init__(self):
        print('__init__方法，执行了。')
        pass
	
    def __call__(self, *args, **kwargs):
        print('__call__方法，执行了。')
    
a = A() # 执行__init__
a()		# 执行__call__
# __init__方法，执行了。
# __call__方法，执行了。

with和__enter__,__exit__

class A:
    
	def __enter__(self):
        print('before')
       
	def __exit__(self, exc_type, exc_val, exc_tb):
    	print('after')
        
with A() as a:
    print('123')

# with 语句和 init
class A:
    def __init__(self):
        print('init')

    def __enter__(self):
        print('before')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('after')

with A() as a:
    print('123')
# init
# before
# 123
# after

# with 语句和 文件操作
class MyFile:
    def __init__(self, path, mode='r', encoding='utf-8'):
        self.path = path
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        self.f = open(self.path, mode=self.mode, encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

with MyFile('file',mode='w') as f:
    f.write('dnf')
# 会在当前文件夹内创建一个名为 file 的文件，并写入 dnf

# with 和 pickle
import pickle

class MyPickledump:
    def __init__(self, path):
        self.path = path
        
	def __enter__(self):
        self.f = open(self.path, mode='ab')
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

with MyPickledump('file') as f:
    f.dump({1,2,3,4,5,6})

# 执行以上序列化后再进行以下的反序列化
class MyPickleload:
    def __init__(self, path):
        self.path = path
        
	def __enter__(self):
        self.f = open(self.path, mode='rb')
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()
        
	def load(self):
        return pickle.load(self.f)
    
    def loaditer(self):
        while True:
            try:
                yield self.load()
			except EOFError:
                break

with MyPickleload('file') as f:
    for item in f.loaditer():
        print(item)

# wint 和 pickle 和 iter
import  pickle
class MyPickledump:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.f = open(self.path, mode='ab')
        return self

    def dump(self,content):
        pickle.dump(content,self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

# with MyPickledump('file') as f:
#      f.dump({1,2,3,4})       

class Mypickleload:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.f = open(self.path, mode='rb')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

    def __iter__(self):
        while True:
            try:
                yield  pickle.load(self.f)
            except EOFError:
                break

with Mypickleload('file') as f:
    for item in f:
        print(item)

__len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

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

a = A()
print(len(a))

__hash__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
    
a = A()
print(hash(a))

__eq__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)
# True