一、面向对象编程介绍

1、1 面向过程编程

面向过程的核心是过程二字，过程指的是解决问题的步骤。

基于面向过程编程的思想编写程序就是好比在设计一条流水线，是一种机械化的思维方式。

• 优点：复杂的问题流程化，进而简单化

• 缺点：扩展展性差

1、2 面向对象编程

面向对象编程的核心是对象二字，对象是特征与技能的集合体。

基于面向对象编程的思想编写程序，就好比是创造一个世界，你就是这个是这个世界的上帝，是一种上帝式的思维方式。

• 优点：可扩展性强

• 缺点：编程的复杂度高于面向过程

二、类与对象

2、1 类与对象的定义

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

• 对象就是特征与技能的结合体

2 、2 定义类与对象

• 定义类建议用驼峰体

#class关键字 类名：
#   pass
class Student:
    school = 'oldboy'
    def choose(self):
        print('选课')
    def study(self):
        print('学习')
​

• 产生对象

  类加括号生成对象

  stu1 = Student()

• 类

  • 获取类的属性和方法

    # 类.__dict__
    ​

  • 类来调用属性和方法

    1、通过dict来取（复杂、不用）

    Student.__dict__
    Student.__dict__['school'](123)

    2、类名.属性/函数

    Student.school
    ​

• 对象

  • 对象获取属性和方法（复杂、不用）

    # 对象.__dict__
    stu1 = Student()
    stu1.__dict__

  • 对象来调用属性和方法

    对象.属性/方法

    stu1.choose    

  • 对象自己的属性和方法

    stu1 = Student()
    stu1.name = 'hanyi'
    stu1.school = 'xxx'

三、对象的属性查找顺序

• 属性查找顺序

  先从对象自身找 ——>类中找——>找不到，报错

• 向对象中放属性

  • 第一种

    stu1 = Student()
    stu1.name = 'hanyi'

  • 第二种：通过__dict__方法

    class Student:
        school = 'oldboy'
        def __init__(self,name):
            self.name = name
        def choose(self):
            print('选课')
        def study(self):
            print('学习')

四、对象的绑定方法

4、1 对象的绑定方法

• 类名称空间中定义的 数据属性和函数属性都是共享给所有对象用的

• 对象名称空间中定义的只有数据属性、而且是对象所独有的数据属性

4、2 类使用对象的绑定

• 类中定义的函数是类的函数属性，类可以使用，但使用就是一个普通的函数而已，意味着需要完全遵守函数的参数规则，该传几个值 就传几个值

4、3 对象使用对象的绑定方法

• 类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象的，

• 绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一参数自动传入

• Python中一切皆对象

五、类和数据类型

5、1 类与数据类型

• python3中统一了类与类型的概念，类就是类型

class Foo:
    pass
​
​
obj = Foo()
print(type(obj))
<class '__main__.Foo'>
lis = [1, 2, 3]
lis2 = [4, 5, 6]
print(type(lis))
<class 'list'>

• lis和lis2都是实例化的对象，因此lis使用append方法和lis2无关

lis.append(7)
print(lis)
[1, 2, 3, 7]
print(lis2)
[4, 5, 6]

5、2 list.append()方法原理

class OldboyStudent:
    school = 'oldboy'
​
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.sex = gender
​
    def choose_course(self, name):
        print(f'{name} choosing course')
​
​
stu1 = OldboyStudent('nick', 18, 'male')
stu1.choose_course(1)  # OldboyStudent.choose_course(stu1, 1)
1 choosing course
OldboyStudent.choose_course(stu1, 1)
1 choosing course
lis = [1, 2, 3]  # lis = list([1,2,3])
print(type(lis))
<class 'list'>
lis.append(4)  # list.append(lis,4)
print(lis)
[1, 2, 3, 4]
list.append(lis, 5)
print(lis)
[1, 2, 3, 4, 5]

六、对象的高度耦合

6、1 没有对象

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

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

• 由于host、port、db、charset可能是固定不变的，sql一直在变化，因此我们通过上述的方法实现不同的sql语句，非常麻烦，因此我们可以改用默认形参

def exc1(sql, host='1.1.1.1', port=3306, db='db1', charset='utf-8'):
    conn = pymysql.connect(host, port, db, charset)
    conn.execute(sql)
    return xxx
​
exc1('select * from t1')
exc1('select * from t2')
exc1('select * from t3')
exc1('select * from t4')

• 虽然是用默认参数简化了操作，但是对于不同引用的对象，参数并不是一成不变的，或者我们需要对exc2方法进行修改，这是非常麻烦的，因此可以考虑使用面向对象

6、2 有对象

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

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')
​
obj2 = Foo('1.1.1.2', 3306, 'db1', 'utf-8')
obj2.exc1('select * from t4')

• 对于上述发生的现象，我们可以总结对象其实就是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）

•  

原文地址：https://www.cnblogs.com/hanyi12/p/11575518.html