Python是一门解释型的、面向对象的、带有动态语义的高级程序语言。面向对象程序设计（Object Oriented Programming，OOP），这种编程方式需要使用“类”和“对象”来实现，所以面向对象编程就是对“类”和“对象”的使用。

简述

面向过程：

根据程序逻辑自顶而下的写代码。

函数式：

将某功能代码封装到函数中，日后便无需重复书写，调用函数即可，一般适用于各个函数之间是独立无共享数据的场景。

面向对象：

对函数进行分类和封装。

关于类与对象

  • 类就是一个模板，在模板里包含有许多函数，每个函数实现一些功能
  • 对象是根据模板创建的实例，通过对象可以执行模板中的函数
#创建类
class A:

    def Func(self):
        print("Afun")

    def Hello(self,name):
        print("Hello,%s"%name)

#根据类A创建对象obj
obj=A()
obj.Func  #调用Func方法
obj.Hello('Alex')  #调用Hello方法

类中的函数第一个参数必须是self（它是对于对象自身的引用）；

类中定义的函数称为“方法”。

面向对象三大特性

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

封装（Encapsulation）

封装即对外部世界隐藏对象的工作细节。在使用面向对象的封装特性时，需要：

  • 将内容封装到某处
  • 从某处调用被封装的内容
class Foo:
    #__init__称为构造方法，创建类的实例时会自动执行
    def __init__(self,name,age):
        self.name=name
        self.age=age

obj=Foo('Alex',20)  #将Alex和20封装在obj/self的name和age属性中

调用被封装的内容时有两种方法：

  1. 通过对象直接调用
  2. 通过self间接调用
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def Detail(self):
        print(self.name)
        print(self.age)

obj=Foo('Alex',20)
print(obj.name)  #直接调用obj对象的name属性
obj.Detail()  #间接调用obj对象属性

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

继承（Inheritance）

以通用的类为基础建立专门的类对象

class Animal():
    def eat(self):
        pass

    def drink(self):
        pass

    def shit(self):
        pass

    def pee(self):
        pass

class Cat(Animal):
    def sound(self):
        print("喵")

class Dog(Animal):
    def sound(self):
        print("汪")

从上面的代码上可以看出，Cat与Dog类都以Animal为基类，所以Cat和Dog都有Animal类的方法，这就是继承。

多继承

  1. Python的类可以继承多个类
  2. Python的类如果继承了多个类，有两种寻找方法：深度优先，广度优先
    • 当类是经典类时，多继承情况下，会按照深度优先方式查找
    • 当类是新式类时，多继承情况下，会按照广度优先方式查找 （当类或者父类继承object类，那么该类便是新式类，否则便是经典类）
class A():
    def foo(self):
        print('A.foo')

class B(A):
    def foo(self):
        print('B.foo')

class C(A):
    def foo(self):
        print('C.foo')

class D(B,C):
    def foo(self):
        print('D.foo')

k=D()

经典类：首先去D类中查找，如果D类中没有，则继续去B类中找，如果B类中没有，则继续去A类中查找，如果A类中没有，则继续去C类中找，如果还是找不到，则报错。

新式类：首先去D类中查找，如果D类中没有，则继续去B类中找，如果B类中没有，则继续去C类中查找，如果C类中没有，则继续去A类中找，如果还是找不到，则报错。

上述过程中，一旦找到，则寻找过程立即中断，不会在继续查找了。

多态（Polymorphism)

多态意味着可以对不同类的对象使用同样的操作。

class Foo:
    pass

class S1(Foo):
    def show(self):
        print('S1.show')

class S2(Foo):
    def show(self):
        print('S2.show')

def Func(obj):
    print(obj.show)

s1_obj=S1()
Func(s1_obj)  #在Func()中传入S1类的对象，执行S1类的show方法

s2_obj=S2()
Func(s2_obj)  #在Func()中传入S2类的对象，执行S2类的show方法

总结

  • 以上即为面向对象的编程方式介绍，这种方式的实现是基于对类和对象的使用
  • 类是一个模板，模板中包装了多个函数供使用
  • 对象，根据模板创建的实例，实例用于调用被包装在类中的函数
  • 面向对象有三各个特性：封装、继承、多态

外话

类和对象在内存中的保存

类以及类中的方法在内存中只有一份，而有类创建出的对象都在内存中需要存一份，以为对象与对象、对象与基类之间的方法或变量的值可能是不一样的。根据类创建对象时，对象中处理封装各自变量的值之外，还会保存一个类对象指针，该指针指向当前对象的类。