day20-面向对象基础

目录

• 面向对象基础
  • 面向过程编程与面向对象编程
    • 面向过程编程
    • 面向对象编程
  • 类与对象
    • 类
    • 对象
    • 定义类和对象
  • 定制对象独有特征
  • 对象属性查找顺序
  • 类与对象的绑定方法
  • 类与数据类型
  • 对象的高度整合

面向对象基础

面向过程编程与面向对象编程

面向过程编程

面向过程编程的核心是过程，过程指的是解决问题的步骤。基于面向过程编程的思想编写程序好比在设计一条流水线，是一种机械式的思维方式。

• 优点：逻辑清晰（逻辑一步一步的，比较系统）
• 缺点：扩展性差（上一个函数的输出是下一个函数的输入，如果改动某项功能时会影响其他功能）

面向对象编程

面向对象编程的核心是对象，在python中一切皆对象，对象就是特征和技能的结合体。基于面向对象编程就是定义出一个个鲜明独特的对象，然后通过对象之间交互编程

• 优点：扩展性非常强
• 缺点：编程的复杂度要高于面向过程

类与对象

类

类的意思是分类、类别。比如在学校中：按照学生和老师可以划分两类，一个是学生类，他们都具有名字、学号、班级以及选课、听课；一个是老师类，他们都有名字以及授课。因此给出类的定义：类就是一系列对象相似的特征与技能的结合体

对象

在python中一切皆对象，根据划分称为某类下的一个对象，比如猫是动物类的对象，人是人类的对象

在显示世界中：先有对象，再有类；在程序中，务必保证先定义类，后产生对象

定义类和对象

定义类：

# 注意类中定义变量使用驼峰体
class OldboyStudent:
    school = 'oldboy'
    def choose_course(self):
        print('is choosing course')

oldboystudent_dict = OldboyStudent.__dict__  ## 双下划线开头的方法会在某种情况下自动触发

曾经定义函数，函数只检测语法，不执行代码，但是定义类的时候，代码会在类定义阶段就立刻执行，并且会产生一个类的名称空间，也就是说类的本身其实就是一个容器/名称空间，是用来存放名字的，这是类的用途之一

print(oldboystudent_dict)    # 打印的是该类名称空间里具有的名字，如我们定义的school,choose_course和内置的其他属性

{'__module__': '__main__', 'school': 'oldboy', 'choose_course': <function OldboyStudent.choose_course at 0x000001BCAD3A2048>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}

print(oldboystudent_dict['school'])  # 取school的值

oldboy

print(oldboystudent_dict['choose_course'])
print(type(oldboystudent_dict['choose_course']))

<function OldboyStudent.choose_course at 0x000001BCAD3A2048>
<class 'function'>

oldboystudent_dict['choose_course']('nick')

is choosing course

print(OldboyStudent.school)

oldboy

OldboyStudent.choose_course('nick')

is choosing course

定义对象：调用类即可产生对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例

stu1 = OldboyStudent()  # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
print(1, stu1.school)
stu1.choose_course()

stu2 = OldboyStudent()  # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
print(2,stu2.school)
stu2.choose_course()

1 oldboy
is choosing course
2 oldboy
is choosing course

定制对象独有特征

类中定义的函数是类的函数属性，类可以使用，对象也可以使用。如果类的属性改了，则对象的属性也会随之改变。但同一类中的对象都会具自己独特的特征，比如张三身高180，李四身高175。

class OldboyStudent:
    school = 'oldboy'
    def choose_course(self):
        print('is choosing course')

stud1 = OldboyStudent()
stud2 = OldboyStudent()

print(stud1.__dict__)

{}

print(stud2.__dict__)

{}

对象本质类似于类，也是一个名称空间，但是对象的名称空间存放对象独有的名字，而类中存放的是对象们共有的名字。因此我们可以直接为对象单独定制名字。

stud1.name = 'nick'
stud1.age = 18
print(stud1.name,stud1.age)

nick 18

print(OldboyStudent.name)  # 在对象中定义的独有属性，不属于类

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-49-d5096aff41d0> in <module>
----> 1 print(OldboyStudent.name)
AttributeError: type object 'OldboyStudent' has no attribute 'name'

使用上述方法虽然让我们定制属性更简单，但是还是太麻烦了，如果可以在实例化对象的时候自动触发定时属性，那就更方便了，因此可以使用类的__init__方法。

