绑定方法与非绑定方法

绑定方法与非绑定方法

一、绑定方法与非绑定方法介绍

注意!!: 绑定方法与非绑定方法存在的意义就是修改类中函数的一种归属, 让类中函数发挥最大的作用.

• 类中定义的函数分为两大类：绑定方法和非绑定方法

• 绑定方法: 其中绑定方法又可以分为绑定到对象的方法和绑定到类的方法

• 非绑定方法: 该方法不与类或对象绑定

二、绑定方法： 特殊之处在于将调用者本身当做第一个参数自动传入

1.对象的绑定方法

• 在类中没有被任何装饰器修饰的方法就是绑定给对象的方法, 这类方法专门为对象定制的

class Penson:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def username(self):
        print(self.name)
    def userage(self):
        print(self.age)
man=Penson("淘小欣",22)
man.username()  #淘小欣
print(Penson.__dict__["username"])  #<function Penson.username at 0x000002BD8013DDC0>

通过__dict__查看类的属性字典, 我们可以发现 username 即为绑定到对象的方法, 这个方法不在对象的名称空间中, 而是在类的名称空间中

对象调用绑定给对象的方法, 这里会有一个自动传值的过程, 即自动将当前对象传递给方法的第一个参数, 也就是 “self” (约定俗成的叫self, 也可以叫别的)

若是类调用, 就是普通函数，有几个值就传几个值，第一个参数需要手动传值

#先实例出一个对象
P1 = Penson('淘小欣',22)

#对象调用绑定给对象的方法
P1.username()       # 淘小欣

#类调用绑定给对象的方法
Penson.username(P1) # 淘小欣

2.类的绑定方法

• 在类中使用 @classmethod 修饰的方法就是绑定给类使用的方法, 这类方法专门为类定制的
• 通过类名调用绑定给类的方法的时候, 会将类本身当做参数传给类方法的第一个参数 “cls”(和self 类似,也可以叫别的名字)

class Computer:
    name="赵总的发家之路"
    age=23
    money=9999999
    @classmethod# 类装饰器classmethod, 将下面的函数装饰成绑定给类的方法
    def user_info(cls):
        print(cls)
        print(cls.__name__)
        print(cls.name,cls.age,cls.money)
Computer.user_info()  # 类调用
'''
<class '__main__.Computer'>
Computer
赵总的发家之路 23 9999999
'''

注意 : 对象调用绑定给类的方法, 传入的还是这个对象对应的类

Computer().user_info()  # 对象调用 (输出结果还是一样)
'''
<class '__main__.Computer'>
Computer
赵总的发家之路 23 9999999
'''

3.类的绑定方法应用实例

将文件里面的信息取出来实例成对象, 这个对象信息是已经存在的, 而不是新建的对象

• 先模拟一个文件,存入信息

import pickle
with open("Pikachu.json","wb")as f:
    pickle.dump({"varieties":"皮苛求","size":88,"colour":"yellow"},f)

• 再把信息拿出来, 通过类的绑定方法创建这个已有信息对象

import pickle
class PiKaQiu:
    def __init__(self,breed,sizes,colors):
        self.breed=breed
        self.size=sizes
        self.color=colors

    @classmethod
    def from_file(cls):
        return cls(Breed, Size, Color)

# 从文件里面拿出信息
with open("Pikachu.json","rb")as f1:
    pkq_info=pickle.load(f1)

# 赋值给这些变量
Breed = pkq_info["varieties"]
Size = pkq_info["size"]
Color = pkq_info["colour"]

info=PiKaQiu.from_file()
print(info) #<__main__.PiKaQiu object at 0x00000264DD5CA3A0>
print(info.breed)   #皮苛求
print(info.size)    #88
print(info.color)   #yellow

三、非绑定方法/静态方法

• 在类的内部使用 @staticmethod 修饰的方法即为非绑定方法, 这类方法和普通的函数没有什么区别, 不与类或对象绑定，
• 类、对象谁都可以来调用, 且没有自动传值的效果, 有几个参数就传几个参数
• 注意：定义在类内部可以方便管理

"""
当前执行文件下创建settings.py, 放入一下代码: 
IP = '127.0.0.1'
PORT = 8080
"""
import settings
class MySql:
    def __init__(self, ip, port):
        self.uuid = self.create_id()
        self.ip = ip
        self.port = port

    @staticmethod  # 将下述函数装饰成一个静态方法
    def create_id():
        import uuid
        return uuid.uuid4()

    @classmethod
    def f1(cls):
        pass

    def f2(self):
        pass


obj1 = MySql('1.1.1.1', 3306)

print(obj1.create_id)  # 被静态方法装饰对象就是类中一个普通的函数. <function MySql.create_id at 0x000002037B9CCDC0>

# 对象的绑定方法, 类的绑定方法与之对比
print(obj1.f2)  # <bound method MySql.f2 of <__main__.MySql object at 0x000002C07E59FC10>>
print(obj1.f1)  # <bound method MySql.f1 of <class '__main__.MySql'>>

# 静态方法对象或者类调用都是一个普通的函数没有自动传参的效果
print(obj1.create_id())
print(MySql.create_id())

应用实例

import hashlib


class User:
    def __init__(self, name):
        self.name = name

    @staticmethod
    def passwd_encrypt(salt, passwd):
        mima = hashlib.md5(salt.encode("utf-8"))
        mima.update(passwd.encode("utf-8"))
        return mima.hexdigest()

# 类调用
ciphertext = User.passwd_encrypt("haha", '123')
# 01ddae4032e17a1c338baac9c4322b30
print(User.passwd_encrypt)
# <function User.passwd_encrypt at 0x000001442FF1EEE8> 可以发现就是个普通函数

# 对象调用
P1 = User("珊迪")
ciphertext2 = P1.passwd_encrypt("haha", '123')
# 01ddae4032e17a1c338baac9c4322b30
print(P1.passwd_encrypt)
# <function User.passwd_encrypt at 0x000001442FF1EEE8> 可以发现就是个普通函数

四、小结

1.绑定方法小结

• 如果函数体代码需要用外部传入的类，则应该将该函数定义成绑定给类的方法
• 如果函数体代码需要用外部传入的对象，则应该将该函数定义成绑定给对象的方法

2.非绑定方法小结

• 如果函数体代码既不需要外部传入的类也不需要外部传入的对象，则应该将该函数定义成非绑定方法/普通函数