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

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

四、封装属性方法

  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的下面
  

猜你喜欢

转载自www.cnblogs.com/xiaobaiskill/p/9213764.html