Definir um Objeto Simples em Python: Guia Prático

Introdução

Neste laboratório, você aprenderá como definir uma classe Python simples para representar informações de ações. Classes são um conceito chave na programação orientada a objetos (POO), permitindo modelar entidades do mundo real e estruturar seu código de forma mais eficiente.

Os objetivos deste laboratório incluem aprender a definir uma classe Python simples, entender atributos e métodos de classe, criar e interagir com instâncias de classe e aplicar formatação para exibir informações de objetos. O arquivo stock.py será criado durante este laboratório.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 97%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Entendendo Classes Python

Em Python, uma classe serve como um modelo para criar objetos. A programação orientada a objetos (POO) é uma abordagem poderosa que nos permite organizar nosso código de forma eficaz. Ela faz isso agrupando dados e funções relacionadas. Dessa forma, podemos gerenciar programas complexos com mais facilidade e tornar nosso código mais modular e sustentável.

Uma classe Python é composta por dois componentes principais:

Atributos (Attributes): São variáveis que armazenam dados dentro de uma classe. Pense nos atributos como as características ou propriedades de um objeto. Por exemplo, se estamos criando uma classe para representar uma pessoa, os atributos podem ser o nome, a idade e a altura da pessoa.
Métodos (Methods): São funções que pertencem a uma classe e podem acessar ou modificar seus atributos. Métodos definem as ações que um objeto pode realizar. Usando o exemplo da classe pessoa, um método pode ser uma função que calcula a idade da pessoa em meses.

Classes são extremamente úteis, pois fornecem uma maneira de criar código reutilizável e modelar conceitos do mundo real. Neste laboratório, criaremos uma classe Stock. Esta classe será usada para representar informações de ações, como o nome da ação, o número de ações e o preço por ação.

Aqui está a estrutura básica de uma classe Python:

class ClassName:
    def __init__(self, parameter1, parameter2):
        self.attribute1 = parameter1
        self.attribute2 = parameter2

    def method_name(self):
        ## Code that uses the attributes
        return result

O método __init__ é um método especial em classes Python. Ele é chamado automaticamente quando criamos um novo objeto a partir da classe. Este método é usado para inicializar os atributos do objeto. O parâmetro self é uma referência à instância da classe. Ele é usado para acessar atributos e métodos de dentro da classe. Quando chamamos um método em um objeto, o Python automaticamente passa o próprio objeto como o primeiro argumento, e é por isso que usamos self nas definições dos métodos. Isso nos permite trabalhar com os atributos da instância específica e realizar operações neles.

Criando a Classe Stock

Em Python, uma classe é um modelo para criar objetos. Ela permite que você agrupe dados e funcionalidades. Agora, vamos criar nossa classe Stock para representar informações de ações. Uma ação tem certas características, como seu nome, o número de ações e o preço por ação. Definiremos atributos para esses aspectos dentro de nossa classe.

Primeiro, você precisa estar no diretório correto no WebIDE. Se você ainda não estiver no diretório /home/labex/project, navegue até ele. É aqui que trabalharemos no código da nossa classe Stock.
Depois de estar no diretório certo, crie um novo arquivo no editor. Nomeie este arquivo stock.py. Este arquivo conterá o código para nossa classe Stock.
Agora, vamos adicionar o código para definir a classe Stock. Copie e cole o seguinte código no arquivo stock.py:

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

Neste código:

A declaração class Stock: cria uma nova classe chamada Stock. Isso é como um modelo para criar objetos de ações.
O método __init__ é um método especial em classes Python. Ele é chamado de construtor. Quando você cria um novo objeto da classe Stock, o método __init__ será executado automaticamente. Ele recebe três parâmetros: name, shares e price. Esses parâmetros representam as informações sobre a ação.
Dentro do método __init__, usamos self para nos referir à instância da classe. Armazenamos os valores dos parâmetros como atributos de instância. Por exemplo, self.name = name armazena o parâmetro name como um atributo do objeto.
O método cost() é um método personalizado que definimos. Ele calcula o custo total da ação multiplicando o número de ações (self.shares) pelo preço por ação (self.price).

