python 面向对象之多态与绑定方法

多态与多态性

一，多态

1，多态指的是一类事物有多种形态（python里面原生多态）

1.1动物有多种形态：人，狗，猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass
 
class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')
 
class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')
 
class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

1.2 文件有多种形态：文本文件，可执行文件

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass
 
class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')
 
class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

　　

二，多态性

1，什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）

1.1 多态性是指在不考虑实例类型的情况下使用实例

　　在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息（！！！obj.func():是调用了
obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。
也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现。

　　比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

1.2 多态性分为静态多态性和动态多态性

　　静态多态性：如任何类型都可以用运算符+进行运算

　　动态多态性：如下

peo=People()
dog=Dog()
pig=Pig()
 
#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()
 
#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

　　

2，为什么要用多态性（多态性的好处）

　　其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么呢？

1.增加了程序的灵活性

　　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)

2.增加了程序额可扩展性

　　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 　　

>>> class Cat(Animal): #属于动物的另外一种形态：猫
...     def talk(self):
...         print('say miao')
...
>>> def func(animal): #对于使用者来说，自己的代码根本无需改动
...     animal.talk()
...
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao
 
'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。
使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

　　

三，鸭子类型

逗比时刻：

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

　　python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

　　也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

　　例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass
 
    def write(self):
        pass
 
class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

　　例2：其实大家一直在享受着多态性带来的好处，比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))
 
#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()
 
len(s)
len(l)
len(t)

　　

绑定方法与非绑定方法

一：类中定义的函数分为两大类

1：绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：

　　绑定方法分为绑定到类的方法和绑定到对象的方法，具体如下：

1. 绑定到类的方法：用classmethod装饰器装饰的方法。
                为类量身定制
                类.boud_method(),自动将类当作第一个参数传入
              （其实对象也可调用，但仍将类当作第一个参数传入）
 
2. 绑定到对象的方法：没有被任何装饰器装饰的方法。
               为对象量身定制
               对象.boud_method(),自动将对象当作第一个参数传入
             （属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）

　　

2：非绑定方法：用staticmethod装饰器装饰的方法

1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已
　　　　注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器
    装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而
    staticmethod装饰的方法，不管谁来调用，都没有自动传值一说

　　

3：对于绑定方法和非绑定方法举个例子

在类内部定义的函数,分为两大类:
    一：绑定对象：绑定给谁就由谁来调用，谁来调用就会把调用者当作第一个参数自动传入
        绑定到对象的方法：在类内定义的没有被任何装饰器修饰的
class Foo():
    def __init__(self,name):
        self.name = name
 
    def tell(self):
        print('名字是%s'%self.name)
 
f = Foo('james')
print(f.tell)
# <bound method Foo.tell of <__main__.Foo object at 0x0000021B7AB3C9E8>>
        绑定到类的方法:在类内定义的被装饰器classmethod修饰的方法
# def 定义的两个都是绑定到对象的方法
class Foo():
    def __init__(self,name):
        self.name = name
    @classmethod
    def func(cls):  #cls = Foo
        print(cls)
print(Foo.func)
# <bound method Foo.func of <class '__main__.Foo'>>
 
    二：非绑定方法：没有自动传值这一说法，简单说就是一个普通方法
        非绑定方法：不与类或者对象绑定，谁都可以调用
class Foo():
    def __init__(self,name):
        self.name = name
    @classmethod
    def func(cls):  #cls = Foo
        print(cls)
 
    @staticmethod
    def func1(x,y):
        print(x+y)
 
print(Foo.func1)
# <function Foo.func1 at 0x0000023D73765840>

　　

二：绑定方法

绑定给对象的方法（略）

绑定给类的方法（classmethod）

　　classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向对象编程\test1\db'

　　

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
 
    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)
 
print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()
 
conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

　　

三：非绑定方法

　　在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数

　　statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果

import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一个普通工具
        m=hashlib.md5(str(time.time()).encode('utf-8'))
        return m.hexdigest()
 
