Tradução do "Introduction to OOP with Python" do site www.voidspace.org.uk

Introdução

Eu tenho programado com Python por mais de 2 anos [1]. Antes, havia feito alguma programação procedural por cerca de 8 anos - mas eu não estava familiarizado com objetos ou OOP.

A filosofia usada no design da Python encoraja um estilo de programação limpo. Os seus tipos de dados básicos (datatypes) e o sistema de espaço de nomes (namespaces) facilitam a escrita de código elegante e modular [2].

Estes fatores, mais a peculiar regra de estruturação de bloco por indentação, tornam a Python uma linguagem ideal para iniciantes. Apesar disso, eu tive dificuldades em aprender sobre classes e objetos. Foi um grande obstáculo a ser vencido, assim como são todos os novos sistemas.

De fato os princípios básicos da programação orientada a objetos são relativamente fáceis de aprender. Assim como outros aspectos da Python, eles são bem concebidos e implementados. Este tutorial é uma introdução a programação orientada a objetos, que eu gostaria de ter tido quando precisei aprender tais princípios.

Este artigo assume um conhecimento básico da sintaxe da Python. Se você sabe como criar os tipos de dados básicos e chamar funções, mas quer saber mais sobre objetos e classes - então você achará esse artigo extremamente útil.

Objetos e OOP

Objetos e OOP estão no coração do modo como a Python funciona. Você não é forçado a usar o paradigma OOP em seus programas - mas entender os conceitos é essencial para se tornar algo mais que um iniciante. Mesmo porque, você precisará usar as classes e objetos fornecidos pela biblioteca padrão da linguagem.

OOP o Novo Paradigma

A programação de computadores é uma disciplina relativamente nova. Surpreendentemente, a programação orientada a objetos data da longínqua década de 60. Simula é considerada a primeira linguagem de programação orientada a objetos.

A OOP não é um paradigma incontroverso, de fato não é claro o que venha a ser uma definição exata de Programação Orientada a Objetos.

Algumas pessoas acham que a OOP já teve a sua chance, e nós já deveríamos procurar pelo paradigma pós-OOP.

Outros como Paul Graham acham que, em primeiro lugar, a OOP nunca foi necessária.

Então, o quê é um Objeto?

O quê é um Objeto? Bem, estamos falando de programação - portanto um objeto é um conceito. Chamar elementos de nossos programas de objetos é uma metáfora - um modo útil de pensar sobre eles.

Em Python os elementos básicos da programação são coisas como strings, dicionários, inteiros, funções, e assim por diante [3] ... Todos eles são objetos [4]. Isto significa que eles possuem certas coisas em comum.

Antes de olharmos mais de perto o que isto significa, nós iremos rapidamente cobrir alguns conceitos básicos de programação.

Programação Procedural

Se você já programou antes, você deve estar familiarizado com o estilo procedural de programação. Neste estilo, você divide o seu programa em 'pedaços' reutilizáveis chamados procedimentos (procedures) ou funções (functions) [5].

Sempre que possível você tenta manter o seu código nestes pedaços modulares - usando a lógica para decidir qual pedaço é chamado. Este estilo faz com que você não se esforce tanto ao visualizar o que o seu programa está fazendo. Ele também facilita a manutenção do seu código - você pode ver quais partes fazem o quê. Ao melhorar uma função (que é reutilizada) você pode, consequentemente, melhorar a performance em várias partes do seu programa.

Nota

Para um visão interessante do desenvolvimento da programação procedural, leia uma mini história da programação

Separação de Dados

O estilo de programação procedural mantém uma estrita separação entre o seu código e seus dados.

Você tem variáveis, que contém os seus dados, e procedimentos. Você passa suas variáveis para os seus procedimentos - que ajem sobre elas e talvez até as modifiquem.

Se uma função quer modificar o conteúdo de uma variável ao passá-la para outra função, ela necessita acesso a ambas, variável e função chamada. Se você realizar operações complexas isto pode compreender o uso de muitas variáveis e muitas funções.

Entra o Objeto

Elementos Básicos da OOP

Qualquer programador OOP experiente lhe dirá que os elementos essênciais da OOP são encapsulamento e passagem de mensagens.

Os equivalentes destes elementos na Python são namespaces e métodos.

A Python não adota o conceito de proteger (ocultar) o código do programador, [6] assim como a maioria das linguagens BSD. Ela encapsula os objetos em um namespace, mas através de um encapsulamento translúcido.

Isso leva a conclusão de que muitas operações são comuns a objetos do mesmo tipo. Por exemplo, a maioria das linguagens possuem modos nativos de criar uma versão somente em minúsculas (caixa baixa) de uma string.

