Python类——面向对象

1、有关面向对象的一些知识

面向过程：根据业务逻辑从上到下写垒代码

函数式：将某功能代码封装到函数中，往后便无需重复编写，仅调用函数便可

面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向过程编程最易被初学者接受，其每每用一长段代码来实现指定功能，开发过程当中最多见的操做就是粘贴复制，即：将以前实现的代码块复制到现需功能处。

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

　　类就是一个模板，模板里能够包含多个函数，函数里实现一些功能

　　对象则是根据模板建立的实例，经过实例对象能够执行类中的函数

class是关键字，表示类

建立对象，类名称后加括号便可

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

1 2 3 4 5 6 7 8 9 10 11 12 13

# 建立类 class Foo:            def Bar( self ):          print 'Bar'        def Hello( self , name):          print 'i am %s' % name   # 根据类Foo建立对象obj obj = Foo() obj.Bar()            #执行Bar方法 obj.Hello( 'wupeiqi' ) #执行Hello方法

 

面向对象：【建立对象】【经过对象执行方法】、

函数编程：【执行函数】

观察上述对比答案则是确定的，而后并不是绝对，场景的不一样适合其的编程方式也不一样。

总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象三大特性

面向对象的三大特性是指：封装、继承和多态。

（一）封装

封装，顾名思义就是将内容封装到某个地方，之后再去调用被封装在某处的内容。

因此，在使用面向对象的封装特性时，须要：

• 将内容封装到某处
• 从某处调用被封装的内容

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

 self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

因此，内容其实被封装到了对象 obj1 和 obj2 中，每一个对象中都有 name 和 age 属性，在内存里相似于下图来保存。

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

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

• 经过对象直接调用
• 经过self间接调用

一、经过对象直接调用被封装的内容

（二）继承

继承，面向对象中的继承和现实生活中的继承相同，即：子能够继承父的内容。

若是咱们要分别为猫和狗建立一个类，那么就须要为 猫 和 狗 实现他们全部的功能，以下所示

 

上述代码不难看出，吃、喝、拉、撒是猫和狗都具备的功能，而咱们却分别的猫和狗的类中编写了两次。若是使用 继承 的思想，以下实现：

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

 

 

因此，对于面向对象的继承来讲，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而没必要一一实现每一个方法。

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不一样而已。

（三）多态 

 Pyhon不支持Java和C#这一类强类型语言中多态的写法，可是原生多态，其Python崇尚“鸭子类型”（其实我也不太清楚什么是鸭子类型，去百度百度吧）。

上图展现了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式能够如此调用被封装的内容：对象.属性名

（四）对象与类之间的关系

       类： 现实生活中对事物的描述。

　　 对象： 这一类事物的实实在在的个体。

　　　　生活中有有一类个体：他们都会拿枪、射击、穿迷彩服、越野、杀敌等功能。------这就是一个军人的类。 类有属性（成员变量）和方法（动态属性）。
　　　　而具体到个体： 士兵1号、士兵2号、士兵3号等 就是这个类中的具体实体-----这就是一些士兵的对象。

　　而映射到java中 ，这些描述就是class定义的一个类
　　具体的对象， 就是new关键字在堆（heap）中建立的实体。

（五）成员变量 与 局部变量
　　做用范围： 成员变量 做用于整个类的内部
　　　　　　　局部变量 做用于方法或者语句块之中

　　内存中的位置 ：   成员变量 存在于堆内存中，由于对象的存在而存在。 会先有系统的默认初始化（0 null）， 以后才是咱们定义个显示初始化。
　　　　　　　　　　在没有引用指向其对象的时候（及变成垃圾对象），被垃圾回收机回收后消失。
　　　　　　　　　　局部变量 存在于栈内存中，由于语句的执行而存在。 必须人工给予初始化，不然次变量不能使用。相关语句执行完毕后自动消失。

 

（六）匿名对象

　　如： new Car（）; new Car().color = "blue"; new Car().runCar();

　　　　特色：只能使用一次， 使用以后便会变成垃圾， 等垃圾回收机回收清空内存。
　　　　　　　匿名对象调用其属性没有意义， 调用其方法具备必定的意义。

　　　　使用状况：1）、只对对象的 方法 进行 一次调用 的时候。 这样写比较简便。 若是要对对象的多个成员进行调用，就必须给对象命名。
　　　　　　　　   2）、能够将匿名对象当成参数紧传递。

 

2、面向对象相关应用

下面展现一下有关三维向量计算的程序

import math

class Vectors:

    def __init__(self):         #计算向量坐标，根据所给点坐标

        self.x1=0

        self.x2=0

        self.y1=0

        self.y2=0

        self.z1=0

        self.z2=0

        self.x=self.x2-self.x1

        self.y=self.y2-self.y1
        
        self.z=self.z2-self.z1
 
    def add(self):              #输入三维点坐标，并计算向量坐标，根据所输入的点坐标

        self.x1=int(input("input x1 :"))

        self.y1=int(input("input y1 :"))

        self.z1=int(input("input z1 :"))

        self.x2=int(input("input x2 :"))

        self.y2=int(input("input y2 :"))

        self.z2=int(input("input z2 :"))

        self.x=self.x2-self.x1

        self.y=self.y2-self.y1

        self.z=self.z2-self.z1

    def out(self):              #输出向量坐标

        print(self.x,self.y,self.z)

    def plus(self,a,b):         #向量相加

        self.x=a.x+b.x

        self.y=a.y+b.y

        self.z=a.z+b.z

    def sub(self,a,b):          #向量相减

        self.x=a.x-b.x

        self.y=a.y-b.y

        self.z=a.z-b.z

    def pointmuti(self,a,b):    #向量的数量积

        return (a.x*b.x+a.y*b.y+a.z*b.z )

    def angle(self,a,b):        #向量的余弦值

        a1=(a.x*a.x+a.y*a.y+a.z*a.z)**0.5   #向量a的模长

        b1=(b.x*b.x+b.y*b.y+b.z*b.z)**0.5   #向量b的模长

        ab=a.x*b.x+a.y*b.y+a.z*b.z  

        return ab/(a1*b1)

 

v=Vectors()

a=Vectors()

b=Vectors()

a.add()

b.add()

print("向量a坐标为：" ,end='')

a.out()

print("向量b坐标为：",end='')

b.out()

print("向量a、向量b相加得：",end='')

v.plus(a,b)

v.out()

print("向量a、向量b相减得：",end='')

v.sub(a,b)

v.out()

print("向量a、向量b的向量积为：",end='')

print(v.pointmuti(a,b))

print("向量a、向量b的夹角余弦值为：",end='')

print(math.acos(v.angle(a,b)))

这些就是个人关于面向对象的一些总结了。