Class类

创建 “类”

 class 类名称(object): 类名称通常大写字母开头

创建实例(self)和属性

  def __init__(self,属性1,属性2):

     将各种属性绑定到实例本身上

self.属性1 = 属性1
self.属性2 = 属性2

      自定义函数，访问实例(self)的各种属性

def 函数名_1(self):
    <statement_1>
    <statement_2>

      自定义函数，访问实例(self)的各种属性，同时也可以添加新的参数进去

def 函数名_2(self,参数2,参数3):
    <statement_1>
    <statemen_2>

 实例化 “类”

   被赋值名称 = 类名称(实例化的属性1, 实例化的属性2)

访问实例化的 “类”

　　被赋值名称.函数名_1()
　　被赋值名称.函数名_2(参数2,参数3))

class Student(object):
    def __init__(self, name, gender, age, high, weight='50t'):
        self.name = name
        self.gender = gender
        self.age = age
        self.high = high
        self.weight = weight

    def print_age_high_weight(self):
        print('%s, %s, %s' % (self.age, self.high, self.weight))


if __name__ == '__main__':
    bart = Student('Jack', 'Man', '18', '175', '108kg')
    bart.print_age_high_weight()

‘类 (class)’ 的继承和多态：

如果一个类没有任何类属性和类方法，那么可以直接用 pass 关键字作为类体即可

class Animal(object):
    def run(self):
        print("Animal is running...")


class Dog(Animal):
    # Dog()子类借用Animal()父类的方法(run())，没有自己的方法。
    pass


class Cat(Animal):
    def run(self):
        print('Cat is running...')

    def eat(self):
        print('Cat is eating...')


if __name__ == '__main__':
    dog = Dog()
    cat = Cat()
    dog.run()
    cat.run()
    cat.eat()
    a = list()
    b = Animal()
    c = Dog()
    print(isinstance(a, list))  # a是一个list()类型
    print(isinstance(b, Animal))  # b是一个Animal()类型
    print(isinstance(c, Animal))  # c是一个Dog()类型，同时由于它从父类(Animal())中继承而来，所以也是一种Aminal()类型

---------------------结果------------------------
Animal is running...
Cat is running...
Cat is eating...
True
True
True

类变量

      类体中、所有函数之外：此范围定义的变量，称为类属性或类变量，类方法的调用方式有 2 种，既可以使用类名直接调用，也可以使用类的实例化对象调用。

      通过类名不仅可以调用类变量，也可以修改它的值

class Student(object):
    name = "jack"
    gender = "men"

    def __init__(self, age, high, weight='50t'):
        self.age = age
        self.high = high
        self.weight = weight

    def print_age_high_weight(self):
        print('%s, %s, %s' % (self.age, self.high, self.weight))


if __name__ == '__main__':
    print('%s , %s' % (Student.name, Student.gender))
    Student.name = "jim"
    Student.gender = "women"
    print('%s , %s' % (Student.name, Student.gender))
    stu = Student(18, 175, "70kg")
    print('%s , %s' % (stu.name, stu.gender))

-------------------------结果--------------------------
jack , men
jim , women
jim , women

　　类体中，所有函数内部：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；实例变量只能通过对象名访问，无法通过类名访问。

　　通过类对象可以访问类变量，但无法修改类变量的值。这是因为，通过类对象修改类变量的值，不是在给“类变量赋值”，而是定义新的实例变量

class Student(object):
    name = "jack"
    gender = "men"

    def __init__(self, age, high, weight='50t'):
        self.age = age
        self.high = high
        self.weight = weight

    def print_age_high_weight(self):
        print('%s, %s, %s' % (self.age, self.high, self.weight))


if __name__ == '__main__':
    stu = Student(18, 175, "70kg")
    print('%s , %s' % (stu.name, stu.gender))
    stu.name = "xiaomi"
    stu.gender = "girl"
    print('%s , %s' % (stu.name, stu.gender))
    print('%s , %s' % (Student.name, Student.gender))

------------------------结果--------------------------
jack , men
xiaomi , girl
jack , men

　　类体中，所有函数内部：以“变量名=变量值”的方式定义的变量，称为局部变量

方法

   　实例方法最大的特点就是，最少也要包含一个 self 参数，用于绑定调用此方法的实例对象（Python 会自动完成绑定）

      @classmethod 修饰的方法为类方法，类方法中通常将其命名为 cls，Python 会自动将类本身绑定给 cls 参数；

      采用 @staticmethod 修饰的方法为静态方法；静态方法的调用，既可以使用类名，也可以使用类对象

class Student(object):

    @classmethod
    def info(cls):
        print("类方法信息:%s " % cls)

    @staticmethod
    def home(address):
        print("家庭住址:%s" % address)


if __name__ == '__main__':
    Student.info()
    Student.home("安道尔")
-------------------结果---------------------
类方法信息:<class '__main__.Student'> 
家庭住址:安道尔

 析构函数

　　当一个类销毁的时候，就会调用析构函数

def __del__(self,[...):