Commits

Francisco Souza committed ba1504f

Conclusão da revisão do Capítulo 15.

  • Participants
  • Parent commits 3c8e15d

Comments (0)

Files changed (1)

File edicao_1.1/capitulo_15.rst

 15.4 Comparando cartas
 ----------------------
 
-Para tipos primitivos, existem operadores condicionais (<, >, ==, etc.) que comparam valores e determinam quando um é maior que, menor que ou igual a outro. Para tipos definidos pelo usuário, nós podemos sobrescrever o comportamento dos operadores pré-definidos fornecendo um método ``__cmp__``. Por convenção, ``__cmp__`` recebe dois parâmetros, ``self`` e ``other``, e retorna 1 se o primeiro objeto for maior, -1 se o segundo objeto for maior, e 0 se eles forem iguais.
+Para tipos primitivos, existem operadores condicionais (<, >, ==, etc.) que comparam valores e determinam quando um é maior que, menor que ou igual a outro. Para tipos definidos pelo usuário, nós podemos sobrescrever o comportamento dos operadores pré-definidos fornecendo um método ``__cmp__``. O método ``__cmp__`` recebe dois parâmetros que, por convenção, chamam-se ``self`` e ``other``, e retorna 1 se o primeiro objeto for maior, -1 se o segundo objeto for maior, e 0 se eles forem iguais.
 
-Alguns tipos são totalmente ordenados, o que significa que nós podemos comparar quaisquer dois elementos e dizer qual é o maior. Por exemplo, os inteiros e os números de ponto flutuante são totalmente ordenados. Alguns conjuntos são não-ordenados, o que significa que não existe maneira significativa de dizer que um elemento é maior que o outro. Por exemplo, as frutas são não-ordenadas, e é por isso que não podemos comparar maçãs e laranjas.
+Alguns tipos são totalmente ordenados, o que significa que nós podemos comparar quaisquer dois elementos e dizer qual é o maior. Por exemplo, os inteiros e os números de ponto flutuante são totalmente ordenados. Alguns conjuntos são não-ordenados, ou seja, não existe maneira significativa de dizer que um elemento é maior que o outro. Por exemplo, as frutas são não-ordenadas, e é por isso que não podemos comparar maçãs e laranjas.
 
 O conjunto de cartas de jogo é parcialmente ordenado, o que significa que às vezes você pode comparar cartas, e às vezes não. Por exemplo, você sabe que o 3 de Paus é maior do que o 2 de Paus, e que o 3 de Ouros é maior do que o 3 de Paus. Mas qual é o melhor, o 3 de Paus ou o 2 de Ouros? Um tem uma posição maior, mas o outro tem um naipe maior.
 
 
   def __cmp__(self, other):
     # verificar os naipes
-    if self.naipe > other.naipe: return 1
-    if self.naipe < other.naipe: return -1
+    if self.naipe > other.naipe:
+      return 1
+    if self.naipe < other.naipe:
+      return -1
+    
     # as cartas têm o mesmo naipe... verificar as posições
-    if self.posicao > other.posicao: return 1
-    if self.posicao < other.posicao> return -1
+    if self.posicao > other.posicao:
+      return 1
+    if self.posicao < other.posicao:
+      return -1
+    
     # as posições são iguais... é um empate
     return 0
 
 15.5 Baralhos
 -------------
 
-Agora que nós temos objetos para representar ``Cartas``, o próximo passo lógico é definir uma classe para representar um ``Baralho``. É claro que um baralho é formado por cartas; portanto, cada objeto ``Baralho`` irá conter uma lista de cartas como um atributo.
+Agora que nós temos objetos para representar ``Cartas``, o próximo passo lógico é definir uma classe para representar um ``Baralho``. É claro que um baralho é formado por cartas, portanto, cada objeto ``Baralho`` irá conter uma lista de cartas como um atributo.
 
 A seguir, damos uma definição para a classe ``Baralho``. O método de inicialização cria o atributo ``cartas`` e gera o conjunto padrão de 52 cartas::
 
-  classe Baralho
+  class Baralho:
     def __init__(self):
       self.cartas = []
       for naipe in range(4):
         for posicao in range(1, 14):
           self.cartas.append(Carta(naipe, posicao))
 
-A maneira mais fácil de popular o baralho é com um laço aninhado. O laço externo enumera os naipes de 0 até 3. O laço interno enumera as posições de 1 até 13. Como o laço externo repete quatro vezes e o laço interno 13 vezes, o número total de vezes que o corpo é executado é 52 (13 vezes quatro). Cada iteração cria uma nova instância de ``Carta`` com o naipe e posição atuais e a inclui na lista ``cartas``.
+A maneira mais fácil de popular o baralho é com um laço aninhado. O laço externo enumera os naipes de 0 até 3. O laço interno enumera as posições de 1 até 13. Como o laço externo repete quatro vezes e o laço interno 13 vezes, o número total de vezes que o corpo é executado é 52 (treze vezes quatro). Cada iteração cria uma nova instância de ``Carta`` com o naipe e posição atuais e a inclui na lista ``cartas``.
 
-O método ``append`` trabalha sobre listas mas não, obviamente, sobre tuplas.
+O método ``append`` trabalha sobre listas, mas obviamente não trabalha sobre tuplas.
 
 -------------------------
 15.6 Imprimindo o baralho
 
 Aqui, e a partir daqui, as reticências (...) indicam que nós omitimos os outros métodos da classe.
 
