python 面向对象：类、继承、元类

类

1、 属性、方法、new / init / del / str、私有__、__slots__

import sys

class Cat:    
        def __new__(cls, *args, **kwargs):    # 创建对象
                return object.__new__(cls)
                
        def __init__(self, name, color):      # 初始化对象
                self.name = name     # 属性
                self.color = color   # 属性

        def __str__(self): # print(类对象)
                return "%s:%s" %(self.name, self.color)

        def __del__(self): # 当对象被释放时，该方法被调用（引用计数方式）
                print("---over---")

        def Introduce(self):   # 方法
                print(self.name, self.color)
        # 私有属性、私有方法，前面加两个下划线__

tom = Cat("Tom","red")  # __new__方法创建对象 ==> __init__ ==> 返回对象的引用
tom.Introduce()
print(tom)

print(sys.getrefcount(tom))  # 测量引用计数的个数 = sys.getrefcount(tom) + 1

class Person:
    __slots__ = ("name","age")  # 只允许添加这两个属性

p = Person()
p.name = "Tom"
p.age = 18

p.score = 100  # 报错

2、属性
为了防止每次都要调用 set/get 方法（显得比较费劲），python设计了property功能

方式1：
	class Money:
	    def __init__(self):
	        self.__money =0
	    def getmoney(self):
	        print("---get---")
	        return self.__money
	    def setmoney(self,money):
	        print("---set---")
	        self.__money = money
	    money = property(getmoney,setmoney)  # 必须先get，后set
	
	obj = Money()
	print(obj.money) # 实际上，调用了getmoney()函数
	obj.money = 100  # 实际上，调用了setmoney(100)函数
	
方式2：
	class Money:
	    def __init__(self):
	        self.__money =0
	    @property
	    def money(self):         # 函数1
	        print("---get---")
	        return self.__money
	    @money.setter
	    def money(self,money):   # 函数2
	        print("---set---")
	        self.__money = money
	
	obj = Money()
	print(obj.money) # 实际上，调用了函数1
	obj.money = 100  # 实际上，调用了函数2

3、实例变量 / 实例方法、类变量 / 类方法、静态方法

class Game:
        def __init__(self,name="逆战"): # 实例方法：必须有self
                self.name = name # 实例属性：必须有self
        # 类属性
        num = 0
        # 类方法：必须有cls
        @classmethod
        def add_num(cls):
                cls.num += 1
        # 静态方法
        @staticmethod
        def pri_menu():
                print("逆战")
                print("开始游戏")

game = Game()
# 调用staticmethod
game.pri_menu() # Game.pri_menu()
# 调用classmethod
game.add_num()  # Game.add_num()
# 访问类属性
print(Game.num) # print(game.num)  

4、单例模式__init__ 、 只初始化一次__init__

class Cat(object):
        __instance = None    # 类属性：实现单例模式
        __init_falg = False  # 只属性：实现只初始化一次
        def __new__(cls, *args, **kwargs):
                if cls.__instance == None:
                        cls.__instance = object.__new__(cls)
                        return cls.__instance
                else:
                        return cls.__instance
        def __init__(self,name):
                if Cat.__init_falg == False:  
                        self.name = name
                        Cat.__init_falg = True
cat1 = Cat("汤姆")
print(id(cat1),cat1.name)
cat2 = Cat("黑猫警长")
print(id(cat2),cat2.name)

4、__getattribute__
说明：__getattribute__方法中禁止使用self.属性/方法

class Cat(object):
    def __init__(self, name, color):  # 初始化对象
        self.name = name  # 属性
        self.color = color  # 属性
    def __getattribute__(self,obj): # 在访问属性变量、函数前，先调用该函数
        if obj == 'name':
            print("---name---")
        else:
            temp_obj = object.__getattribute__(self,obj)
            return temp_obj
    def getColor(self):  # 方法
        print(self.color)

cat = Cat("Tom","red")
cat.name
cat.getColor()

继承

1、继承的语法格式： class Son(Parent)

class Animal:
        def eat(self):
                print("...eat...")
class Dog(Animal): # 语法格式  class Son(Parent):
        pass

dog = Dog()
dog.eat()

2、构造函数有参数 + 继承

有两种方式
class Animal:
        def __init__(self,name):
                self.name = name
class Dog(Animal):
        def __init__(self,name,age):
                # Animal.__init__(self,name)  # 方式1：父类名.方法名(self,形参)
                super().__init__(name)        # 方式2：super().方法名(形参)
                self.age = age

dog = Dog("Tom",20)

3、调用被重写的父类的方法

1、子类重写了父类的函数bark
2、子类的bark函数中，想调用[被重写的父类的函数bark]，有两种方式
class Animal:
        def bark(self):
                print("----汪汪汪---")
class Dog(Animal):
        def bark(self):  # 重写
                print("狂叫不止")
                # Animal.bark(self)  # 方式1：父类名.方法名(self,形参)
                super().bark()       # 方式2：super().方法名(形参)

元类：type

type有两个作用
① 查看变量类型：type(100)、type(Cat)
② 创建类
     Cat = type( “Cat”, (Animal,) ,{“color”:“red”, “getColor”:getColor} )
     解释：创建一个名字是“Cat”的类，该类继承自Animal，有color = red属性，有getColor方法。

__metaclass__ 属性，决定了这个类是怎么创建的。