多态 ,绑定方法

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(),自动将对象当作第一个参数传入

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

class MySQL:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port
    @classmethod
    def from_conf(cls):
        import settings  #从文件里读取
        obj=cls(settings.ip,settings.port) #obj=MySQL('1.1.1.1',8080)
        obj.x=111111111111111111111111111111111
        return obj

m=MySQL('127.0.0.1',8080)
# print(m.ip,m.port)

obj=MySQL.from_conf()
#
print(obj.ip)
print(obj.port)
print(obj.x)

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

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

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

#非绑定方法
import hashlib
import time
import pickle
class People:
    def __init__(self,name,sex,user_id):
        self.name=name
        self.sex=sex
        self.user_id=user_id
        self.id = self.create_id()
    def bar(self):
        print('--->',self.name)

    def create_id(self):
        m=hashlib.md5()
        m.update(self.name.encode('utf-8'))
        m.update(self.sex.encode('utf-8'))
        m.update(str(self.user_id).encode('utf-8'))
        return m.hexdigest()

    def save(self):
        with open(self.id,'wb') as f:
            pickle.dump(self,f)


f1=People('egon1','male',123123123123123)
# f2=People('egon2','female',123123123123123)
# f3=People('egon3','male',123123123123123)

# print(f.create_id())
print(f1.id)
# print(f2.id)
# print(f3.id)
#
f1