python基础-day19

day18回顾:

面向对象
    对象 object(实例　instance)
        面向对象
    类 class
        类的定义的语句 class 语句
        class 类名(继承列表):
            #实例方法
            def 实例方法名(self,方法的形参)
            ...
        def __init__(self,形参列表)
        def__del__(self):   析构方法
        ...

构造函数:
    类名(调用传参)

对象的特征:
    行为(实例方法)
        吃，睡...
    属性(实例变量)
        姓名,年龄

del 语句
    删除对象的属性

预置属性:
    __dict__属性
        绑定存储此对象属性的字典
    __class__属性
        绑定创建此对象的类
函数:
    isinstance(对象,类或元组)　　判断对象是否属于某个类或某些类的一个类的实例
    type(对象)  #返回一个对象的类

----------------------------------------------------------------------
day19笔记:
    类变量
    类方法
    静态方法
    单继承
    封装
    多态

类变量
    类变量是类的属性，此属性属于类，不属于类的实例
    作用:
        通常用来存储该类创建的对象的共有属性
    说明:
        类变量可以通过该类直接访问
        类变量可以通过类的实例直接访问(取值)
        类变量可以通过此类的对象的__class__属性间接访问
    示例见:
        class_variable.py
            #此示例示意类变量的定义方法和用法
            class car:
                total_count=0  #创建类变量
            print(car.total_count)
            car.total_count+=100
            print(car.total_count) #修改类变量

            c1=car()
            print(c1.total_count) #借助对象访问类变量

            c1.total_count=999 #创建实例变量
            print(c1.total_count)  #999
            print(car.total_count)  #100

            c1.__class__.total_count=888
            print(c1.total_count)  #999
            print(car.total_count)  #888
        -----------------------------------------
            #此示例示意类变量的定义方法和用法
            class car:
                total_count=0  #创建类变量
                def __init__(self,info):
                    self.info=info
                    print('汽车',info,'被创建')
                    self.__class__.total_count+=1
                def __del__(self):
                    print('汽车',self.info,'被销毁')
                    #self.__class__.total_count+=-1
                    car.total_count+=-1
            c1=car('BYD E6')
            c2=car('吉利　E7')
            print('当前有%d个汽车对象'%car.total_count)
            del c2
            print('当前有%d个汽车对象'%car.total_count)

类的文档字符串
    类的第一个没有赋值给变量的字符串为文档字符串
    类的文档字符串可以用类的__doc__属性访问

类的__slots__列表
    作用:
        1.限定一个类创建的实例只能有固定的实例变量(实例属性)
        2.不允许对象添加列表以外的实例属性
        3.防止用户因错写属性名称而发生错误
    说明:
        1.__slots__属性是一个列表,列表的值是字符串
        2.含有__slots__属性的类所创建的对象没有__dict__属性，即此实例不用字典来存储实例属性
    示例见:
        slots.py
    此示例示意类内的__slots__列表的用法
        class human:
            #限制human类的对象只能有'name'和'age'属性，不能有其他属性
            __slots__=['name','age']
            def __init__(self,n,a):
                self.name,self.age=n,a
            def show_info(self):
                print(self.name,self.age)
        s1=human('tarena',15)
        s1.show_info()
        s1.age=16
        s1.show_info()

类方法 @classmethod
    类方法是用于描述类的行为的方法，类方法属于类，不属于该类创建的实例对象
    说明:
        1类方法需要使用@classmethod装饰器定义
        2类方法至少有一个形参，第一个形参用于绑定类，约定为'cls'
        3类和该类的实例都可以调用类方法
        4类方法不能访问此类创建的对象的实例属性
    实例见:
        class_method
            #此示例示意类方法的定义及调用
            class A:
                v=0
                @classmethod
                def get_v(cls):
                    return cls.v
                @classmethod
                def set_v(cls,value):
                    cls.v=value   #设置类变量v=value
            print(A.v) # 0直接访问类变量
            value=A.get_v() 
            print('value=',value) #0

            A.set_v(999)
            print(A.get_v())
            a=A() #创建实例对象
            print(a.get_v())
            a.set_v(100)
            print(a.get_v()) #100
            print(A.v)  #100

静态方法＠staticmethod
    静态方法是定义在类的内部的函数，此函数的作用域是类的内部

    说明:
        1.静态方法需要使用@staticmethod装饰器定义
        2.静态方法与普通函数定义相同，不需要传入'self'和'cls' 参数
        3.静态方法只能凭借该类或类的实例调用
        4.静态方法不能访问类变量和实例变量
    示例见:
        static_method.py
            class A:
                @staticmethod
                def myadd(a,b):
                    '''这是静态方法'''
                    return a+b
            #用类来调用静态方法
            print(A.myadd(100,200)) #300
            #用实例来调用静态方法
            a=A()
            print(a.myadd(300,400)) #700        

练习:
    1.用类来描述一个学生的信息(可以修改之前写的sutednt类)
        class student:
            ...
        学生信息有:
            姓名，年龄，成绩
        将这些学生对象存于列表中，可以任意添加和修改学生信息
            (1)打印出学生的个数
            (2)打印出所有学生的成绩
            (3)打印出所有学生的平均年龄
        见:student1.py
----------------------------------------------------
继承(inhertance)和派生(derived)

    继承是从已有的类中派生出新的类，新类具有原类的属性和行为，并能扩展新的能力
    派生类就是从一个已有类中衍生出新类，在新的类上可以添加新的属性和行为

    作用:
    1.用继承派生机制,可以将一些共有功能加在基类中，实现代码的共享
    2.在不改变基代码的基础上改变原有类的功能

    名词:
        基类(base class),超类(super class),父类(father class)
        派生类(derived class),子类(child class))

    单继承
        语法:
            class 类名(基类名):
                语句块
        说明:
            单继承是指派生类由一个基类衍生出来
        示例见:
            inherit.py
    继承说明:
        python3任何类都直接或间接的继承自object类
        object类是一切类的超类
类的__base__属性 
    作用:
        用来绑定此类的基类

>>>help(__builtins__)

覆盖 override
    什么是覆盖:
        覆盖是指在有继承关系的类中，子类中实现了与基类同名的方法，在子类的实例调用
        该方法时，实际调用的是子类中覆盖版本，这种现象叫覆盖
    示例见:
        override.py
子类对象显示调用基类方法的方式:
    基类名.方法名(实例,实际调用传参...)

super函数
    super(cls,obj) 返回绑定超类的实例(要求obj必须是cls类型的实例)
    super() 返回绑定超类的实例，等同于super(__class__,实例方法的第一个参数)，必须在方法内调用

    作用:
        借助super()返回实例间接调用父类的覆盖方法
    示例见:
        super.py

显示调用基类的初始化方法:
    当子类中实现了__init__方法,基类的初始化方法并不会被调用



练习:
    1修改原来的学生信息管理程序，将原来用字典存储学生信息改变用学生student类型的对象来存储信息
        要求:1 类student存于文件   student.py中
            2.尽量少在类的外部使用实例变量(建议增加实方法来获取实例变量)