print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8>
 #查看结果为普通函数
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8>
 #查看结果为普通函数

　　

四：绑定方法与非绑定方法的使用举例

import settings
import hashlib
import time
class People:
    def __init__(self,name,age,sex):
        self.id =self.create_id()
        self.name = name
        self.age = age
        self.sex = sex
    def tell_info(self):  #绑定到对象啊
        print("name:%s Age:%s Sex:%s"%(self.name,self.age,self.sex))
    @classmethod
    def from_conf(cls):
        obj = cls(
            settings.name,
            settings.age,
            settings.sex
        )
        return obj
    @staticmethod
    def create_id():
        m = hashlib.md5(str(time.time()).encode('utf-8'))
        return m.hexdigest()
p = People('tom',18,'male')
#绑定到对象，就应该由对象来调用,自动将对象本身当作第一个参数传入
# p.tell_info()  #tell_info(p)
#绑定给类，就应该由类来调用，自动将类本身当作第一个参数传入
# p1 = People.from_conf() #from_conf(People)
# p1.tell_info()
#非绑定方法，不与类或者对象绑定，谁都可以调用，没有自动传值这一说
p1 = People('tom1',18,'male')
p2 = People('tom2',18,'male')
p3 = People('tom3',18,'male')
print(p1.id)
print(p2.id)
print(p3.id)
# 08885a46a83b92f94c0f4de537fce9c3
# 08885a46a83b92f94c0f4de537fce9c3
# 2b2df79b379a5f7f709ead6268eb3361

　　

五：classmethod 与 staticmethod的区别

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
 
    @staticmethod
    def from_conf():
        return MySQL(settings.HOST,settings.PORT)
 
    # @classmethod #哪个类来调用,就将哪个类当做第一个参数传入
    # def from_conf(cls):
    #     return cls(settings.HOST,settings.PORT)
 
    def __str__(self):
        return '就不告诉你'
 
class Mariadb(MySQL):
    def __str__(self):
        return '<%s:%s>' %(self.host,self.port)
 
m=Mariadb.from_conf()
print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：
 
mariadb是mysql

　　

5.1，类方法，静态方法的定义

Python 是双面向的,既可以面向函数编程,也可以面向对象编程,所谓面向函数就是单独一个. py 文件,里面没有类,全是一些函数,调用的时候导入模块,通过模块名.函数名()即可调用,完全不需要类,那么你可能会问,那要类还有什么毛用? 类就是用来面向对象编程啦,类可以有自己的属性,类可以创建很多实例,每个实例可以有不同的属性,这也就保存了很多私有的数据,总之都有存在的必要.

面向对象程序设计中，类方法和静态方法是经常用到的术语，逻辑上将：类方法只能由类名调用，静态方法可以由类名或者对象名调用。在python 语法中，类有三种方法，分别是实例方法，静态方法，类方法

class Foo(object):
    '''类三种方法语法形式'''
    
    #在类中定义普通方法，在定义普通方法的时候，必须添加self  
    def instance_method(self):
        print("是类{}的实例方法，只能被实例对象调用".format(Foo))

　　#在类中定义静态方法，在定义静态方法的时候，不需要传递任何类的东西 
    @staticmethod
    def static_method():
        print("是静态方法")

　　#在类中定义类方法，在定义类方法的时候，需要传递参数cls  cls即为类本身
    @classmethod
    def class_method(cls):
        print("是类方法")
 
foo = Foo()
foo.instance_method()
foo.class_method()
foo.static_method()
print("---------------")
Foo.static_method()
Foo.class_method()

　　可以看出：

       实例方法只能被实例对象调用，静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用。
   实例方法，第一个参数必须要默认传实例对象，一般习惯用self。对象方法中有self参数，类方法有cls参数，静态方法是不需要这些附加参数（在c++中，是没有类这个概念）

静态函数（@staticmethod）:即静态方法，静态方法是一类特殊的方法，有时候你可能需要填写一个属于这个类的方法，但是这些代码完全不会使用到实例对象本身。它主要处理这个类的逻辑关联，如验证数据；而且对参数没有要求。

