Commits

Francisco Souza committed 9741771

Revisão de parte do Capítulo 13.

Comments (0)

Files changed (1)

edicao_1.1/capitulo_13.rst

 
 .. contents:: Tópicos
 
--------------
-13.1 Horario
--------------
+-----------------------------------------------
+13.1 Criando uma classe para informar as horas
+-----------------------------------------------
  
 Como exemplo de outro tipo definido pelo usuário, vamos definir uma classe chamada ``Horario`` que grava os registros de horário do dia. Eis a definição da classe::
 
-	class Horario: 
-		pass 
+  class Horario: 
+	pass 
 
 Podemos criar uma nova instância de ``Horario`` e determinar atributos para horas, minutos e segundos::
 
 
   Como exercício, escreva uma função 'imprimirHorario' que tenha como argumento um objeto Horario e imprima-o na forma horas:minutos:segundos.
 
-  Como um segundo exercício, escreva uma função booleana que tenha como argumento dois objetos Horario, h1 e h2, e retorne verdadeiro (1) se h1 vem depois de h2 cronologicamente, do contrário, retorne falso (0).
+  Como um segundo exercício, escreva uma função booleana que tenha como argumento dois objetos Horario, h1 e h2, e retorne verdadeiro (``True``) se h1 vem depois de h2 cronologicamente, do contrário, retorne falso (``False``).
  
 -------------------
 13.2 Funções Puras
 ------------------- 
 
-Nas próximas sessões, vamos escrever duas versões de uma função chamada ``adicionaHorario``, que calcula a soma de dois horários. Elas vão demonstrar 2 tipos de funções: funções puras e funções modificadoras. 
+Nas próximas seções, vamos escrever duas versões de uma função chamada ``adicionaHorario``, que calcula a soma de dois horários. Elas vão demonstrar 2 tipos de funções: funções puras e funções modificadoras. 
 
 Segue uma versão tosca de ``somaHorario``::
 
 	>>> horarioTermino = somaHorario(horarioAtual, horarioDoPao) 
 	>>> imprimirHorario(horarioTermino) 
 
-A saída deste programa é 12:49:30, o que é correto. Por outro lado, existem casos onde o resultado não é correto. Você pode pensar em algum ?
+A saída deste programa é 12:49:30, o que é correto. Por outro lado, existem casos onde o resultado não é correto. Você pode pensar em algum?
 
-O problema é que esta função não lida com casos onde o número de segundos ou minutos é acrescentado em mais de sessenta. Quando isso acontece, temos de "transportar" os segundos extras para a coluna dos minutos ou os minutos extras na coluna das horas.
+O problema é que esta função não trata casos onde o número de segundos ou minutos é acrescentado em mais de sessenta. Quando isso acontece, temos de "transportar" os segundos extras para a coluna dos minutos ou os minutos extras na coluna das horas.
 
 Aqui está a segunda versão corrigida da função::
 
 
 		return soma 
 
-Apesar desta função estar correta, ela está começando a ficar grande. Depois vamos sugerir uma aproximação alternativa que rende um código menor. Clique aqui para feedback
+Apesar desta função estar correta, ela está começando a ficar grande. Depois vamos sugerir uma aproximação alternativa que rende um código menor.
 
 ------------------- 
 13.3 Modificadores
  
 Existem momentos quando é útil para uma função modificar um ou mais dos objetos que ela recebe como parâmetro. Usualmente, quem está chamando a função mantém uma referência para os objetos que ele passa, de forma que quaisquer mudanças que a função faz são visíveis para quem está chamando. Funções que trabalham desta forma são chamadas modificadores. 
 
-``incrementar``, que adiciona um número dado de segundos para um objeto Horario, que poderia ser escrito quase naturalmente como um modificador. Um rascunho tosco da função seria algo parecido com isso::
+A função ``incrementar``, que adiciona um número dado de segundos para um objeto ``Horario``, poderia ser escrita quase naturalmente como um modificador. Um rascunho tosco da função seria algo parecido com isso::
 
 
 	def incrementar(horario, segundos): 
 			horario.horas = horario.horas + 1 
 
 
-A primeira linha executa a operação básica; o resto lida com os caso especiais que vimos antes. 
+A primeira linha executa a operação básica, o resto trata os caso especiais que vimos antes. 
 
-Esta função esta correta ? O que aconteceria se o parametro segundos for muito maior que sessenta ? Nesse caso, não é suficiente transportar apenas uma vez; teríamos de continuar fazendo isso até que segundos seja menor que sessenta. Uma solução seria substituir os comando if por comandos while::
+Esta função está correta? O que aconteceria se o parâmetro segundos for muito maior que sessenta? Nesse caso, não é suficiente transportar apenas uma vez, teríamos de continuar fazendo isso até que segundos seja menor que sessenta. Uma solução seria substituir os comando ``if`` por comandos ``while``::
 
 
 	def incrementar(horario, segundos): 
 			horario.horas = horario.horas + 1 
 
 
