Learning-Python【22】：面向对象初识

一、面向过程：是一种编程思想，核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么，基于该编程思想写程序就好比在设计一条流水线，是一种机械式的思维方式

优点：把复杂问题流程化，进而简单化，降低开发难度

缺点：扩展性差

二、面向对象：也是一种编程思想，核心对象二字，对象就是特征与功能的结合体。基于该思想编写程序就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式

优点：可扩展性强，对于程序员来说，不用再关心具体的步骤

缺点：编程复杂度高，得需要设计这些对象，要避免过度设计得问题，程序的可控性也很低，无法与流水线式的思想一样可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互去解决问题，即便是上帝也无法预测最终结果

三、类与对象

类：具有相同特征和行为的一类事物（人、狗、猫等），是一个抽象的概念，不实际存在。类的作用是用于描述该类的对象具备什么样的特征和行为

其中表明事物特征的叫做属性（变量），表明事物的行为或功能的叫做方法（函数），属性和方法又叫做成员

对象：具体的某一事物，单个个体

类到对象的过程，叫做实例化，因而对象又可以称之为实例

四、初始化类和对象

在现实世界中，先有一个个具体存在的对象，然后随着人类文明的发展才出现了分类的概念，而在程序中，必须先定义类，然后通过类实例化产生对象

类的命名遵循变量的命名规范，一般使用驼峰命名法（由一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连）

类的定义

class 类名():
    类体

类体代码会在类定义阶段就立刻执行，会产生一个类的名称空间，对象的本质也是一个名称空间，对象名称空间是用来存放对象自己独有的属性，而类的名称空间中存放的是所有对象共有的属性，两个名称空间是独立存在的

类的两种作用：属性引用和实例化

属性引用：类本质就是一个名称空间，可以对该名称空间进行增删改查

实例化：调用类来产生对象（会做两件事）

　　1、产生一个空对象

　　2、触发类中 __init__方法

class Person():
    country = 'China'   # 类属性 —— 静态属性

    # 这里的函数叫做方法 —— 动态属性
    def language(self): # 注意: self必须写
        print('someone say Chinese')

print(Person.country)   # 查看类属性
print(Person.language)  # 查看类方法, 用类名去调用方法名, 打印出来的是内存地址

属性引用

class Person():
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def language(self):
        print('someone say Chinese')

# 实例化: 类名(参数1, 参数2)  类名加括号就等于在执行Person.__init__()
qx = Person('qiuxi', 22)
print(qx.name)  # 对象名.属性名, 直接查看属性
print(qx)   # 返回的是一个对象
qx.language()   # 对象名.方法名(), 用来调用方法

实例化

对象的属性查找顺序：对象自己的名称空间 ---> 类的名称空间

五、关于 self

self 在对象的方法中表示当前对象本身，__init__ 称之为初始化函数，在创建对象时自动将对象本身传给 __init__ 的第一个参数

注意：

　　def  __init__(self):   这句话可以写也可以不写，但只要有参数传进来的时候就必须得写

　　def  方法名（self）：这里的 self 必须得写

六、绑定方法

对象的绑定方法

首先我们明确一个知识点，凡是类中的方法或函数，默认情况下都是绑定给对象使用的。

class People():

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        pass

p = People('qiu', 22)
print(p.talk)

# 运行结果
<bound method People.talk of <__main__.People object at 0x00000202267A8278>>

从上面的输出结果来看，talk() 这个类中的方法，是绑定给对象使用的，下面再看另一种情况

class People():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk():
        pass

p = People('qiu', 22)
print(p.talk)

# 输出结果
<bound method People.talk of <__main__.People object at 0x000002214E0C8278>>

现在，将 talk() 函数的参数去掉，结果显示与上面是一样。这说明，不管是类中的方法，还是类中函数，默认情况下都是绑定给对象使用的。绑定给对象使用有一种好处，那就是不用手动将对象传入，对象是自动传到类中。

class People():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk():
        pass

p = People('qiu', 22)
print(People.talk)　　# 类来调用类中的方法
print(p.talk)

# 运行结果
<function People.talk at 0x0000022BF5B19B70>
<bound method People.talk of <__main__.People object at 0x0000022BF5B18278>>

上面的例子很好说明了，如果用类来调用类中的方法，那么这个方法仅仅只是一个函数，那么既然是函数，就不会有自动传值这一功能

class People():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        pass

p = People('qiu', 22)
People.talk()   # 报错
print(p.talk)   # 正常

# 报错处
TypeError: talk() missing 1 required positional argument: 'self'

从上面输出结果来看，当类调用类中的方法时候，是不会进行自动传值的，也就是说，函数有几个参数，我们就得传递进去几个参数。如果想结果正常运行，那么在类名调用 talk() 的时候，将参数一一都传递进去。即：

People.talk(312312)

这个参数可以是任意的，但是，必须传递进去。而，当对象调用类中方法时候，则不用传递，如上面报错的下一行正常执行。既然知道了区别，那么，我们来看看下面代码：

class People():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk():
        pass

p = People('qiu', 22)
People.talk()   # 正常
p.talk()        # 报错

# 报错处
TypeError: talk() takes 0 positional arguments but 1 was given

从输出结果来看，People 来调用 talk() 方法时候，并不需要传递参数；而当对象来调用 talk() 的时候，由于对象调用自己的绑定方法，会自动将对象当作第一个参数传递进去，所以，当类中 talk() 方法没有带参数时，而我又给它传递了一个，显然是会报错的。

综上所述：

　　1、凡是类中的方法和函数，都是绑定给对象使用的

　　2、绑定方法都有自动传值的功能，传递进去的值，就是对象本身

　　3、如果类想调用绑定方法，就必须遵循函数的参数规则，有几个参数，就必须传递几个参数

既然类中的方法都是绑定给对象使用的，那么有没有方法是绑定给类使用的呢？答案是，当然有！但是现在不告诉你