黑马python入门(5):Python基础(面向对象相关)

class TestClassObject(object):
    """
    展示下新类的常见结构
    """
    name = "TestClassObject.name"  # 类属性 name 可以在该类的所有实例下调用 但是只能通过类名.类属性进行修改 不能类实例.类属性进行修改
    fun = "测试用类"  # 类属性 fun

    def __init__(self, a, b, c):  # 固定的类初始化函数 在类实例化的时候自动隐式调用 该类方法内也是统一声明类实例属性的地方
        self.a = a  # 类实例属性 a
        self.b = b  # 类实例属性 b
        self.c = c  # 类实例属性 c

    def test1(self):  # 类实例方法 第一个参数是self 但是调用类实例方法第一个参数不用写
        print(self.a + self.b)

    @classmethod
    def test2(cls):  # 这是类方法 第一个参数代指类本身 可以在这个类方法里面调用类属性 其他类方法来运算
        print(cls.name)


    @staticmethod
    def test4():  # 这是静态方法 注意这个静态方法不能有 类的属性方法 或者 类实例的属性和方法在 看做是一个普通的函数即可
        print("这里是静态方法")

class TestClassObject(object):
    """
    展示下新类的常见结构
    """
    name = "TestClassObject.name"  # 类属性 name 可以在该类的所有实例下调用 但是只能通过类名.类属性进行修改 不能类实例.类属性进行修改
    fun = "测试用类"  # 类属性 fun

    def __init__(self, a, b, c):  # 固定的类初始化函数 在类实例化的时候自动隐式调用 该类方法内也是统一声明类实例属性的地方
        self.a = a  # 类实例属性 a
        self.b = b  # 类实例属性 b
        self.c = c  # 类实例属性 c

    def test1(self):  # 类实例方法 第一个参数是self 但是调用类实例方法第一个参数不用写
        print(self.a + self.b)

    @classmethod
    def test2(cls):  # 这是类方法 第一个参数代指类本身 可以在这个类方法里面调用类属性 其他类方法来运算
        print(cls.name)


    @staticmethod
    def test3():  # 这是静态方法 注意这个静态方法不能有 类的属性方法 或者 类实例的属性和方法在 看做是一个普通的函数即可
        print("这里是静态方法")


# 调用类属性 类方法：  类名.类属性 类名.类方法()  不推荐 类实例名.类属性 类实例名.类方法()
print("类属性为：{}".format(TestClassObject.name))
# 类方法
TestClassObject.test2()
# 实例属性
print("类实例属性为：{}".format(test_class_object.a))
# 类实例方法
 test_class_object.test1()
 # 类静态方法 类名.静态方法()  类实例名.静态方法() 都可以
TestClassObject.test3()
test_class_object.test3()

class TestProperty(object):
    """
    测试私有属性的Property的用法
    """
    def __init__(self, aa):
        self.__aa = aa  # 给私有属性赋初值

    # 外界想要用 类实例名.变量名的方式来获取这个私有变量的时候触发 注意 类实例名.变量名的变量名 以下面的 变量名=property 为准
    def getaa(self):
        print("=[获取]私有属性aa的值=")
        return self.__aa

    # 外界想要用 类实例名.变量名的方式来修改这个私有变量的时候触发
    def setaa(self, v):
        print("=[修改]私有属性aa的值=")
        self.__aa = v

    # 外界想要用 del(类实例名.变量名)的方式来修改这个私有变量的时候触发 注意的是del函数无法真正的销毁这个私有属性 要想彻底销毁这个私有属性 需要在类内执行del才可以
    def delaa(self):
        print("=[删除]私有属性aa的值=")
        # del(self.__aa)  # 要想彻底销毁这个私有属性 需要在类内执行del才可以
        self.__aa = 0  # 假装销毁一下归零吧

    # 这个变量才是外面要直接调用的变量名 而不是私有属性名 这个变量可以随意改
    aaa = property(getaa, setaa, delaa, "doc1111")
    # aaa = property(getaa)  #设置为外界只读

testaa = TestProperty(14)

