一、面向对象和面向过程
面向过程编程
核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么。。。
基于该思想编写程序好比在设计一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化、进而简单化
缺点：扩展性差
面向对象编程
核心对象二字，对象是特征与技能的结合体
基于该思想编写程序就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式
优点：可扩展性强
缺点：编程的复杂度要高于面向过程
二、类
''' 类：种类、分类、类别 对象是特征与技能的结合体，类是一系列对象相似的特征与技能的结合体 强调：站的角度不同，总结出的类是截然不同的 在现实世界中：先有的一个个具体存在的对象，然后随着人类文明的发展才有了分类的概念 在程序中：必须先定义类，后调用类来产生对象 现实世界中对对象==》总结出现实世界中的类==》定义程序中的类==》调用类产生程序中的对象 站在老男孩选课系统的角度，先总结现实世界中的老男孩的学生对象（这些对象有相似的特征和技能） 对象1： 特征： 学校='oldboy' 姓名='耗哥' 年龄=18 性别='male' 技能： 选课 对象2： 特征： 学校='oldboy' 姓名='猪哥' 年龄=17 性别='male' 技能： 选课 对象3： 特征： 学校='oldboy' 姓名='帅翔' 年龄=19 性别='female' 技能： 选课 站在老男孩选课系统的角度，先总结现实世界中的老男孩学生类 老男孩学生类： 相似的特征： 学校='oldboy' 相似的技能 选课 ''' #在程序中 #1、先定义类 class OldboyStudent: #先定义类，定义阶段类体代码立刻执行，产生一个类的名称空间，将一系列相似的特征与技能的名字丢到类的名称空间中 school='oldboy' #将student名字丢到类的名称空间中，指向’oldboy'的内存地址 def choose_course(self): #将choose_course名字丢到类的名称空间中，指向函数的内存地址 print('is choosing course') #类体代码会在类定义阶段就立刻执行，会产生一个类的名称空间 # 类的本身其实就是一个容器/名称空间，是用来存放名字的，这是类的用途之一 # print(OldboyStudent.__dict__) #类的字典属性，里面存放了一堆名字 # print(OldboyStudent.__dict__['school']) #数据属性：字典通过key值，就可以取到对应的value值 # print(OldboyStudent.__dict__['choose_course']) #函数属性：字典通过key值，就可以取到对应的value值，value值是是函数的内存地址 # OldboyStudent.__dict__['choose_course']() #内存地址加括号就可以直接调用 # print(OldboyStudent.school) #OldboyStudent.__dict__['school'] #另外一种访问数据属性的方法，直接使用点就可以访问类的名称空间中的名字 # print(OldboyStudent.choose_course) #OldboyStudent.__dict__['choose_course']#另外一种访问函数属性的方法，直接使用点就可以访问类的名称空间中的名字 # OldboyStudent.choose_course(111) #类通过点直接访问的函数属性就是一个普通的函数，要遵循函数的传参的规则 # 类的增删改查 # 增 # OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China' # 改 # OldboyStudent.country='CHINA' #OldboyStudent.__dict__['country']='China' # 删 # del OldboyStudent.school # 查 # print(OldboyStudent.__dict__) #2、后调用类产生对象,调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例 # stu1=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例 # stu2=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例 # stu3=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例 # 类的实例化过程都发生了哪些事？ # 如何在实例化的过程中为对象定制自己独有的特征 # 程序中对象到底是什么，如何使用？
三、为对象定制自己独有的属性
# # 例1 class OldboyStudent: #定义一个类，执行类体代码 school='oldboy' #在类的名称空间产生一个数据属性的名字（特征） def choose_course(self):#在类的名称空间产生一个函数属性的名字（技能） print('is choosing course') stu1=OldboyStudent() #实例化(调用类)产生一个空对象，对象就是一个名称名称空间，就是用来存放一堆自己独有的数据属性的 stu2=OldboyStudent() stu3=OldboyStudent() #对象本质也就是一个名称空间而已，对象名称空间(容器)是用存放对象自己------独有的名字/属性，而 #类中存放的是对象们---------------------------------------------------共有的属性 print(stu1.__dict__) #-----{}，通过字典属性，可以查看字典是一个空字典{} print(stu2.__dict__) print(stu3.__dict__) # 问题点：以下产生的三个对象，有相似的特征与技能，首先想到的是将其放到一个函数中，减少代码冗余 stu1.name='耗哥' #本质stu1.__dict__['name']='耗哥' stu1.__dict__['name']='耗哥' #就是往空对象中加入了一个key:value stu1.age=18 stu1.sex='male' print(stu1.name,stu1.age,stu1.sex) #-----耗哥 18 male，通过点就可以访问对象名称空间中的名字，进而拿到与名字绑定的值 print(stu1.__dict__) #-----{'name': '耗哥', 'age': 18, 'sex': 'male'}，可以看到对象中独有的数据属性 stu2.name='猪哥' stu2.age=17 stu2.sex='male' stu3.name='帅翔' stu3.age=19 stu3.sex='female' # # 例2--------------------------------------------------------------------------- class OldboyStudent: school='oldboy' def choose_course(self): print('is choosing course') stu1=OldboyStudent() stu2=OldboyStudent() stu3=OldboyStudent() '''在类之外定义类一个函数，将相似的特征封装成了一个函数，不同的对象来调用只需要直接传参就可以了''' def init(obj,x,y,z): #将对象和需要的实参按位置传给形参，将不同的对象传入都可以来调用 obj.name=x obj.age=y obj.sex=z # stu1.name='耗哥' # stu1.age=18 # stu1.sex='male' init(stu1,'耗哥',18,'male') #封装成函数后，上面的三行代码就可以不用写了，减少了代码冗余的目的 # # stu2.name='猪哥' # stu2.age=17 # stu2.sex='male' init(stu2,'诸哥',17,'male') #对象2来调用也只需要，将参传入即可 # stu3.name='帅翔' # stu3.age=19 # stu3.sex='female' init(stu3,'帅翔',19,'female') #对象3来调用也只需要，将参传入即可 print(stu1.__dict__) #--------{'name': '耗哥', 'age': 18, 'sex': 'male'} print(stu2.__dict__) #--------{'name': '诸哥', 'age': 17, 'sex': 'male'} print(stu3.__dict__) #--------{'name': '帅翔', 'age': 19, 'sex': 'female'} # 例3 # 在类体内定义一个__init__函数，将其名字存放在类的名称空间中，这样可以被所有调用类产生的对象引用 class OldboyStudent: school='oldboy' def __init__(obj, x, y, z): #会在调用类时自动触发，(调用类产生对象，将对象自动传入给obj,而此时的obj不在仅仅是一个形参，而是一个对象，对象就是一个容器，容器内存放很多名字，都可以被引用) obj.name = x #stu1.name='耗哥' (通过点拿到对象名称空间中的name) obj.age = y #stu1.age=18 obj.sex = z #stu1.sex='male' def choose_course(self): #choose_course是存放在类的名称空间中的，哪个对象来调用就会将其绑定给谁，并将对象当做第一个参数传入(精髓在与对象就是一个名称空间，这样对象中的名称空间的名字都可以被引用) print('is choosing course') #调用类时发生两件事 #1、创造一个空对象stu1 #2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入 stu1=OldboyStudent('耗哥',18,'male') #本质就是：OldboyStudent.__init__(stu1,'耗哥',18,'male')-----类点一个类体代码内的函数属性，就是跟访问一个普通函数没有任何区别，按照函数的属性给其传参即可 stu2=OldboyStudent('猪哥',17,'male') stu3=OldboyStudent('帅翔',19,'female') # print(stu1.__dict__) #------{'name': '耗哥', 'age': 18, 'sex': 'male'} print(stu2.__dict__) #------{'name': '猪哥', 'age': 17, 'sex': 'male'} print(stu3.__dict__) #------{'name': '帅翔', 'age': 19, 'sex': 'female'}
配图
四、属性查找
class OldboyStudent: #------------------重点：类体代码产生的所用名字都放在类的名称空间中，这样可以被共享给所有的对象用，对象通过点就可以引用 school='oldboy' count=0 #这个count是放在类的名称空间中，可以别调用类产生的不同的对象引用 def __init__(self, x, y, z): #会在调用类时自动触发 self.name = x #stu1.name='耗哥' self.age = y #stu1.age=18 self.sex = z #stu1.sex='male' OldboyStudent.count+=1 #每调用一次类产生一个对象，count就加一，调用单词就加了三次 def choose_course(self): print('is choosing course') # 先从对象自己的名称空间找，没有则去类中找，如果类也没有则报错 stu1=OldboyStudent('耗哥',18,'male') stu2=OldboyStudent('猪哥',17,'male') stu3=OldboyStudent('帅翔',19,'female') print(OldboyStudent.count) #类直接点访问类名称空间中的名字 print(stu1.count) #-----类被调用了三次所以结果是3：对象点名字，会先从自己的名称空间找，没找到到自己类的名称空间找 print(stu2.count) print(stu3.count)
五、绑定方法
class OldboyStudent: school='oldboy' #-------------------------类中定义的数据属性是共享给所有对象用的 def __init__(self, x, y, z): #会在调用类时自动触发--------类中定义的所有函数属性是共享给所有对象用的 self.name = x #stu1.name='耗哥'======》stu1.__dict__['name']='耗哥' self.age = y #stu1.age=18 self.sex = z #stu1.sex='male' def choose_course(self,x): #-------------------------类中定义的所有函数属性是共享给所有对象用的，调用类会将对象自动传入，就可以应用对象下的数据属性 print('%s is choosing course' %self.name)#-----------通过点引用了对象下的name数据属性 # def func(): #类中定义的函数会默认传入一个self，如果不写调用类时会自动将产生的对象传入，此时就会报错，TypeError: func() takes 0 positional arguments but 1 was given # pass # 类名称空间中定义的数据属性和函数属性都是共享给所有对象用的 # 对象名称空间中定义的只有数据属性，而且是对象所独有的数据属性 stu1=OldboyStudent('耗哥',18,'male') #调用类，会将对象自动传入给self，参数会按位置传__init__函数的其他形参 stu2=OldboyStudent('猪哥',17,'male') stu3=OldboyStudent('帅翔',19,'female') print(stu1) # print(stu1.name) #访问对象下的数据属性 # print(stu1.school) # 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个 # print(OldboyStudent.choose_course) #打印结构是一个函数的内存地址，所以类通过点使用类中定义的函数，跟使用一个普通函数一样，需要参数传参即可 # OldboyStudent.choose_course(123) # 类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的， #绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入(自动传入给self) # print(id(stu1.choose_course)) #2176273098184(每次运行同一个对象得到的id是不一样的，因为每次都要重新申请一个内存地址) # print(id(stu2.choose_course)) #2176273098184（将类的函数属性绑定给对象） # print(id(stu3.choose_course)) #2176273098184 #三个不同的对象应用了类的名称空间的函数属性，指向的是同一个内存地址，所以三者的id值一样的 # print(id(OldboyStudent.choose_course)) # # print(id(stu1.school)) #将类的数据属性绑定给对象 # print(id(stu2.school)) # print(id(stu3.school)) # # print(id(stu1.name),id(stu2.name),id(stu3.name)) # stu1.choose_course(1) #绑定给对象用的，所以会将对象当作第一个参数传入，即此时我们只需要再传入一个参数就可以了，并不是self没有被传参 # stu2.choose_course(2) # stu3.choose_course(3) # stu1.func() # 重点： # 补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self
六、类即类型
#在python3中统一了类与类型的概念，类就是类型 class OldboyStudent: school='oldboy' def __init__(self, x, y, z): #会在调用类时自动触发 self.name = x #stu1.name='耗哥' self.age = y #stu1.age=18 self.sex = z #stu1.sex='male' def choose_course(self,x): print('%s is choosing course' %self.name) stu1=OldboyStudent('耗哥',18,'male') # stu1.choose_course(1) #OldboyStudent.choose_course(stu1,1) # OldboyStudent.choose_course(stu1,1) l=[1,2,3] #l=list([1,2,3]) #list即列表类型也即列表类，l就是调用列表类加括号产生的对象 print(type(l)) #<class 'list'> # l.append(4) #list.append(l,4) #类可以访问类中定义的函数属性，对象也可以访问类中定义的函数属性 list.append(l,4) # print(l)
七、小结
''' 重点 # 对象是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法） class Foo: def __init__(self,host,port,db,chartset): self.host=host self.port=port self.db=db self.charset=charset def exc1(self,sql): conn = connect(self.host, self.port, self.db, self.charset) conn.execute(sql) return xxx def exc2(self,proc_name) conn = connect(self.host, self.port, self.db, self.charsett) conn.call_proc(sql) return xxx class Bar: def __init__(self,x,y,z,a,b,c): self.x=x self.y=y self.z=z self.a=a self.b=b self.c=c def exc3(self,xxx): pass def exc4(self,yyy) pass 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') '''
八、继承与派生
''' 1、什么是继承 继承是一种新建类的方式，新建的类称为子类，被继承的类称为父类 继承的特性是：子类会遗传父类的属性 强调：继承是类与类之间的关系 2、为什么用继承 继承的好处就是可以减少代码的冗余 3、如何用继承 在python中支持一个类同时继承多个父类 在python3中 如果一个类没有继承任何类，那默认继承object类 在python2中： 如果一个类没有继承任何类，不会继承object类 新式类 但凡继承了object的类以及该类的子类，都是新式类 经典类 没有继承object的类以及该类的子类，都是经典类 在python3中都是新式类，只有在python2中才区别新式类与经典类 新式类vs经典类? ''' class Parent1(object): pass class Parent2(object): pass class Sub1(Parent1,Parent2): pass print(Sub1.__bases__) #bases是查看类的所有父类(<class '__main__.Parent1'>, <class '__main__.Parent2'>) print(Parent1.__bases__) #(<class 'object'>,)-----没有父类，默认父类是object print(Parent2.__bases__) #(<class 'object'>,)-----没有父类，默认父类是object
九、继承的应用
#派生：子类中新定义的属性，子类在使用时始终以自己的为准 class OldboyPeople: #父类----------------将类与类相似的数据属性和函数属性放在父类中，这样可以减少代码冗余 school = 'oldboy' def __init__(self,name,age,sex): #定制对象自己独有的数据属性，哪个对象来调用，哪个对象就具有该数据属性，我们只需要给其添加属性值即可 self.name = name #tea1.name='egon' self.age = age #tea1.age=18 self.sex = sex #tea1.sex='male' class OldboyStudent(OldboyPeople):#子类-------子类内的就是派生类，就是除父类之外的自己独有的数据属性和函数属性 def choose_course(self): print('%s is choosing course' %self.name) class OldboyTeacher(OldboyPeople):#子类-------子类内的就是派生类，就是除父类之外的自己独有的数据属性和函数属性 # tea1,'egon',18,'male',10 def __init__(self,name,age,sex,level): # self.name=name # self.age=age # self.sex=sex OldboyPeople.__init__(self,name,age,sex)#类点一个函数属性和引用一个普通的函数没有什么区别，按照位置传参就可以了，指名道姓，与继承无关 self.level=level def score(self,stu_obj,num):#传入要给的学生对象，和要改的分数 print('%s is scoring' %self.name) stu_obj.score=num #这样就可以拿到学生对象的名称空间，将其数据属性score进行修改，实现不同类的数据属性进行交互 stu1=OldboyStudent('耗哥',18,'male') tea1=OldboyTeacher('egon',18,'male',10) #对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。 # print(stu1.school) # print(tea1.school) # print(stu1.__dict__) # print(tea1.__dict__) tea1.score(stu1,99) #----egon is scoring，对象绑定到方法，会将对象自动传入，再将其他参数传入，再有该对象来调用该函数，执行函数体代码 # print(stu1.__dict__) #{'name': '耗哥', 'age': 18, 'sex': 'male', 'score': 99} # 在子类派生出的新功能中重用父类功能的方式有两种： #1、指名道姓访问某一个类的函数：该方式与继承无关
# class Foo: # def f1(self): # print('Foo.f1') # # def f2(self): # print('Foo.f2') # self.f1() # # class Bar(Foo): # def f1(self): # print('Bar.f1') # # #对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。 # obj=Bar() # obj.f2() # ''' # Foo.f2 # Bar.f1 # '''