python中的类

'''
面向过程：
    以结果为目的
面向对象：
    以设计的角度去考虑问题-----注重程序的扩展性、维护性
    扩展性：继承、多态，功能扩展
    维护性：分模块开发（分类）
类：
    不是一个具体的实物，比较抽象，只是一个设计的模型
对象：
    由类这个模型产生出的具体对象（多个），但是对象之间并没有什么关系(体现出程序的扩展性),每个对象都有自己的内存地址
    对象都是要加载到内存的，其实类也是能够加载到内存中的（反射）

面向对象的思想：
    封装

    继承

    多态

销毁时间：
    在程序执行完毕自动销毁
    也可以手动销毁del,一旦销毁不可在使用

1、对象中的函数:只要是类中的函数都要带self
    1.构造函数__init__(self,可以有参数),可对变量赋值
        定义类变量：
            self.变量名=value （普通变量）
            self.__变量名=value（具有访问权限的变量）
        继承中的构造函数：
            单继承：
                super(子类名, self).__init__():
                        python2中常用，父类的构造函数如果有参数必须要先调用父类的构造函数并赋值,没有参数最好也调用
                super().__init__():
                        python3中常用
                父类名.__init__():
                        也可以实现父类方法的调用
            多继承：
                父类名.__init__(self)，由于不确定是那个父类所以用父类名调用
                注意：父类名是传递过来的(继承的格式)
        有参：
            要重写父类的__init__()并传递参数
        无参：
            可以不写，也可以写出来，对象在创建时其实就是调用的构造函数
    2.析构函数__del__(self)
        在对象销毁（不再占用内存）或者程序结束时会自动执行，程序结束是指整个运行的程序结束时，也就是整个程序代码执行完毕时
        1.del手动销毁对象
        2.整个程序执行完毕（全局变量）
        3.覆盖（应该是该对象不再使用，垃圾回收机制销毁了该对象）
        4.当对象是局部变量时，比如函数中的对象，在函数执行结束而被销毁
        总之对象不再占用内存（销毁）时，就会执行析构函数
    3.__str__(self)：只能return str
        在打印对象时会自动调用该函数显示该对象的信息，当然也可以覆盖用来打印类中变量的信息来使用
    4.__repr__(self)
        同__str__(self)一样,只有在str不存在时才会调用repr,两者都存在只执行str
2、变量
    python可以动态创建变量，即可以在类外创建变量（一般不用）
    1.对象中的变量
        随对象的创建而创建，随对象的销毁而销毁
    2.函数中的变量
        随函数的销毁而销毁（函数执行完）
    3.实例变量：
        对象名调用，对象可以访问类变量，但是不能修改类变量（会创建一个新的实例变量，坑）
        实例调用和类同名的变量，优先调用实例变量
    4.类变量
        类名调用，类不可访问实例变量
    5.生命周期：
        实例变量：
            对象销毁变量就销毁
        类变量：
            随类创建而创建随类销毁而销毁
    6.类的生命周期：
        程序结束
    注意：python可以动态添加实例变量
3、类中的权限
    目的：
        设置访问权限，防止数据被别人修改，限制别人调用一些属性或者函数
    用法：
        类中的变量名或者方法名前面加上两个下划线
4、类的属性
    get(self): 也可以用@property注解，使调用时用实例.方法名或者属性名即可，不用在最后带上函数的小括号（没啥用）
        获取类的不可直接访问属性
    set(self,参数): 也可以用@方法名.setter注解 ，实例.方法名或者属性名=值
        设置类的不可直接访问属性,可以设置一些逻辑过滤代码
    属性的声明限制: __slots__ = (变量)
        __slots__ = ("a","version"),网上说更快的属性访问速度
        不加声明限制(默认)每个实例都会创建一个字典来存储属性(键值对)，加了__slots__=()不会再创建字典来存储实例的属性（自己定义的属性，非python标准库的），在使用该属性时会报错no attribute
    注意：子类添加__slots__要考虑父类（父类如果不加__slots__=(),子类就不受该限制,正常创建字典正常存储实例属性）
5、格式
    class 类名:
        pass

6、继承(可多继承)
    当多个类都有大量相同的代码的时候使用继承
    1.含义：
        子类继承父类，子类拥有了父类的所有属性和方法(非私有的)
    2.作用：
        减少代码量：
            父类已有的直接调用即可不需要再写逻辑代码
        扩展功能：
            在父类的基础上添加父类所没有的功能，扩大子类的功能(子承父业，青出于蓝而胜于蓝)
    3.格式：可以多继承，用逗号隔开
        class 子类类名(父类名1,父类名2)：
            pass
        注意：当父类中有相同的方法或者属性，优先级：从左到右
    4.缺点：
        程序要求高内聚低耦合，同一个类中的关系要紧密，不同类之间要尽量减少联系，否则牵一发而动全身

7.多态：多种形态
    对象在不同时刻体现的不同形态就是多态（多种身份）
    前提：
        继承（无继承不多态）
8、@property：
        在方法上添加，节省一个括号
    函数名.setter:
        在方法上添加
    注意：要先写取值，即：先写@property再写,函数名.setter
    知道就行，不用
'''

