13、初识面向对象

一、面向对象简介

1.1 什么是面向对象？

首先，Python是一门面向对象的编程语音。
通过对象来进行操作，来达到一个想要的结果和目的。从根本上理解，假如内存中 a = 1,创建 a 这个对象，然后我们需要时候的时候，就可以对 a 进行操作。

1.2 面向过程

面向过程： 是将我们的程序分解为一个一个的步骤，通过对每个步骤再进行抽象来完成程序。
特性
- 面向过程，往往只是适用于一个功能，如果要实现别的功能，往往复用性较低。
- 编程方式符合人类的思维，比较容易，比如下面妈妈买菜的一个过程：

1. 妈妈穿衣服出门下楼
2. 妈妈骑上电瓶车出发
3. 妈妈到超时门口放好电瓶车
4. 妈妈买菜
5. 妈妈结账
6. 妈妈骑车回家
7. 妈妈到家开始做法

那么上面的过程，对每一个过程都要考虑到，是一个执行者，假如对于面向对象要怎么实现呢？

1.3 面向对象

面向对象： 关注的是对象本身，而不注重过程，对于面向对象一切皆对象。比如上面的例子中，面向对象只关注最终结果妈妈买菜做饭，过程怎么实现并不关系，只要定义妈妈这样一个类就好。

特性
- 将所有的功能统一保存到对应的对象中，要使用某个功能，直接找到对应的对象即可。
- 编码方式比较容易阅读，容易复用。

二、类 (class)

2.1 背景

目前，我们学习的都是 Python 中的内置对象，但是内置对象并不能满足我们的需求，所以我们在开发中经常需要自定义一些对象。

2.2 类的简介

简单理解，类就相当于一张图纸，在程序汇总时，我们需要根据它来创建对象。

那么，为啥我们不直接定义函数，而来定义类呢？

每个函数只能实现单一功能，每定义一个功能，我们就要去定义一个函数，随着项目的增大，函数也会越来越多，不好定义函数名，另一方面，出现bug，也不方便排除问题。

2.3 自定义类

a = 123
print(type(a))

### 等价于下面
a = int(123)
print(a)
print(type(a))

# 创建类
class MyClass():  # 定义类，给它取名为 MyClass。
      pass

mc = MyClass()  # 创建实例对象（类的实例化）实例对象，实现效果的功能

类对象：创建实例对象(类的实例化)，主要是用于存储功能，比如上面的 MyClass。
实例对象：实现效果的功能，比如上面例子中的 "mc"。

总结：

类可以创建多个实例，每个实例各不相同，这一些实例我们称呼为一类实例。

函数 isinstance()

作用：用来检测一个实例是否属于某个类创建出来的。
比如上面的例子：

print(isinstance(mc, MyClass))
True

2.4 类的调用

类的调用：实例.属性()

class Person():       # 类里面有的东西，实例里面也一定会有
    name = '高圆圆'    # 属性

p1 = Person()
p1.name = '张敏'
print(p1.name)        # 实例.属性 的格式就可以获取这个属性值。
p2 = Person()
p2.name = '林青霞'
print(p2.name)

2.5 方法的调用

方法：类中的函数叫做方法
方法调用：实例.方法

class Person():       # 类里面有的东西，实例里面也一定会有
    name = '高圆圆'    # 属性

    def speak(s):     # 方法： 类中的函数叫做方法，就不诚为函数了。
        print('你好')

p1 = Person()
p1.name = '张敏'
print(p1.name)      # 实例.属性 的格式就可以获取这个属性值。
p1.speak()          # 调用p1实例中的方法 
p2 = Person()
p2.name = '朱茵'
print(p2.name)
p2.speak()          # 调用p2实例中的方法

结论：

在类代码中，我们可以定义变量和函数
定义在类中的变量会成为该类实例的公共属性，所有的实例都可以通过 对象.属性名的形式来访问；
定义在类中的函数会成为该类实例的公共方法，所有的实例都可以通过 对象.方法名的形式来访问。

三、参数 self

class Person():  #
    #name = '刘亦菲'  # 属性

    def speak(s):    # 方法
        print('你好，我是%s' % p1.name)


p1 = Person()
p1.name = '张敏'
p2 = Person()
p2.name = '朱茵'
print(p1.name)
print(p2.name)
p1.speak()
print(p1)
p2.speak()
print(p2)
-------------------输出----------------------
张敏
朱茵
你好，我是张敏
<__main__.Person object at 0x0000027D3E9C74C0>
你好，我是张敏
<__main__.Person object at 0x0000027D3E9D5160>

从上面程序中我们可以看到，通过p1.speak() 与 p2.speak() 来调用方法，但是调用的都是同一个类 p1.name , 那么怎么实现调用不同的方法来调用不同的类呢？

