二.python面对对象 ------工厂 单列模式 isintannce()函数

1. 工厂类：在一个类中生成很多对象,   简单工厂模式

   (Simple Factory Pattern)

   是通过专门定义一个类来负责创建其他类的实例，

   被创建的实例通常都有共同的父类 并且重写父类方法。

2.pass

 __new__(cls): #用来创建对象，而且必须有返回值

 return  object.__new__(cls);

 return super(子类,cls).__new__(cls,args, kwargs)

3. 可以用id(cls)看地址

当有属性时，需要在__new__()中也添加属性

单例模式：该模式的主要目的是确保某一个类只有一个实例存在。

class singleton:
   __instance=None
 def __new__(cls):
        if cls.__instance==None:
            cls.__instance=object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance
s=singleton()
ss=singleton()
print(id(s))
print(id(ss))

 4.isinstance()函数 判断是否 继承关系 某一个变量是否是某一个数据类型

 getattr(类名/对象名)、setattr(类名/对象名)以及hasattr(类名/对象名,'属性名')，

 类名/对象名有 __getattribute__ __setattr__   没有__hasattr__()

 5.我们可以直接操作一个对象的 形态-

 给类动态添加函数 所有对象都能用 给某一个对象添加

 def set_score(self, score):

   self.score = score

6.Student.set_score = set_score

动态语言的灵活性:

为了达到限制的目的，Python允许在定义class的时候，

定义一个特殊的__slots__变量，

来限制该class实例能添加的属性

class 类名：

_slots__ = ('name', 'age') #第一句

7.@property注解优化gettersetter --> @函数名.setter

__call__直接在实例本身上调用s = Student('Michael')s()

通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。

dir()展示一个类对象的内部属性和函数__dir__

===============================

如下例：

class Operation:

    def __init__(self,numA,numB):

        self.numA=numA

        self.numB=numB

    def yunshuan(self):

        pass

class OperationAdd(Operation):

    __slots__ = ('numA','numB')

    def __init__(self,numA,numB):

        super().__init__(numA,numB)

    def yunsuan(self):

        return self.numA+self.numB

class OperationSub(Operation):

    def __init__(self,numA,numB):

        super().__init__(numA,numB)

    def yunshuan(self):

        return self.numA-self.numB

class OperationMul(Operation):

    def __init__(self,numA,numB):

        super().__init__(numA,numB)

    def yunshuan(self):

        return self.numA * self.numB

class OperationDiv(Operation):

    def __int__(self,numA,numB):

        super().__init__(numA,numB)

    def yunshuan(self):

        return self.numA//self.numB

========================================

# 工厂类课上练习

class OperationFactory(object):

    @classmethod

    def getOperation(self,fu,numA,numB):

        if '+'.__eq__(fu):

            return OperationAdd(numA,numB)

        elif '-'.__eq__(fu):
            return OperationSub(numA,numB)

        elif '*'.__eq__(fu):

            return OperationMul(numA,numB)

        elif '/'.__eq__(fu):

            return OperationDiv(numA,numB)

def setName(self,name):

        self.name = name

if '__main__' == __name__:

    # numA=int(input('请输入第一个操作符'))

    # numB=int(input('请输入第一个操作符'))

    # fu = input('请输入操作符')

    # # 返回与操作符对应的 运算对象

    # # 父类类型  容纳  子类对象————->里氏代换原则

    # Oper=OperationFactory.getOperation(fu,numA,numB)

    # jg=Oper.yunshuan()

    # print('运算结果：',jg)

    # if isinstance(Oper,OperationAdd):

    #     print('创建的是 OperationAdd 类型的对象')

    # elif isinstance(Oper,OperationSub)

    #     print('创建的是  类型的对象')

    # elif isinstance(Oper,OperationMul):

    #     print('创建的是 OperationSub 类型的对象')

    # elif isinstance(Oper,OperationSub):

    #     print('创建的是 OperationDiv 类型的对象')

    #

    # print(isinstance(Oper,Operation))

    # print(isinstance(Oper,object))

    Oper=OperationFactory.getOperation('+',6,6)

    # Oper.name=''

    # print(getattr(Oper,'numA'))

    setattr(Oper,'numC',7)

    Oper.numD=6

    Oper.__setattr__('numE',666)

    print(Oper.numD)

    print(hasattr(Oper,'numC'))

    # print(dir(Oper))

    Operation.setName=setName

    Oper.setName('加法')

    print('运算方式：'+Oper.name)

    Oper2 = OperationFactory.getOperation('-', 6, 6)

    Oper2.setName('减法')

    print('Oper2 运算方式：' + Oper2.name)