Existem várias operações padrão que estão associadas apenas a strings. Dentre elas temos, por exemplo, retornar uma versão em minúsculas, retornar uma versão em maiúsculas, particionar a string, e assim por diante. Em uma linguagem orientada a objetos nós podemos embutir essas operações como propriedades do objeto string. Em Python nós chamamos estas operações de métodos [7].

Todo objeto string possui um conjunto padrão de métodos - alguns dos quais você provavelmente já usou.

Por exemplo :

   1 string_original = ' algum texto '
   2 
   3 # remove espaços em branco no início e fim da string
   4 string1 = string_original.strip()
   5 
   6 # retorna uma versão em maiúsculas
   7 string2 = string1.upper()
   8 print string2
   9 ALGUM TEXTO
  10 
  11 # retorna uma versão em minúsculas
  12 string2.lower() == string1
  13 True

A Python usa a sintaxe de ponto para acessar os atributos dos objetos. A instrução string2.lower() significa chamar o método lower do objeto string2. Este método retorna uma nova string - o resultado da chamada ao método.

Então toda string é atualmente um objeto string - e tem todos os métodos de um objeto string [8]. Na terminologia da Python nós dizemos que todas as strings são do tipo string.

No modelo de objetos as funções (métodos) e outros atributos que estão associados a um tipo particular de objeto, tornam-se parte do objeto. Os dados, e as funções que lidam com esses dados não estão mais separados - mas empacotados juntos no objeto.

Criando Novos Objetos

Olhemos mais claramente para o que está acontecendo.

Em python existe um objeto de modelo para o tipo string. Seu nome real é str. Ele tem todos os métodos e propriedades associadas com a string.

Toda vez que uma nova string é criada, o modelo é usado para criar um novo objeto com todas as propriedades do modelo.

Todos os tipo de dados nativos têm seu próprio "modelo" - o inteiro (int), o ponto flutante (float), booleanos (bool), listas (list), dicionários (dict), e mais.

Para estes tipo de dados nativos, nós podemos ou usar a sintaxe normal da Python para criá-los - ou nós podemos usar o próprio modelo (o tipo).

   1 # cria um dicionário da forma normal
   2 dicionario = {
   3     'chave' : 'valor',
   4     'chave2' : 'valor2'
   5     }
   6 # usa 'dict' para criá-lo
   7 lista_de_tuplas = [('chave', 'valor'),
   8                  ('chave2', 'valor2')]
   9 outro_dicionario = dict(lista_de_tuplas)
  10 #
  11 print dicionario == outro_dicionario
  12 True
  13 print type(dicionario)
  14 <type 'dict'>
  15 print type(outr_dicionario)
  16 <type 'dict'>

Veja como nós criamos o objeto outro_dicionario por passar uma lista de tuplas para o dicionário. São coisas básicas, mas ilustram que novos objetos são criados a partir de modelos. Estes objetos têm todos os métodos definidos no modelo.

O novo objeto é chamado 'instância' - e o processo de criá-lo é chamado 'instanciação' (isto é, a criação de uma instância). Para os tipos de dados nativos o modelo é conhecido como o tipo do objeto. Você pode testar o tipo de um objeto por usar a função nativa 'type' [9].

Pode parecer muito para digerir - mas isso provavelmente não envolve nada que você já não conheça.

Python como uma Linguagem Orientada a Objeto

Se você fizer uma busca pela internet poderá encontrar algumas discussões inúteis sobre se Python é ou não orientado a objeto. Este debate é particularmente amado pelos programadores Ruby que como reivindicam que sua linguagem é mais orientada a objeto do que Python.

Isso parece vir dos dias pré-Python 2.2 quando existia uma grande diferença entre os tipos nativos e as classes definidas pelo usuário. Desde a 2.2 você pode fazer classes que herdam de tipos nativos. Na Python 3.0 a unificação será completa.

Nós já vimos um exemplo usando alguns métodos de string. Nós fecharemos esta seção usando alguns métodos de dicionário.

   1 um_dicionario = {
   2     'key' : 'value',
   3     'key2' : 'value2'
   4     }
   5 outro_dicionario = um_dicionario.copy()
   6 print um_dicionario == outro_dicionario
   7 True
   8 um_dicionario.clear()
   9 print um_dicionario
  10 {}
  11 print um_dicionario.clear
  12 <built-in method clear of dict object at 0x0012E540>
  13 print type(um_dicionario.clear)
  14 <type 'builtin_function_or_method'>

Acima nós usamos o método 'clear' da variável 'um_dicionario' chamando 'um_dicionario.clear()'. Quando nós imprimos 'clear', em vez de chamá-lo, podemos ver que é apenas outro objeto. É um objeto de método do tipo apropriado.

Funções são Objetos

Apenas para mostrar que funções são objetos, mostrarei um truque elegante com elas.

