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

多态 ,绑定方法

2024-10-17 22:40:38   215人阅读

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

 

多态 ,绑定方法


联系
我们