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__# 实例对应的类(仅新式类中)