面相对象初始

一.初始面向对象

面向对象的程序的核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西.

优点是:极大的降低了写程序的复杂度,只需要顺着要执行的步骤,堆叠代码即可.

缺点是:一套流水线或者流程就是用来解决一个问题,代码牵一发而动全身.

应用场景:一旦完成基本很少改变的场景,著名的例子有Linux内核, git,以及Apach,HTTP,Server等.

面相对象的程序设计的核心是对象(上帝式思维),要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来.面相对象的程序设计好比如来来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的属性和方法),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保健护航,这些都是对象,然后取经开始,师徒四人与妖魔鬼怪神仙互相缠斗直到最后取得真经,如来根本不会管师徒四人按照什么流程去取.

面相对象的程序设计的

优点是:解决了程序的扩展性,岁某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易.

缺点:可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法预测最终结果,于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现,一刀砍死3个人,这个游戏就失去平衡.

应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方.

在python中面向对象的程序设计并不是全部.

面向对象编程可以使用程序的维护和扩展变得更简单,并且可以大大提高程序开发效率,另外,基于面向对象的程序可以使它人更加容易理解你的代码逻辑,从而使团队开发变得更从容.

了解一些名词:类,对象,实例,实例化

类:具有相同特征的一类事物(人,狗,老虎)

对象/实例:具体的某一个事物(隔壁啊花,楼下旺财)

实例化:类--->对象的过程(这在生活中变现的不明显,我们在后面再慢慢解释)

1.1类的相关知识

声明

'''
def functionName(args):
    "函数文档字符串"
    函数体
'''
'''
class 类名:
    "类的文档字符串"
    类体
'''


# 我们创建一个类
class Data:  # 类名首字母大写
    pass

属性

class Person:  # 定义一个人类
    role = "person"  # 人的角色属性都是人

    def walk(self):  # 人都可以走路,也就是说有一个走路方法
        print("person is walking.....")


print(Person.role)  # 查看人的role属性
print(Person.walk)  # 引用人的走路方法,注意,这里不是在调用

实例化:类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每一个实例定制自己的特征

class Person:  # 定义一个人类
    role = "person"  # 人的角色属性是人

    def __init__(self, name):
        self.name = name  # 每一个角色都有自己的昵称

    def walk(self):  # 人都可以走路,也就是有一个走路方法
        print("person is walking")


print(Person.role)  # 查看人的role 属性
print(Person.walk)  # 引用人的走路方法,注意,这里不是在调用

实例化的过程就是类------->对象的过程

原本我们只有一个Person类,在这个过程中,产生了一个egg对象,有自己具体的名字,攻击力,和生命值.

语法: 对象名 = 类名(参数)

　　self

self :在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字,但是正常人都不会这么做.

因为你瞎改别人就不认识

类属性的补充

一 :我们定义的类的属性到底存到哪里了?有两种方式查看
dir(类名):查出的是一个名字列表
类名.__dict__:查出的是一个字典,key为属性名,value为属性值


二 :特殊的类属性
类名.__name__     #类的名字(字符串)
类名.__doc__         #类的文档字符串
类名.__base__        #类的第一个父类(在讲继承时会讲)
类名.__bases__       #类所有父类构成的元祖(在讲继承时会讲)
类名.__dict__       #类的字典属性
类名.__module__     #类定义所在的模块
类名.__class__       #实例对应的类(仅新式类中)

1.2对象的相关知识

