python入门高阶--面向对象

python面向对象
Python 是一种面向对象的编程语言。
Python 中的几乎所有东西都是对象，拥有属性和方法。
类（Class）类似对象构造函数，或者是用于创建对象的“蓝图”

面向对象技术简介
类(Class):
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：
类中定义的函数。
类变量：
类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
方法重写：
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：
定义在方法中的变量，只作用于当前实例的类。
实例变量：
在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：
即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：
创建一个类的实例，类的具体对象。
对象：
通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

创建类和对象

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

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

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

class是关键字，表示类
创建对象，类名称后加括号即可

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

创建类
class className:
#类中包含属性和方法
#类中要用来生成对象，首先支持对象的调用
#初始化，有个特别要求，init
#self 在对象内部起作用，代表着自己
def init(self): #self 代表对象
print ‘Bar’

#如何实例化一个对象：调用
#调用不调用的区别是：加不加（）

class_run = className() #加括号调用类，让实例化一个对象

面向对象的特性是指：封装，继承，多态。

一、封装–可以使类具有独立性和隔离性，从而保证了类的高内聚，只需要给类外部或子类必须的数据和操作

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容，便于后面的使用

所以，在使用面向对象的封装特性时，需要：

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

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

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

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

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

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

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

通过对象直接调用
通过self间接调用

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

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

• View Code

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

执行类中的方法时，需要通过self间接调用被封装的内容

• View Code

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

函数式编程
面向对象

上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了...  ；而对于面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。

二、继承

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

class Animal:  #父类
    def eat(self):
        print('chifanle')
    def drink(self):
        print('heshuile')

class Dog(Animal):  #子类
    def wangwangjiao(self):
        print('小狗汪汪叫')

class Cat(Animal):  #子类
    def miaomiaojiao(self):
        print('小猫喵喵叫')

aa = Dog()
BB = Cat()
aa.eat()  #子类调用父类方法
BB.drink()  #子类调用父类方法

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法，这样可以极大的提高效率，减少代码的重复，精简代码的层级结构

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

多继承：

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

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

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

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

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

经典类多继承
新式类多继承

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

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

注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

class shenxian:  #父类
    def fly(self):
        print('shenxiandouhuifei')

class monkey:   #父类
    def chitao(self):
        print('houzichitao')

class sunwuk(shenxian,monkey):  #多继承,通过多个类名申明
    pass

dd = sunwuk()
dd.fly()
dd.chitao()

继承的传递性：类的传递过程中，我们把父类又称之为基类，子类又称为派生类，父类的属性和方法可以一级一级的传递到子类

class grandfather:
    def eat(self):
        print('haochide henduo')
class father(grandfather):
    pass
class son(father):
    pass

so = son()
so.eat()

方法重写（覆盖）以调用父类方法传递参数
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中相同的方法，用在继承中
作用：当父类的方法不再满足需求时，就可以重写，一旦子类有了和父类一样的方法的时候，会覆盖掉父类方法，执行子类方法，不再执行父类方法

class dog:
    def wangwangjiao(self):
        print('wangwangjiao')

class keji(dog):
    def wangwangjiao(self):  #重写父类的方法，和父类方法名一样
        print('miaomiaojiao')

kj = keji()
kj.wangwangjiao()

class Animal:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print(id(self))
    def chi(self):
        print(f'{self.name}喜欢吃{self.age}')

class Cat(Animal):
    def __init__(self,name,age,color):
        self.color = color
        super().__init__(name,age)

        pass
    def jiao(self):
        print(f'{self.name}的颜色时{self.color}的')

aa = Cat('laohu','cao','hongse')
aa.chi()
aa.jiao()

三、多态
顾名思义就是多种状态，多种形态，就是同一种行为对于不同的子类【对象】有不同的行为表现
要想实现多态，必须的有两个前提需要遵守：
继承：多态必须发生在父类和子类之间
重写：子类重写父类的方法

Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。
Python伪代码实现Java或C#的多态
Python “鸭子类型”
总结

以上就是本节对于面向对象初级知识的介绍，总结如下：

面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
类 是一个模板，模板中包装了多个“函数”供使用
对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
面向对象三大特性：封装、继承和多态

问答专区

问题一：什么样的代码才是面向对象？

答：从简单来说，如果程序中的所有功能都是用 类 和 对象 来实现，那么就是面向对象编程了。

问题二：函数式编程 和 面向对象 如何选择？分别在什么情况下使用？

答：须知：对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。

所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用

面向对象的应用场景:

多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码
Demo
需要创建多个事物，每个事物属性个数相同，但是值的需求
如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同
Demo

问题三：类和对象在内存中是如何保存？

答：类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份，大致如下图：

如上图所示，根据类创建对象时，对象中除了封装 name 和 age 的值之外，还会保存一个类对象指针，该值指向当前对象的类。

当通过 obj1 执行 【方法一】 时，过程如下：

根据当前对象中的 类对象指针 找到类中的方法
将对象 obj1 当作参数传给 方法的第一个参数 self 

析构方法
属性方法私有化