Commits

Francisco Souza committed c29c03e

Revisão do Capítulo 16.

Existia um erro no Python da seção 16.4.

Comments (0)

Files changed (1)

edicao_1.1/capitulo_16.rst

 
 Nao é lá uma grande mão, mas tem potencial para um *straight flush*.
 
-Embora seja conveniente herdar os métodos existentes, há outras informacoes num objeto ``Mao`` que podemos querer incluir quando ao exibí-lo. Para fazer isso, podemos fornecer um método ``__str__`` para a classe ``Mao`` que sobrescreva o da classe ``Baralho``::
+Embora seja conveniente herdar os métodos existentes, há outras informacoes num objeto ``Mao`` que podemos querer incluir quando ao exibí-lo. Para fazer isso, podemos fornecer um método ``__str__`` para a classe ``Mao`` que sobrescreva o da classe ``Baralho`` ::
 
-  class Mao(Baralho)
-    #...
+  class Mao(Baralho):
+    # ...
     def __str__(self):
       s = "Mao " + self.nome
       if self.estahVazia():
       self.baralho = Baralho()
       self.baralho.embaralhar()
 
-Este é o primeiro dos casos que vimos até agora em que o método de inicialização realiza uma computação significativa, para além de inicializar atributos.
+Este é o primeiro dos casos que vimos até agora em que o método de inicialização realiza uma operação diferente de apenas inicializar atributos.
 
-Para implementar jogos específicos, podemos herdar de ``JogoDeCartas`` e adicionar caracteristicas para o novo jogo. Como exemplo, vamos escrever uma simulação de Mico.
+Para implementar jogos específicos, podemos criar classes que herdam de ``JogoDeCartas`` e adicionar características para o novo jogo. Como exemplo, vamos escrever uma simulação de Mico.
 
-O objetivo do jogo é livrar-se das cartas que estiverem na mão. Para fazer isso, é preciso combinar cartas formando pares ou casais que tenham a mesma cor e o mesmo número ou figura. Por exemplo, o 4 de paus casa com o 4 de espadas porque os dois naipes são pretos. O Valete de copas combina com o Valete de ouros porque ambos são vermelhos. 
+O objetivo do jogo é livrar-se das cartas que estiverem na mão. Para fazer isso, é preciso combinar cartas formando pares ou casais que tenham a mesma cor e o mesmo número ou figura. Por exemplo, o 4 de paus casa com o 4 de espadas por que os dois naipes são pretos. O Valete de copas combina com o Valete de ouros porque ambos são vermelhos. 
 
 Antes de mais nada, a Dama de paus é removida do baralho, para que a Dama de espadas fique sem par. A Dama de espadas então faz o papel do mico. As 51 cartas que sobram são distribuidas aos jogadores em ao redor da mesa (uma carta de cada vez para cada mão). Depois que as cartas foram dadas, os jogadores devem fazer todos os casais possíveis que tiverem na mão, e em seguida descartá-los na mesa.
 
 16.6 Classe ``MaoDeMico``
 ---------------------------
 
-Uma mão para jogar Mico requer algumas habilidades para alem das habilidades gerais de uma ``Mao``. Vamos definir uma nova classe, ``MaoDeMico``, que herda de ``Mao`` e provê um método adicional chamado ``descartarCasais``::
+Uma mão para jogar Mico requer algumas habilidades além das habilidades gerais de uma ``Mao``. Vamos definir uma nova classe, ``MaoDeMico``, que herda de ``Mao`` e provê um método adicional chamado ``descartarCasais``::
 
   class MaoDeMico(Mao):
     def descartarCasais(self):
           conta = conta + 1
       return conta
 
-Começamos fazendo uma cópia da lista de cartas, para poder percorrer a cópia enquanto removemos cartas do original. Uma vez que ``self.cartas`` é modificada no laço, não queremos usá-la para controlar o percurso. Python pode ficar bem confuso se estiver percorrendo uma lista que está mudando!
+Começamos fazendo uma cópia da lista de cartas, para poder percorrer a cópia enquanto removemos cartas do original. Uma vez que ``self.cartas`` é modificada no laço, não queremos usá-la para controlar o percurso. O Python não permite que você percorra uma lista que está mudando, ou mude uma lista que está percorrendo.
 
 Para cada carta na mão, verificamos qual é a carta que faz par com ela e vamos procurá-la. O par da carta tem o mesmo ``valor`` (número ou figura) e ``naipe`` da mesma cor. A expressão ``3 - carta.naipe`` transforma um paus (naipe 0) numa espadas (naipe 3) e um ouros (naipe 1) numa copas (naipe 2). Você deve analisar a fórmula até se convencer de que as operações opostas também funcionam. Se o par da carta tambem estiver na mão, ambas as cartas são removidas.
 
 
 Quando o número total de pares alcança 25, 50 cartas foram removidas das mãos, o que significa que sobrou só uma carta e o jogo chegou ao fim.
 
-A variável ``vez`` mantém controle sobre de quem é a vez de jogar. Começa em 0 e incrementa de um em um; quando atinge ``numMaos``, o operador módulo faz ela retornar para 0.
+A variável ``vez`` mantém controle sobre de quem é a vez de jogar. Começa em 0 e incrementa de um em um, quando atinge ``numMaos``, o operador módulo faz ela retornar para 0.
 
 O método ``jogarVez`` recebe um argumento que indica de quem é a vez de jogar. O valor de retorno é o número de pares feitos durante essa rodada::
 
 
 Se ``buscarVizinho`` alguma vez circulasse pela mesa sem encontrar cartas, retornaria ``None`` e causaria um erro em outra parte do programa. Felizmente, podemos provar que isso nunca vai acontecer (desde que o fim do jogo seja detectado corretamente).
 
-Não mencionamos o método ``exibirBaralhos``. Esse você mesmo pode escrever.
+  Não mencionamos o método ``exibirBaralhos``. Esse você mesmo pode escrever.
 
 A saída a seguir é produto de uma forma reduzida do jogo, onde apenas as 15 cartas mais altas do baralho (do 10 para cima) foram dadas, para três jogadores. Com esse baralho reduzido, a jogada pára depois que 7 combinações foram feitas, ao invés de 25:: 
 
 16.8 Glossário
 ---------------
 
+classe filho/subclasse (*child class*)
+    Um nova classe criada herdando de uma classe existente.
+
+classe mãe/superclasse (*parent class*)
+    A classe de quem a classe filha herda.
+
 herança (*inheritance*)
     Habilidade de definir uma nova classe que é a versão modificada de uma classe definida anteriormente.
 
-classe mãe (*parent class*)
-    A classe de quem a classe filha herda.
-
-classe filho (*child class*)
-    Um nova classe criada herdando de uma classe existente; também chamada de "subclasse".
-