Depois de adicionar o código, salve o arquivo. Você pode fazer isso pressionando Ctrl+S ou clicando no ícone Salvar. Salvar o arquivo garante que suas alterações sejam preservadas.

Vamos examinar o código novamente para garantir que o entendemos:

Definimos uma classe chamada Stock. Esta classe será usada para criar objetos de ações.
O método __init__ recebe três parâmetros: name, shares e price. Ele inicializa os atributos do objeto com esses valores.
Dentro de __init__, armazenamos esses parâmetros como atributos de instância usando self. Isso permite que cada objeto tenha seu próprio conjunto de valores para esses atributos.
Adicionamos um método cost() que calcula o custo total multiplicando as ações pelo preço. Esta é uma funcionalidade útil para nossos objetos de ações.

Quando criamos um objeto Stock, o método __init__ será executado automaticamente, configurando o estado inicial do nosso objeto com os valores que fornecemos. Dessa forma, podemos facilmente criar vários objetos de ações com diferentes nomes, números de ações e preços.

Criando Objetos de Ações

Agora que definimos nossa classe Stock, é hora de colocá-la em ação. Criar instâncias de uma classe é como fazer exemplos específicos com base em um modelo geral. Neste caso, a classe Stock é nosso modelo, e criaremos alguns objetos de ações. Depois de criar esses objetos, aprenderemos como acessar seus atributos (características) e métodos (ações que eles podem realizar).

Primeiro, precisamos abrir um terminal no WebIDE. O terminal é como um centro de comando onde podemos dar instruções ao nosso computador. Para abri-lo, clique em "Terminal" no menu.
Depois que o terminal estiver aberto, precisamos garantir que estamos no diretório correto do projeto. O diretório do projeto é onde todos os arquivos relevantes para nosso projeto são armazenados. Se você ainda não estiver no diretório do projeto, use o seguinte comando para navegar até lá:

cd /home/labex/project

Agora, queremos iniciar o Python no modo interativo com nosso arquivo stock.py. O modo interativo nos permite testar nosso código passo a passo e ver os resultados imediatamente. O arquivo stock.py contém a definição da nossa classe Stock. Use o seguinte comando:

python3 -i stock.py

A flag -i é importante aqui. Ela diz ao Python para executar o script stock.py primeiro. Após executar o script, ele inicia uma sessão interativa. Nesta sessão, podemos acessar quaisquer classes e variáveis que foram definidas no script stock.py.

Vamos criar um novo objeto Stock para as ações do Google. Criar um objeto é como fazer uma instância específica da classe Stock com valores particulares. Use o seguinte código:

s = Stock('GOOG', 100, 490.10)

Esta linha de código cria uma nova instância da classe Stock. Aqui está o que cada valor significa:

Name: 'GOOG' - Este é o símbolo das ações do Google.
Shares: 100 - Representa o número de ações do Google que temos.
Price: 490.10 - Este é o preço por ação do Google.

Agora que temos nosso objeto Stock, podemos acessar seus atributos. Atributos são como as propriedades de um objeto. Para acessar um atributo, usamos o nome do objeto seguido por um ponto e o nome do atributo.

s.name

Quando você executar este código, ele exibirá o nome da ação:

'GOOG'

Vamos acessar o número de ações:

s.shares

A saída será o número de ações que definimos:

Finalmente, vamos acessar o preço por ação:

s.price

A saída será o preço por ação:

490.1

Nossa classe Stock tem um método chamado cost(). Um método é como uma ação que um objeto pode realizar. Neste caso, o método cost() calcula o custo total de nossas ações. Para chamar este método, use o seguinte código:

s.cost()

A saída será o custo total:

49010.0

O método cost() funciona multiplicando o número de ações (100) pelo preço por ação (490.10), o que nos dá 49010.0.

