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
'''

  

上一篇:Alpha冲刺(五)


下一篇:web系统登陆页面增加验证码