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

Diferenças para "IntroducaoOop"

Diferenças entre as versões de 20 e 21
Revisão 20e 2006-08-13 16:16:03
Tamanho: 29146
Comentário:
Revisão 21e 2006-09-09 05:19:46
Tamanho: 30462
Comentário:
Deleções são marcadas assim. Adições são marcadas assim.
Linha 376: Linha 376:
#Some people regard it as a Python 'wart' that we have to include self. Java (?) includes it automatically and calls it this.
Agumas pessoas consideram uma deficiência de Python nós termos de incluir o parâmetro self. Java (?) inclui ele automaticamente e o chama '''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.
##Some people regard it as a Python 'wart' that we have to include self. Java (?) includes it automatically and calls it this.

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'''.

##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.
Linha 382: Linha 384:
#This means in the __init__ method we can do : ##This means in the __init__ method we can do :
Linha 389: Linha 392:
#Here we are setting attributes on the object. You can verify this by doing the following : ##Here we are setting attributes on the object. You can verify this by doing the following :
Linha 397: Linha 401:
#values like this are known as object attributes. Here the __init__ method sets the arg1 and arg2 attribute of the instance. ##values like this are known as object attributes. Here the __init__ method sets the arg1 and arg2 attribute of the instance.
Linha 402: Linha 407:
#We now know enough to understand what is happening in the printargs method. ##We now know enough to understand what is happening in the printargs method.
Linha 405: Linha 410:
#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. ##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.
Linha 415: Linha 420:
#Hint ##Hint
Linha 418: Linha 423:
#Let's get our terminology straight. ##Let's get our terminology straight.
Linha 421: Linha 426:
#The 'functions' that are part of an object are called methods. ##The 'functions' that are part of an object are called methods.
Linha 424: Linha 429:
#The values are called 'attributes'. ##The values are called 'attributes'.
Linha 427: Linha 432:
#You can examine all the methods and attributes that are associated with an object using the dir command : ##You can examine all the methods and attributes that are associated with an object using the dir command :
Linha 433: Linha 438:
#The Power of Objects ##The Power of Objects
Linha 436: Linha 441:
#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. ##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.
Linha 439: Linha 444:
#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. ##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.
Linha 442: Linha 447:
#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. ##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.
Linha 445: Linha 450:
#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. ##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.
Linha 448: Linha 453:
#Advanced Subjects ##Advanced Subjects
Linha 451: Linha 456:
#We've only covered the basics in this tutorial. Hopefully you now understand enough to create and use your own classes.
Apenas cobrimos o básico neste tutorial. Espera-se que você agora saiba o suficiente para criar suas próprias classes.

#There is lots more still to learn. Some subjects I could expand this tutorial to cover include :
##We've only covered the basics in this tutorial. Hopefully you now understand enough to create and use your own classes.

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

##There is lots more still to learn. Some subjects I could expand this tutorial to cover include :
Linha 457: Linha 464:
# * inheritance
#    * class attributes
# * __dict__
# * subclassing built in types
# * __new__
# * __getattr__ and __setattr__
# * private attributes (single and double underscore)
# * classmethods and staticmethods
## * inheritance
## * class attributes
## * __dict__
#
# * subclassing built in types
## * __new__
## * __getattr__ and __setattr__
## * private attributes (single and double underscore)
## * classmethods and staticmethods
Linha 476: Linha 483:
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.||
##Footnotes
Notas de rodapé

##
||[1]||It was two years in June 2005.... I started learning Python for a project called atlantibots.||

||[1]||Fez 2 anos em Junho de 2005.... Eu comecei a aprener Python para um projeto chamado atlantibots.||

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

||[2]||São módulos do sistema e pacotes - estes são relacionados ao namespaces, e são os desafetos de outras linguagens.||

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

||[3]||Estes são os chamados tipos básicos de dados - junte mais coisas como classes, instâncias, e métodos e nós iremos nos encontrar logo, logo nesta introdução.||

Linha 481: Linha 500:
||[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.||

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

||[5]||A diferença técnica costumava ser que uma função retornava um valor mas um procedure não. De agora em diante, todos eles tendem a ser chamado de funções. Nós não chamamos isso de programação funcional mesmo assim, é algo diferente. :D||

##
||[6]||Or is that to protect the programmer from the code ?||
||[6]||Ou isso é para proteger o programador do código ?||

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

||[7]||O antigo nome da orientação a objetos para isso era 'message passing'. Estes dias não é lá uma metáfora que ajuda muito.||

##
||[8]||You can see a list of string methods at string methods.||
||[8]||Você pode ver uma lista de métodos string nos métodos do módulo strings..||

##||[
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.||
||[9]||Na realidade, type não é uma função - é um tipo. É o tipo dos tipos! (type(type) é type). :D Podemos usar como uma função mesmo assim!.||

##
||[10]||Try import this at an interactive interpreter prompt. This is called the Zen of Python.||
||[10]||Tente importar isto em um prompt interativo. Isso é chamado "The Zen Of Python".||

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é

[1]

Fez 2 anos em Junho de 2005.... Eu comecei a aprener Python para um projeto chamado atlantibots.

[2]

São módulos do sistema e pacotes - estes são relacionados ao namespaces, e são os desafetos de outras linguagens.

[3]

Estes são os chamados tipos básicos de dados - junte mais coisas como classes, instâncias, e métodos e nós iremos nos encontrar logo, logo nesta introdução.

[4]

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

[5]

A diferença técnica costumava ser que uma função retornava um valor mas um procedure não. De agora em diante, todos eles tendem a ser chamado de funções. Nós não chamamos isso de programação funcional mesmo assim, é algo diferente. :D

[6]

Ou isso é para proteger o programador do código ?

[7]

O antigo nome da orientação a objetos para isso era 'message passing'. Estes dias não é lá uma metáfora que ajuda muito.

[8]

Você pode ver uma lista de métodos string nos métodos do módulo strings..

[9]

Na realidade, type não é uma função - é um tipo. É o tipo dos tipos! (type(type) é type). :D Podemos usar como uma função mesmo assim!.

[10]

Tente importar isto em um prompt interativo. Isso é chamado "The Zen Of Python".

BR Traduzido por FabioCorrea, LuizCarlosGeron