面向对象
面向过程
核心是过程，过程指的是问题的解决步骤，即先干什么再干什么，基于面向过程去设计程序就好比设计一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化，进而简单化
缺点：可扩展性差
面向对象
核心是对象，对象就是特征与技能的结合体，如果把设计程序比喻成创造一个世界，那你就是这个世界的上帝，与面向过程对机械流水线的模拟形成鲜明的对比，
面向对象更加注重的是对现实世界的模拟
优点：可扩展性高
缺点：极易出现过度设计
类
一系列对象相似的特征与技能的结合体
在现实世界中，先有一个个具体存在的对象，随着发展，总结相似之处，得到现实中的类
在程序中，一定是先定义类，后调用类来产生对象
第一阶段：由现实中的对象，总结出现实中的类
obj1: 特征 学校=oldboy 名字=李 年龄=18 性别=女 技能 学习 吃饭 obj2: 特征 学校=oldboy 名字=张 年龄=28 性别=男 技能 学习 吃饭 obj3: 特征 学校=oldboy 名字=牛 年龄=18 性别=女 技能 学习 吃饭
类就是现实中的老男孩学生类：
相似的特征 学校=oldboy 相似的技能 学习 吃饭
第二阶段：程序中的类产生程序中的对象
class OldboyStudent: # 定义了类，类体中的代码在类定义阶段就会执行 school = 'oldboy' # 特征 ,类的数据属性 def learn(self): # 技能，类的函数属性 print('is learning') def eat(self): print('is eating') print(OldboyStudent.__dict__) # 查看类的 名称空间（用来存放类中的变量名和函数名） #通过字典访问里面的属性 print(OldboyStudent.__dict__['school']) print(OldboyStudent.__dict__['learn']) #python提供了访问属性的语法 print(OldboyStudent.school) print(OldboyStudent.learn) OldboyStudent.learn(123) #新增属性 OldboyStudent.x=11111 OldboyStudent.school='Oldboy' print(OldboyStudent.__dict__) #删除属性 del OldboyStudent.school print(OldboyStudent.__dict__)
对象
如何产生程序中的对象？类名加括号，调用类，产生一个该类的实际存在的对象，该过程称为实例化，产生的结果又可以称为实例
obj1=OldboyStudent() obj2=OldboyStudent() obj3=OldboyStudent()
产生了3个相同的对象，因为并没有使用__init__()
class OldboyStudent: school = 'oldboy' def __init__(self,name,age,sex): # 只在实例化的时候执行,在对象产生之后才会执行 if not isinstance(name,str): raise TypeError('名字必须是字符串类型') self.name=name self.age=age self.sex=sex def learn(self): print('%s is learning' % self.name) def eat(self): print('is eating') obj1=OldboyStudent('李',18,'女') #两步：1.先生成一个空对象 2.连同空对象和后面的三个参数，组成一组（obj1,'李',18,'女'）传给__init__(),相当于 OldboyStudent.__init__(obj1,'李',18,'女') print(obj1.name) # obj1.__dict__['name'] obj1.name='网' print(obj1.name) print(obj1.school,id(obj1.school)) print(obj2.school,id(obj2.school)) print(obj3.school,id(obj3.school)) print(OldboyStudent.school,id(OldboyStudent.school)) #以上4个完全相同，就是同一个 #对象可以访问类的数据属性，类的数据属性是共享给所有对象使用的，id都一样 #类的函数属性 OldboyStudent.learn(obj1) print(obj1.learn) #绑定方法 print(OldboyStudent.learn) # 函数属性 obj1.learn() # OldboyStudent.learn(obj1) #绑定方法的特殊之处在于，绑定给谁，就由谁来调用，谁来调用，就把谁当作第一个参数传入
统计
class Foo: count=0 def __init__(self,x,y,z): self.x=x self.y=y self.z=z Foo.count+=1 obj1=Foo(1,1,1) obj2=Foo(1,2,1) obj3=Foo(1,2,3) print(obj1.count)
print(Foo.count)
对象之间的交互
class Garen: camp='Demacia' def __init__(self,nickname,life_value=100,aggresivisity=80): self.nickname=nickname self.aggresivity=aggresivity def attack(self,enemy): enemy.life_value-=self.aggresivity class Riven: camp='Noxus' def __init__(self,nickname,life_value=80,aggresivisity=100): self.nickname=nickname self.aggresivity=aggresivity def attack(self,enemy): enemy.life_value-=self.aggresivity g1=Garen('草丛') r1=Riven('兔') print(r1.life_value) g1.attack(r1) print(r1.life_value)
继承
1.解决代码重用问题
2.继承是类与类之间的关系，是一种，什么是什么的关系
3.在子类派生出新的方法内重用父类功能的方式：指名道姓法
OldboyPeople.__init__()
这种调用方式本身与继承没有关系
class ParentClass1: pass class ParentClass2: pass class SubClass1(ParentClass1): pass class SubClass2(ParentClass1,ParentClass2): pass print(SubClass1.__bases__) print(SubClass2.__bases__)
print(ParentClass1.__bases__) #python3的基类默认继承object，这是经典类与新式类的区别 #查看父类
class OldboyPeople: school='oldboy' def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def eat(self): print('is eating') class OldboyStudent(OldboyPeople): def learn(self): print('%s is learning' % self.name) class OldboyTeacher(OldboyPeople): def __init__(self,name,age,sex,salary,title): OldboyPeople.__init__(self,name,age,sex): self.salary=salary self.title=title def teach(self): print('%s is teaching' % self.name) obj1=OldboyStudent('tom',23,'female') egon_obj=OldboyTeacher('egon',23,3000,'沙河讲师')
组合
class OldboyPeople: school='oldboy' def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def eat(self): print('is eating') class OldboyTeacher(OldboyPeople): def __init__(self,name,age,sex,salary,title): OldboyPeople.__init__(self,name,age,sex) self.salary=salary self.title=title self.course=[] def teach(self): print('%s is teaching' % self.name) class Course: def __init__(self,course_name,course_period,course_price): self.course_name=course_name self.course_period=course_period self.course_price=course_price def tell_info(self): print('<课程名:%s 周期:%s 价格:%s>' % (self.course_name,self.course_period,self.course_price)) python=Course('Python','6month',3000) linux=Course('Linux','3month',2000) bigdata=Course('Bigdata','1month',1000) egon_obj=OldboyTeacher('egon',18,'male',3000,'沙河讲师') egon_obj.course.append(python) egon_obj.course.append(linux) for obj in egon_obj.course: obj.tell_info() yl_obj=OldboyStudent('杨',15,'male') yl_obj.course.append(python) for i in yl_obj.course: i.tell_info()
绑定方法与非绑定方法
1.绑定给谁，谁来调用就自动将它本身当作第一个参数传入
2.绑定到对象的方法前面已经写了
绑定到类的方法
#settings.py HOST='192.168.0.1' PORT=3307
import settings import uuid class MySql: def __init__(self,host,port): self.host=host self.port=port self.id=self.create_id() #每产生一个对象就赋予一个唯一的id #def func1():pass #def func2(self):pass #上面两种都是给对象用的，并且def func():pass是一种错误的方法 @classmethod #绑定给类 def from_conf(cls): # cls就是这个类，函数内部的不需要对象，需要的是类 return cls(settings.HOST,settings.PORT) def func1(self): #绑定给对象 pass @staticmethod 和谁都没有关系，就是一个普通函数,工具,不与任何对象绑定 def create_id(): #函数内既不需要类也不需要对象，就定义成非绑定方法 return str(uuid.uuid1()) conn1=MySql('127.0.0.1',3306) #实例化传入 conn2=MySql.from_conf() #配置文件中取出 print(conn1.host,conn2.host) #和对象没有关系就定义成类方法 conn3=MySql('127.0.0.1',3306) conn4=MySql('127.0.0.2',3307) conn5=MySql('127.0.0.3',3308) print(conn3.id,conn4.id,conn5.id)
继承实现原理
单继承
class A: def f1(self): print('A.f1') def f2('A.f2'): print('A.f2') self.f1() # b.f1() class B(A): def f1(self): print('B.f2') b=B() b.f2() #A.f2 #B.f2
多继承
class A: def test(self): print('A') class E: def test(self): print('E') class H: def test(self): print('H') class G(H): def test(self): print('G') class B(A): def test(self): print('B') class D(E): def test(self): print('D') class F(G): def test(self): print('F') class C(B,D,F): def test(self): print('C') print(C.mro()) # 查看C类的继承关系
super()
子类的方法重用父类的功能
class OldboyPeople: school='oldboy' def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def eat(self): print('is eating') def teach(self): print('这是父类的teach') class OldboyTeacher(OldboyPeople): def __init__(self,name,age,sex,salary,title): #OldboyPeople.__init__(self,name,age,sex) # 指名道姓，与继承无关 #super(OldboyTeacher,self).__init__() #适用于python2 print(super().school) # oldboy print(super().eat) super().__init__(name,age,sex) self.salary=salary self.title=title def teach(self): #OldboyPeople.teach(self) super().teach() print('%s is teaching' % self.name) print(OldboyTeacher.mro()) egon_obj=OldboyTeacher('egon',18,'male',300,'沙河将讲师') print(egon_obj.title) print(egon_obj.__dict__) egon_obj.teach()
class A: def test(self): super().test() classB: def test(self): print('B') class C(A,B): pass c=C() c.test() #并不会发生报错，因为super是只看C类的mro列表，并不是看到A类的父类object没有test方法就会报错 #B
