面向对象（一）--魔术方法（特殊方法）

1、__new__方法

__new__方法：创建对象调用的方法

__init__方法：初始化对象调用的方法

一个类如果重写了__new__方法，又没有调用父类的__new__方法创建对象，那__init__方法也不会调用

class MyTest(object):

    def __init__(self, *args, **kwargs):
        print("这是初始化对象的方法")

    def __new__(cls, *args, **kwargs):
        print("这是new方法，创建对象调用的方法")


m = MyTest()
print(m)
没有调用__init__初始化方法，因为__new__方法没有调用父类的new方法创建对象，故初始化方法不会自动调用

 2、单例模式

a、什么是单例模式？

单例模式：一个类只能创建一个对象,这个类就是一个单例模式的类

b、单例模式的实现

1）重写__new__方法实现单例模式

class MyTest(object):
    obj = None  # 定义一个类属性，存储创建的对象，如果对象存在，则返回该对象，如果对象不存在则创建对象

    def __init__(self, *args, **kwargs):
        print("这是初始化对象的方法")

    def __new__(cls, *args, **kwargs):
        if not cls.obj:
            cls.obj = super().__new__(cls,*args,**kwargs)
        return cls.obj


m1 = MyTest()
m2 = MyTest()
m3 = MyTest()
print("{}:内存地址：{}".format(m1, id(m1)))
print("{}:内存地址：{}".format(m2, id(m2)))
print("{}:内存地址：{}".format(m3, id(m3)))

2）使用装饰器实现单例模式

"""
通过装饰器实现单例模式，只要任意一个类使用该装饰器装饰，那么就会变成一个单例模式的类
"""

status = {"obj": None}  # 定义一个全局变量，存储创建的类


# 装饰器
def test_decorator(func):
    def wrapper(*args, **kwargs):
        if not status["obj"]:
            status["obj"] = func(*args, **kwargs)
        return status["obj"]

    return wrapper


# 被装饰的类
@test_decorator
class MyTest(object):

    def __init__(self, *args, **kwargs):
        print("这里是初始化方法")


m1 = MyTest()
m2 = MyTest()
m3 = MyTest()

print("{}:内存地址：{}".format(m1, id(m1)))
print("{}:内存地址：{}".format(m2, id(m2)))
print("{}:内存地址：{}".format(m3, id(m3)))

c、单例模式的作用

单例模式的作用：节省内存开销

 

例子：

"""
实现一个类，前五次创建对象，每次都可以返回一个新的对象，第六次开始，每次创建，都随机返回前5哥对象中的一个
"""
import random


class CreateObject(object):
    obj_list = []

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if len(cls.obj_list) < 5:
            obj = super().__new__(cls, *args, **kwargs)
            cls.obj_list.append(obj)
            return obj
        else:
            return random.choice(cls.obj_list)


for c in range(10):
    obj = CreateObject()
    print("对象第{}次创建，内存地址：{}".format(c + 1, id(obj)))

 

 

3、上下文管理器---with

1）迭代器协议是由__iter__方法和__next__方法这两个魔术方法组成的。

__iter__方法：会在使用内置函数iter(obj)，将可迭代对象转换为迭代器时调用。

__next__方法：会在使用内置函数next(obj)，对迭代器进行迭代操作时调用。

2）为什么with去打开文件进行操作，会自动关闭文件呢？

因为with启动了文件操作对象的上下文管理器

3）上下文管理器协议的构成：__enter__方法和__exit__方法

__enter__方法：启动上下文时会自动调用

__exit__方法：退出上下文时会自动调用

4）如果说一个对象实现了__enter__方法和__exit__方法，那么这个对象就实现了上下文管理器协议，就可以使用with这个关键字来开启对象的上下文管理。

class FileOpen(object):

    def __init__(self, file, mode, encoding):
        self.file = file
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        print("-----进入enter方法----")
        self.io = open(self.file, self.mode, encoding=self.encoding)
        return self.io

    def __exit__(self,exc_type, exc_value, exc_traceback):
        print("异常的类型：{}".format(exc_type))
        print("异常的值：{}".format(exc_value))
        print("异常的溯源：{}".format(exc_traceback))
        self.io.close()


with FileOpen("d06_new.py", "r", "utf-8") as f:
    file_content = f.read()
    # raise AssertionError
    print(file_content)

4、__call__方法

1）一切皆对象，其实函数也是对象，函数是可调用的对象

callable(obj):输出bool，判断对象是否可调用

name = "123"
print(callable(name)) # 输出False
print(callable(str))  # 输出True

象是否可调用

2）__call__方法：实现了该方法的对象，该对象是可调用的对象（像调用函数一样调用对象）

class MyTest(object):

    def __init__(self):
        print("这是初始化方法")

    def __call__(self, *args, **kwargs):
        print("实现了call方法，对象可被调用")


m = MyTest()
print(callable(m))
m()  # 对象调用的时候，执行的是__call__()方法

 

 3）通过类实现装饰器

class MyDecorator(object):

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

    def __call__(self, *args, **kwargs):
        print("装饰器扩展功能1")
        res = self.func(*args, **kwargs)
        print("装饰器扩展功能2")
        return res


@MyDecorator  # ==>  worker = MyDecorator(worker)
def worker():
    print("这是Worker功能函数")


worker()

 

 

5、__str__方法

1）print输出的内容：是用什么方法来控制的？

print输输出的其实就是对象的__str__返回的值

注意点：__str__方法必须要些返回值，返回值的类型只能是字符串

class MyTest:

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def __str__(self):
        return str(self.name)


m1 = MyTest("gen", 18, "dalao")
m2 = MyTest("fei", 18, "pingm")
print(m1)
print(m2)