面向对象绑定方法与非绑定方法及使用

标签（空格分隔）： 绑定方法与非绑定方法

---

在类的内部定义的函数，分类为两个大类：
一、绑定方法:绑定给谁，就应该有谁来调用，谁来调用就会把调用者当作第一个参数自动传入
    1.绑定到对象的方法：
        在类内部定义的，没有被装饰器修饰的
    例如：
    ``` python
    class Foo:
        def __init__(self,name):
            self.name=name
        def tell(self):  #第一个参数是对象                                 print('mingzi%s'%self.name)
    f = Foo('egon')
    print(Foo.tell())
    ```
    2.绑定到类的方法：在类内定义的装饰器classmateod修饰的方法；
    ``` python
        在类的内部定义的函数，分类为两个大类：
        一、绑定方法:绑定给谁，就应该有谁来调用，谁来调用就会把调用             者当作第一个参数自动传入
            1.绑定到对象的方法：
            在类内部定义的，没有被装饰器修饰的
            例如：
    ``` python
    class Foo:
        def __init__(self,name):
            self.name=name
        def tell(self):  #第一个参数是对象                 print('mingzi%s'%self.name)
        @classmethod
        def func(cls):#类方法，就是把类当做第一个参数
            print(cls)
    f = Foo('egon')
    print(Foo.tell())
    print(Foo.func)
    ```
    执行（print(Foo.func)）的结果：
    ![image.png-189.6kB][1]

            绑定类的方法，就是应该有类来调用：
                ![image.png-246.8kB][2]
                
    
    
二、非绑定方法：
        没有自动传值这么一说，
    非绑定方法：不与类或者对象绑定,(谁都可以用，就普通一个函数)
 ``` python
    class Foo:
        def __init__(self,name):
            self.name=name
        def tell(self):  #第一个参数是对象                 print('mingzi%s'%self.name)
        @classmethod
        def func(cls):#类方法，就是把类当做第一个参数
            print(cls)
        @staticmethod
        def func1(x,y):
            return x+y
            
    f = Foo('egon')
    print(Foo.tell())
    print(Foo.func)

![image.png-240.6kB][3]

tell(self):这是对象的方法；
@classmethod
func(cls)：这是类的方法
@staticmethod
def func1(x,y):这是非绑定方法

总结：在类内部，定义的方法分为：2大类:
1.绑定方法：
在类内部，什么都不加的直接：tell(self):这是绑定对象的方法，这种方法，只有对象可以调用
在类内部：@classmethod，这就是类绑定的方法，这种方法，只有类可以调用
2.非绑定的方法：
在类内部：@staticmethod这种方法，类和对象都可以调用，其实这个方法就是一个普通的方法，只是方法上边加了：@staticmethod，这种就是类里面的非绑定方法，类和对象都可以用；

绑定与非绑定的使用：

目的：

1.主要学习，什么情况下用绑定，什么用非绑定；

例子

clall People:
    def __init__(self,name,age,sex):
        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)  )
p= People('egon',18,'male')

总结上述：

• 绑定给对象，就应该有对象来调用，自动将对象本身当做第一个参数传入

需求2：
如果我们现在建立一个配置文件：settings.py，需求要求你在实例化的时候从配置文件里面读取配置来实例化；

例如setting.py

name='wang'
age=18
sex='female'

然后开始程序编写;

import settings
settings.name
class People:
    def __init__(self,name,age,sex):
        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))
    @classmathod
    def from_conf(cls):#从配置文件读取，然后读配置
        obj=cls(
            settings.name,
            settings.age,
            settings.sex
        )
        return obj

• 绑定给类，就应该由类来调用自动将对象本身当做参数传入：
  p=People.from_conf()
  p.tell_info()

以上就是通过配置文件，实例化；

例如;
上边每个人加个新的身份证号，就是说每个人有一个新的ID号，

例如代码如下：

import settings
import hashlib
import time

settings.name
class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        self.id=
    def tell_info(self):
        print('Name :%s Age:%s Sex:%s'                 %(self.name,self.age,self.sex))
    @classmathod
    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()

• 总结：
  以上：reate_id()这个方法，不依赖于类，也不依赖与对象，就是非绑定方法，就是谁都可以调用，他就是一个普通的方法;

• 以上就是绑定类，绑定对象，非绑定方法的在各自的场景的调用；