Trabalhando com Múltiplos Objetos de Ações

Em programação orientada a objetos, uma classe é como um modelo, e as instâncias dessa classe são os objetos reais criados com base nesse modelo. Nossa classe Stock é um modelo para representar ações. Podemos criar múltiplas instâncias desta classe Stock para representar diferentes ações. Cada instância terá seu próprio conjunto de atributos, como o nome da ação, o número de ações e o preço por ação.

Com a sessão interativa do Python ainda em execução, vamos criar outro objeto Stock. Desta vez, ele representará a IBM. Para criar uma instância da classe Stock, chamamos o nome da classe como se fosse uma função e passamos os argumentos necessários. Os argumentos aqui são o nome da ação, o número de ações e o preço por ação.

t = Stock('IBM', 50, 91.5)

Nesta linha de código, estamos criando um novo objeto Stock chamado t que representa a IBM. Ele tem 50 ações, e cada ação custa $91,5.

Agora, queremos calcular o custo desta nova ação. A classe Stock tem um método chamado cost() que calcula o custo total da ação multiplicando o número de ações pelo preço por ação.

t.cost()

Quando você executa este código, o Python chamará o método cost() no objeto t e retornará o custo total.

Saída:

4575.0

Podemos formatar e exibir nossas informações de ações de uma maneira agradável e organizada usando a formatação de strings do Python. A formatação de strings nos permite especificar como diferentes tipos de dados devem ser apresentados em uma string.

print('%10s %10d %10.2f' % (s.name, s.shares, s.price))

Neste código, estamos usando a formatação de strings de estilo antigo no Python. O operador % é usado para substituir valores em um modelo de string. O modelo de string '%10s %10d %10.2f' define como o nome da ação, o número de ações e o preço devem ser formatados.

Saída:

      GOOG        100     490.10

Esta string formatada funciona da seguinte forma:

%10s formata uma string em um campo com 10 caracteres de largura (alinhado à direita). Isso significa que o nome da ação será colocado em um espaço que tem 10 caracteres de largura, e será alinhado à direita dentro desse espaço.
%10d formata um inteiro em um campo com 10 caracteres de largura. Portanto, o número de ações será colocado em um espaço com 10 caracteres de largura.
%10.2f formata um float com 2 casas decimais em um campo com 10 caracteres de largura. O preço será mostrado com duas casas decimais e colocado em um espaço com 10 caracteres de largura.

Agora, vamos formatar as informações da ação da IBM da mesma maneira. Só precisamos substituir o nome do objeto de s para t no código de formatação de string.

print('%10s %10d %10.2f' % (t.name, t.shares, t.price))

Saída:

       IBM         50      91.50

No Python moderno, também podemos usar f-strings para formatação. F-strings são mais legíveis e fáceis de usar. Vamos comparar os custos de ambas as ações usando f-strings.

print(f"Google stock costs ${s.cost()}, IBM stock costs ${t.cost()}")

Nesta f-string, estamos incorporando diretamente expressões dentro de chaves {}. O Python avaliará essas expressões e inserirá os resultados na string.

Saída:

Google stock costs $49010.0, IBM stock costs $4575.0

Quando você terminar de experimentar, é hora de sair do modo interativo do Python. Você pode fazer isso usando a função exit().

exit()

Cada objeto Stock mantém seu próprio conjunto de atributos, o que demonstra como as instâncias de classe funcionam em programação orientada a objetos. Isso nos permite criar múltiplos objetos de ações, cada um com valores diferentes, enquanto compartilha os mesmos métodos.

Aprimorando a Classe de Ações

No Python, as classes são uma maneira poderosa de organizar dados e comportamento. Elas nos permitem agrupar dados e funções relacionadas. Nesta seção, aprimoraremos nossa classe Stock adicionando um método que exibe informações de ações formatadas. Este é um ótimo exemplo de como podemos encapsular dados e comportamento em nossas classes. Encapsulamento significa agrupar dados com os métodos que operam nesses dados, o que ajuda a manter nosso código organizado e mais fácil de gerenciar.