class 类名:
    def __init__(self, 参数1, 参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名1(self):
        pass

    def 方法名2(self):
        pass
对象名 = 类名(1,2) # 对象就是实例,代表一个具体的东西
                   # 类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法
                   # 括号里传参数,参数不需要传self,其他与init中的形参一一对象
                   # 结果返回一个对象
对象名.对象的属性1  #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名1()     # 调用类中的方法,直接用 对象名.属性名 即可

'''
练习一：在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张…

练习题
'''
class A:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex =sex
    def chop_wood(self):   # chop_wood   砍柴
        print("%s,%s,%s,上山去砍柴" %(self.name,self.age,self.sex))
    def drive(self):      # drive  驾驶
        print("%s,%s,%s,开车去东北" % (self.name, self.age, self.sex))
    def great_health_care(self):  # great_health_care  卫生保健系统
        print("%s,%s,%s,最爱大保健" % (self.name, self.age, self.sex))
p1 =A("小名",10,"男")
p1.chop_wood()
p1.drive()
p1.great_health_care()
p2 = A("老李",90,"男")
p2.chop_wood()
p2.drive()
p2.great_health_care()

1.3类名称空间与对象的名称空间

创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性

而类有两种属性:静态属性和动态属性

　　静态属性就是直接在类中定义的变量

　　动态属性就是定义在类中的方法

其中类的数据属性是共享给所有对象的

>>>id(egg.role)
4341594072
>>>id(Person.role)
4341594072

而类的动态属性是绑定到所有对象的

>>>egg.attack
<bound method Person.attack of <__main__.Person object at 0x101285860>>
>>>Person.attack
<function Person.attack at 0x10127abf8>

创建一个对象/实例就会创建一个对象/实例的名称空间,存放对象/实例的名字,称为对象/实例的属性

在obj.nama 会先从obj自己的名称空间找name,找不到则去类中找,类也找不到就去父类.....最后找不到就抛出异常

二.面向对象的三大特性:继承,多态,封装.

2.1继承

继承时一种创建新类的方式,在python中,新建的类可以继承一个或者多个父类,父类又可称为基类或超类,新建的类称为派生类或子类

python 中类的继承分为:单继承和多继承

class ParentClass1:  # 定义父类
    pass


class ParentClass2:  # 定义父类
    pass


class SubClass1(ParentClass1):  # 单继承,基类是ParentClass1 ,派生类是SubClass
    pass


class SubClass2(ParentClass1, ParentClass2):  # python 支持多继承,
用逗号分隔开多个继承的类
    pass

查看继承 

 SubClass1.__bases__ 
　　　　　　　#__base__只查看从左到右继承的第一个子类
　　　　　　　#__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

 提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见的方法(如__str__)的实现.

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

继承的重要性

==========================第一部分
例如

　　猫可以：爬树、吃、喝、拉、撒

　　狗可以：看门、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
#猫和狗有大量相同的内容
class 猫:
    def 爬树(self):
        print("爬树")

    def 吃(self):
        print("吃")

    def 喝(self):
        print("喝")

    def 拉(self):
        print("拉")

    def 撒(self):
        print("撒")


class 狗:
    def 看门(self):
        print("看门")

    def 吃(self):
        print("吃")

    def 喝(self):
        print("喝")

    def 拉(self):
        print("拉")

    def sa(self):
        print("撒")


==========================第二部分
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，
而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　   猫：爬树（猫继承动物的功能）

　　   狗：看门（狗继承动物的功能）

伪代码如下：
class 动物:
    def 吃(self):
        print("吃")

    def 喝(self):
        print("喝")

    def 拉(self):
        print("拉")

    def 撒(self):
        print("撒")


# 在类后面括号中写入另一个类名,表示当前类继承另一个类
class 猫(动物):
    def 爬树(self):
        print("爬树")


# 在类后面括号中写入另一个类名,表示当前类继承另一个类
class 狗(动物):
    def 看门(self):
        print("看门")

==========================第三部分

# 继承的代码实现
class Animal:  # 定义一个动物类
    def eat(self):
        print("%s吃" % self.name)

    def drink(self):
        print("%s喝" % self.name)

    def shit(self):
        print("%s拉" % self.name)

    def pee(self):
        print("%s撒" % self.name)


class Cat(Animal):  # 猫
    def __init__(self, name):
        self.name = name
        self.breed = "猫"

    def climb_tree(self):  # 爬树
        print("%s爬树" % self.name)


class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = "狗"

    def door(self):  # 门
        print("%s看门" % self.name)


# ######### 执行 #########
c1 = Cat("小白家的小黑猫")
c1.eat()
c2 = Cat("小黑的小白猫")
c2.drink()
d1 = Dog("胖子家的小瘦狗")
d1.eat()
# 使用继承来重用代码比较好的例子

那么问题又来了,多继承呢?

 　　是否可以继承多个类

　　如果继承的多个类每个类中都定了相同的函数,那么那一个会被使用呢?

1.python 的类可以继承多个类 ,Java 和C#中则只能继承一个类

2.python 的类如果继承了多个类,那么其寻找的方式有两种,分别是:深度优化和广度优先

 　　当类是经典类时,多继承情况下,会按照深度优先方式查找

　　当类是新式类时,多继承情况下,会按照广度优先方式查找

经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了更多的功能,也是之后推荐的写法,从写法上区分的话,如果 当前类或者父类继承了 object 类 ,那么该类便是新式类,否则便是经典类.

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")


a = A()
# 执行bar方法时
# 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中没有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错
# 所以,查找顺序:A-->B-->C-->D
a.bar()


新式类多继承

经典类:首先去A类中查找,如果A类中没有.则继续去B类中找,如果B类中么有,ze继续去D类中找,如果D类中没有,则继续去C类中找,如果还是未找到,则报错

新式类:首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中没有,则继续去C类中找,如果C类中没有,则继续去D类中找,如果还是未找到,则报错

抽象类与接口类

一 :继承基类的方法,并且做出自己的改变或者扩展(代码重用)

二 :声明某个子类兼容于某基类,定义一个接口Interface ,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能

接口类示例

# 一:这样不好,我们要统一一下支付的规则.
class QQpay:
    def pay(self, money):
        print("使用qq支付%s远" % money)


class Alipay:
    def pay(self, money):
        print("使用阿里支付%s元" % money)


a = Alipay()
a.pay(100)

b = QQpay()
b.pay(200)


# 二:统一支付的规则,归一化设计,统一  pay接口
class QQpay:
    def pay(self, money):
        print("使用qq支付%s元" % money)


class Alipay:
    def pay(self, money):
        print("使用阿里支付%s元" % money)


def pay(obj, moeny):
    obj.pay("money")


a = Alipay()
b = QQpay()

pay(a, 100)
pay(b, 200)


# 三,但是,来了一个野生程序员,他不知道你的约定俗称的规则,就会出问题
class QQpay:
    def pay(self, money):
        print("使用qq支付%s元" % money)


class Alipay:
    def pay(self, money):
        print("使用阿里云支付%s元" % money)


class Wechatpay:
    def fuqian(self, money):
        print("使用微信支付%s元" % money)


def pay(obj, money):
    obj.pay(money)


a = Alipay()
b = QQpay()

pay(a, 100)
pay(b, 200)

c = Wechatpay()
c.fuqian(300)


# 四 :解决方式
# 定义一个父类,什么都不写,只是要求继承我的所有类的一个pay方法,这样就制定了一个规范,这就叫做接口,后者抽象类.

class Payment:
    def pay(self): pass


class QQpay(Payment):
    def pay(self, money):
        print('使用qq支付%s元' % money)


class Alipay(Payment):
    def pay(self, money):
        print('使用阿里支付%s元' % money)


class Wechatpay(Payment):
    def fuqian(self, money):
        print('使用微信支付%s元' % money)


def pay(obj, money):
    obj.pay(money)


a = Alipay()
b = QQpay()

pay(a, 100)
pay(b, 200)

c = Wechatpay()
c.fuqian(300)

# 五,他还是不知道看你的这些都继承了一个类,所以你要定制一个规范,强制他执行
# 创建一个规范
from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):  # 抽象类  接口类 规范和约束 metaclass 指定的是一个元类
    @abstractmethod
    def pay(self):
        pass  # 抽象方法