Você já escreveu código parecido com este ?

   1 if valor == 'um':
   2     # faça alguma coisa
   3     funcao1()
   4 elif valor == 'dois':
   5     # faça outra coisa
   6     funcao2()
   7 elif valor == 'três':
   8     # faça outra coisa
   9     funcao3()

Outras linguagens tem uma construção chamada 'switch' que escreve código como o anterior de uma maneira mais fácil.

Em Python nós podemos conseguir a mesma coisa (em um menor número de linhas de código) usando dicionário de funções.

Como exemplo, suponha que tenhamos três funções. Você quer chamar uma das funções, dependendo do valor na variável chamada 'escolha'.

   1 def funcao1():
   2     print 'Você escolheu um.'
   3 def funcao2():
   4     print 'Você escolheu dois.'
   5 def funcao3():
   6     print 'Você escolheu três.'
   7 #
   8 # 'switch' é nosso dicionário de funções
   9 switch = {
  10     'um': funcao1,
  11     'dois': funcao2,
  12     'três': funcao3,
  13     }
  14 #
  15 # escolha pode ser 'um', 'dois', ou 'três'
  16 escolha = raw_input('Enter um, dois, or três :')
  17 #
  18 # chama uma das funções
  19 try:
  20     resultado = switch[escolha]
  21 except KeyError:
  22     print 'Não entendi sua escolha.'
  23 else:
  24     resultado()

A mágica ocorre na linha resultado = switch[escolha]. switch[escolha] retorna uma de nossos objetos do tipo função (ou levanta uma exceção KeyError).

Cuidado!

Você poderia eliminar uma linha ou duas por fazer o bloco final desta forma:

   1 # chama uma das funções
   2 try:
   3     switch[escolha]()
   4 except KeyError:
   5     print 'Eu não entendi a sua escolha.'

Esta forma chama diretamente a função retornada por switch[escolha]. No entanto, se aquela função levanta uma exceção KeyError (devido a um bug) - e exceção será capturada pelo bloco try...except. Esse erro pode ser bem difícil de encontrar, porque o seu código de tratamento de erros está reportando o erro errado.

Em geral você deve ter seus blocos try...except encobrindo o mínimo de código possível.

Classes Definidas Pelo Usuário

O truque real é que nós podemos criar nossos próprios modelos, chamados de classes. Nós podemos definir nosso pŕoprio tipo de objeto - e assim criar quantas instâncias desta classe quanto quisermos. Todas as instâncias serão diferentes - dependendo que dados são guardados nelas quando criadas. Elas terão todos os métodos (e outras propriedades) do modelo - a classe.

Vamos então ver um exemplo simples. Nós podemos definir nossa própria classe usando a palavra-chave class.

Métodos são definidos como funções - usando a palavra-chave def. Eles são identados para mostrar que estão dentro da classe.

   1 class NossaClasse(object):
   2     """Docstring da classe."""
   3 
   4     def __init__(self, arg1, arg2):
   5         """Docstring do método."""
   6         self.arg1 = arg1
   7         self.arg2 = arg2
   8 
   9     def imprime_args(self):
  10         """Docstring do método."""
  11         print self.arg1
  12         print self.arg2

Eu acho que existem algumas coisas que precisam ser explicadas aqui. Isto será mais fácil se você ver um exemplo funcionaldo.

   1 instance = NossaClasse('arg1', 'arg2')
   2 print type(instance)
   3 <class 'NossaClasse'>
   4 instance.imprime_args()
   5 arg1
   6 arg2

Neste exemplo criamos uma instância de NossaClasse, e a chamamos de instance. Quando criamos ela, passamos arg1 e arg2 como argumentos. Quando chamamos instance.printargs() estes argumentos originais são impressos.

Mencionando a Herança

A definição de Classe começa com: class NossaClasse(object):

A definição de classe permite algo chamado de herança. Isto significa que a sua clase pode herdar propriedades de outra classe. Eu não vou explicar isto ainda.

Tudo o que você precisa saber agora é - se você nao está herdando de outra classe então voce deve herdar de object. Suas definições de classe devem se parecer com isto: class NomeDaClasse(object):

Classes do Antigo Estilo ('''old-style''')

Só é possível herdar de object desde Python 2.2. Estas classes são chamadas de new-style, o antigo estilo de definição. Você poderá ainda ver algumas definições de classes no antigo estilo por aí.

   1 class NomeDaClasse:
   2     """
   3     Uma classe com estilo antigo que
   4     não está usando herança.
   5     """

Elas ainda funcionam - mas elas estão ultrapassadas e provavelmente não vão funcionar em Python 3.

O Método __init__

O método init (init de inicializar) é chamado quando o objeto é instanciado. A instanciação é feita (efetivamente) chamando a classe.

Do nosso exemplo :

   1 instancia = NossaClasse('arg1', 'arg2')

