类：包括 方法（函数）和 属性（相当于参数）
属性：类属性，实例属性
class Name(object):
eye = 3 #类属性，静态属性
leg = []
def __init__(self,name,age): #构造方法 类在实例化时调用self相当于指向实例化对象
self.name=name #实例属性
self.age=age
pass
def fun(self): #self是必备参数
pass
duixiang=Name() #实例化对象duixiang
'''
属性eye是不可变的数字 int:
duixiang.eye # 3
Name.eye=4 #改值
duixiang.eye # 4 类属性改变，实例化对象属性改变 @该属性是不可变的 int
duixiang.eye=5 #改值
Name.eye # 4 实例化对象属性改变，类属性不改变 @该属性是不可变的 int
属性leg是可变的列表 [] :
duixiang.leg # []
Name.leg # []
duixiang.leg.append(1) #添加 [1]
Name.leg # [1] 实例化对象属性改变，类属性改变 @该属性是可变的 []
'''
类的私有变量：
_a 单下划线 __b 双下划线 # 这2种下划线开头命名的只是一种约定，私有
print(_a) print(duixiang.__类名__b) #如果要访问，通过类调用他的 __b
类的特殊方法：
#xxx.__dict__ # 打印实例属性 ,返回字典 {}，不包类属性。
class A:
''' 简介....... '''
a=1
def __init__(self,length,width):
self.length = length
self.width = width
def play(self):
return self.length+self.width
def __str__(self):
return '提示1'
def __repr__(self):
return '提示2'
def __call__(self):
return '类不能直接调用，类是调用类的方法'
def __add__(self,other):
return self.play()+other.play()
def __sub__(self,other):
return self.play()-other.play()
ces = A(10,5)
ces1=A(10,1)
print(ces.__dict__) #返回{'length': 10, 'width': 5} 不包括类属性a=1
ces.a=10 #实例化后，将类属性修改，变为自己的实例属性
print(ces.__dict__) #返回{'length': 10, 'width': 5,'a':10}
#ces.__doc__ # 导入简介
#__str__ # print(ces) -给人看的，字符不会显示引号 没有__str__返回ces的类型及地址，有就默认调用__str__的值 '提示1'
#__repr__ # ces -给机器看的,显示所有，字符会显示引号 没有__repr__返回ces的类型及地址 ,有就默认调用__repr__的值 '提示2' 。如果没有__str__方法 ，
print(ces) 也调用__repr__的值 '提示2'。
#__call__ #ces() 没有__call__，ces()不能直接调用，类是调用类的方法ces.play()，有就调__call__的值
#__add__ #ces+ces1 没有__add__，ces和ces1不能直接相加，有就调用 __add__能得到 值 26（15+11）
#__sub__ #ces-ces1 没有__sub__, ces和ces1不能直接相减，有就调用 __sub__能得到 值 4（15-11)
面向对象三大特征：
1.封装：
'''
def add(name,age):
pass
def delate(name,age):
pass
#这儿调用函数需要每次传入参数
'''
class Test:
def __init__(self,name,age):
self.name=name
self.age=age
def add(self):
pass
def delate(self):
pass
#而类只需要在实例化对象是传入参数，在调用类的方法 将同类的的属性（参数？）封装为一个类，提高可读性
2.继承：
单继承
子类（派生类）继承 父类（基类）。
子类可重写父类方法
class Animal:
def __init__(self,name,age):
self.name=name #实例属性
self.age = age
def eat(self):
return '吃饭'
class Dog(Animal): # 单继承 子类（派生类）继承 父类（基类）。
def eat(self): # 子类可重写父类方法
print(super().eat()) # super 调用父类 Animal
#print(super(Animal,self).eat()) # super 调用父类Animal的父类（没写Animal的父类）
return '吃啥呢'
多继承:
super :用法 调用 该类(可以指定) 的父类方法
#继承排序:
xxx().__class__.mro() #可查看继承顺序
A,B(A在前调用A类): C-> A-> B-> Base-> object
B,A(B在前调用B类): C-> B-> A-> Base-> object
class Base: #这儿没写构造方法，默认继承基类object的构造方法
def play(self):
print('this is Base')
class A:
def play(Base): #继承 Base 类
print('this is A')
class B:
def play(Base): #继承 Base 类
print('this is B')
class C:
def play(B,A): #继承 A和B 类
#A.play(self) #在C 里调用 A的play方法 | B.play(self)
#super().play() #super调用C类的父类的方法 A,B(A在前调用A 类) | B,A（调用B）
#super(C,self).play() #等同上面
#super(A,self).play() #调用 Base 类
#super(B,self).play() #调用 A 类
print('this is C')
3.多态
#多态, (子类重写父类方法) ,继承。 （同一个方法，有不同表形式）
class A:
def play(self):
return 1
class B(A):
def play(self): #子类重写父类play方法
return 2
