Commits

Francisco Souza  committed e2429a1

Revisão da parte do Capítulo 14 que estava traduzida.

Foram feitas correções com as referências cruzadas aos outros capítulos (principalmente o capítulo 13), que agora estão funcionando ok.

  • Participants
  • Parent commits 6a5eef1

Comments (0)

Files changed (1)

File edicao_1.1/capitulo_14.rst

 
 .. contents:: Tópicos
 
-**ATENÇÃO** As referências cruzadas a nomes em códigos de outros capítulos (especialmente 13) ainda não foram unificadas...
-
+---------------------------------------------
 14.1 Características da orientação a objetos
------------------------------------------------
+---------------------------------------------
 
 Python é uma **linguagem de programação orientada a objetos**, o que significa que ela tem características que suportam a **programação orientada a objetos**.
 
-Não é fácil definir programação orientada a objetos, mas temos visto already algumas de suas características:
+Não é fácil definir programação orientada a objetos, mas já vimos algumas de suas características:
 
-- Programas são construídos sobre definições de objetos e definições de funções, e a maioria das computações é expressa em termos de operações sobre objetos.
+- Programas são construídos sobre definições de objetos e funções, e a maioria das operações é expressa sobre objetos.
 
 - Cada definição de objeto corresponde a algum objeto ou conceito do mundo real, e as funções que operam com aqueles objetos correspondem à maneira como os objetos do mundo real interagem.
 
-Por exemplo, a classe ``Tempo``, definida no capítulo 13 corresponde à maneira como as pessoas registram as horas do dia, e as funções que definimos correspondem aos tipos de coisas que as pessoas fazem com times. Do mesmo modo, as classes ``Ponto`` e ``Retângulo`` correspondem aos conceitos matemáticos de um ponto e de um retângulo.
+Por exemplo, a classe ``Horario``, definida no capítulo 13, corresponde à maneira como as pessoas denotam as horas do dia, e as funções que definimos correspondem às coisas que a pessoas fazem com uma determinada hora. Do mesmo modo, as classes ``Ponto`` e ``Retangulo`` correspondem aos conceitos matemáticos de um ponto e de um retângulo, respectivamente.
 
-Até aqui, não tiramos vantagem das características fornecidas por Python que suportam a programação orientada a objetos. Estritamente falando, estas características não são necessárias. Na maior parte das vezes, elas fornecem uma sintaxe alternativa para as coisas que já fizemos, mas em muitos casos, a alternativa é mais concisa e convém mais acuradamente à estrutura do programa.
+Até aqui, não tiramos vantagem dos recursos do Python que suportam a programação orientada a objetos. De maneira estrita, estas características não são necessárias. Na maioria das vezes, elas fornecem uma sintaxe alternativa para as coisas que já fizemos, mas em muitos casos a alternativa é mais concisa e faz mais sentido na estrutura do programa.
 
-Por exemplo, no programa ``Time``, não existe uma conexão óbvia entre a definição da classe e a definição da função que segue. Com alguma investigação, fica aparente que toda função toma pelo menos um objeto ``Time`` como um parâmetro.
+Por exemplo, no programa ``Horario``, não existe uma conexão óbvia entre a definição da classe e a definição da função que segue. Podemos observar que toda função toma pelo menos um objeto ``Horaro`` na lista de parâmetros.
 
-Esta observação é a motivação por trás dos **métodos**. Já temos visto alguns métodos, tais como ``keys`` (``chaves``) e ``values`` (``valores``), os quais foram invocados em dicionários. Cada método é associado com uma classe e é intended para ser invocado em instâncias daquela classe.
+Esta observação é a motivação por trás dos **métodos**. Já temos visto alguns métodos, tais como ``keys`` e ``values``, que foram invocados em dicionários. Cada método é associado a classe e é invocado em instâncias daquela classe.
 
 Métodos são simplesmente como funções, com duas diferenças:
 
-- Métodos são definidos dentro da definição de uma classe para tornar explícita a relação entre a classe e o método.
+- Métodos são definidos dentro da definição de uma classe, o que torna explícita a relação entre a classe e o método.
 
