Programação orientada a objetos em Python (OOP): Tutorial

Instanciando objetos

Para instanciar um objeto, digite o nome da classe, seguido de dois colchetes. Você pode atribuir isso a uma variável para manter o controle do objeto.

ozzy = Dog()

E imprima-o:

print(ozzy)

<__main__.Dog object at 0x111f47278>

Adição de atributos a uma classe

Após imprimir ozzy, fica claro que esse objeto é um cachorro. Mas você ainda não adicionou nenhum atributo. Vamos dar à classe Dog um nome e uma idade, reescrevendo-a:

class Dog:

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

Você pode ver que a função agora recebe dois argumentos após self: name e age. Em seguida, eles são atribuídos a self.name e self.age, respectivamente. Agora você pode criar um novo objeto ozzy com um nome e uma idade:

ozzy = Dog("Ozzy", 2)

Para acessar os atributos de um objeto em Python, você pode usar a notação de ponto. Isso é feito digitando o nome do objeto, seguido de um ponto e o nome do atributo

print(ozzy.name)

print(ozzy.age)

Ozzy
2

Isso também pode ser combinado em uma frase mais elaborada:

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

Ozzy is 2 year(s) old.

A função str() é usada aqui para converter o atributo age, que é um número inteiro, em uma cadeia de caracteres, para que você possa usá-lo na função print().

Definir métodos em uma classe

Agora que você tem uma classe Dog, ela tem um nome e uma idade, que você pode acompanhar, mas na verdade não faz nada. É aqui que entram os métodos de instância. Você pode reescrever a classe para incluir agora um método bark(). Observe como a palavra-chave def é usada novamente, bem como o argumento self.

class Dog:

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

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

O método bark agora pode ser chamado usando a notação de ponto, depois de instanciar um novo objeto ozzy. O método deve imprimir "bark bark!" na tela. Observe os parênteses (chaves) em .bark(). Eles são sempre usados ao chamar um método. Eles estão vazios nesse caso, pois o método bark() não recebe nenhum argumento.

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

Lembra-se de como você imprimiu o site ozzy anteriormente? O código abaixo agora implementa essa funcionalidade na classe Dog, com o método doginfo(). Em seguida, você instancia alguns objetos com propriedades diferentes e chama o método neles.

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.

Como você pode ver, é possível chamar o método doginfo() em objetos com a notação de ponto. A resposta agora depende do objeto Dog no qual você está chamando o método.

Como os cães envelhecem, seria bom se você pudesse ajustar a idade deles de acordo. Ozzy acabou de completar 3 anos, então vamos mudar sua idade.

ozzy.age = 3

print(ozzy.age)

3

É tão fácil quanto atribuir um novo valor ao atributo. Você também poderia implementar isso como um método birthday() na classe Dog:

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

Agora, você não precisa alterar manualmente a idade do cão. Sempre que for o aniversário dele, basta chamar o método birthday(). 

Passagem de argumentos para métodos

Você gostaria que nossos cães tivessem um companheiro. Isso deve ser opcional, pois nem todos os cães são tão sociáveis. Dê uma olhada no método setBuddy() abaixo. Ele recebe self, como de costume, e buddy como argumentos. Nesse caso, buddy será outro objeto Dog. Defina o atributo self.buddy como buddy e o atributo buddy.buddy como self. Isso significa que o relacionamento é recíproco; você é o amigo do seu amigo. Nesse caso, Filou será amigo de Ozzy, o que significa que Ozzy automaticamente se tornará amigo de Filou. Você também poderia definir esses atributos manualmente em vez de definir um método, mas isso exigiria mais trabalho (escrever duas linhas de código em vez de uma) toda vez que quisesse definir um amigo. Observe que, em Python, você não precisa especificar o tipo do argumento. Se fosse em Java, isso seria obrigatório.

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

Agora você pode chamar o método com a notação de ponto e passar a ele outro objeto Dog. Nesse caso, o companheiro do Ozzy será o Filou:

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

ozzy.setBuddy(filou)

Se agora você quiser obter algumas informações sobre o amigo de Ozzy, poderá usar a notação de ponto duas vezes: Primeiro, para se referir ao amigo de Ozzy, e uma segunda vez para se referir ao seu atributo.

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

Filou
8

Observe como isso também pode ser feito para o Filou.

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

Ozzy
2

Os métodos do amigo também podem ser chamados. O argumento self que é passado para doginfo() agora é ozzy.buddy, que é filou.

 ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Exemplo de OOP em Python

Um exemplo de como a programação orientada a objetos em Python pode ser útil é o nosso site Python For Finance: Algorithmic Trading tutorial. Nele, explicamos como configurar uma estratégia de negociação para uma carteira de ações. A estratégia de negociação é baseada na média móvel do preço de uma ação. Se signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] for atendido, um sinal será criado. Esse sinal é uma previsão da futura mudança de preço da ação. No código abaixo, você verá que primeiro há uma inicialização, seguida do cálculo da média móvel e da geração do sinal. Como não se trata de um código orientado a objetos, é apenas uma grande parte que é executada de uma só vez. Observe que estamos usando aapl no exemplo, que é o ticker de ações da Apple. Se você quisesse fazer isso para uma ação diferente, teria que reescrever o código.

# 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)

Em uma abordagem orientada a objetos, você só precisa escrever o código de inicialização e geração de sinal uma vez. Em seguida, você pode criar um novo objeto para cada ação em que deseja calcular uma estratégia e chamar o método generate_signals() nele. Observe que o código OOP é muito semelhante ao código acima, com a adição de 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'] = 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

Agora você pode simplesmente instanciar um objeto, com os parâmetros desejados, e gerar sinais para ele.

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

Fazer isso para outra ação é muito fácil. É apenas uma questão de instanciar um novo objeto com um símbolo de ação diferente.

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

Programação orientada a objetos em Python: Resumo

Cobrimos alguns dos principais conceitos de OOPs em Python. Agora você sabe como declarar classes e métodos, instanciar objetos, definir seus atributos e chamar métodos de instância. Essas habilidades serão úteis em sua futura carreira como cientista de dados. Se você quiser expandir os principais conceitos necessários para continuar trabalhando com Python, não deixe de conferir nosso curso Python Intermediário para Ciência de Dados.

Com a OOP, a complexidade de seu código aumentará à medida que o programa ficar maior. Você terá diferentes classes, subclasses, objetos, herança, métodos de instância e muito mais. Você deve manter seu código adequadamente estruturado e legível. Para isso, é aconselhável seguir padrões de design. Esses são princípios de design que representam um conjunto de diretrizes para evitar um design ruim. Cada uma delas representa um problema específico que ocorre com frequência na OOP do Python e descreve a solução para esse problema, que pode ser usada repetidamente. Esses padrões de design OOP podem ser classificados em várias categorias: padrões de criação, padrões estruturais e padrões comportamentais. Um exemplo de padrão de criação é o singleton, que deve ser usado quando você quiser garantir que apenas uma instância de uma classe possa ser criada. Um iterador Python, que é usado para percorrer todos os objetos em uma coleção, é um exemplo de padrão comportamental.