python 类方法

一、类

　　1.1 类的定义

# 1.1.1 无参定义
class test(object):
    def __init__(self):
        pass
    def func(self):  # 类方法
        pass
# 1.1.2 有参定义
class foo(object):
    def __init__(self,name,age):
        self.name = name    # 类属性
        self.age = age

　　1.2 类的调用方式

obj = test()
# obj 此刻叫对象，是实例化test类后，产生的对象
print(obj)
# <__main__.test object at 0x00000000024C7EF0>
obj1 = foo('王大炮',23)   # 调用类时传参，等于调用了类中的__init__方法，调用该方法和调用函数一样，只是在调用是会传入self自身参数
print(obj1.age)  # 对象属性调用
# 23

　　1.3 对象方法调用

class student():   # 定义类
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def learn(self,object):          # 定义类方法，参数object， 课程
        print('%s 正在学习 %s 中'%(self.name,object))

wdp = student('王大炮',23)   #实例化产生对象，赋值给wdp，此时wdp 继承了类的方法和属性
print(wdp.__dict__)   #查看对象属性
# {'name': '王大炮', 'age': 23}
wdp.learn('英语')             # 调用 对象方法，调用时无需参数self 参数
# 王大炮 正在学习 英语 中

class student():   # 定义类
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def learn(self,object):          # 定义类方法，参数object， 课程
        print('%s 正在学习 %s 中'%(self.name,object))

ltg = student('李坦克',33)
# 类方式调用时是需要传入self参数的，对象不需要
student.learn(ltg,'历史')    # 此方式与 ltg.learn('历史') 结果一样。
# 李坦克 正在学习 历史 中

二、类的非绑定方法

　　1.1 类的非绑定方法使用

class foo(object):
    def __init__(self):
        pass
    @staticmethod      # 只需要在方法的上方加 一个 @staticmethod，同时去除 方法中的self 参数
    def func(content):
        print(content)
# 调用
obj = foo()
obj.func('我是对象非绑定方法')
# 我是对象非绑定方法
foo.func('我是类非绑定方法')
# 我是类非绑定方法

　　1.2 非绑定方法的注意点

　　非绑定方法和普通函数一样，不可直接调用自身的属性和方法。

# 非绑定方法的注意点
class teacher(object):
    addr = '上海'
    def __init__(self,name,course):
        self.name = name
        self.course= course
    @staticmethod      # 只需要在方法的上方加 一个 @staticmethod，同时去除 方法中的self 参数
    def func():
        print('这里是%s'%teacher.addr)   # 这里是上海
        print('这是一位%s老师'%self.course) # 报错，因为没有self参数

teacher_li = teacher('李XX','语文')
teacher_li.func()   # 这样会

　　1.3 总结

# 总结
    # 1、非绑定方法 类本省和对象都可以调用
    # 2、非绑定方法不可以直接调用类或对象本身的属性或方法

三、类绑定方法

 　　1.1 类绑定方法的使用

class foo():
    def __init__(self):
        pass
    @classmethod
    def get_instance(cls):  # cls == foo
        if not hasattr(cls,"instance"):
            cls.instance = cls()
        return cls.instance


# 单例模式 ， 只实例化一次
obj1 = foo.get_instance()
obj2 = foo.get_instance()
print(obj1,obj2)
# 两次实例化结果一样，说明只实例化一次

# --------上下对比--------
obj_x = foo()
obj_y = foo()
print(obj_x,obj_y)
# 两个实例化结果不一样

　　1.2 总结

# 特点：    绑定给谁就由谁来调用，谁来调用就会将谁当做第一个参数传入

#绑定到对象的方法：       在类中定义的函数，在没有被任何装饰器装饰的情况下，默认都是绑定给对象的

#绑定到类的方法        在类中定义的函数，在被装饰器classmethod装饰的情况下，该方法是绑定类的

#注意：
    类的绑定方法，对象一样可以正常使用

四、对象的绑定方法

　　类在实例化后，内部的方法被称为对象的绑定方法

注意：
    @classmethod  既可以称为类的绑定方法也可以称为对象的绑定方法