associação pythonbrasil[11] django zope/plone planet Início Logado como (Entrar)

Diferenças para "IntroducaoOop"

Diferenças entre as versões de 17 e 18
Revisão 17e 2006-07-28 16:17:19
Tamanho: 24054
Comentário: Alguns trechos traduzidos
Revisão 18e 2006-07-28 22:21:39
Tamanho: 25190
Comentário: mais um pouco
Deleções são marcadas assim. Adições são marcadas assim.
Linha 330: Linha 330:
The __init__ Method

The __init__ method (init for initialise) is called when the object is instantiated. Instantiation is done by (effectively) calling the class.

F
rom our example :
== O Método __init__ ==

##
The __init__ method (init for initialise) is called when the object is instantiated. Instantiation is done by (effectively) calling the class.
O Método __init__ (init de inicializar) é chamado quando o objeto é instanciado. A instanciação é efeita (efetivamente) chamando a classe.

Do nosso
exemplo :
Linha 339: Linha 340:
Here a new instance is created. Then it's __init__ method is called and passed the arguments 'arg1' and 'arg2'.

To properly understand the __init__ method you need to understand self.
The self Parameter

The arguments accepted by the __init__ method (known as the method signature) are :
## Here a new instance is created. Then it's __init__ method is called and passed the arguments 'arg1' and 'arg2'.
Aqui uma nova instância é criada. Então seu método __init__ é chamado são passados os argumentos 'arg1' e 'arg2'.

##
To properly understand the __init__ method you need to understand self.
Para entender adequadamente o método __init__ você precisa entender o self.

##
The self Parameter
== O Parâmetro self ==

##
The arguments accepted by the __init__ method (known as the method signature) are :
Os argumentos aceitos pelo método __init__ (conhecido como metodo assinatura) são:
Linha 349: Linha 355:
But we only actually pass it two arguments : ## But we only actually pass it two arguments :
Mas nós passamos atualmente somente dois argumentos:
Linha 354: Linha 361:
What's going on, where has the extra argument come from ?

When we access attributes of an object we do it by name (or by reference). Here instance is a reference to our new object. We access the printargs method of the instance object using instance.printargs.

In order to access object attributes from within the __init__ method we need a reference to the object.

Whenever a method is called, a reference to the main object is passed as the first argument. By convention you always call this first argument to your methods self.
## What's going on, where has the extra argument come from ?
O que está acontecendo, de onde está vindo o argumento extra
?

## When we access attributes of an object we do it by name (or by reference). Here instance is a reference to our new object. We access the printargs method of the instance object using instance.printargs.
Quando acessaos 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 printargs da instância do objeto usando instance.printargs


## In order to access object attributes from within the __init__ method we need a reference to the object.
Afim de acessar os atributos de dentro do método __init__ precisamos de uma referência ao objeto.

##
Whenever a method is called, a reference to the main object is passed as the first argument. By convention you always call this first argument to your methods self.
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.

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         """Method docstring."""
   6         self.arg1 = arg1
   7         self.arg2 = arg2
   8 
   9     def printargs(self):
  10         """Method docstring."""
  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 = OurClass('arg1', 'arg2')
   2 print type(instance)
   3 <class 'OurClass'>
   4 instance.printargs()
   5 arg1
   6 arg2

Neste exemplo criamos uma instância de OurClass, 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 OurClass(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. Sorria

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

Classes de Estilo Antigo

Só é possível herdar de object desde Python 2.2. Isto é chamado de Novo Estilo de Classes. Você poderá ainda ver algumas definições de classes no Estilo Velho por aí.

   1 class ClassName:
   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 provavelmenta 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 é efeita (efetivamente) chamando a classe.

Do nosso exemplo :

   1 instance = OurClass('arg1', 'arg2')

Aqui uma nova instância é criada. Então seu método init é chamado 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 nós passamos atualmente somente dois argumentos:

   1 instance = OurClass('arg1', 'arg2')

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

Quando acessaos 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 printargs da instância do objeto usando instance.printargs

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.

Is self a Wart ?

Some people regard it as a Python 'wart' that we have to include self. Java (?) includes it automatically and calls it this.

The main argument in favour of self is the Pythonic principle explicit is better than implicit [10]. This way we can see exactly where all our variable names come from.

This means in the init method we can do :

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

Here we are setting attributes on the object. You can verify this by doing the following :

   1 instance = OurClass('arg1', 'arg2')
   2 print instance.arg1
   3 arg1

values like this are known as object attributes. Here the init method sets the arg1 and arg2 attribute of the instance. printargs

We now know enough to understand what is happening in the printargs method.

This method doesn't take any arguments - so when we define it, we only need to specify the self parameter which is always passed to object methods.

   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.

Hint

Let's get our terminology straight.

The 'functions' that are part of an object are called methods.

The values are called 'attributes'.

You can examine all the methods and attributes that are associated with an object using the dir command :

   1 print dir(some_obj)

The Power of Objects

As you can see objects combind data and the methods used to work with the data. This means it's possible to wrap complex processes - but present a simple interface to them. How these processes are done inside the object becomes a mere implementation detail. Anyone using the object only needs to know about the public methods and attributes. This is the real principle of encapsulation. Other parts of your application (or even other programmers) can use your classes and their public methods - but you can update the object without breaking the interface they use.

You can also pass around objects instead of just data. This is one of the most useful aspects of object oriented programming. Once you have a reference to the object you can access any of the attributes of the object. If you need to perform a complex group of operations as part of a program you could probably implement it with procedures and variables. You might either need to use several global variables for storing state (which are slower to access than local variables and not good if a module needs to be reusable within your application) - or your procedures might need to pass around a lot of variables.

If you implement a single class that has lots of attributes representing the state of your application, you only need to pass around a reference to that object. Any part of your code that has access to the object, can also access its attributes.

The main advantage of objects though is that it is a useful metaphor. It fits in with the way we think. In real life objects have certain properties and interact with each other. The more our programming language fits in with our way of thinking, the easier it is to use it to think creatively. Advanced Subjects

We've only covered the basics in this tutorial. Hopefully you now understand enough to create and use your own classes.

There is lots more still to learn. Some subjects I could expand this tutorial to cover include :

  • inheritance
  • class attributes
  • dict

  • subclassing built in types
  • new

  • getattr and setattr

  • private attributes (single and double underscore)
  • classmethods and staticmethods

Footnotes

[1]

It was two years in June 2005.... I started learning Python for a project called atlantibots.

[2]

It's system of modules and packages as well - these are related to namespaces, and are the envy of other languages.

[3]

These are called the basic datatypes - plus lots more things like classes, instances, and methods that we'll meet soon in this introduction.

[4]

Like smalltalk - which is sometimes spoken of as the archetypal object oriented language.

[5]

The technical difference used to be that a function returns a value but a procedure doesn't. Nowadays they tend to all get called functions. We don't call it functional programming though, that's something else altogether. Very Happy

[6]

Or is that to protect the programmer from the code ?

[7]

The 'old' object oriented name for this is 'message passing'. These days it's not a helpful metaphor.

[8]

You can see a list of string methods at string methods.

[9]

Actually type isn't a function - it's a type. It is the type of types (type(type) is type). Very Happy We can use it as a function though.

[10]

Try import this at an interactive interpreter prompt. This is called the Zen of Python.

BR Traduzido por FabioCorrea, LuizCarlosGeron