我们先前看过两种编程模式 - 命令式（使用语句，循环和函数）和 函数式（使用纯函数，高阶函数和递归）。

另一个非常流行的范例是面向对象编程（OOP）。

对象是使用类来创建的，而这些类实际上是 OOP 的模具。

这个类描述了这个对象是什么，但是和对象本身是分开的。换句话说，一个类可以被描述为一个对象的蓝图，描述或定义。

您可以使用相同的类作为创建多个不同对象的蓝图。

类是使用关键字 class 和一个包含类方法的缩进块创建的。

下面是一个简单的类和它的对象的例子。

class Cat:
    def __init__(self, color, legs):
        self.color = color
        self.legs = legs
felix = Cat("ginger", 4)
rover = Cat("dog-colored", 4)
stumpy = Cat("brown", 3)

print("felix:",felix.__dict__) #dict是用来存储对象属性的一个字典，其键为属性名，值为属性的值.
print("rover:",rover.__dict__)
print("stumpy:",stumpy.__dict__)

结果:

felix: {'color': 'ginger', 'legs': 4}
rover: {'color': 'dog-colored', 'legs': 4}
stumpy: {'color': 'brown', 'legs': 3}

init

init 方法是一个类中最重要的方法。

这是在创建类的实例（对象）时使用类名称作为函数调用的。

所有的方法都必须以 self 作为自己的第一个参数，虽然它没有被明确地传递，但是 Python 为自己添加了自变量;

在调用方法时，不需要包含它。在一个方法定义中，self 指的是调用该方法的实例。

注意: init 是两个下划线, 不是一个下划线

类的实例具有属性，这些属性是与它们相关联的数据片段。

在这个例子中，Cat 实例具有属性 color 和 legs。这些可以通过在一个实例之后加一个点和属性名来访问。

在 init 方法中，可以使用 self.attribute 来设置实例属性的初始值。

例如：

class Cat:
  def __init__(self, color, legs):
    self.color = color
    self.legs = legs

felix = Cat("ginger", 4)
print(felix.color)

结果：
ginger

在上面的例子中，init 方法接受两个参数并将它们分配给对象的属性。init 方法被称为类构造函数。

方法

类可以定义方法来为其添加功能。

请记住，所有的方法必须有 self 作为他们的第一个参数。

这些方法使用与属性相同的点语法进行访问。

例如：

class Dog:
  def __init__(self, name, color):
    self.name = name
    self.color = color

  def bark(self):
    print("Woof!")

fido = Dog("Fido", "brown")
print(fido.name)
fido.bark()
=============================
结果：
Fido
Woof!

类还可以具有通过在类的主体内分配变量而创建的类属性。这些可以从类的实例或类本身访问。

例如：

class Dog:
  legs = 4
  def __init__(self, name, color):
    self.name = name
    self.color = color

fido = Dog("Fido", "brown")
print(fido.legs)
print(Dog.legs)
======================
结果：
4
4

类属性由类的所有实例共享。

继承

继承提供了一种在类之间共享功能的方法。

想象几个类，Cat，Dog，Rabbit等。虽然它们在某些方面可能有所不同（只有 Dog 可能有 bark 方法），但它们可能在其他方面相似（都具有 color 和 name 的属性）。

这种相似性可以通过使它们全部从包含共享功能的超类 Animal 中继承来表示。

要从另一个类继承一个类，请将超类名放在类名后面的括号中。

例如：

class Animal: 
  def __init__(self, name, color):
    self.name = name
    self.color = color

class Cat(Animal):
  def purr(self):
    print("Purr...")

class Dog(Animal):
  def bark(self):
    print("Woof!")

fido = Dog("Fido", "brown")
print(fido.color)
fido.bark()
====================
结果：
brown
Woof!

从另一个类继承的类称为子类。

被继承的类被称为超类。

如果一个类继承了另一个具有相同属性或方法的类，它的属性和方法将覆盖它们。

class Wolf: 
  def __init__(self, name, color):
    self.name = name
    self.color = color

  def bark(self):
    print("Grr...")

class Dog(Wolf):
  def bark(self):
    print("Woof")

husky = Dog("Max", "grey")
husky.bark()
===
结果：
Woof

在上面的例子中，Wolf 是超类，Dog 是子类。
继承也可以是间接的。一个类B继承类A，而类C也可以继承类B。

例如：

class A:
  def method(self):
    print("A method")

class B(A):
  def another_method(self):
    print("B method")

class C(B):
  def third_method(self):
    print("C method")

c = C()
c.method()
c.another_method()
c.third_method()
===
结果：
A method
B method
C method

但是，不允许循环继承。(感觉这就是有点变相的继承多态,虽然不允许继承多个,可是这样也间接的继承了)

super 函数

super函数是一个与父类继承相关的函数。它可以用来在对象的超类中找到具有特定名称的方法。

例如：

class A:
  def spam(self):
    print(1)

class B(A):
  def spam(self):
    print(2)
    super().spam()

B().spam()
====
结果：
2
1  

super().spam() 是调用超类的 spam 方法。