class Alipay(Payment):
    def pay(self, money):
        print('使用支付宝支付了%s元' % money)


class QQpay(Payment):
    def pay(self, money):
        print('使用qq支付了%s元' % money)


class Wechatpay(Payment):
    # def pay(self,money):
    #     print('使用微信支付了%s元'%money)
    def recharge(self): pass


def pay(a, money):
    a.pay(money)


a = Alipay()
a.pay(100)
pay(a, 100)  # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q, 100)
w = Wechatpay()
pay(w, 100)  # 到用的时候才会报错

#抽象类和接口类做的事情:建立规范
#指定一个类的 metaclass是 ABCMeta
#那么这个类就变成了一个抽象类(接口类)
#这个类的主要功能就是建立一个规范

实践中,继承的第一种含义意义并不很大,甚至常常是有害的,因为它使得子类与基类出现强耦合.

继承的第二种含义非常重要,他又叫"接口继承"

接口继承实质上是要求"做出一个良好的抽象",这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象"-----这个程序设计上,叫做归一化

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合---就好象linux 的泛之文件概念一样,所有的东西都可以当文件处理,不必关心它是内存,磁盘,网络还是屏幕(当然,对底层设计者,当然也可以区分"字符设备"和"块设备",然后做出正针对性的设计:细致到什么程度,视需求而定).

依赖倒置原则:
高层模块不应该依赖底层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象,换言之,
要针对接口编程,而不是针对实现编程

在python中根本就没有一个叫做interface的关键字,上面的代码只是看起来像接口,其实并没有起到接口的作用,子类完全可以不用去实现接口,如果非要去模仿接口的概念,可以借助第三方模块:

http://pypi.python.org/pypi/zope.interface

twisted的twistedinternetinterface.py里使用zope.interface

 文档https://zopeinterface.readthedocs.io/en/latest/

设计模式：https://github.com/faif/python-patterns

接口提取了一群类共同的函数,可以把接口当做一个函数的集合.

然后让子类去实现接口中的函数

这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,
那么所有的这些类产生的对象在使用时,从用法上来说都一样

归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,
这极大地降低了使用者的使用难度.

比如:我们定义一个动物接口,接口里定义了有跑,吃,呼吸等接口函数,这样老鼠的类去实现了该接口,
松鼠的类也去实现了该接口,由二者恩别产生一只老鼠和一只松鼠送到你面前,
即便是你分别不到底那只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸.

再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,
奥迪汽车的类,大众汽车的类,我们都实现了汽车接口,这样就好办了,
大家只需要学会了这么开汽车,那么无论是本田,还是奥迪,
还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样

 抽象类

什么是抽象类

　　与Java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

为什么要有抽象类