-Esta função agora esta correta, mas não é a solução mais eficiente. 
+Esta função agora está correta, mas não é a solução mais eficiente. 
 
-Como um exercício, reescreva esta função de maneira que ela não contenha nenhum loop. Como um segundo exercício, reescreva ``incrementar`` como uma função pura, e escreva chamadas de funções para as duas funções. Clique aqui para feedback
+  Como um exercício, reescreva esta função de maneira que ela não contenha nenhum loop.
+  
+  Como um segundo exercício, reescreva ``incrementar`` como uma função pura, e escreva chamadas de funções para as duas funções.
  
 -----------------------
-13.4 O que é melhor ?
+13.4 O que é melhor?
 -----------------------
 
-Qualquer coisa que pode ser feita com modificadores também podem ser feitas com funções puras. De fato, algumas linguagens de programação permitem apenas funções puras. Existe alguma evidência que programas que usam funções puras são desenvolvidos mais rapidamente e são menos propensos a erros que programas que usam modificadores. No entanto, modificadores as vezes são convenientes, e em alguns casos, programação funcional é menos eficiente. 
+Qualquer coisa que pode ser feita com modificadores também podem ser feitas com funções puras. De fato, algumas linguagens de programação permitem apenas funções puras. Existe alguma evidência que programas que usam funções puras são desenvolvidos mais rapidamente e são menos propensos a erros que programas que usam modificadores. No entanto, modificadores às vezes são convenientes, e em alguns casos, programação funcional é menos eficiente. 
 
-Em geral, recomendamos que você escreva funções puras sempre que for necessário e recorrer para modificadores somente se existir uma grande vantagem. Esta aproximação poderia ser chamada de um estilo de programação funcional. Clique aqui para feedback
+Em geral, recomendamos que você escreva funções puras sempre que for necessário e recorrer para modificadores somente se existir uma grande vantagem. Esta aproximação poderia ser chamada de um estilo de programação funcional.
 
----------------------------------------------------------------------
-13.5 Desenvolvimento Prototipado versus Desenvolvimento Planejamento
----------------------------------------------------------------------
+-----------------------------------------------------
+13.5 Desenvolvimento Prototipado versus Planejamento
+-----------------------------------------------------
 
-Neste capítulo, demonstramos uma aproximação para o desenvolvimento de programas que chamamos de desenvolvimento prototipado. Em cada caso, escrevemos um rascunho tosco (ou prototipo) que executou os cálculos básicos e então, o testamos em uns poucos casos, corrigindo então, as falhas que fomos encontrando. 
+Neste capítulo, demonstramos uma aproximação para o desenvolvimento de programas que chamamos de **desenvolvimento prototipado**. Em cada caso, escrevemos um rascunho tosco (ou protótipo) que executa os cálculos básicos e, então, o testamos em uns poucos casos, corrigindo as falhas que forem encontradas. 
 
-Embora esta aproximação possa ser eficaz, ela pode conduzir para código que é desnecessariamente complicado desde que trata de muitos casos especiais e unreliable desde que é difícil saber se você encontrou todos os erros.
+Embora esta aproximação possa ser eficaz, ela pode conduzir o código para um formato desnecessariamente complicado, já que trata de muitos casos especiais e inseguro, já que é difícil saber se você encontrou todos os erros.
 
 An alternative is planned development, in which high-level insight into the problem can make the programming much easier. In this case, the insight is that a Time object is really a three-digit number in base 60! The second component is the "ones column," the minute component is the "sixties column," and the hourcomponent is the "thirty-six hundreds column." 
 
 
 Mas se XXXX But if we have the insight to treat times as base 60 numbers and make the investment of writing the conversion functions (converterParaSeguntos e criarHorario), nós conseguimos um programa que é menor, fácil de ler e depurar, e mais confiável. 
 
-É também fácil para adicionar funcionalidades depois. Por exemplo, imagine subtrair dois Horarios para encontrar a duração entre eles. Uma aproximação ingênua seria implementar subtração com empréstimo (?? borrowing - Isso mesmo ??). Usando as funções de conversão será mais fácil e provavelmente estará correto. 
+É também fácil para adicionar funcionalidades depois. Por exemplo, imagine subtrair dois Horarios para encontrar a duração entre eles. Uma aproximação ingênua seria implementar subtração com empréstimo (?? borrowing - Isso mesmo??). Usando as funções de conversão será mais fácil e provavelmente estará correto. 
 
 Ironicamente, algumas vezes fazer um problema mais difícil (ou mais genérico) o torna mais simples (porque existem alguns poucos casos especiais e poucas oportunidades para errar). Clique aqui para feedback