Python 面向对象编程：完整指南

实例化对象

要实例化一个对象，输入类名，后跟一对括号。您可以将其赋给变量，以便跟踪该对象。

ozzy = Dog()

然后打印它：

print(ozzy)

<__main__.Dog object at 0x111f47278>

为类添加属性

打印出 ozzy 后，很明显这个对象是一只狗。但您还没有添加任何属性。我们通过改写为 Dog 类添加名字和年龄：

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

您可以看到，该函数现在在 self 之后接收两个参数：name 和 age。它们分别被赋给 self.name 和 self.age。现在您可以创建一个带名字和年龄的新 ozzy 对象：

ozzy = Dog("Ozzy", 2)

要在 Python 中访问对象的属性，可以使用点号语法。即输入对象名，后跟一个点和属性名：

print(ozzy.name)

print(ozzy.age)

Ozzy
2

也可以把它组合成一句更完整的话：

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")

Ozzy is 2 year(s) old.

这里使用了 str() 函数，将整数类型的 age 属性转换为字符串，以便在 print() 函数中使用。

在类中定义方法

现在您有了一个 Dog 类，它确实有名字和年龄，您也可以跟踪它们，但它实际上还不会做什么。这时就需要实例方法。您可以重写该类，加入一个 bark() 方法。注意再次使用了 def 关键字，以及 self 参数。

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

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

现在可以在实例化新的 ozzy 对象后，使用点号调用 bark 方法。该方法会在屏幕上打印 "bark bark!"。注意 .bark() 中的括号。调用方法时总是需要括号。本例中是空的，因为 bark() 方法不接收任何参数。

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

还记得之前如何打印 ozzy 吗？下面的代码将该功能实现到了 Dog 类中的 doginfo() 方法里。然后您实例化一些具有不同属性的对象并调用它们的方法。

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

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

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()

Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.

如您所见，您可以用点号在对象上调用 doginfo() 方法。返回的结果现在取决于您正在对哪个 Dog 对象调用该方法。

由于狗会变老，最好能相应地调整它们的年龄。Ozzy 刚过 3 岁生日，我们来修改它的年龄。

ozzy.age = 3

print(ozzy.age)

3

只需为属性赋予一个新值即可。您也可以在 Dog 类中实现一个 birthday() 方法：

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

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

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)

2

ozzy.birthday()

print(ozzy.age)

3

现在，您无需手动修改狗的年龄。每逢生日，直接调用 birthday() 方法即可。

向方法传递参数

您可能希望让我们的狗有个伙伴。由于不是所有的狗都那么合群，因此这应是可选的。

看看下面的 setBuddy() 方法。它像往常一样接收 self，并接收 buddy 作为参数。这里，buddy 将是另一个 Dog 对象。将 self.buddy 属性设为 buddy，并将 buddy.buddy 属性设为 self。

这意味着关系是互相的：您是您伙伴的伙伴。在这里，Filou 将成为 Ozzy 的伙伴，这也意味着 Ozzy 会自动成为 Filou 的伙伴。

您也可以不定义方法，改为手动设置这些属性，但那样每次设置伙伴都要多写一行代码。

注意在 Python 中，您无需指定参数类型。如果这是 Java，就需要这样做。

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

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

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = self

现在您可以用点号调用该方法，并向其传入另一个 Dog 对象。在本例中，Ozzy 的伙伴将是 Filou：

ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)

ozzy.setBuddy(filou)

如果您现在想获取有关 Ozzy 的伙伴的一些信息，可以使用两次点号：第一次引用 Ozzy 的伙伴，第二次引用其属性。

print(ozzy.buddy.name)
print(ozzy.buddy.age)

Filou
8

注意，对 Filou 也可以这样做。

print(filou.buddy.name)
print(filou.buddy.age)

Ozzy
2

还可以调用伙伴的方法。传递给 doginfo() 的 self 参数现在是 ozzy.buddy，也就是 filou。

ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Python OOP 示例

一个可能用到 Python 面向对象编程的示例是我们的Python 金融：算法交易教程。在其中，我们讲解如何为股票投资组合设置交易策略。

该交易策略基于股票价格的移动平均。如果满足 signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:]，则会产生一个信号。该信号是对股票未来价格变动的预测。

在下面的代码中，您会看到先进行初始化，然后计算移动平均并生成信号。由于这不是面向对象的代码，它就是一大段一次性执行的逻辑。

请注意，我们在示例中使用了 aapl，即苹果公司的股票代码。如果您想对另一只股票进行同样的操作，就必须重写代码。

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)

在面向对象的方法中，您只需把初始化和信号生成代码写一次。

然后，您可以为每只需要计算策略的股票创建一个新对象，并在其上调用 generate_signals() 方法。请注意，OOP 代码与上面的代码非常相似，只是多了 self。

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = self.bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signals

现在，您只需用想要的参数实例化一个对象并为其生成信号即可。

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())

对另一只股票进行同样操作就非常容易了。只需用不同的股票代码实例化一个新对象即可。

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())

结语

我们已经介绍了 Python 中的一些主要 OOP 概念。您现在知道如何声明类和方法、实例化对象、设置其属性以及调用实例方法。这些技能将在您未来的数据科学职业生涯中大有裨益。

若想以更现代的方式定义类，请查看Python 数据类，它能减少样板代码。如果您想进一步扩展继续使用 Python 所需的关键概念，请务必查看我们的Python 进阶课程。

随着程序规模扩大，使用 OOP 的代码复杂度也会增长。您会有不同的类、子类、对象、继承、实例方法等。对于复杂的继承场景，请了解多重继承与 super()。