day20-面向对象基础

时间 2019-11-18

标签 day20 day 面向对象基础栏目软件设计繁體版

原文原文链接

目录python

面向对象基础

面向对象基础

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

面向过程编程

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

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

面向对象编程

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

优势：扩展性很是强
缺点：编程的复杂度要高于面向过程

类与对象

类

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

对象

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

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

定义类和对象

定义类：函数

# 注意类中定义变量使用驼峰体
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

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

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')

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