只调用p1.speak() 方法：

class Person():  # 类
    name = '刘亦菲'

    def speak(s):  # 方法
        print('你好，我是%s' % p2.name)
        print(s)


p1 = Person()
p1.name = '张敏'
print(p1.name)
p2 = Person()
p2.name = '朱茵'
p1.speak()
print(p1)
-------------------输出----------------------
张敏
你好，我是张敏
<__main__.Person object at 0x0000024154BD71C0>
<__main__.Person object at 0x0000024154BD71C0>

只调用p2.speak() 方法：

class Person():  # 类
    name = '刘亦菲'

    def speak(s):  # 方法
        print('你好，我是%s' % p1.name)
        print(s)


p1 = Person()
p1.name = '张敏'
# print(p1.name)
p2 = Person()
p2.name = '朱茵'
print(p2.name)
# p1.speak()
# print(p1)
p2.speak()
print(p2)
-------------------输出----------------------
朱茵
你好，我是朱茵
<__main__.Person object at 0x0000012843797250>
<__main__.Person object at 0x0000012843797250>

上面2次调用中 p1 与 p2 在调用speak(s)方法时，都与 print(s) 结果一致。

class Person():  # 类
    name = '刘亦菲'

    def speak(s):  # 方法
        print('你好，我是%s' % s.name)
        #print(s)


p1 = Person()
p1.name = '张敏'
print(p1.name)
p2 = Person()
p2.name = '朱茵'
p1.speak()
print(p1)
-------------------输出----------------------
张敏
你好，我是张敏
<__main__.Person object at 0x00000190FC005160>

结论：哪个对象调用speak方法，那么s就是这个对象

从上面2次方法调用 p1.speak() 和 p2.speak 中可以看出，哪个对象调用speak(s)方法，那么s就是这个对象。

那么如果有更多的对象 p3, p4, p5……呢？我们是不是就可以通过一个参数来代替，那么就是self。

3.1 定义 Self 参数

class Person():

    # 哪个对象调用我们这个方法speak, 那么s就是这个对象
    def speak(s): # 方法
        print('你好，我是%s' % s.name)
        # print(s)

    def run(self): # self 就等于任何调用这个方法的对象本身。
        pass


p1 = Person()
p1.name = '张敏'
p2 = Person()
p2.name = '朱茵'
p1.speak()
p2.speak()

3.2 self 的特性：

self 在定义时需要定义，但是调用时会自动传入对象，不需要去调用类来传递。

class Person():
    def speak(s):
        print('你好，我是%s' % s.name)

    def run(self):
        self.name = p1

# p1 = Persion()
p1.name = '张敏'
p1.speak()    # 调用方法时，self.name 会自动接受传入的对象p1,因此我们不再需要通过实例对象p1=Person()来传入这个对象p1。
print(p1)

self 的名字并不是规定死的，但是最好还是按照约定用self。
self 总是值调用时的类的实例。
即 self = p1= Person()。

3.3 特殊方法

(1) 使用背景

案例分析

class Person():
    name = '刘亦菲'

    def speak(self):
        print('大家好，我是%s' % self.name)


p1 = Person()
p1.name = '张敏'
p1.speak()

p2 = Person()
p2.name = '朱茵'
p2.speak()

p3 = Person()
p3.name = '高圆圆'
p3.speak()
--------------输出--------------
大家好，我是张敏
大家好，我是朱茵
大家好，我是高圆圆

上面例子中，我们次调用一次方法，都得传递一次参数，这样就不是特别灵活，忘记传参就会报错，特别麻烦~
那么有什么好的解决方案呢？就是特殊方法。

(2) 特殊方法定义

特殊方法，也叫魔法方法。
定义格式： xxx()

定义特殊方法

class Person():
    print('hello')
    def __init__(self): # 定义魔法方法 实例创建的时候，init方法就会被调用
        print('hello')

    def speak(self):
        print('大家好，我是%s，芳龄%' % self.name)

p1 = Person()
#p1.__init__()
--------------输出--------------
hello

定义魔法方法实例创建的时候，init方法就会被调用。

可以通过特殊方法来达到效果：

class Person():
    # 初始化方法
    def __init__(self, name, age): # 实例创建的时候，init方式就会被调用
        self.name = name
        self.age = age

    def speak(self):
        print('大家好，我是%s' % self.name)


p1 = Person('刘亦菲', 18)
p1.speak()

p2 = Person('张敏', 18)
p2.speak()

p3 = Person('朱茵', 18)
p3.speak()
-------------输出-------------
大家好，我是刘亦菲
大家好，我是张敏
大家好，我是朱茵