what's the python之面向对象
Posted ゛竹先森゜
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了what's the python之面向对象相关的知识，希望对你有一定的参考价值。
编程分为面向过程和面向对象，首先我们要了解什么是面向对象。
面向对象
面向过程就是我们之前学的内容，主要是函数式，其核心是过程，过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。
优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。
缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。
应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。
面向对象的程序设计的核心是对象（上帝式思维），对象就是指由我们程序员创造出来的，所以可以吧自己理解为上帝，对象的一切属性都需要我们给予，
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。
缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致bug出现，一刀砍死3个人，这个游戏就失去平衡。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。
面向对象编程其实就是对 “类” 和 “对象” 的使用。
类：具有相同特征的一类事物(人类、狗类、武器类等等)
对象／实例：具体的某一个事物（爱抠鼻的如花，爱日天的泰迪，拥有炫酷皮肤的英雄级武器等等）
实例化：类——>对象的过程（这在生活中表现的不明显，我们在后面再慢慢解释）
注：在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。
注：使用函数式编程和面向对象编程方式来执行一个“方法”的方式为——面向对象：【创建对象】【通过对象执行方法】 函数编程：【执行函数】
难点：待弄懂面向对象后再来看这里
class MyType(type): """ 自定义的元类metaclass，用于创建类的类，对于此类而言，普通的类只是它实例化后得到的对象 如果没有自定义这个类，就会用内建的元类 """ def __init__(self,*args,**kwargs): super(SingletonType,self).__init__(*args,**kwargs) def __call__(cls, *args, **kwargs): obj = cls.__new__(cls,*args, **kwargs) cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj) return obj class Foo(metaclass=SingletonType): """ 自己定义的普通的类，是type类的对象 """ def __init__(self,name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) obj = Foo(\'name\')#由类实例化生成的对象 """ 原理剖析： 1.内存首先加载元类，然后加载到Foo类的时候就相当于生成了元类的对象，所以会执行元类 中的__init__方法 2.内存加载到obj，obj是由类Foo实例化来的，而Foo实例化的过程就是Foo加括号，obj被实例化的 时候回执行Foo类的__init__，但是在执行之前还需执行3个方法。往下看…… 3.当Foo加括号时，就会执行元类中的__call__方法（对象加括号立即执行该对象的类的__call__） 4.而元类的__call__方法首先执行了其对象的__new__方法即Foo类的__new__，最后才再执行Foo类 中的__init__方法 5.最后得到obj对象。 后话：一般情况下，我们平时使用的时候就只关注obj实例化时执行其类的__init__方法就行，但是在高阶 开发时一定要注意其原理 """
面向对象的三大特性：封装、继承、多态
面向对象的基本格式
class 类名: def __init__(self,参数1,参数2): self.对象的属性1 = 参数1 self.对象的属性2 = 参数2 def 方法名(self):pass def 方法名2(self):pass 对象名 = 类名(1,2) #对象就是实例，代表一个具体的东西 #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法 #括号里传参数，参数不需要传self，其他与init中的形参一一对应 #结果返回一个对象 对象名.对象的属性1 #查看对象的属性，直接用 对象名.属性名 即可 对象名.方法名() #调用类中的方法，直接用 对象名.方法名() 即可
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
而类有两种属性：静态属性和动态属性
- 静态属性就是直接在类中定义的变量
- 动态属性就是定义在类中的方法
类的数据属性是共享给所有对象的，而类的动态属性是绑定到所有对象的。创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性。在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常。
关于面向对象的一系列知识，我们通过一串代码来讲解，只要撸懂了以下代码，有关面向对象的知识就已经入门了（前方高能）：
#传说中的有这么一个人，他平生嫉犬如仇，誓要与恶犬大战一场，人狗大战一触即发…… class Person:#定义一个人类 role=\'chinese\'#此类中的人统统是中国人，这种定义的属性都称为静态属性 money=200#也是静态属性，以下由函数定义的称为动态属性 def __init__(self,name,life_value,aggressivity):#使之后创造的每一个对象都有自己的名字、生命值、攻击力 self.name=name#使对象的名字具体化，这样每创造一个对象时就可以给予一个不同的名字 self.life_value=life_value#同上，生命值 self.aggressivity=aggressivity#同上，攻击力 def attack(self,enemy):#定义人的攻击方式和enemy为攻击对象，具体传参后就可以进行互动 print(self.name, \'痛扁\', enemy.name) enemy.life_value-=self.aggressivity#人攻击敌人后，敌人的生命值会根据人的攻击力而减少 class Dog:#定义一个狗类 role=\'dog\'#狗的属性 def __init__(self,name,breed,life_value,aggressivity):#使之后创造的每一个对象都有自己的名字、品种、生命值、攻击力 self.name = name self.breed = breed self.life_value = life_value self.aggressivity = aggressivity def bite(self,enemy):#定义人的攻击方式和enemy为攻击对象，具体传参后就可以进行互动 print(self.name,\'疯狂撕咬\',enemy.name) enemy.life_value -= self.aggressivity#狗攻击敌人后，敌人的生命值会根据人的攻击力而减少 class Weapon:#定义了一个武器， def __init__(self,name,price,aggressivity,life_value,attack_force):#使之后创造的每一个对象都有自己的名字、价格、攻击力、生命、大招 self.name=name self.price=price self.aggressivity=aggressivity self.life_value=life_value self.attack_force=attack_force def update(self,person):#定义装备了该武器后的人的各项属性加成 person.money-=self.price#钱会减少 person.aggressivity+=self.aggressivity#攻击力叠加 person.life_value+=self.life_value#生命值叠加 def kill(self,person,obj):#定义人使用该武器时又拥有的大招，攻击敌人 print(person.name,\'使用\',self.name,\'狂砍\',obj.name) obj.life_value-=self.attack_force#敌人的生命减少了大招的伤害值 #以下是测试交互内容： #对象是关于类而实际存在的一个例子，即实例 #实例化过程，类名加括号后会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征 egg=Person(\'egon\',10000,50)#这里我们将类变成了对象，就是实例化过程，默认传参 al=Person(\'alex\',250,5)#可以看出al相比egg而言完全是个弱鸡 sword=Weapon(\'sword_soul\',50,50,1000,500)#实例化了一把名叫sword_soul的剑，赋予其相应属性 ted=Dog(\'Tyler\',\'teddy\',20000,100)#实例化一只名为Tyler的泰迪狗，赋予其必要的属性 print(Person.role)#查看人的role属性，chinese print(egg.life_value)#对象名.属性名的方式就可以查看其相应的属性，这里查看的是egg的生命值10000 print(egg.aggressivity)#50 print(al.name,al.life_value)#alex 250 egg.attack(al)#egg攻击了al print(al.life_value)#查看被攻击后al的生命值变化，结果为掉了200血 #egg准备买一把剑装个逼 if egg.money>sword.price:#判断egg的钱是不是够买那把剑 sword.update(egg)#egg买了剑以后就拥有了剑给他的实行加成 egg.weapon=sword#egg装备上剑 print(egg.money,egg.life_value,egg.aggressivity)#查看拥有剑以后egg的属性，发现有了相应变化，150 11000 100 egg.attack(ted)#egg对着狗反手就是一剑，此时的狗为ted print(ted.name,\'剩余血量\',ted.life_value)#查看ted被egg刺了一剑之后的血量，Tyler 剩余血量 19900 egg.weapon.kill(egg,ted)#egg心一狠，蓄力使用大招再次对ted刺出一剑 \'\'\'这在面向对象中是一种称之为组合的用法 组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合 这里egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法\'\'\' print(ted.name,\'剩余血量\',ted.life_value)#查看ted被egg大招击中后的血量，Tyler 剩余血量 19400
有关类属性的补充
一：我们定义的类的属性到底存到哪里了？有两种方式查看 dir(类名)：查出的是一个名字列表 类名.__dict__:查出的是一个字典，key为属性名，value为属性值 二：特殊的类属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中)
人狗大战的代码最后引入了一个叫做“组合”的知识，下面我们就要来了解面向对象的两种重要的重用方式，一个是“组合”，一个是“继承”。
组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
比如我们创建了一个圆形的类，然后我们又要创造一个圆环的类，突然发现圆环中很多的代码可以套用圆形的类中的代码，于是我们就可以使用“组合”的方式使我们的代码更精简，美观易懂高端大气上档次。
from math import pi#因为圆要用到π，这里可以用数学模块导入π到程序中 class Circle: \'\'\' 定义了一个圆形类； 提供计算面积(area)和周长(perimeter)的方法 \'\'\' def __init__(self,radius): self.radius = radius#半径 def area(self):#面积 return pi * self.radius * *2 def perimeter(self):#周长 return 2 * pi *self.radius circle = Circle(10) #实例化一个半径为10的圆 area1 = circle.area() #计算圆面积 per1 = circle.perimeter() #计算圆周长 print(area1,per1) #打印圆面积和周长 class Ring: \'\'\' 定义了一个圆环类 提供圆环的面积和周长的方法 \'\'\' def __init__(self,radius_outside,radius_inside): self.outsid_circle = Circle(radius_outside)#“组合” self.inside_circle = Circle(radius_inside)#“组合” def area(self): return self.outsid_circle.area() - self.inside_circle.area() def perimeter(self): return self.outsid_circle.perimeter() + self.inside_circle.perimeter() ring = Ring(10,5) #实例化一个外半径是10，内半径是5的环形 print(ring.perimeter()) #计算环形的周长 print(ring.area()) #计算环形的面积
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系
下面针对“组合”再举一个小栗子：比如教授有生日，教授教python课程
class BirthDate:#定义生日 def __init__(self,year,month,day): self.year=year self.month=month self.day=day class Couse:#定义职业 def __init__(self,name,salary,period):#名字、工资、工龄 self.name=name self.price=price self.period=period class Teacher:#定义一个老师 def __init__(self,name,sex,birth,course): self.name=name self.sex=sex self.birth=birth self.course=course def teach(self): print(\'teaching\') p1=Teacher(\'egon\',\'male\', BirthDate(\'1995\',\'1\',\'27\'), Couse(\'python\',\'28000\',\'4 months\') ) print(p1.birth.year,p1.birth.month,p1.birth.day) print(p1.course.name,p1.course.price,p1.course.period) \'\'\' 运行结果: 1995 1 27 python 28000 4 months \'\'\'
继承
继承：继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类
注：python中类的继承分为单继承和多继承而Java语言C语言只支持单继承
对于面向对象的继承来说，继承就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
class ParentClass1: #定义父类 pass class ParentClass2: #定义父类 pass class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass1 pass class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类 pass
查看继承：
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个父类，__bases__则是查看所有继承的父类 (<class \'__main__.ParentClass1\'>,) >>> SubClass2.__bases__ (<class \'__main__.ParentClass1\'>, <class \'__main__.ParentClass2\'>)
注：如果没有指定基类，python3中的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。
下面小插一嘴，在python2中如果没有指定基类，那么这就是一个经典类，而在python3中就会默认继承object类，这个我们称之为新式类。
#python2中 class A: pass class B(A): pass #A和B都是经典类 #而在python3中，A会默认继承object类，所以A和B都是新式类
多继承
经典类和新式类的多继承方法的寻找方法是不同的
经典类——深度优先
新式类——广度优先
以代码进行说明：（钻石继承）
class D: def bar(self): print \'D.bar\' class C(D): def bar(self): print \'C.bar\' class B(D): def bar(self): print \'B.bar\' class A(B, C): def bar(self): print \'A.bar\' a = A() #执行bar()方法时，经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> D --> C # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a.bar() class D(object): def bar(self): print \'D.bar\' class C(D): def bar(self): print \'C.bar\' class B(D): def bar(self): print \'B.bar\' class A(B, C): def bar(self): print \'A.bar\' #执行bar()方法时，新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> C --> D # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a=A()
a.bar()
注：python3中有一个mro方法可以帮你分析出继承顺序，即a.mro或者a.__mro__
继承与抽象之间是有关系的，抽象即抽取类似或者说比较像的部分，而继承就是抽象的反方向。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度），抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象就可以得到类
继承是基于抽象的结果，通过编程语言去实现它，我们实际中肯定是先在脑海中或者草稿中经历抽象这个过程，然后才能通过继承的方式去表达出抽象的结构。
在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时，我们不可能从头开始写一个类B，这就用到了类的继承的概念。通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。
继承时子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），这就叫派生。需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
关于继承和派生，这里举个栗子：
class Animal: \'\'\' 人和狗都是动物，所以创造一个Animal基类 \'\'\' def __init__(self, name, aggressivity, life_value): self.name = name # 人和狗都有自己的昵称; self.aggressivity = aggressivity # 人和狗都有自己的攻击力; self.life_value = life_value # 人和狗都有自己的生命值; def eat(self): print(\'%s is eating\'%self.name) class Dog(Animal): \'\'\' 狗类，继承Animal类 \'\'\' def __init__(self,name,breed,aggressivity,life_value): super().__init__(name, aggressivity, life_value) #执行父类Animal的init方法 self.breed = breed #派生出了新的属性 def bite(self, people): \'\'\' 派生出了新的技能：狗有咬人的技能 :param people: \'\'\' people.life_value -= self.aggressivity def eat(self): # Animal.eat(self) #super().eat() print(\'from Dog\') class Person(Animal): \'\'\' 人类，继承Animal \'\'\' def __init__(self,name,aggressivity, life_value,money): #Animal.__init__(self, name, aggressivity, life_value) #super(Person, self).__init__(name, aggressivity, life_value) super().__init__(name,aggressivity, life_value) #执行父类的init方法 self.money = money #派生出了新的属性 def attack(self, dog): \'\'\' 派生出了新的技能：人有攻击的技能 :param dog: \'\'\' dog.life_value -= self.aggressivity def eat(self): #super().eat() Animal.eat(self) print(\'from Person\') egg = Person(\'egon\',10,1000,600) ha2 = Dog(\'二愣子\',\'哈士奇\',10,1000) print(egg.name) print(ha2.name) egg.eat()
附：在python3中，子类执行父类的方法也可以直接用super方法，上面代码中有说明
注：像ha2.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类
接口类与抽象类
接口类：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能。
普通的继承以为会使子类与父类耦合，所以往往不推荐。接口继承的意义非常重大，接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程。
为何要用接口：接口提取了一群类共同的函数，可以把接口当做一个函数的集合。然后让子类去实现接口中的函数。这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样。
#这里我们用支付软件举例进行说明 class Alipay: \'\'\' 支付宝支付 \'\'\' def pay(self,money): print(\'支付宝支付了%s元\'%money) class Applepay: \'\'\' apple pay支付 \'\'\' def pay(self,money): print(\'apple pay支付了%s元\'%money) class Wechatpay: def fuqian(self,money): \'\'\' 实现了pay的功能，但是名字不一样 \'\'\' print(\'微信支付了%s元\'%money) def pay(payment,money): \'\'\' 支付函数，总体负责支付 对应支付的对象和要支付的金额 \'\'\' payment.pay(money) p = Wechatpay() pay(p,200) #执行会报错 #我们设置一个接口，就可以手动让他报出异常 class Payment: def pay(self): raise NotImplementedError class Wechatpay(Payment): def fuqian(self,money): print(\'微信支付了%s元\'%money) p = Wechatpay() #这里不报错 pay(p,200) #这里报错了 #使用abc模块来实现接口 from abc import ABCMeta,abstractmethod class Payment(metaclass=ABCMeta): @abstractmethod def pay(self,money): pass class Wechatpay(Payment): def fuqian(self,money): print(\'微信支付了%s元\'%money) p = Wechatpay() #不调就报错了
抽象类：抽象类是一个特殊的类，他只能被继承，不能被实例化
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
以上是关于what's the python之面向对象的主要内容，如果未能解决你的问题，请参考以下文章