python面向对象高级编程_Python 面向对象高级编程

面向对象高级编程春花不红不如草，少年不美不如老。

限制实例的属性 slot使用__slots__这样不允许私自增加属性

class Student(obj):

__slot__ = ('name','age') #使用元祖定义允许绑定的属性名称

然后测试一下

s = Student()

s.name = 'Mike'

s.age = 18

s.score = 25

# 这样直接报错

由于 ‘score’ 没有放到slot中,所以不能绑定 score 属性,所以报错误

要注意的是 __slot__定义的属性仅仅对当前类的实例起作用,对继承的子类是不起作用的

比如

class GraduateStudent():

pass

g = GraduateStudent()

g.score = 9999

@property 装饰器负责把方法当成限制属性调用的@property 属性

class Student(obj):

@property

def score(self):

return self._score

@score.setter

def score(self,value):

if not isinstance(value,int):

raise ValueError('score must be an integer!')

if value<0 or value>100:

raise ValueError('score must be between 0 to 100 !')

self._score = value

@property 的实现比较复杂,它是把一个 getter 方法变成属性,只需要加上@property 就可以了

@property 本身又创建了另外一个装饰器@score.setter 负责把一个 setter 方法变成属性在赋值.于是我们就拥有了一个可控的操作

s = Student()

s.score = 60 # OK 实际转化为s.set_score(60)

s.score # OK 实际转化为s.get_score()

# 结果 60

s.score = 999

# 这样就报错误

@property 还可以定义只读属性,只定义 getter 方法,不定义 setter 方法就是个只读属性

class Student(obj):

@property

def birth(self):

return self._birthday

@birth.setter

def birth(self,value):

self._birth = value

@property

def age(self):

return 2015 - self._birth

上面的 birth 就是可读写的 下面的 age 只能是可读的属性

@property 广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查

多重继承有的时候我们需要一个类继承好多个基类,用法类似

class Man():

pass

class Woman():

pass

class Person(Man,Woman):

pass

通过多重继承一个子类就可以同时获取多个父类的所有功能

定制类__str__ 返回一个用户看的懂的字符串,它必须和 print 结合使用

我们先定义了一个 Student 类,打印实例

class Student():

def __init__(self,value):

self.name = name

def __str__(self):

return 'Student object(name:%s' %self.name)

print(Student('Mike'))

__call__ 一个对象实例可以又自己的属性和方法,当我们调用实例方法后,我们用 instance.method()来调用,自己掉自己

class Student():

def __init__(self,name):

self.name = name

def __call__(self):

print('My name is $s' % self.name)

# 调用方式

# s = Student('Mike')

# s() # self参数不要传入

# My name is Mike

调用了 call 方法你完全可以把类当作一个方法,自己调自己

@classmethod 和@staticmethod 区别看代码

class test:

class_name = "test"

def __init__(self, name):

self.class_name = name

def my_print(self, value):

print(value + " " +self.class_name)

@staticmethod

def my_static_print(val):

print(val)

@classmethod

def my_class_print(cls, val):

print(val +" "+ cls.class_name)

if __name__ == "__main__":

my_test = test("xxx")

test.my_static_print("static print")

test.my_class_print("class print")

my_test.my_static_print("static print")

my_test.my_class_print("class print")

my_test.my_print("my_print")

最后结果

static print

class print test

static print

class print test

my_print xxx

总结

classmathod 必须要传入一个 cls 参数,这个参数就代表类本身,后面跟的是值

staticmethod 则完全没必要

记忆

如果你定义了一个方法它的返回值和类的属性以及实例无关,结果永远不变 那就用@staticmethod

如果你定义了一个方法它的返回值只和类的属性有关,结果可变.那就用@classmethod