print("私有类属性aa为：{}".format(testaa.aaa))
testaa.aaa = 24
print("私有类属性aa为：{}".format(testaa.aaa))

del(testaa.aaa)
print("私有类属性aa为：{}".format(testaa.aaa))

print(testaa._TestProperty__aa)
testaa._TestProperty__aa = 34  # 知道了类名和私有属性名 用这种方式可以直接修改访问私有属性
print("私有类属性aa为：{}".format(testaa.aaa))

class People:
    def __init__(self,name):
        self.name = name
    def say(self):
        print("我是人，名字为：",self.name)
class Animal:
    def __init__(self,food):
        self.food = food
    def display(self):
        print("我是动物,我吃",self.food)
class Person(People, Animal):
    #自定义构造方法
    def __init__(self,name,food):
        #调用 People 类的构造方法
        super().__init__(name)
        #super(Person,self).__init__(name) #执行效果和上一行相同
        #People.__init__(self,name)#使用未绑定方法调用 People 类构造方法
        #调用其它父类的构造方法，需手动给 self 传值
        Animal.__init__(self,food)    
per = Person("zhangsan","熟食")
per.say()
per.display()

#定义一个实例方法
def say(self):
    print("我要学 Python！")
#使用 type() 函数创建类
CLanguage = type("CLanguage",(object,),dict(say = say, name = "C语言中文网"))
#创建一个 CLanguage 实例对象
clangs = CLanguage()
#调用 say() 方法和 name 属性
clangs.say()
print(clangs.name)

class object:
 """ The most base type """

 # del obj.xxx或delattr(obj,‘xxx‘)时被调用，删除对象中的一个属性
 def __delattr__(self, *args, **kwargs): # real signature unknown
 """ Implement delattr(self, name). """
 pass

 # 对应dir(obj)，返回一个列表，其中包含所有属性和方法名（包含特殊方法）
 def __dir__(self, *args, **kwargs): # real signature unknown
 """ Default dir() implementation. """
 pass

 # 判断是否相等 equal ，在obj==other时调用。如果重写了__eq__方法，则会将__hash__方法置为None
 def __eq__(self, *args, **kwargs): # real signature unknown
 """ Return self==value. """
 pass

 # format(obj)是调用，实现如何格式化obj对象为字符串
 def __format__(self, *args, **kwargs): # real signature unknown
 """ Default object formatter. """
 pass

 # getattr(obj,‘xxx‘)、obj.xxx时都会被调用，当属性存在时，返回值，不存在时报错（除非重写__getattr__方法来处理）。
 # 另外，hasattr(obj,‘xxx‘)时也会被调用（估计内部执行了getattr方法）
 def __getattribute__(self, *args, **kwargs): # real signature unknown
 """ Return getattr(self, name). """
 pass

 # 判断是否大于等于 greater than or equal，在obj>=other时调用
 def __ge__(self, *args, **kwargs): # real signature unknown
 """ Return self>=value. """
 pass

 # 判断是否大于 greater than，在obj>other时调用
 def __gt__(self, *args, **kwargs): # real signature unknown
 """ Return self>value. """
 pass

 # 调用hash(obj)获取对象的hash值时调用
 def __hash__(self, *args, **kwargs): # real signature unknown
 """ Return hash(self). """
 pass

 def __init_subclass__(self, *args, **kwargs): # real signature unknown
 """
 This method is called when a class is subclassed.

 The default implementation does nothing. It may be
 overridden to extend subclasses.
 """
 pass

 # object构造函数，当子类没有构造函数时，会调用object的__init__构造函数
 def __init__(self): # known special case of object.__init__
 """ Initialize self. See help(type(self)) for accurate signature. """
 pass

 # 判断是否小于等于 less than or equal，在obj<=other时调用
 def __le__(self, *args, **kwargs): # real signature unknown
 """ Return self<=value. """
 pass

 # 判断是否小于 less than，在obj<other时调用
 def __lt__(self, *args, **kwargs): # real signature unknown
 """ Return self<value. """
 pass

 # 创建一个cls类的对象，并返回
 @staticmethod # known case of __new__
 def __new__(cls, *more): # known special case of object.__new__
 """ Create and return a new object. See help(type) for accurate signature. """
 pass

 # 判断是否不等于 not equal,在obj!=other时调用
 def __ne__(self, *args, **kwargs): # real signature unknown
 """ Return self!=value. """
 pass

 def __reduce_ex__(self, *args, **kwargs): # real signature unknown
 """ Helper for pickle. """
 pass

 def __reduce__(self, *args, **kwargs): # real signature unknown
 """ Helper for pickle. """
 pass

 # 如果不重写__str__，则__repr__负责print(obj)和交互式命令行中输出obj的信息
 # 如果重写了__str__，则__repr__只负责交互式命令行中输出obj的信息
 def __repr__(self, *args, **kwargs): # real signature unknown
 """ Return repr(self). """
 pass

 # 使用setattr(obj,‘xxx‘,value)、obj.xxx=value是被调用（注意，构造函数初始化属性也要调用）
 def __setattr__(self, *args, **kwargs): # real signature unknown
 """ Implement setattr(self, name, value). """
 pass

 # 获取对象内存大小
 def __sizeof__(self, *args, **kwargs): # real signature unknown
 """ Size of object in memory, in bytes. """
 pass

 # 设置print(obj)打印的信息，默认是对象的内存地址等信息
 def __str__(self, *args, **kwargs): # real signature unknown
 """ Return str(self). """
 pass

 @classmethod # known case
 def __subclasshook__(cls, subclass): # known special case of object.__subclasshook__
 """
 Abstract classes can override this to customize issubclass().

 This is invoked early on by abc.ABCMeta.__subclasscheck__().
 It should return True, False or NotImplemented. If it returns
 NotImplemented, the normal algorithm is used. Otherwise, it
 overrides the normal algorithm (and the outcome is cached).
 """
 pass
 # 某个对象是由什么类创建的，如果是object，则是type类<class ‘type‘>
 __class__ = None
 # 将对象中所有的属性放入一个字典，例如{‘name‘:‘Leo‘,‘age‘:32}
 __dict__ = {}
 # 类的doc信息
 __doc__ = ‘‘
 # 类属于的模块,如果是在当前运行模块，则是__main__，如果是被导入，则是模块名（即py文件名去掉.py）
 __module__ = ‘‘

