1、https://py.eastlakeside.cn/book/DataStructures/classes.html 2、https://mofanpy.com/tutorials/python-basic/interactive-python/class/

通常约定类的首字母要大写
self是作为类自己的一个索引，不管你在定义类的时候，想要获取这个类的什么属性或功能，都可以通过self来获取

实例变量与类变量

实例变量用于每个对象是唯一的数据
类变量用于在类的不同实例之间共享的数据

  1. class Cal(object):
  2.     # pi 是类变量
  3.     pi = 3.142
  5.     def __init__(self, radius):
  6.         # self.radius 是实例变量
  7.         self.radius = radius
  9.     def area(self):
  10.         return self.pi * (self.radius ** 2)
  12. a = Cal(32)
  13. a.area()
  14. # Output: 3217.408
  15. a.pi
  16. # Output: 3.142
  17. a.pi = 43
  18. a.pi
  19. # Output: 43
  21. b = Cal(44)
  22. b.area()
  23. # Output: 6082.912
  24. b.pi
  25. # Output: 3.142
  26. b.pi = 50
  27. b.pi
  28. # Output: 50
  1. class SuperClass(object):
  2.     superpowers = []
  4.     def __init__(self, name):
  5.         self.name = name
  7.     def add_superpower(self, power):
  8.         self.superpowers.append(power)
  10. foo = SuperClass('foo')
  11. bar = SuperClass('bar')
  12. foo.name
  13. # Output: 'foo'
  15. bar.name
  16. # Output: 'bar'
  18. foo.add_superpower('fly')
  19. bar.superpowers
  20. # Output: ['fly']
  22. foo.superpowers
  23. # Output: ['fly']

魔术方法

__init__

是一个类初始化器，每当类创建一个类实例时，都会调用其__init__方法，例如：

  1. class GetTest(object):
  2.     def __init__(self):
  3.         print('Greetings!!')
  4.     def another_method(self):
  5.         print('I am another method which is not'
  6.               ' automatically called')
  9. a = GetTest()
  10. # Output: Greetings!!
  12. a.another_method()
  13. # Output: I am another method which is not automatically
  14. # called

在创建实例后会立即调用**__init__**,还可以在初始化期间将参数传递给类

  1. class GetTest(object):
  2.     def __init__(self, name):
  3.         print('Greetings!! {0}'.format(name))
  4.     def another_method(self):
  5.         print('I am another method which is not'
  6.               ' automatically called')
  8. a = GetTest('yasoob')
  9. # Output: Greetings!! yasoob
  11. # Try creating an instance without the name arguments
  12. b = GetTest()
  13. Traceback (most recent call last):
  14.   File "<stdin>", line 1, in <module>
  15. TypeError: __init__() takes exactly 2 arguments (1 given)

__getitem__

  1. class GetTest(object):
  2.     def __init__(self):
  3.         self.info = {
  4.             'name':'Yasoob',
  5.             'country':'Pakistan',
  6.             'number':12345812
  7.         }
  9.     def __getitem__(self,i):
  10.         return self.info[i]
  12. foo = GetTest()
  14. foo['name']
  15. # Output: 'Yasoob'
  17. foo['number']
  18. # Output: 12345812

继承

定义文本文件和视频文件，如果分开定义两个类，可以这样写：

  1. class Video:
  2.     def __init__(self, name, window_size=(1080, 720)):
  3.         self.name = name
  4.         self.window_size = window_size
  5.         self.create_time = "today"
  7. class Text:
  8.     def __init__(self, name, language="zh-cn"):
  9.         self.name = name
  10.         self.language = language
  11.         self.create_time = "today"

这两个文件其实是有共性的，比如都有name
它们可以抽象出一个更底层的类，也就是“文件类”。这个类包含了属于文件所具备的共同属性和功能
可以通过继承的方式，将细分类嵌入到抽象类中，减少共有属性/功能的重复开发

  1. class File:
  2.     def __init__(self,name,create_time="today"):
  3.         self.name = name
  4.         self.create_time = create_time
  5.     def get_info(self):
  6.         return self.name + "is create at " + self.create_time
  9. class Video(File): #继承了File的属性和方法
  10.     def __init__(self,name,window_size=(1080,720)):
  11.         #将公用属性的设置导入
  12.         super.__init__(name=name,create_time="today")
  13.         self.window_size = window_size
  16. class Text(File):
  17.     def __init__(self,name,language="zh-cn"):
  18.         super().__init__(name=name,create_time="today")
  19.         self.language = language
  21.     def get_more_info(self):
  22.         return self.get_info()+", using language of " + self.language
  24. v = Video("my_video")
  25. t = Text("my_text")
  26. print(v.get_info())  #调用父类的功能
  27. print(t.create_time) #调用父类的属性