-Como uma alternativa a ``imprimirBaralho``, nós poderíamos escrever um método ``__str__`` para a classe ``Baralho``. A vantagem de ``__str__`` é que ela é mais flexível. Em vez de apenas imprimir o conteúdo de um objeto, ela gera uma representação em string que outras partes do programa podem manipular antes de imprimir ou armazenar para uso posterior.
+Como uma alternativa ao método ``imprimirBaralho``, nós poderíamos escrever um método ``__str__`` para a classe ``Baralho``. A vantagem de ``__str__`` é que ela é mais flexível. Em vez de apenas imprimir o conteúdo de um objeto, ela gera uma representação em string que outras partes do programa podem manipular antes de imprimir ou armazenar para uso posterior.
 
 Abaixo, uma versão de ``__str__`` que devolve uma representação em string de um ``Baralho``. Para adicionar um pouco de estilo, ela distribui as cartas em uma cascata, na qual cada carta é indentada um espaço a mais do que a carta anterior::
 
 
 Em vez de assumir que existem 52 cartas no baralho, nós obtivemos o comprimento real da lista e o guardamos na variável ``nCartas``.
 
-Para cada carta no baralho, nós escolhemos uma carta aleatória dentre as cartas que ainda não foram embaralhadas. Então, nós trocamos a carta atual (``i``) pela carta selecionada (``j``). Para trocar as cartas, nós usamos uma atribuição de tupla, como visto na Seção 9.2::
+Para cada carta no baralho, nós escolhemos uma carta aleatória dentre as cartas que ainda não foram embaralhadas. Então, nós trocamos a carta atual (``i``) pela carta selecionada (``j``). Para trocar as cartas, nós usamos uma atribuição de tupla, como visto na Seção 9.2.
 
-  self.cartas[i], self.cartas[j] = self.cartas[j], self.cartas[i]
-
-
-*Como exercício, reescreva esta linha de código sem usar uma atribuição de sequência.*
+  *Como exercício, reescreva esta linha de código sem usar uma atribuição de sequência.*
 
 ------------------------------------
 15.8 Removendo e distribuindo cartas
 ------------------------------------
 
-Outro método que pode ser útil para a classe ``Baralho`` é ``removerCarta``. Ele recebe uma carta como parâmetro, remove-a do baralho e retorna verdadeiro (1), se a carta estava no baralho e falso (0), caso contrário::
+Outro método que pode ser útil para a classe ``Baralho`` é ``removerCarta``. Ele recebe uma carta como parâmetro, remove-a do baralho e retorna verdadeiro (``True``), se a carta estava no baralho e falso (``False``), caso contrário::
 
   class Baralho:
     ...
     def removerCarta(self, carta):
       if carta in self.cartas:
         self.cartas.remove(carta)
-        return 1
+        return True
       else
-        return 0
+        return False
 
 O operador ``in`` retorna verdadeiro se o primeiro operando estiver contido no segundo, que deve ser uma lista ou uma tupla. Se o primeiro operando for um objeto, Python usa o método ``__cmp__`` do objeto para determinar igualdade com os itens da lista. Como o método ``__cmp__`` da classe ``Carta`` verifica por igualdade profunda, o método ``removerCarta`` também testa por igualdade profunda.
 
   class Baralho:
     ...
     def distribuirCarta(self):
-      return self.cards.pop()
+      return self.cartas.pop()
 
 Na verdade, ``pop`` remove a *última* carta da lista. Portanto, nós estamos realmente distribuindo as cartas do fim para o início do baralho.
 
-Uma última operação que nós poderíamos querer é a função booleana ``estahVazio``, que retorna verdadeiro se o baralho não contém cartas::
+Uma última operação que nós poderíamos querer é o método booleano ``estahVazio``, que retorna verdadeiro se o baralho não contém cartas::
 
   class Baralho:
     ...
 15.9 Glossário
 --------------
 
-**codificar** (*encode*) 
-  Representar um conjunto de valores usando outro conjunto de valores,  construindo um mapeamento entre eles.
-
-**atributo de classe** (*class atribute*)
-  Uma variável que é definida dentro de uma definição de classe, mas fora de qualquer método. Atributos de classe podem ser acessados a partir de qualquer método da classe e são compartilhados por todas as instâncias da classe.
-
-**acumulador** (*accumulator*)
+acumulador (*accumulator*)
   Uma variável usada em um laço para acumular uma série de valores, para, por exemplo, concatená-los em uma string ou somá-los a uma soma em andamento.
 
+atributo de classe (*class atribute*)
+  Uma variável que é definida dentro de uma definição de classe, mas fora de qualquer método. Atributos de classe podem ser acessados a partir de qualquer método da classe e são compartilhados por todas as instâncias da classe.
+  
+atributo de instância (*instance atribute*)
+  Uma variável que é definida em uma instância de uma classe. Atributos de instância não são compartilhados entre todas as instâncias de uma classe, sendo exclusivos de uma determinada instância.
+
+codificar (*encode*) 
+  Representar um conjunto de valores usando outro conjunto de valores,  construindo um mapeamento entre eles.