class Student(object):
    def __init__(self,id,name,age):
        self.id=id
        self.name=name
        self.age=age
 
    def __str__(self):
        return "学号:{}--姓名:{}--年龄{}".format(self.id,self.name,self.age)
    
s=Student(111,"Bob",18)
print(s)

class TestOnlyMode(object):
    """
    简单的一个单例模式结构
    """
    # 类属性 用来记录唯一的类实例对象和是否要初始化实例的各个参数
    _only_record = None
    _is_init = False

    def __new__(cls, *args, **kwargs):
        if cls._only_record:
            # _only_record里面已经存储了一个类实例了 就不用创建了
            print("_only_record 为真 不用创建实例了[{}]".format(cls._only_record))
            pass
        else:
            # 还没创建实例呢 就现在创建1个
            print("_only_record 为假 创建实例中")
            cls._only_record = object.__new__(cls)
            print("_only_record 为真 创建实例完毕[{}]".format(cls._only_record))
        return cls._only_record  # 返回个实例对象给init处理

    def __init__(self, a, b, c):
        print(self._is_init)
        if self._is_init:
            # 为真表示已经实例化完毕了 不用再次连续设置初值
            print("无需初始化参数")
            pass
        else:
            # 没实例化自然要设置初值
            print("初始化参数了")
            self.a = a
            self.b = b
            self.c = c
            self._is_init = True
    def showit(self):
        print("a:{} ,b:{} ,c:{}".format(self.a, self.b, self.c))

aa = TestOnlyMode(1, 2, 3)
print(aa.showit())
bb = TestOnlyMode(1, 2, 4)
print(bb.showit())
cc = TestOnlyMode(2, 2, 3)
print(cc.showit())
print(id(aa))
print(id(bb))
print(id(cc))