class OldboyStudent:
    school = 'oldboy'
    # 调用类的时候自动触发
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def choose_course(self):
        print('is choosing course')

stud1 = OldboyStudent('nick', 18)
print(stud1.__dict__, stud1.name, stud1.age)

{'name': 'nick', 'age': 18} nick 18

通过上述现象可以发现，调用类的时候创造了一个空对象，同时自动触发类中__init__功能，将stud1以及调用类括号内的参数一同传入

对象属性查找顺序

class OldboyStudent:
    school = 'oldboy'
    name = 'tank'
    # 调用类的时候自动触发
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def choose_course(self):
        print('is choosing course')

stud1 = OldboyStudent('nick', 18)
print(stud1.name, stud1.school)

nick oldboy

print(stud1.height)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-61-ff2d39934944> in <module>
----> 1 print(stud1.height)
AttributeError: 'OldboyStudent' object has no attribute 'height'

• 类中定义name为tank，定义对象时传入name为nick，在打印stud1.name时打印的是nick。可见：当类和对象同时定义属性时，先从对象本身查找
• 类中定义school为oldboy，对象中未定义，打印stud1.school时打印的是oldboy。可见：当对象中未定义该属性时，从类中查找
• 类和对象都未定义时，则报错

总结：查找属性先从对象本身查找，对象没有去类中查找，类中也没有则报错

类与对象的绑定方法

class OldboyStudent:
    school = 'oldboy'
    name = 'tank'
    # 调用类的时候自动触发
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def choose_course(self):
        print('is choosing course')

stud1 = OldboyStudent('nick', 18)  # 每次实例化对象的时候都会自动调用__init__方法（排在第一位）

stud1.choose_course()

is choosing course

OldboyStudent.choose_course()  # 报错，提示缺少参数self

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-77-d104c34c78e5> in <module>
----> 1 OldboyStudent.choose_course()  # 报错，提示缺少参数self
TypeError: choose_course() missing 1 required positional argument: 'self'

OldboyStudent.choose_course('nick')  # 将nick传给形参self，类似于普通函数调用

is choosing course

在类调用类中定义的函数时，需要传值给self；在对象调用类中定义的函数时，不需要传入参数。

总结：

• 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个
• 类中定义的函数对象也可以使用，而且是绑定给对象用的，绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入。所以不需要传参给self
• 类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self

类与数据类型

之前在学习定义数据时，比如定义一个列表，可以使用lis = list([1,2,3])。其实list就是一个类，lis就是list类中的一个实例化对象。只不过这个list类是python为我们封装好的，我们可以直接调用生成一个列表。而append就是list类定义的一个函数方法，对象lis也可以直接调用。其他数据类型也是同理

总结：python3中统一了类与类型的概念，类就是类型。因此数据类型就是将数据分成不同的类，生成一个具体的数据时就是在生成一个类的对象

对象的高度整合

• 以未来我们要连接数据库举例，如果没有面向对象的思想，我们只要想要使用一个方法，就必须得这样做

import pymysql  # 连接mysql的三方库，可以pip3 install pymysql安装
def exc1(host, port, db, charset, sql):
    conn = pymysql.connect(host, port, db, charset)
    conn.execute(sql)
    return xxx
def exc2(proc_name):
    conn = pymysql.connect(host, port, db, charsett)
    conn.call_proc(sql)
    return xxx
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t1')
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t2')
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t3')
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t4')

• 有了面向对象之后，对于上述的例子，我们可以这样做

import pymysql
class Foo:
    def __init__(self, host, port, db, chartset):
        self.host = host
        self.port = port
        self.db = db
        self.charset = chartset
    def exc1(self, sql):
        conn = pymysql.connect(self.host, self.port, self.db, self.charset)
        conn.execute(sql)
        return xxx
    def exc2(self, proc_name):
        conn = pymysql.connect(self.host, self.port, self.db, self.charsett)
        conn.call_proc(sql)
        return xxx
obj1 = Foo('1.1.1.1', 3306, 'db1', 'utf-8')
obj1.exc1('select * from t1')
obj1.exc1('select * from t2')
obj1.exc1('select * from t3')
obj1.exc1('select * from t4')

总结：对象其实就是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）