首页 > 代码库 > 多态 ,绑定方法

多态 ,绑定方法

1\ 多态

一种事物,有多种形态,都可以调用同一种方法.

以列表,字符串,元组为例,都有长度,都可以调用 len() 函数,

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 Animal 就是对多态性的表现
@abc.abstractmethod
def talk(self):
pass

class People(Animal): #动物的形态之一:人
def talk(self):
print(‘say hello‘)
class Pig(Animal): #动物的形态之二:猪
def talk(self):
print(‘heng‘)
class Dog(Animal): #动物的形态之三:狗
def talk(self):
print(‘wang‘)
alex=People()
yuan=Pig()
wu=Dog()
# alex.talk()
# yuan.talk()
# wu.talk()
def talk(obj):
#obj 就是多态性的表现,obj可以是人,,,,是对有同一类事物的描述
obj.talk()
talk(alex) #Alex是通过父类继承出People子类里实例化出来的
talk(wu) #wu是通过父类继承出pig子类里实例化出来的
talk(yuan) #yuan是通过父类继承出Dog子类里实例化出来的
#三个对象是来自不同的子类,但都有来自父类的函数名调用了不同的功能

一个抽象类可以有多个子类,子类 之间都有相同属性,多态都依赖继承概念

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

不同的对象都用了一样的函数名,产生了不同的行为(方法)

一个 接口  (函数) ,多种功能实现

继承于一个父类产生的不同对象,用同一个函数名实现 不同的功能,多态

 

3\绑定方法

类中定义的函数分成两大类:

  一:绑定方法(绑定给谁,谁来调用就自动将它本身当作第一个参数传入):

    1. 绑定到类的方法:用classmethod装饰器装饰的方法。

                为类量身定制

                类.boud_method(),自动将类当作第一个参数传入

              (其实对象也可调用,但仍将类当作第一个参数传入)

    2. 绑定到对象的方法:没有被任何装饰器装饰的方法。

               为对象量身定制

               对象.boud_method(),自动将对象当作第一个参数传入

             (属于类的函数,类可以调用,但是必须按照函数的规则来,没有自动传值那么一说)

 1 class MySQL:
 2     def __init__(self,ip,port):
 3         self.ip=ip
 4         self.port=port
 5     @classmethod
 6     def from_conf(cls):
 7         import settings  #从文件里读取
 8         obj=cls(settings.ip,settings.port) #obj=MySQL(‘1.1.1.1‘,8080)
 9         obj.x=111111111111111111111111111111111
10         return obj
11 
12 m=MySQL(127.0.0.1,8080)
13 # print(m.ip,m.port)
14 
15 obj=MySQL.from_conf()
16 #
17 print(obj.ip)
18 print(obj.port)
19 print(obj.x)

 二:非绑定方法:用staticmethod装饰器装饰的方法

     1. 不与类或对象绑定,类和对象都可以调用,但是没有自动传值那么一说。就是一个普通工具而已

    注意:与绑定到对象方法区分开,在类中直接定义的函数,没有被任何装饰器装饰的,都是绑定到对象的方法,可不是普通函数,对象调用该方法会自动传值,而staticmethod装饰的方法,不管谁来调用,都没有自动传值一说

 1 #非绑定方法
 2 import hashlib
 3 import time
 4 import pickle
 5 class People:
 6     def __init__(self,name,sex,user_id):
 7         self.name=name
 8         self.sex=sex
 9         self.user_id=user_id
10         self.id = self.create_id()
11     def bar(self):
12         print(--->,self.name)
13 
14     def create_id(self):
15         m=hashlib.md5()
16         m.update(self.name.encode(utf-8))
17         m.update(self.sex.encode(utf-8))
18         m.update(str(self.user_id).encode(utf-8))
19         return m.hexdigest()
20 
21     def save(self):
22         with open(self.id,wb) as f:
23             pickle.dump(self,f)
24 
25 
26 f1=People(egon1,male,123123123123123)
27 # f2=People(‘egon2‘,‘female‘,123123123123123)
28 # f3=People(‘egon3‘,‘male‘,123123123123123)
29 
30 # print(f.create_id())
31 print(f1.id)
32 # print(f2.id)
33 # print(f3.id)
34 #
35 f1

 

多态 ,绑定方法