python对象的三个属性查询和判断方法 python对象的三个特性

大家好，今天跟大家介绍面向对象的三大特性：封装，继承和多态。

一、封装

  顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要：

  1）将内容封装到某处

  2）从某处调用被封装的内容

第一步，将内容封装到某处

  self 是一个形式参数，当执行 passat = Car(‘passat’, 250000 ) 时，self 等于passat;当执行 ford = Car(‘ford’, 250000 ) 时，self 等于 ford.所以，内容其实被封装到了对象passat 和 ford中，每个对象中都有 type和 price属性。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

  1)通过对象直接调用

  2)通过self间接调用

通过对象直接调用被封装的内容

class Foo:
     def __init__(self, name, age):
        self.name = name
        self.age = age
 obj1 = Foo('wupeiqi', 18)
print ('obj1.name')    # 直接调用obj1对象的name属性
print ('obj1.age')     # 直接调用obj1对象的age属性
 obj2 = Foo('alex', 73)
print ('obj2.name')    # 直接调用obj2对象的name属性
print ('obj2.age')     # 直接调用obj2对象的age属性

通过self间接调用被封装的内容

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def detail(self):
        print (self.name)
        print (self.age)  
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

  综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
二、继承
  编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类 的特殊版本，可使用继承 。一个类继承 另一个类时，它将自动获得另 一个类的所有属性和方法；原有的类称为父类 ，而新类称为子类 。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
比如说，大学同学聚餐，大家的职业各不相同，（假设有程序员和老师两种）但是大家在餐桌上的行为都是吃喝，倘若要描述这些人员的餐桌行为，那么可以写下如下代码：

class Teacher:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('%s is eating,'%self.name)
    def drink(self):
        print('%s is drinking'%self.name)
    def occupation(self):
        print('%s is a teacher,'%self.name)
class Pythoner:
    def __init__(self,name):
        self.name = name
    def eat(self):
        print('%s is eating,' % self.name)
    def drink(self):
        print('%s is drinking' % self.name)
    def occupation(self):
        print('%s is a pythoner,' % self.name)
lisa = Teacher('lisa')
tom = Pythoner('Tom')
lisa.occupation()
lisa.eat()
lisa.drink()
tom.occupation()
tom.eat()
tom.drink()

  但是实际情况中大家的职业各不相同，难道要对每个职业都写个类吗？如果按照这样去描述餐桌行为，代码特别累赘。因此，使用一种代码较少的方法——继承。代码如下：

class Classmate:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('%s is eating,' % self.name)
    def drink(self):
        print('%s is drinking' % self.name)
class Pythoner(Classmate):
    def occuption(self):
        print('%s is drinking' % self.name)
class Teacher(Classmate):
    def occuption(self):
        print('%s is drinking' % self.name)
lisa = Teacher('lisa')
lisa.drink()
lisa.eat()
tom = Pythoner('Tom')
lisa.drink()
lisa.eat()

  首先我们定义了一个类叫做Classmate，称之为父类，这个里面放了吃、喝两个方法，下面我们又定义了两个类，pythoner和Teacher类，里面各写了一个occupation方法，打印出了人物的职业。我们看到，classmate类和我们之前见到的类并没什么不同，可是pythoner和Teacher类定义的时候，写了classmate类的类名，但是我们最终在调用的时候，pythoner和Teacher类集成了classmate的所有属性和方法。这样就实现了继承。

重写父类的方法

  对于父类中的有些方法倘若不符合子类的要求，那么可以把子类的方法重写，基于上述例子，我们将父类的方法drink，在子类Teacher中做一点更改，如下：

多继承

  是否可以继承多个类？如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

  1、Python的类可以继承多个类，Java和C#中则只能继承一个类

  2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

  1）当类是经典类时，多继承情况下，会按照深度优先方式查找

  2）当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类多继承：

class D:
    def bar(self):
        print (D.bar)
class C(D):
    def bar(self):
        print (C.bar)
class B(D):
    def bar(self):
        print (B.bar)
class A(B, C):
    def bar(self):
        print (A.bar)
a = A()
a.bar()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

新式类多继承

class D(object):
    def bar(self):
        print (D.bar)
class C(D):
    def bar(self):
        print (C.bar)
class B(D):
    def bar(self):
        print (B.bar)
class A(B, C):
    def bar(self):
        print (A.bar)
a = A()
a.bar()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

  现在让我们回到之前的那个例子，又有一个新的需求，就是把这一桌的男生和女生分开，此时应该怎么怎么做呢？

class Classmate:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('%s is eating,' % self.name)
    def drink(self):
        print('%s is drinking' % self.name)
class Pythoner(Classmate):
    def occuption(self):
        print('%s is drinking' % self.name)
    def sleep(self):
        print('%s do not need!'%self.name)
class Teacher(Classmate):
    def occuption(self):
        print('%s is drinking' % self.name)
class female(Classmate):
    def drink(self):
        print('%s drink juice'%self.name)
class male(Classmate):
    def drink(self):
        print('%s drink alcohol'%self.name)
class fepythoner(Pythoner,female):
    pass
class mapython(Pythoner,male):
    pass
lisa = fepythoner('lisa')
lisa.drink()
tom = mapython('Tom')
tom.drink()

  上述使用经典类来写的，也可以用新式类来写，两者只是查找方式的区别。
三、多态
  Python中多态不常用，就不赘述了。

今天就到此结束，祝大家生活愉快！

参考博客：