面向对象

面向对象：
1、类的定义使用的关键字是class
2、类的首字母必须是大写
3、目前学习的类都是新式类,python2经典类
4、所有类的基类(祖先)都是object，因此都是需要来继承的
5、面向对象的三大特性：
   封装   让我们调用的属性隐藏内部实现的数据
   继承
   多态
6、在OOP的编程中，如果要调用类里面的方法，首先要对类进行实例化，
实例化后的对象可以调用类中的方法
数据属性可以理解为类里面的全局变量它是属于类
实例属性可以理解为类里面的局部变量，它是属于对象
7、类的数据属性是针对所有对象共享的，也就是说针对一个类进行实例化后的对象，调用数据属性，它的内存地址都
是一样的
8、当一个方法我们只想获取它的值并且这个方法里面不需要形式参数的时候，那么这个方法我们可以定义成特性方法

class Person(object):    object新式类，可写可不写单一般标明
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def show(self):
        print('my name is {0},my age is {1},my sex is {2}'.format(
            self.name,self.age,self.sex))
obj=Person(name='chenli',age=23,sex='boy')     对类进行实例化obj是它的对象
obj.show()    调用类的方法

 调用name

class Person(object):
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def getName(self):
        return self.name


    def show(self):
        print('my name is {0},my age is {1},my sex is {2}'.format(
            self.name,self.age,self.sex))
obj=Person(name='chenli',age=23,sex='boy')
print(obj.getName())
obj.show()

得到结果：

chenli
my name is chenli,my age is 23,my sex is boy

更改name=xiaoqi

class Person(object):
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def getName(self):
        return self.name

    def setName(self,name):
        self.name=name

    def show(self):
        print('my name is {0},my age is {1},my sex is {2}'.format(
            self.name,self.age,self.sex))
obj=Person(name='chenli',age=23,sex='boy')
obj.setName(name='xiaoqi')
print(obj.getName())
obj.show()

得到结果为：

xiaoqi
my name is xiaoqi,my age is 23,my sex is boy

特殊方法

class Person(object):
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def getName(self):
        return self.name

    def setName(self,name):
        self.name=name
#特殊方法
    @property
    def getNameAge(self):
        return 'my name is {0},my age is {1}'.format(self.name, self.age)

obj=Person(name='chenli',age=23,sex='boy')
print(obj.getNameAge)

class Person(object):
    country='china'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def getName(self):
        return self.name

    def setName(self,name):
        self.name=name

# 普通方法
    def show(self):
        print('my name is {0},my age is {1},my sex is {2}'.format(
            self.name,self.age,self.sex))


#特殊方法
    @property
    def getNameAge(self):
        return 'my name is {0},my age is {1}'.format(self.name, self.age)

obj1=Person(name='chenli',age=23,sex='boy')
obj2=Person(name='xiaoqi',age=1,sex='boy')
print(id(obj1.country))
print(id(obj2.country))

可以得到obj1和obj2中country属性的内存地址是一致的

 

继承

java和Python的继承有什么区别
Java是单继承的，Python是多继承的(可以继承多个类）
所有类的基类都是object
基类（父类）被继承的类
派生类（子类）继承其他的类
super().__init__(xingge)
father(xingge).__init__(self)
方法重写：当子类的方法与父类的方法名一致的时候，就说子类重写了父类的方法
目的：父类的方法无法满足子类的诉求

class father(object):

    country='chinese'

    def __init__(self,xingge):
        self.xingge=xingge

    def show(self):
        print('性格是温和的')

class son(father):
    def __init__(self,xingge,hobby):
        self.hobby=hobby
        super().__init__(xingge)     son类继承了father类的方法，

    def show(self):
        print('我的性格是:{0}，我的爱好是：{1}'.format(self.xingge,self.hobby))

obj=son(xingge='温和',hobby='read')
obj.show()
print(obj.country)

得到结果：

我的性格是:温和，我的爱好是：read
chinese

继承的原则：

继承第一原则：
约束条件：从上到下原则的前提是类没有重写父类的方法
继承第二原则：
约束条件：从下到上原则的前提是类重写父类的方法
从左至右

class father(object):

    country='chinese'
    def __init__(self,xingge):
        self.xingge=xingge

    def show(self):
        print('性格是温和的')

class mother(object):
    def __init__(self,xueli):
        self.xueli=xueli

    def show(self):
        print('学历是博士')

class son(father,mother):
    def __init__(self,xingge,xueli,hobby):
        self.hobby=hobby
        # super().__init__(xingge)
        # super().__init__(xueli)
        father.__init__(self,xingge)
        mother.__init__(self,xueli)

    def show(self):
        print('我的性格是:{0}，我的学历是：{1}，我的爱好是：{2}'.format(self.xingge,self.xueli,self.hobby))


obj=son(xingge='温和',xueli='博士',hobby='read')
obj.show()

 

所以在Python中，基于MRO的解析顺序规则，就会从左到右开始查找基类，如果找到第一个匹配的属性类，就会 停止查找，如果没有，那就继续查找，直到查找到符合要求的为止。
MRO其实就是通过一个C3线性化算法来实现 的，它的核心思想为:
子类会优先于父类检查
多个父类会根据它们在列表中的顺序被依次检查
如果对下一个类存在两个合法的选择，只能选择第一个
继承原理：
1、当实例化子类的对象后，那么子类调用某一个方法，优先考虑子类是否这个方法，如果存在，优先调用子类的方法
2、如果调用的方法子类不存在，那么就按照线性查找的方式来进行寻找，直到找到符合要求的方法为止
'''

'''python3的继承顺序:D--->B--->C--->A
python2的继承顺序:D--->B--->A'''

class A:
  def show(self):
    print('A')

class B(A):
  pass

class C(A):
  def show(self):
    print('C')

class D(B,C):
  pass

if __name__ == '__main__':
  obj=D()
  obj.show()