python 类方法

Posted 2020-11-19 xiaobaiskill

一、类

　　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装饰的情况下，该方法是绑定类的

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

 

四、封装属性方法

　　4.1 看起来像属性的方法（是属性，但内部实现是方法）

class people(object):
    def __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight
    @property
    def bmi(self):
        return self.weight / (self.height ** 2)


me = people(‘jmz‘,1.75,68)
# 将方法封装成属性
print(me.bmi)    # 22.20408163265306
print(me.bmi())  # 报typeError 的错

　　4.2 属性可修改可删除（上面的方式无法改删），如何实现？

class good():
    def __init__(self,name,price):
        self.name = name
        self.__price = price # 双下线是类私有属性，只能类内部本身使用，外部无法访问
    @property
    def price(self):
        return self.__price
    @price.setter     # 改   属性.setter
    def price(self,price):

        is_int_price = str(price).strip().replace(‘.‘,‘‘)    # 转化成数字
        if not is_int_price.isdigit():
            raise TypeError(‘%s 不是数字类型‘%price)
        self.__price = price
    @price.deleter   # 删   属性.deleter
    def price(self):
        # del self.__price
        print(‘不让删啊老铁‘)

sy = good(‘山芋‘,‘1.3‘)
print(sy.price)
sy.price = 1.4
print(sy.price)
del sy.price

　　4.3 总结

 封装属性要点：
    1、修改@price.setter和删除 @price.deleter必须在@property的下面