一、面向对象和面向过程
面向过程编程
核心是过程二字,过程指的是解决问题的步骤,即先干什么再干什么然后干什么。。。
基于该思想编写程序好比在设计一条流水线,是一种机械式的思维方式
优点:复杂的问题流程化、进而简单化
缺点:扩展性差
面向对象编程
核心对象二字,对象是特征与技能的结合体
基于该思想编写程序就好比是在创造一个世界,你就是这个世界的上帝,是一种上帝式的思维方式
优点:可扩展性强
缺点:编程的复杂度要高于面向过程
二、类
'''
类:种类、分类、类别
对象是特征与技能的结合体,类是一系列对象相似的特征与技能的结合体
强调:站的角度不同,总结出的类是截然不同的
在现实世界中:先有的一个个具体存在的对象,然后随着人类文明的发展才有了分类的概念
在程序中:必须先定义类,后调用类来产生对象
现实世界中对对象==》总结出现实世界中的类==》定义程序中的类==》调用类产生程序中的对象
站在老男孩选课系统的角度,先总结现实世界中的老男孩的学生对象(这些对象有相似的特征和技能)
对象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 #左边name是属性,右边name是变量
# self.age=age
# self.sex=sex
OldboyPeople.__init__(self,name,age,sex)#(实现代码的重用,实现代码的冗余)类点一个函数属性和引用一个普通的函数没有什么区别,按照位置传参就可以了,指名道姓,与继承无关
self.level=level
def score(self,stu_obj,num):#传入要给的学生对象,和要改的分数,stu1是一个高度整合的产物,拿到self不仅拿到对象独有的数据属性还有公有的属性,还有处理数据的所有方法
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
# '''
python之基础知识大全