一、类和实例

  1. 定义一个类
  • 定义类的关键字: class
  • 所有定义的类会自动继承于object这个类
  1. class Student(object):
  2.     pass
  1. 类的初始化方法
  1. class Student(object):
  3.     '__init__ 初始化方法， 当有定义有__init__方法时，创建类实例时会自动反射获取该方法进行初始化 ； 有点像java中的构造方法'
  5.     def __init__(self, name, age):
  6.         self._name = name
  7.         self._age = age
  1. 定义变量
  • 类中的public变量命名方式：xxx 规范的命名变量就是public的。
  • 私有变量private : __xxx ; 在变量前添加双下划线
  • 定义函数的访问权限与变量一样
  1. class Student(object):
  2.     profession = 'Student'  # 定义一个公开变量，职业； 所有的实例都可以访问
  3.     __name = None  # 私有变量, 外界不可直接访问
  4.     __age = None

二、获取对象的信息

  1. type() 返回对象的类型
  1. a = 'abcc'
  2. print(type(a))
  1. isinstance() 也是判断变量的类型
  1. # 判断a变量是否时str或int类型
  2. print(isinstance(a, (str, int)))
  1. dir() 获得一个对象的所有属性和方法，
  1. print(dir(str))
  1. len() 获取对象的长度
  • 自定义对象返回长度的方法; 注意xxx这样的变量或函数在Python中都是有特殊用途的
  1. class MyDog(object):
  2.     # 以下的方法是在对象使用len()方法是返回对象的长度为100
  3.     def __len__(self):
  4.         return 100
  7. print(len(MyDog()))  # 结果为100
  1. getattr()、setattr()以及hasattr() 获取属性、设置属性和判断是否有该属性的方法
  1. class Test(object):
  2.     _name = 'test'
  4.     def test(self):
  5.         print('test function')
  8. t = Test()
  9. # 判断类Test是否有_name属性
  10. print('class Test has _name attr ', hasattr(t, '_name'))
  12. # 设置类Test的属性_name
  13. setattr(t, '_name', 'test132465')
  14. # 打印类Test的属性_name
  15. print(getattr(t, '_name'))

三、继承与多态

  1. python 支持多重继承
  1. # 继承的写法
  2. #父类 1 
  3. class class1(object):
  4.     pass
  6. #父类 2
  7. class class2(object):
  8.     pass
  10. #子类1 继承父类1 和 2
  11. class subclass1(class1,class1):
  12.     pass
  1. 多态
  2. # 这里定义一个工厂的类，用来喂养动物的
  3. class FeedingFactory(object):
  5.     # 在没有用多态时，每喂养一种动物，则需要定义特定的方法
  6.     def feed_dog(self):
  7.         print('dog feed raw')
  9.     def feed_cat(self):
  10.         print('cat feed fish')
  12.     # 使用多态后，可以之定义一种喂养的方法，无论喂多少种动物都不需要更改此方法
  13.     def feed(self, animate):
  14.         print('%s feed %s' % (animate.__getattribute__('_name'), animate.__getattribute__('_food')))
  17. factory = FeedingFactory()
  19. dog = Dog('dog', 'raw')
  20. cat = Cat('cat', 'fish')
  22. factory.feed(dog)
  23. factory.feed(cat)

四、面向对象高级

  1. 限制该class实例能添加的属性：
  • python是动态语言，可以才类创造后任务绑定变量和函数
  • 特殊的slots变量，来限制该class实例能添加的属性：
  • 注意：使用slots要注意，slots定义的属性仅对当前类实例起作用，对继承的子类是不起作用的：
  1. class Student(object):
  2.     pass
  5. # 为Studnet类绑定name属性, 通过实例绑定的变量或函数只能本实例能访问到
  6. s = Student();
  8. s.name = 'abc'
  9. print(s.name)
  11. s2 = Student()
  12. # print(s2.name)  # 会抛出异常： AttributeError: 'Student' object has no attribute 'name'
  14. # 为了让全部的实例能绑定变量或函数，可以通过类来绑定
  15. Student.age = 12  # 有类Student创建的实例都有age属性绑定
  16. s3 = Student()
  17. print('the age of s3 is ', s3.age)
  1. 装饰器 @property
  • Python内置的@property装饰器就是负责把一个方法变成属性调用的：
  • 注意：属性和方法名不要相同，否则后导致不断的调用自身而没有设终止条件而栈溢出
  1. class Student(object):
  3.     @property
  4.     def name(self):
  5.         return self._name
  7.     @name.setter
  8.     def name(self, name):
  9.         self._name = name
  11.     @property
  12.     def score(self):
  13.         return self.score
  15.     '使用@property的好处是：可以在变量赋值时，对变量进行约束检查'
  16.     @score.setter
  17.     def score(self, value):
  18.         if not isinstance(value, int):
  19.             raise ValueError('score must be an integer!')
  20.         if value < 0 or value > 100:
  21.             raise ValueError('score must between 0 ~ 100!')
  22.         self.score = value
  25. s = Student()
  26. s.name = '123'
  27. print(s.name)
  29. s.score = 60  # OK，实际转化为s.set_score(60)
  30. s.score  # OK，实际转化为s.get_score()