类方法（@classmethod）：即类方法，类方法不是绑定到对象上，而是绑定在类上的方法，它更关注于从类中调用方法，而不是从实例中调用方法，如构造重载；

成员函数：实例的方法，只能通过实例进行调用；第一个参数必须要默认传类，一般习惯用cls。

5.2，类方法与静态方法说明

　　1：self表示为类型为类的object，而cls表示为类也就是class

　　2：在定义普通方法的时候，需要的是参数self,也就是把类的实例作为参数传递给方法，如果不写self的时候，会发现报错TypeError错误，表示传递的参数多了，其实也就是调用方法的时候，将实例作为参数传递了，在使用普通方法的时候，使用的是实例来调用方法，不能使用类来调用方法，没有实例，那么方法将无法调用。

　　3：在定义静态方法的时候，和模块中的方法没有什么不同，最大的不同就是在于静态方法在类的命名空间之间，而且在声明静态方法的时候，使用的标记为@staticmethod，表示为静态方法，在叼你用静态方法的时候，可以使用类名或者是实例名来进行调用，一般使用类名来调用

　　4：静态方法主要是用来放一些方法的，方法的逻辑属于类，但是有何类本身没有什么交互，从而形成了静态方法，主要是让静态方法放在此类的名称空间之内，从而能够更加有组织性。

　　5：在定义类方法的时候，传递的参数为cls.表示为类，此写法也可以变，但是一般写为cls。类的方法调用可以使用类，也可以使用实例，一般情况使用的是类。

　　6：在重载调用父类方法的时候，最好是使用super来进行调用父类的方法。静态方法主要用来存放逻辑性的代码，基本在静态方法中，不会涉及到类的方法和类的参数。类方法是在传递参数的时候，传递的是类的参数，参数是必须在cls中进行隐身穿

　　7：python中实现静态方法和类方法都是依赖python的修饰器来实现的。静态方法是staticmethod，类方法是classmethod。

5.3，静态方法，类方法的使用区别

1：类方法用在模拟java定义多个构造函数的情况

由于python类中只能有一个初始化方法，不能按照不同的情况初始化类，举例如下：

class book(object):
 
    def __init__(self,title):
        self.title = title
 
    @classmethod
    def creat(cls,title):
        book = cls(title=title)
        return book
 
book1=book("python")
book2 = book.creat("python is my work")
print(book1)
print(book2)
print(book1.title)
print(book2.title)

　2：类中静态方法方法调用静态方法的情况

下面的代码，静态方法调用另一个静态方法，如果改用类方法调用静态方法，可以让cls代替类，（让代码看起来精简一些，也防止类名修改了，不用在类定义中修改原来的类名）

class foo(object):
    x =1
    u =1
 
    @staticmethod
    def average(*mixes):
        return sum(mixes)/len(mixes)
 
    @staticmethod
    def static_method():
        return foo.average(foo.x,foo.u)
 
    @classmethod
    def class_method(cls):
        return cls.average(cls.x,cls.u)
 
a = foo()
print(a.static_method())
print(a.class_method())

　　

六：练习

定义MySQL类

　　1.对象有id、host、port三个属性

　　2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一

　　3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化

　　4.为对象定制方法，save和get_obj_by_id，save能自动将对象序列化到文件中，文件路径为配置文件中DB_PATH,文件名为id号，保存之前验证对象是否已经存在，若存在则抛出异常，;get_obj_by_id方法用来从文件中反序列化出对象

小提示：创建唯一id之UUID

原文链接：http://www.cnblogs.com/dkblog/archive/2011/10/10/2205200.html
 Python官方Doc：《20.15. uuid — UUID objects according to RFC 4122》
    UUID的算法介绍：《A Universally Unique IDentifier (UUID) URN Namespace》
 
