16_python_面向对象

一、面向对象和面向过程的区别

    

    1、面向对象：一切以对象为中心。有相同属性和动作的结合体叫做对

 

        优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护

        缺点：性能比面向过程低

 

    2、面向过程：一切以实物的流程为中心

 

         优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

         缺点：没有面向对象易维护、易复用、易扩展

 

二、面向对象的编写

class Car:     #  class是关键字，表示类
    def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建 的是谁, 谁来访问的这个方法.那这个self就是谁.
            self.color = color
            self.pai = pai        
            self.pailiang = pailiang
    def run(self, speed):
            print("车可以跑%s迈" % speed)
c = Car("red", "京A66666", "2.0T")   # 创建对象，类名称后加括号即可，即为实例化
c.run(100) # 这时. python会自动把对象c传递给run方法的第一个参数位置.

　　1、面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

   　　  类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

 

　　2、类中的函数第一个参数必须是self（详细见：类的三大特性之封装）；类中定义的函数叫做 “方法”

  　　   实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

三、面向对象的三大特征 -- 封装、继承和多态

 

    1、封装

 

    封装:  把很多数据封装到一个对象中.  把固定功能的代码封装到一个代码块, 函数, 对象,  打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了一个很牛B 的函数. 那这个也可以被称为封装.  在面向对象思        想中. 是把一些看似无关紧要的内容组合到一起统一进行行存储和使用. 这就是封装.

  2、继承

 

    (1) 单继承

    

    子类可以自动拥有父类中除了私有属性外的其他所有内容

class DerivedClassName(BaseClassName1):
    <statement-1>
    . . .
    <statement-N>

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()
结果：
ken 说: 我 10 岁了，我在读 3 年级

(2) 多继承

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
     . . .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。(MRO算法)

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法
结果：
我叫 Tim，我是一个演说家，我演讲的主题是 Python

    (3) 方法重写

 

    如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

3、多态

 

多态: 同一个对象, 多种形态. 这个在python中其实是很不容易说明白的. 因为我们一 直在用. 只是没有具体的说.  比如. 我们创建一个变量a = 10 , 我们知道此时a是整数类型. 但是我们可以通过程序让a = "alex", 这时, a又变成了字符串类型.  这是我们都知道的. 但是, 我要告诉你的是. 这个就是多态性. 同一个变量a可以是多种形态.

class Animal:    
    def chi(self):
        print("动物就知道吃")
class Pig(Animal):
    def chi(self):
            print("猪在吃")
class Haski(Animal):
    def chi(self):
            print("哈?士奇在吃")
class Alasika(Animal):
    def chi(self):       
        print("阿拉斯加在吃")
class SiYangYuan:
    def yanng_animal(self, ani):  
        ani.chi()
        
zhu = Pig()
erha = Haski()
ala = Alasika()
alex = SiYangYuan()
alex.yanng_animal(zhu)
alex.yanng_animal(erha)
alex.yanng_animal(ala)

程序具有超高的可扩展性.  面向对象思想的核心与灵魂. python自带多态

 

四、类对象补充

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)