1、类的属性和方法的重写、调用、私有、修改
1.1、重写：子类重写父类同名属性和方法
如果两个子类和父类的方法名和属性相同，默认使用子类的，子类虽然方法名和属性与父类相同，但是进行了修改，使用子类的方法和属性做子类独有的事情，这就叫做子类重写父类同名属性和方法
# 定义三个类，一个子类继承两个父类
class R(object):
# 类的属性
def __init__(self):
self.name = '父类R'
# 类的方法
def Xinxi(self):
print('学生的基本资料：名字:%s' % self.name)
class X(object):
def __init__(self):
self.name = '父类X'
def Xinxi(self):
print('学生的基本资料：名字:%s' % self.name)
class G(R,X):
def __init__(self):
self.name = '子类独有'
def Xinxi(self):
print('只需要名字：%s' % self.name)
xiaoming = G() # 子类和父类有同名的属性
xiaoming.Xinxi()# 子类和父类有同名的方法，但子类做自己独有的事情1.2、子类调用父类同名的属性和方法
在子类中新建一个子类的方法，方法内容调用父类的方法，然后子类调用对应的方法，如此间接达到子类调用父类方法的目的
# 定义三个类，一个子类继承两个父类
class R(object):
# 类的方法
def Xinxi(self):
print('学生的基本资料：名字:R')
class X(object):
def Xinxi(self):
print('学生的基本资料：名字:X')
class G(R,X):
def Xinxi(self):
print('只需要名字：G')
def Xxinxi(self):
X.Xinxi(self)
def Rxinxi(self):
R.Xinxi(self)
# 实例化对象，自动执行子类的__init__方法
xiaoming = G()
# 调用本类的实例方法： 子类和父类同名的方法，但子类做自己独有的事情
xiaoming.Xinxi()
# 进入实例方法去调用父类X、R的方法
xiaoming.Xxinxi()
xiaoming.Rxinxi()当然，不同名的父类方法，子类继承后可以直接调用
1.3、通过super()来调用父类方法
super()通过子类调用当前父类的方法，super默认会调用第一个父类的方法(适用于单继承的多层继承 或者只想使用第一个父类的方法)
class R(object):
# 类的方法
def Xinxi(self):
print('学生的基本资料：名字:R')
class X(object):
def Xinxi(self):
print('学生的基本资料：名字:X')
class G(X,R):
def Xinxi(self):
# 调用父类的方法
print('只需要名字：G')
R.Xinxi(self)
X.Xinxi(self)
def all_Xinxi(self):
super().Xinxi()
wan = G()
# 调用父类方法
wan.all_Xinxi()1.4、私有属性和私有方法
Python是以属性命名方式来区分，如果在属性和方法名前面加了2个下划线'__'，则表明该属性和方法是私有权限，否则为公有权限
类的私有属性和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问
私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。
私有属性和方法示例：
class Master(object):
# 构造方法
def __init__(self):
self.kongfu = '古法配方'
# 添加一个属性
# 如果一个属性的名字开头是两个下划线，代表此属性是私有的
self.__money = 1000
# 制作煎饼果
def make_cake(self):
print('古法煎饼果')
print(self.__money)#私有属性只能在类的里面使用
self.__print()#私有方法可以在类的内部使用
# 定义一个私有方法
def __print(self):
print('这是私有方法')
lishifu = Master()
print(lishifu.kongfu)
# 若一个属性私有后，就不能使用对象调用此属性（私有属性不能在类的外面使用）
# print(lishifu.__money)
lishifu.make_cake()
# lishifu.__print()#这是私有方法，不能调用
class Prentice(Master):
pass
damao = Prentice()
print(damao.kongfu)
damao.make_cake()
# 结论：子类继承父类，若父类属性或方法私有后，将不会被继承，只能在父类里使用1.5、修改私有属性的值
修改私有属性的值一般有两种方法：
直接修改：对象名 . 属性名 = 新数据
通过两个方法间接修改：对象名 . 方法名(新数据)
如下代码，属于间接修改属性的值
# 自定义一个人类
class person(object):
def __init__(self):
self.name = '小明'
self.__age = 20#私有属性
# 定义一个方法（获取属性的值，一般方法中使用get）
def get_age(self):#用于返回一个私有属性的值
return self.__age
# 定义一个方法，对属性赋值的时候一般方法中使用set
def set_age(self,new_age):
self.__age = new_age
xiao = person()
print(xiao.get_age())#使用对象调用私有属性完成打印age的值
xiao.set_age(33)#使用对象设置属性的值
print(xiao.get_age())2、类属性和实例属性
顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，对于公有的类属性，在类外可以通过类对象和实例对象访问
2.1、类属性
类属性的好处：每定义个对象实例属性会占用一份内存，而类属性只占用一份内存，使用类属性可以节约空间提高性能，为后期业务需求更改，方便开发
访问：不能在类外通过实例对象访问私有类属性，可以访问共有的类属性
class People(object):
name = 'Tom' # 公有的类属性
__age = 12 # 私有的类属性
p = People()
print(p.name) # 正确
print(People.name) # 正确
print(p.__age) # 错误，不能在类外通过实例对象访问私有的类属性
print(People.__age) # 错误，不能在类外通过类对象访问私有的类属性2.2、实例属性
class People(object):
address = '山东' # 类属性
def __init__(self):
self.name = 'xiaowang' # 实例属性
self.age = 20 # 实例属性
p = People()
p.age = 12 # 实例属性
print(p.address) # 正确
print(p.name) # 正确
print(p.age) # 正确
print(People.address) # 正确
print(People.name) # 错误
print(People.age) # 错误2.3、通过实例去修改类属性
class People(object):
country = 'china' #类属性
print(People.country)
p = People()
print(p.country)
p.country = 'japan'
print(p.country) # 实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country # 删除实例属性
print(p.country)运行结果：
china
china
japan
china
china
如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性
2.4、实例属性和方法的开辟空间规则
创建对象占用内存地址，对象的属性也另外占用内存地址，对象占用的地址与对象属性占用的地址不一样（同一个类创建的对象，其属性的占用地址不一样）
不同的对象，但是调用的对象、方法的id相同（地址相同），因为调用的是同一个方法
创建不同对象表达的是不同的人，其属性特征是不同的，但方法相同，因为方法中有个形参self可以区分是哪个对象调用的
class Person(object):
def __init__(self,name):
self.name = name
def eat(self):
print('人会吃饭')
# 使用一个类创建一个对象后，就会占用内存地址（空间）
# 用id查看空间地址，如print(id(xiaoming))
# 对象的内存地址不同，代表各占一个空间
xiaoming = Person('小明')
print(id(xiaoming))
print(id(xiaoming.name))
print(id(xiaoming.eat()))
xiaohong = Person('小红')
xiaohong.eat()
print(id(xiaohong.name))
print(id(xiaohong))#创建两个对象后需要分别开辟空间，占用内存较多
print(id(xiaohong.eat()))2.5、类方法和静态方法
2.5.1、类方法
类方法是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法
对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。
实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。
静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类实例对象来引用
class People(object):
country = 'china'
#类方法，用classmethod来进行修饰
@classmethod
def get_country(cls):
return cls.country
p = People()
print(p.get_country()) #可以用过实例对象引用
print(People.get_country()) #可以通过类对象引用2.5.2、类方法对类属性进行修改
class People(object):
country = 'china'
#类方法，用classmethod来进行修饰
@classmethod
def get_country(cls):
return cls.country
@classmethod
def set_country(cls,country):
cls.country = country
p = People()
print(p.get_country()) #可以用过实例对象访问
print(People.get_country()) #可以通过类访问
p.set_country('japan')
print(p.get_country())
print(People.get_country())结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变
2.5.3、静态方法（了解）
需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数，可以通过对象和类来访问。
class People(object):
country = 'china'
@staticmethod
#静态方法
def get_country():
return People.country
p = People()
# 通过对象访问静态方法
p.get_contry()
# 通过类访问静态方法
print(People.get_country())