Aqui uma nova instância é criada. Então seu método init é chamado e são passados os argumentos 'arg1' e 'arg2'.

Para entender adequadamente o método init você precisa entender o self.

O Parâmetro self

Os argumentos aceitos pelo método init (conhecido como metodo assinatura) são:

   1 def __init__(self, arg1, arg2):

Mas na realidade nós passamos somente dois argumentos:

   1 instancia = NossaClasse('arg1', 'arg2')

O que está acontecendo, de onde está vindo o argumento extra?

Quando acessamos atributos de um objeto o fazemos por nome (ou por referência). Aqui a instância é uma referência para nosso novo objeto. Acessamos o método imprime_args da instância do objeto usando instancia.imprime_args.

Afim de acessar os atributos de dentro do método init precisamos de uma referência ao objeto.

Sempre que um método é chamado, uma referência para o objeto principal é passada como o primeiro argumento. Por convenção você sempre chama esse primeiro argumento dos seus métodos de self.

Self é um problema da linguagem Python?

Algumas pessoas consideram uma deficiência de Python nós termos de incluir o parâmetro self. Java (?) inclui ele automaticamente e o chama this.

O principal argumento a favor de self é o princípio Pythonico de explícito é melhor que implícito[10]. Desta forma nós podemos ver exatamente de onde todos os nomes de variáveis vêm.

Isso significa que podemos fazer assim no método init:

   1 self.arg1 = arg1
   2 self.arg2 = arg2

Aqui nós setamos os atributos no objeto. Você pode verificar isso fazendo o seguinte:

   1 instancia = NossaClasse('arg1', 'arg2')
   2 print instancia.arg1
   3 arg1

Valores assim são conhecidos como atributos de objeto. Aqui o método init configura os atributos arg1 e arg2 da instância.

printargs

Agora já sabemos o bastante para entender o que está acontecendo no método pintargs.

Este método não recebe nenhum argumento - então quando definimos ele, precisamos apenas definir o parâmetro self que sempre é passado para os métodos de objetos.

   1 def printargs(self):

#When this method is called it looks up (and prints) the original arguments which were saved as object attributes by init. Quando este método é chamado ele procura (e imprime) os argumentos originais que foram salvos como atributos de objeto pelo init.

Dica

Vamos colocar nossa terminologia em ordem.

As 'funções' que fazem parte de um objeto são chamadas métodos.

Os valores são chamados 'atributos'.

Você pode examinar todos os métodos e atributos que estão associados com um objeto usando o comando dir:

   1 print dir(algum_objeto)

O Poder dos objetos

Como você pode ver, objetos combinam dados e métodos usados pada trabalhar com os dados. Isto significa que é possível empacotar processos complexos - mas apresentar uma interface simples para eles. Como estes processos são feitos dentro do objeto torna-se um mero detalhe de implementação. Qualquer um usando o objeto precisa saber apenas os métodos e atributos públicos. Este é o princípio real da encapsulação. Outras partes da sua aplicação (ou outros programadores) podem usar suas classes e seus métodos públicos - mas você pode atualizar o objeto sem quebrar a inferface que eles usam.

Você também pode passar objetos ao invés de apenas dados. Este é um dos aspectos mais úteis da programação orientada a objetos. Uma vez que você tenha uma referência do objeto você pode acessar qualquer um dos atributos do objeto. Se você precisa performar um grupo complexo de operações como parte de um programa você poderia provavelmente implementar com funções e variáveis. Você pode ainda precisar usar diversas variáveis globais para estado (o que é mais lento do que acessar variáveis locais e mal se um módulo precisa ser reusável em sua aplicação) - ou seus procedimentos podem precisar passar um monte de variáveis.

Se você implementar uma única classe que possui um monte de atributos representando o estado da sua aplicação, você somente vai precisar passar a referência deste objeto. Qualquer parte do seu código que tenha acesso ao objeto, pode também usar seus atributos.

A principal vantagem dos objetos no entanto é ser uma metáfora útil. Encaixa-se na forma como pensamos. Na vida real, objetos possuem certas propriedades e interagem uns com outros. Quanto mais nossa linguagem de programação se encaixa no nosso modo de pensar, mais fácil ela será para usar e pensar criativamente.

Assuntos avançados

Apenas cobrimos o básico neste tutorial. Espera-se que você agora saiba o suficiente para criar swuas próprias classes.

Ainda tem muito para aprender. Alguns assuntos para se expandir neste tutorial incluem:

• herança
• atributos de classes

• dict

• subclasseando tipos built in

• new

• getattr e setattr

• atributos privados (underscore simples e duplo)
• classmethods e staticmethods

Sugestão: Por que não continuamos este artigo escrevendo sobre estes assuntos? - RodrigoNishino

Notas de rodapé

Traduzido por FabioCorrea, LuizCarlosGeron, NicholasAmorim