'''
一部手机：类
    属性：
        颜色、内存、型号、价钱-----变量
    行为：
        打电话、玩游戏-----函数
'''
# class phone:
#     color=None#类变量
#     def __init__(self):
#         pass
#     def a(self):
#         print(self)
#         phone.color="红色"
#         print(phone.color)

# class phone:
#     #定义有参构造函数
#     def __init__(self,version,color,price,RAM):
#         #定义类变量，两个下划线表示只能本类中能够访问
#         self.__version=version
#         self.__color=color
#         self.__price=price
#         self.__RAM=RAM
#     # 重写__str__(self)方法,打印对象的时候自动调用
#     def __str__(self):
#         return  self.__version+"手机"
#     #重写__del__(self)方法，在对象销毁时执行
#     def __del__(self):
#         print("关机。。。。。")
#     #设置类属性，并对外提供
#     def setVersion(self,version):
#         self.__version=version
#     #对外提供可访问的方法
#     def getVersion(self):
#         return self.__version
#     @property#取值,get
#     def color(self):
#         return self.__color
#     @color.setter#赋值，set
#     def color(self,color):
#         self.__color=color
#     def getPrice(self):
#         return self.__price
#     def getRAM(self):
#         return self.__RAM
#     def call(self,person):
#         print("用%s、售价为%d的%s手机给%s打电话。。" %(self.__color,self.__price,self.__version,person))
#     def playGame(self,game):
#         print("用%s、售价为%d的%s手机玩%s游戏。。。" %(self.__color,self.__price,self.__version,game))
#     def watchVideo(self,video):
#         print("用%s、售价为%d的%s手机看%s视频。。。" %(self.__color,self.__price,self.__version,video))

# class erji(phone):#耳机
#     __slots__ = ("a")
#     #父类构造函数的重写
#     def __init__(self,version,a,b):
#         # super(erji, self).__init__("华为","红色",1999,"4G")#单继承
#         #调用父类的构造函数，给父类的有参构造函数赋值
#         phone.__init__(self,"华为","红色",1999,"4G")#单继承或者多继承
#         #无访问权限的类变量
#         self.version=version
#         self.a=a
#         self.b=b
#
#     def erjiCall(self,person):
#         print("用%s、售价为%d的%s手机的%s耳机给%s打电话。。。" %(self.getColor(),self.getPrice(),self.getVersion(),self.version,person))
#     #父类普通函数的重写
#     def call(self,person):
#         print("复写父类的方法。。。")
#
# p=phone("华为","红色",1999,"4G")
# # # p.call("张三")
# # e=erji("小米","a","b")
# # # e.erjiCall("李四")
# # print(e.version,e.b)
# #get和set注解的测试
# # p.color="黑色"
# # print(p.color)

# class a:
#     # __slots__ = ("b")#父类会影响子类
#     def __init__(self,a):
#         self.a=a
#     #重写加法运算，self加法前的对象，other加法后的对象
#     def __add__(self, other):
#         return self.a+other.a
#
#     # __dict__ = {"f":"小红"}
#
# # print(a("b","c").c)
# class d:
#     # __slots__ = ("f")
#     def __init__(self,d):
#         self.d=d
# a1=a(1)
# a2=a(2)
# print(a1+a2)