-- A sintaxe para a chamada do método é diferente da sintaxe para a chamada de uma função.
+- A sintaxe para a chamada de um método é diferente da sintaxe para a chamada de uma função.
 
-Nas próximas seções, vamos pegar as funções dos dois capítulos anteriores e transformá-las em métodos. Esta transformação é puramente mecânica: você pode conseguí-la simplesmente seguindo uma seqüência de passos. Se você se sentir confortável convertendo de uma forma para a outra, você estará apto para escolher a melhor forma para seja o lá o que for que você estiver fazendo.
+Nas próximas seções, vamos pegar as funções dos dois capítulos anteriores e transformá-las em métodos. Esta transformação é puramente mecânica: você pode consegui-la simplesmente seguindo uma sequência de passos. Se você se sentir confortável convertendo de uma forma para a outra, você estará apto para escolher a melhor forma para qualquer coisa que você estiver fazendo.
 
-14.2 exibeHora (printTime)
------------------------------
+-------------------------------
+14.2 Método ``imprimirHorario``
+-------------------------------
 
-No capítulo 13, definimos uma classe chamada ``Horário`` (``Time``) e você escreveu uma função chamada ``exibeHora`` (``printTime``), que deve ter ficado mais ou menos assim::
+No capítulo 13, definimos uma classe chamada ``Horario`` e você escreveu uma função chamada ``imprimirHorario`` (no primeiro exercício), que deve ter ficado mais ou menos assim::
 
   class Horario:
     pass
 
-  def exibeHora(time)
-    print str(time.horas) + ?:? + \
-      str(time.minutos) + ?:? + \
-      str(time.segundos)
+  def imprimirHorario(horario)
+    print str(horario.horas) + ':' + \
+      str(horario.minutos) + ':' + \
+      str(horario.segundos)
 
-Para chamar esta função, passamos um objeto ``Time`` como um parâmetro:
+Para chamar esta função, passamos um objeto ``Horario`` como um parâmetro:
 
->>> horaCorrente = Hora()
+>>> horaCorrente = Horario()
 >>> horaCorrente.horas = 9
 >>> horaCorrente.minutos = 14
 >>> horaCorrente.segundos = 30
->>> exibeHora(horaCorrente)
+>>> imprimirHorario(horaCorrente)
 
-Para fazer de ``exibeHora`` um método, tudo o que temos a fazer é mover a definição da função para dentro da definição da classe. Note a mudança na endentação::
+Para fazer de ``imprimirHorario`` um método, tudo o que temos a fazer é mover a definição da função para dentro da definição da classe. Note a mudança na endentação::
 
   class Horario:
-    def exibeHora(time):
-      print str(time.horas) + ?:? + \
-        str(time.minutos) + ?:? + \
-        str(time.segundos)
+    def imprimirHorario(horario):
+      print str(horario.horas) + ':' + \
+        str(horario.minutos) + ':' + \
+        str(horario.segundos)
 
-Agora podemos chamar ``exibeHora`` usando a natação de ponto::
+Agora podemos chamar ``imprimirHorario`` usando a natação de ponto::
 
-  >>> horaCorrente.exibeHora()
+  >>> horaCorrente.imprimirHorario()
 
-Como é usual, o objeto no qual o método é invocado aparece antes do ponto e o nome do método aparece depois do ponto.
+Como já vimos, o objeto no qual o método é invocado aparece antes do ponto e o nome do método aparece depois do ponto.
 
-O objeto no qual o método é invocado é atribuído ao primeiro parâmetro, então, neste caso, ``horaCorrente`` é atribuído ao parâmetro ``time``.
+O objeto no qual o método é invocado é atribuído ao primeiro parâmetro, então, neste caso, ``horaCorrente`` é atribuído ao parâmetro ``horario``.
 
-Por convenção, o primeiro parâmetro de um método é chamado ``self``. A razão para isto é um pouco convoluted, mas é baseada numa metáfora útil.
+Por convenção, o primeiro parâmetro de um método é chamado ``self``. A razão para isto é um pouco confusa, mas é baseada numa metáfora útil.
 
