类的函数调用和对象的绑定方法

• 在类内部定义的函数,分为2大类:
  1,绑定方法: 绑定给谁,就应该由谁调用,谁来调用就把调用者当作第一个参数自动传入
  绑定到对象的方法: 在类内部定义的没有被任何装饰器修饰的,对象自动传值
  绑定到类的方法: 在类内部定义的被装饰器classmethod修饰的方法

  2,非绑定方法: 没有自动传值这么一说,就是一个普通函数,对象和类都可以使用
  非绑定方法: 不与类或者对象绑定

面向对象中的@classonlymethod 与 @classmethod的区别

如果要使用classonlymethod ,则需要先定义好一个classonlymethod 类。
首先我们需要明白无论是classonlymethod还是classmethod，本质都是一个类，而classonlymethod继承了classmethod。

classonlymethodz作用:只能被类调用，不能被实例对象调用。

class classonlymethod(classmethod):  # 继承classmethod
    def __get__(self, instance, cls=None): # 
        if instance is not None:
            raise AttributeError("This method is available only on the class, not on instances.")
        return super(classonlymethod, self).__get__(instance, cls)

from django.utils.decorators import classonlymethod

class Foo:
    def __init__(self, name, a = None):
        self.name = name

    def tell(self):    # 绑定到对象
        print('名字是%s'%self.name)
        return self.name

    @classonlymethod # classmethod可以被一个实例调用, 但是classonlymethod不能,它只能被类调用.
    def tell2(cls, page=None):    # 绑定到对象
        print('@classonlymethod名字是%s' %cls.tell)
        if page is not None:
            print(page,'page你好啊')

    @classmethod   # 绑定到类
    def func(cls):
        print(cls,'这是classmethod')

    @staticmethod    # 非绑定方法,静态方法
    def func1(x,y):
        print(x+y)


f = Foo('egon')
# print(f,'对象f')
# print(Foo.tell,'类方法tell')
# print(Foo.tell(f),'类方法tell()运行')
# Foo.tell(f)
# print(f.tell,'对象方法tell')
# def func3():print('这是函数func3')
# print(Foo.func,'函数func')

Foo.func()

# print('----------------------')
Foo.tell2()
Foo.tell2(123)
# print('----------------------')
# # f.tell2()
Foo.as_view(actions='get')
# f.func3()
# print(Foo.func1)
# print(f.func1)

Foo.func1(1,2)
f.func1(1,3)
输出:
<class '__main__.Foo'> 这是classmethod
@classonlymethod名字是<function Foo.tell at 0x000000000A0021E0>
@classonlymethod名字是<function Foo.tell at 0x000000000A0021E0>
123 page你好啊
3
4

#_*_ encoding: utf-8 _*_   @author: ty  hery   2019/8/21

from types import FunctionType

class Foo(object):
    def func(self,name):
        print(name)

obj = Foo()
obj.func('alex')  # 对象调用方法直接调用(self是 对象自己,name是'alex'  打印出 alex
print('---------------------------')
Foo.func('obj1','egon')      # 类调用方法类名调用(自己传入作为对象的名称,name是'alex'  打印出 egon
print('======================')
print(obj.func)  # <bound method Foo.func of <__main__.Foo object at 0x00000000023C0B38>>  绑定方法
print(Foo.func) # <function Foo.func at 0x00000000023AA950>  函数