[TOC]

面向对象基础

1.0 什么是面向对象

1.1 面向过程编程

核心就是“过程”，过程指的是做事情的步骤，即先做什么，再做什么。基于该编程思想编写程序，就好比一条工程流水线，一种机械式的思维方式。

优点：逻辑清晰，复杂问题流程化，，进而简单化。

缺点：可扩展性差。

1.2 面向对象编程

核心就是“对象”，对象指的是特征与技能的结合体。基于改编成思想编写程序，就好比在创造世界，一种上帝式的思维方式。

优点：可扩展性高。

缺点：编写程序的复杂程度要远高于面向过程编程

2.0 在编程的时候优先使用面向过程变成还是使用面向对象编程？

面向过程结合面向对象一起使用。

类和对象

1.0 什么是对象，什么是类？

对象：特征与技能的结合体

类：一系列对象相似的特征与技能的结合体

在现实世界中:现有一个个具体存在的对象，人后将这些类似的对象结合在一起，就形成了类。

在python程序中：必须先定义类，然后调用类来产生对象

2.0 程序中定义类

定义函数的时候，只检测语法，不执行代码。

定义类的时候，类体代码会在类定义阶段就立刻执行。

2.1 定义类

如何定义类：先定义类，后调用类创造对象

定义类的语法：

def 函数名():
    pass

class 类名:
    对象相同的特征
    对象相同的技能
  
class：用来定义类的，class后跟的是类名。
类名：类的名字，用来调用创造对象的。

注意：类名不许遵循驼峰命名法，python在定义变量与函数的时候不推荐使用驼峰命名法，但在定义类使推荐使用。


学生类:
    相同特征 --> 类内部的变量
    school
    
    相同技能 --> 类内部的函数
    learn
    choice_course

2.2 定义类的时候发生的事情：

1.类在定义的时候，会产生一个空的名称空间。

2.会把类内部的所有名字扔进这个名称空间中

注意：类在定义阶段就已经产生好了名称空间，执行python文件的时候会执行类内部的代码。

2.3 调用类的时候发生的事情（重要）

1.首先会产生一个空的对象，就是产生”对象的名称空间“。

2.会自动触发__init__.

3.会把对象本身以及括号内的参数一并传给__init__函数。

总结：调用类会产生一个对象，调用类的过程就叫做类的实例化，产生的对象称之为类的一个实例。

2.4 查看类的名称空间

print(Oldbaystudent.__dict__)

2.5 类中的增，删，改，查

class Oldboystudent:

    school = 'oldboy'

    def learn(self):
        print('learn python......')

    def choose_course(self):
        print('choose_course......')

print(Oldboystudent)
# 输出结果  <class '__main__.Oldboystudent'>

print(Oldboystudent.__dict__) # 查看名称空间内的所有名字，以字典的行式返回。
# 输出结果 {'__module__': '__main__', 'school': 'oldboy', 'learn': <function Oldboystudent.learn at 0x00000266DB3352F0>, 'choose_course': <function Oldboystudent.choose_course at 0x00000266F23FFAE8>, '__dict__': <attribute '__dict__' of 'Oldboystudent' objects>, '__weakref__': <attribute '__weakref__' of 'Oldboystudent' objects>, '__doc__': None}

# 增
Oldboystudent.adress = '上海'
print(Oldboystudent.adress)   #输出结果  上海

# 删
Oldboystudent.school
print(Oldboystudent.school)   #输出结果  oldboy

# 改
Oldboystudent.school = 'shanghai'
print(Oldboystudent.school)    #输出结果  shanghai

# 查
print(Oldboystudent.school)    #输出结果   oldbay

# 总结使用增删改查的过程中，直接类名.需要操作的变量名

2.6 类的用法

学生类
class OldboyStudent:
    # 特征
    school = 'oldboy'
    print('tank is handsome...')

    # 技能
    def learn(self):
        print('learn python...')

    def choose_course(self):  # self = None
        print('choose_course ....')
调用方法一:
stu1 = OldboyStudent()  # OldboyStudent()---> 学生对象
print(stu1, stu2, stu3)
print('stu1', stu1.school)    # 输出结果 oldboy
stu1.learn()                  # 输出结果 learn python...
stu1.choose_course()          # 输出结果 choose_course ....

# 总结：类在调用的时候，通过将类名加()的方式将这个类赋给一个变量名，想获取类内部的某些值或者函数的使用方法，赋予变量名.想要获取的内容。这种方法调用出来的内容是一致的，所有的对象与对象之间的特征与技能一样。

调用方法二：给对象添加特征
学生类
class OldboyStudent:
    # 若__init__中有self以外的参数，调用类时必须在括号内传入参数。
    def __init__(self, x, y, z):  # self --> 就是对象本身  x = 高峰峰  y=93   z=female
        # print(self, x, y, z)
        # print('此处时__init__。。。。')
        # 给对象添加特征的方式二：
        self.name = x
        self.age = y
        self.sex = z

    # 特征
    school = 'oldboy'
    # print('tank is handsome...')

    # 技能
    def learn(self):
        print('learn python...')

    def choose_course(self):  # self = None
        print('choose_course ....')


stu1 = OldboyStudent('高峰峰', 93, 'female')  # OldboyStudent()---> 学生对象
stu2 = OldboyStudent('小丁丁', 84, 'female')  # OldboyStudent()---> 学生对象
stu3 = OldboyStudent('大丁丁', 18, 'male')  # OldboyStudent()---> 学生对象

print(stu1)
print(stu2)
print(stu3)

给对象添加属性的方式一:
print(stu1.name)
stu1.name = '高峰峰'
stu1.age = 93
stu1.sex = 'female'
print(stu1.name, stu1.age, stu1.sex)

方式二打印：
print(stu1.name)

3.0 程序中定义对象

调用类即可产生对象，调用类的过程，又被称为是类的实例化，实例化的结果被称为类的对象

3.1 查看对象的名称空间

print(stul.name, stul.school)

4.0 名称空间的产生

1.类的名称空间在类定义阶段就已经产生了。

2.对象的名称空间在调用类的时候产生。

5.0 对象与类的查找顺序

1.对象.属性，若对象本身有，则有限查找对象自己的。

2.若对象本身没有，则去类里面找，若类没有，则报错。

class OldboyStudent:
    SCHOOL = 'oldboy'
    NAME = 'DDDDDDDD'

    def __init__(self, name, age, sex, school):
        self.name = name
        self.age = age
        self.sex = sex
        self.SCHOOL = school


stu1 = OldboyStudent('小正正', 17, 'male', 'oldgirl')
print(stu1.SCHOOL)
print(stu1.NAME)

6.0 对象绑定方法的特殊之处

类内部的函数主要给对象用的：

1.由类来调用类内部的函数，该函数知识一个普通的函数，普通函数需要几个参数就得传入几个参数。

2.有对象来调用称之为对象的绑定方法，不同的对象调用该绑定方法，则会将不同的对象传入该绑定方法中。

对象的绑定方法，是由对象来调用的，特殊之处就是把对象当作第一个参数传入该方法中

class OldboyStudent:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 特征
    school = 'oldboy'
    # 技能
    def learn(self):  # 普通函数
        # print('stu:', self)
        print('learn python...')

    def choose_course(self, course):  # self =
        print(f'[{self.name}]choose_course {course} ....')

stu1 = OldboyStudent('高凤凤1', 73, 'female')
stu2 = OldboyStudent('高凤凤2', 84, 'male')

stu1.choose_course('python')  # choose_course(self, 'python')
stu2.choose_course('linux')  # choose_course(self, 'python')