概述：
 
    UUID是128位的全局唯一标识符，通常由32字节的字符串表示。
    它可以保证时间和空间的唯一性，也称为GUID，全称为：
            UUID —— Universally Unique IDentifier      Python 中叫 UUID
            GUID —— Globally Unique IDentifier          C#  中叫 GUID
 
    它通过MAC地址、时间戳、命名空间、随机数、伪随机数来保证生成ID的唯一性。
    UUID主要有五个算法，也就是五种方法来实现：
 
       1、uuid1()——基于时间戳
 
               由MAC地址、当前时间戳、随机数生成。可以保证全球范围内的唯一性，
               但MAC的使用同时带来安全性问题，局域网中可以使用IP来代替MAC。
 
       2、uuid2()——基于分布式计算环境DCE（Python中没有这个函数）
 
                算法与uuid1相同，不同的是把时间戳的前4位置换为POSIX的UID。
                实际中很少用到该方法。
 
      3、uuid3()——基于名字的MD5散列值
 
                通过计算名字和命名空间的MD5散列值得到，保证了同一命名空间中不同名字的唯一性，
                和不同命名空间的唯一性，但同一命名空间的同一名字生成相同的uuid。    
 
       4、uuid4()——基于随机数
 
                由伪随机数得到，有一定的重复概率，该概率可以计算出来。
 
       5、uuid5()——基于名字的SHA-1散列值
 
                算法与uuid3相同，不同的是使用 Secure Hash Algorithm 1 算法
 
使用方面：
 
    首先，Python中没有基于DCE的，所以uuid2可以忽略；
    其次，uuid4存在概率性重复，由无映射性，最好不用；
    再次，若在Global的分布式计算环境下，最好用uuid1；
    最后，若有名字的唯一性要求，最好用uuid3或uuid5。
 
编码方法：
 
    # -*- coding: utf-8 -*-
 
    import uuid
 
    name = "test_name"
    namespace = "test_namespace"
 
    print uuid.uuid1()  # 带参的方法参见Python Doc
    print uuid.uuid3(namespace, name)
    print uuid.uuid4()
    print uuid.uuid5(namespace, name)

　　

代码：

#settings.py内容
'''
HOST='127.0.0.1'
PORT=3306
DB_PATH=r'E:\CMS\aaa\db'
'''
import settings
import uuid
import pickle
import os
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
 
    def save(self):
        if not self.is_exists:
            raise PermissionError('对象已存在')
        file_path=r'%s%s%s' %(settings.DB_PATH,os.sep,self.id)
        pickle.dump(self,open(file_path,'wb'))
 
    @property
    def is_exists(self):
        tag=True
        files=os.listdir(settings.DB_PATH)
        for file in files:
            file_abspath=r'%s%s%s' %(settings.DB_PATH,os.sep,file)
            obj=pickle.load(open(file_abspath,'rb'))
            if self.host == obj.host and self.port == obj.port:
                tag=False
                break
        return tag
    @staticmethod
    def get_obj_by_id(id):
        file_abspath = r'%s%s%s' % (settings.DB_PATH, os.sep, id)
        return pickle.load(open(file_abspath,'rb'))
 
    @staticmethod
    def create_id():
        return str(uuid.uuid1())
 
    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)
 
# print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()
conn.save()
 
conn1=MySQL('127.0.0.1',3306)
conn1.save() #抛出异常PermissionError: 对象已存在
 
obj=MySQL.get_obj_by_id('7e6c5ec0-7e9f-11e7-9acc-408d5c2f84ca')
print(obj.host)

　　

其他练习

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去产生实例,该实例用的是当前时间
        t=time.localtime() #获取结构化的时间格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)
 
a=Date('1987',11,27) #自己定义时间
b=Date.now() #采用当前时间
c=Date.tomorrow() #采用明天的时间
 
print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)
 
#分割线==============================
import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)
 
class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)
 
e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
'''
输出结果:
<__main__.Date object at 0x1013f9d68>
'''
因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethod
 
import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)
 
    @classmethod #改成类方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化
 
class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)
 
e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
'''
输出结果:
year:2017 month:3 day:3
'''