Primeiro, você precisa abrir o arquivo stock.py no editor do WebIDE. O arquivo stock.py é onde temos trabalhado em nossa classe Stock. Abri-lo no editor nos permite fazer alterações na definição da classe.
Agora, vamos modificar a classe Stock para adicionar um novo método display(). Este método será responsável por imprimir as informações da ação de uma maneira bem formatada. Veja como você pode fazer isso:

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

    def display(self):
        print(f"Stock: {self.name}, Shares: {self.shares}, Price: ${self.price:.2f}, Total Cost: ${self.cost():.2f}")

No método __init__, inicializamos o nome da ação, o número de ações e o preço. O método cost calcula o custo total da ação multiplicando o número de ações pelo preço. O novo método display usa uma f-string para formatar e imprimir as informações da ação, incluindo o nome, número de ações, preço e custo total.

Depois de fazer essas alterações, você precisa salvar o arquivo. Você pode fazer isso pressionando Ctrl+S no seu teclado ou clicando no ícone Salvar no editor. Salvar o arquivo garante que suas alterações sejam preservadas e possam ser usadas posteriormente.
Em seguida, iniciaremos uma nova sessão interativa do Python. Uma sessão interativa nos permite testar nosso código imediatamente. Para iniciar a sessão, execute o seguinte comando no terminal:

python3 -i stock.py

A opção -i diz ao Python para iniciar uma sessão interativa após executar o arquivo stock.py. Dessa forma, podemos usar a classe Stock e seus métodos imediatamente.

Agora, vamos criar um objeto de ação e usar o novo método display(). Criaremos um objeto representando as ações da Apple e, em seguida, chamaremos o método display para ver as informações formatadas. Aqui está o código:

apple = Stock('AAPL', 200, 154.50)
apple.display()

Quando você executar este código na sessão interativa, verá a seguinte saída:

Stock: AAPL, Shares: 200, Price: $154.50, Total Cost: $30900.00

Esta saída mostra que o método display está funcionando corretamente e está formatando as informações da ação conforme o esperado.

Finalmente, vamos criar uma lista de ações e exibi-las todas. Isso mostrará como podemos usar o método display com vários objetos de ações. Aqui está o código:

stocks = [
    Stock('GOOG', 100, 490.10),
    Stock('IBM', 50, 91.50),
    Stock('AAPL', 200, 154.50)
]

for stock in stocks:
    stock.display()

Quando você executar este código, obterá a seguinte saída:

Stock: GOOG, Shares: 100, Price: $490.10, Total Cost: $49010.00
Stock: IBM, Shares: 50, Price: $91.50, Total Cost: $4575.00
Stock: AAPL, Shares: 200, Price: $154.50, Total Cost: $30900.00

Ao adicionar o método display() à nossa classe, encapsulamos a lógica de formatação dentro da própria classe. Isso torna nosso código mais organizado e mais fácil de manter. Se precisarmos alterar a forma como as informações da ação são exibidas, só precisamos modificar o método display em um só lugar, em vez de fazer alterações em todo o nosso código.

Resumo

Neste laboratório, você aprendeu a definir uma classe Python com atributos e métodos, criar instâncias de classe com valores de atributo específicos, acessar atributos de objeto e chamar métodos de objeto. Você também aprendeu a formatar e exibir informações de objeto de várias maneiras, trabalhar com vários objetos da mesma classe e aprimorar uma classe adicionando novos métodos.

Esses conceitos de programação orientada a objetos são fundamentais em Python e servem como base para organizar o código em aplicações maiores. As classes ajudam a agrupar dados e funcionalidades relacionadas, tornando seu código mais modular e fácil de manter. Para aprimorar ainda mais suas habilidades, considere adicionar recursos à classe Stock, como validação de dados, métodos para atualizar ações ou preço e um método para calcular lucro ou prejuízo.