-A sintaxe para uma chamada de função, ``exibeHora(horaCorrente)``, sugere que a função é um agente ativo. Diz algo como, ?Ei, ``exibeHora``! Aqui está um objeto para você exibir.?
+A sintaxe para uma chamada de função, ``imprimirHorario(horaCorrente)``, sugere que a função é um agente ativo. Diz algo como, 'Ei, ``exibeHora``! Aqui está um objeto para você exibir.'.
 
-Na programação orientada a objetos, os objetos são agentes ativos. Uma chamado do tipo ``horaCorrente.exibeHora()`` diz ?Ei, ``horaCorrente``! Por favor exiba-se a si mesmo!?
+Na programação orientada a objetos, os objetos são agentes ativos. Uma chamado do tipo ``horaCorrente.imprimirHorario()`` diz 'Ei, ``horaCorrente``! Por favor exiba-se a si mesmo!'.
 
-Esta mudança de perspectiva pode ser mais polida, mas não fica óbvio que seja útil. Nos exemplos que temos visto até aqui, pode ser que não seja. Mas às vezes, deslocar a responsabilidade das funções para cima dos objetos torna possível escrever funções mais versáteis, e torna mais fácil manter e reutilizar o código.
+Esta mudança de perspectiva pode ser mais polida e bela, mas não demonstra a utilidade que existe no uso de métodos ao invés de funções. Nos exemplos que vimos até aqui, poder ser que não haja tanta utilidade em usar métodos. Mas às vezes, deslocar a responsabilidade das funções para cima dos objetos torna possível escrever funções mais versáteis, e torna mais fácil manter e reutilizar o código.
 
+-----------------------
 14.3 Um outro exemplo
 -----------------------
 
-Vamos converter ``incremento`` (da Seção 13.3) em um método. Para poupar espaço, deixaremos de fora métodos definidos previamente(anteriormente?), mas você deve mantê-los em sua versão::
+Vamos converter ``incrementar`` (da Seção 13.3) em um método. Para poupar espaço, deixaremos de fora métodos definidos previamente, mas você deve mantê-los em sua versão::
 
-  class Time:
-    #previous method definitions here...
+  class Horario:
+    # Métodos definidos previamente devem estar aqui
 
-    def increment(self, segundos):
-    self.seconds = seconds + self.seconds
+    def incrementar(self, segundos):
+      self.segundos = segundos + self.segundos
 
-    while self.segundos >= 60:
-      self.seconds = self.segundos - 60
-      self.minutes = self.minutos + 1
+      while self.segundos >= 60:
+        self.segundos = self.segundos - 60
+        self.minutos = self.minutos + 1
 
-    while self.minutes >= 60:
-      self.minutes = self.minutos - 60
-      self.hours = self.horas + 1
+      while self.minutos >= 60:
+        self.minutos = self.minutos - 60
+        self.horas = self.horas + 1
 
-A transformação é puramente mecânica ? movemos a definição do método para dentro da definição da classe e mudamos o nome do primeiro parâmetro.
+A transformação é puramente manual e mecânica: movemos a definição do método para dentro da definição da classe e mudamos o nome do primeiro parâmetro.
 
-Agora podemos chamar ``incremento`` como um método::
+Agora podemos chamar ``incrementar`` como um método::
 
-  horaCorrente.incremento(500)
+  horaCorrente.incrementar(500)
 
-De novo, o objeto no qual o método é chamado gets atribui ao primeiro parâmetro, ``self``. O segundo parâmetro, ``segundo`` toma(gets) o valor ``500``.
+De novo, o objeto no qual o método é chamado é atribuído ao primeiro parâmetro, ``self``. O segundo parâmetro, ``segundos`` recebe o valor ``500``.
 
-  *Como um exercício, converta ?converteParaSegundos? (da Seção 13.5) para um método na classe ?Time?.*
+  Como exercício, converta 'converterParaSegundos' (da Seção 13.5) para um método na classe ``Horario``.
 
+--------------------------------
 14.4 Um exemplo mais complicado
----------------------------------
+--------------------------------
 
 ...