面向对象三（异常、模块）

__new__方法

class A(object):
    def __init__(self):
        print("这是 init 方法")

    def __new__(cls):
        print("这是 new 方法")
        return object.__new__(cls)

A()

class Dog:
    def __init__(self):
        print('这是init方法')

    def __str__(self):
        return '这是str方法'

    def __del__(self):
        print('这是del方法')

    def __new__(cls, *args, **kwargs):
        print(id(cls))
        print('这是new方法')
        return object.__new__(cls)

print(id(Dog))
dog = Dog()
print(dog)

总结：

1. __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供；
2. __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例；
3. __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

class Person:
    def __init__(self,name):
        self.name = name


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

a = Person('kenny')
b = Person('peter')
print(id(a))
print(id(b))
print(getattr(a,'name'))
print(getattr(b,'name'))

总结
单例模式下，创建的实例对象指向同一片空间，后面创建的对象会覆盖前面创建的对象，而非单例模式每次实例化一个对象都会开辟一个空间地址，所以说单例模式节约了大量的内存空间。

创建单例是，如果只初始化一次该怎么做

# 实例化一个单例
class Person(object):
    __instance = None
    __init_flag = False

    def __new__(cls, age, name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):
        if not self.__init_flag:
            self.age = age
            self.name = name
            Person.__init_flag = True


a = Person(18, "kenny")
b = Person(8, "peter")

print(id(a))
print(id(b))


print(a.age)
print(b.age)
print(a.name)
print(b.name)

工厂方法模式

当买车时，有很多种品牌可以选择，比如北京现代、别克、凯迪拉克、特斯拉等，那么此时该怎样进行设计呢？

# 定义一个基本的4S店类
class CarStore(object):

    #仅仅是定义了有这个方法，并没有实现，具体功能，这个需要在子类中实现
    def createCar(self, typeName):
        pass

    def order(self, typeName):
        # 让工厂根据类型，生产一辆汽车
        self.car = self.createCar(typeName)
        self.car.move()
        self.car.stop()

# 定义一个北京现代4S店类
class XiandaiCarStore(CarStore):

    def createCar(self, typeName):
        self.carFactory = CarFactory()
        return self.carFactory.createCar(typeName)


# 定义伊兰特车类
class YilanteCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义索纳塔车类
class SuonataCar(object):

    # 定义车的方法
    def move(self):
        print("---车在移动---")

    def stop(self):
        print("---停车---")

# 定义一个生产汽车的工厂，让其根据具体得订单生产车
class CarFactory(object):

    def createCar(self,typeName):
        self.typeName = typeName
        if self.typeName == "伊兰特":
            self.car = YilanteCar()
        elif self.typeName == "索纳塔":
            self.car = SuonataCar()

        return self.car

suonata = XiandaiCarStore()
suonata.order("索纳塔")

工厂方法模式的定义：

1. 定义了一个创建对象的接口(可以理解为函数)，但由子类决定要实例化的类是哪一个，工厂方法模式让类的实例化推迟到子类，抽象的CarStore提供了一个创建对象的方法createCar，也叫作工厂方法。
2. 子类真正实现这个createCar方法创建出具体产品。
   创建者类不需要直到实际创建的产品是哪一个，选择了使用了哪个子类，自然也就决定了实际创建的产品是什么。

异常处理

当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"

import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    except Exception as ret:
        #如果在读取文件的过程中，产生了异常，那么就会捕获到
        #比如 按下了 ctrl+c
        print(ret)
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

抛出自定义异常

class ShortInputException(Exception):
    '''自定义的异常类'''
    def __init__(self, length, atleast):
        super().__init__()
        self.length = length
        self.atleast = atleast

def main():
    try:
        s = input('请输入: ')
        if len(s) < 3:
            # raise引发一个你定义的异常
            raise ShortInputException(len(s), 3)
    except ShortInputException as result:
        print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (result.length, result.atleast))
    else:
        print('没有异常发生.')

main()