一、面向对象编程介绍
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')
-
对于上述发生的现象，我们可以总结对象其实就是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）
-
