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()
可以看出:
实例方法,第一个参数必须要默认传实例对象,一般习惯用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 '''