初始化函数
    class ClassA(object):
    def init(self):
    print(‘实例化成功’)
    # 实例化
    a = ClassA()
    其中definit(self):就是初始化函数也叫构造函数
    初始化函数的写法是固定的格式：中间是 init，意思是初始化，然后前后都要有【两个下划线】，然后 init() 的括号中，第一个参数一定要写上 self，不然会报错.

    构造函数（初始化函数）格式如下：
    def init(self,[ 其 他 元 素 ]):
    初始化函数也可以传递参数,例如↓
    class ClassA(object):
    def init(self,str):
    print(‘实例化成功’)
    print(str)
    # 实例化
    a = ClassA(‘hello python’)

    析构函数
    类在创建的时候，会调用构造函数，那么理所当然，当这个类销毁的时候，就会调用析构函数。
    析构函数语法如下：
    del del(self,[ 其 他 元 素 ]):
    例子↓
    class ClassA(object):
    def init(self):
    print(‘实例化成功’)
    def del(self):
    print(‘实例化销毁’)
    a = ClassA()
    del a

    类的继承
    单继承
    class ClassName(BaseClassName):
    多继承
    class ClassName(Base1,Base2,Base3…):
    继承的子类的好处：

    • 会继承父类的属性和方法
    • 可以自己定义，覆盖父类的属性和方法

    调用父类的方法
    一个类继承了父类后，可以直接调用父类的方法的，比如下面的例子，UserInfo2继承自父类UserInfo ，可以直接调用父类的 get_account 方法
    class UserInfo(object):
    lv = 5
    def init(self, name, age, account):
    self.name = name
    self._age = age
    self.__account = account
    def get_account(self):
    return self.__account
    class UserInfo2(UserInfo):
    pass
    if name == ‘main‘:
    userInfo2 = UserInfo2(‘两点水’, 23, 347073565);
    print(userInfo2.get_account())
    当需要调用相对的数值时，则根据你的方法改成相应的元素。当然也可以重写父类的方法
    @classmethod
    def get_name(cls):
    return cls.lv
    @property
    def get_age(self):
    return self._age
    class UserInfo2(UserInfo):
    def init(self, name, age, account, sex):
    super(UserInfo2, self).init(name, age, account)
    self.sex = sex;
    if name == ‘main‘:
    userInfo2 = UserInfo2(‘两点水’, 23, 347073565, ‘男’);
    # 打印所有属性
    print(dir(userInfo2))
    # 打印构造函数中的属性
    print(userInfo2.dict)
    print(UserInfo2.get_name())
    这一段就重写父类的构造函数↑
    子类的类型判断
    当我们需要判断class的类型时，可以使用isinstance函数来辨别其类型，例子↓

    1. class User1(object):
    2.     pass
    3. class User2(User1):
    4.     pass
    5. class User3(User2):
    6.     pass
    7. if __name__ == '__main__':
    8.     user1 = User1()
    9.     user2 = User2()
    10.     user3 = User3()
    11.     # isinstance()就可以告诉我们，一个对象是否是某种类型
    12.     print(isinstance(user3, User2))
    13.     print(isinstance(user3, User1))
    14.     print(isinstance(user3, User3))
    15.     # 基本类型也可以用isinstance()判断
    16.     print(isinstance('两点水', str))
    17.     print(isinstance(347073565, int))
    18.     print(isinstance(347073565, str))

    最后测试的输出结果为true，true，true，true，true，false，由此我们可知最后一个的两个类型不相同，是错误的.可以看到 isinstance() 不仅可以告诉我们，一个对象是否是某种类型，也可以用于基本类型的判断。

    类的多态
    什么是多态，看下面例子就理解了
    >>> 1 + 3
    4
    >>> ‘a’ + ‘b’
    ‘ab’
    多态即为两个数（字符串）相加（连），形成一个数（一句话）；也就是说不同的类型会做出不一样的反应。

    1. class User(object):
    2.     def __init__(self, name):
    3.         self.name = name
    4.     def printUser(self):
    5.         print('Hello !' + self.name)
    6. class UserVip(User):
    7.     def printUser(self):
    8.         print('Hello ! 尊敬的Vip用户：' + self.name)
    9. class UserGeneral(User):
    10.     def printUser(self):
    11.         print('Hello ! 尊敬的用户：' + self.name)
    12. def printUserInfo(user):
    13.     user.printUser()
    14. if __name__ == '__main__':
    15.     userVip = UserVip('两点水')
    16.     printUserInfo(userVip)
    17.     userGeneral = UserGeneral('水水水')
    18.     printUserInfo(userGeneral)

    上面的范例中可以清晰的看到userVip(userGeneral)和UserVip(UserGeneral)是两个不同的对象，对他们调用printUserInfo方法时，他们会自行调用相应的printUser方法，作出不同的相应，这就是多态带来的实际用处.

    类专有的方法
    image.png