Commits

Francisco Souza committed 3db55b9

Revisão do Capítulo 9.

  • Participants
  • Parent commits 9aa3056

Comments (0)

Files changed (1)

edicao_1.1/capitulo_09.rst

 
 .. contents:: Tópicos
 
--------------------------
-9.1 Mutabilidade e tuplas
--------------------------
+----------------------------------
+9.1 Capacidade de mutação e tuplas
+----------------------------------
 
 Até agora, você tem visto dois tipos compostos: strings, que são compostos de caracteres; e listas, que são compostas de elementos de qualquer tipo. Uma das diferenças que notamos é que os elementos de uma lista podem ser modificados, mas os caracteres em uma string não. Em outras palavras, strings são **imutáveis** e listas são **mutáveis**.
 
 >>> type(t2)
 <type 'string'>
 
-Questões de sintaxe de lado, as operações em tuplas são as mesmas operações das listas. O operador índice seleciona um elemento da tupla.
+Deixando as questões de sintaxe de lado, as operações em tuplas são as mesmas operações das listas. O operador índice seleciona um elemento da tupla.
 
 >>> tupla = ('a', 'b', 'c', 'd', 'e')
 >>> tupla[0]
 
 >>> a, b = b, a
 
-O lado esquedo é uma tupla de variáveis; o lado direito é uma tupla de valores. Cada valor é atribuído à sua respectiva variável. Todas as expressões do lado direito são avaliadas antes de qualquer das atribuições. Esta característica torna as atribuições de tupla bastante versáteis.
+O lado esquedo é uma tupla de variáveis, o lado direito é uma tupla de valores. Cada valor é atribuído à sua respectiva variável. Todas as expressões do lado direito são avaliadas antes de qualquer das atribuições. Esta característica torna as atribuições de tupla bastante versáteis.
 
 Naturalmente, o número de variáveis na esquerda e o número de valores na direita deve ser igual:
 
 
 então ``a`` e ``x`` são apelidos para um mesmo valor. Mudar ``x`` dentro da função ``troca``, faz com que ``x`` se referencie a um valor diferente, mas sem  efeito sobre ``a`` dentro de ``__main__``. Do mesmo modo, a mudança em ``y`` não tem efeito sobre ``b``.
 
-Esta função roda sem produzir uma mensagem de erro, mas ela não faz o que pretendemos. Este é um exemplo de um erro semântico.
+Esta função roda sem produzir uma mensagem de erro, mas ela não faz o que pretendemos. Este é um exemplo de um erro de semântica.
 
-  *Como exercício, desenhe um diagrama de estado pra esta função de modo que você possa ver porque ela não funciona.*
+  Como exercício, desenhe um diagrama de estado pra esta função de modo que você possa ver por que ela não funciona.
 
 -----------------------
 9.4 Números aleatórios
 -----------------------
 
-A maioria dos programas de computador fazem a mesma coisa sempre que são executados, então, podemos dizer que eles são **determinísticos**. Determinismo em geral é uma coisa boa, se nós esperamos que um cálculo dê sempre o mesmo resultado. Entretanto, para algumas aplicações queremos que o computador se torne imprevisível. Jogos são um exemplo óbvio, mas existem outros.
+A maioria dos programas de computador fazem a mesma coisa sempre que são executados, então, podemos dizer que eles são **determinísticos**. Determinismo, em geral, é uma coisa boa, se nós esperamos que um cálculo dê sempre o mesmo resultado. Entretanto, para algumas aplicações queremos que o computador se torne imprevisível. Jogos são um exemplo óbvio, mas existem outros.
 
 Fazer um programa realmente não-determinístico se mostra não ser tão fácil, mas existem maneiras de fazê-lo ao menos parecer não-determinístico. Uma dessas maneiras é gerar números aleatórios e usá-los para determinar o resultado de um programa. Python tem uma função nativa que gera números **pseudo aleatórios**, os quais não são verdadeiramente aleatórios no sentido matemático, mas para os nossos propósitos eles são.
 
-O módulo ``random`` contém uma função chamada ``random`` que retorna um número em ponto flutuante (*floating-point number*) entre 0.0 e 1.0. Cada vez que você chama ``random``, você recebe o próximo número de uma longa série. Para ver uma amostra, execute este loop::
+O módulo ``random`` contém uma função chamada ``random`` que retorna um número ``float`` entre 0.0 e 1.0. Cada vez que você chama ``random``, você recebe o próximo número de uma longa série. Para ver uma amostra, execute este loop::
 
   import random
 
 
 Para gerar um número aleatório ente 0.0 e um limite superior, digamos ``superior``, multiplique ``x`` por ``superior``.
 
-	*Como exercício, gere um número aleatório entre 'inferior' e 'superior'.*
+	Como exercício, gere um número aleatório entre 'inferior' e 'superior'.
 
-	*Como exercício adicional, gere um número inteiro aleatório entre 'inferior' e 'superior', inclusive os dois extremos.*
+	Como exercício adicional, gere um número inteiro aleatório entre 'inferior' e 'superior', inclusive os dois extremos.
 
 
 --------------------------------
 9.5 Lista de números aleatórios
 --------------------------------
 
-O primeiro passo é gerar uma lista aleatória de valores. ``listaAleatoria`` pega um parâmetro inteiro e retorna uma lista de números aleatórios com o comprimento dado. Inicia-se com uma lista de ``n`` zeros. A cada iteração do loop, ele substitui um dos elementos por um número aleatório. O valor retornado é uma referência para a lista completa::
+O primeiro passo é gerar uma lista aleatória de valores. A função ``listaAleatoria`` pega um parâmetro inteiro e retorna uma lista de números aleatórios com o comprimento dado. Inicia-se com uma lista de ``n`` zeros. A cada iteração do loop, ele substitui um dos elementos por um número aleatório. O valor retornado é uma referência para a lista completa::
 
   def listaAleatoria(n):
     s = [0] * n
       s[i] = random.random()
     return s
 
-Vamos realizar um teste desta função com uma lista de oito elementos. Para efeitos de depuração, é uma boa idéia começar com uma lista pequena.
+Vamos realizar um teste desta função com uma lista de oito elementos. Para efeitos de depuração, é uma boa ideia começar com uma lista pequena.
 
 >>> listaAleatoria(8)
 0.15156642489
 -------------
 9.6 Contando
 -------------
+
 Uma boa maneira de abordar problemas como esse é dividir o problema em subproblemas, e encontrar um subproblema que se enquadre em um padrão de solução computacional que você já tenha visto antes.
 
 Neste caso, queremos percorrer uma lista de números e contar o número de vezes que valor se encaixa em um determinado intervalo. Isso soa familiar. Na Seção 7.8, nós escrevemos um programa que percorria uma string e contava o número de vezes que uma determinada letra aparecia.
 
 Com ``numeroDeIntervalos = 8``, o resultado é::
 
-  0.0 to 0.125
-  0.125 to 0.25
-  0.25 to 0.375
-  0.375 to 0.5
-  0.5 to 0.625
-  0.625 to 0.75
-  0.75 to 0.875
-  0.875 to 1.0
+  do 0.0 ao 0.125
+  do 0.125 ao 0.25
+  do 0.25 ao 0.375
+  do 0.375 ao 0.5
+  do 0.5 ao 0.625
+  do 0.625 ao 0.75
+  do 0.75 ao 0.875
+  do 0.875 ao 1.0
 
 
 Você pode confirmar que cada intervalo tem a mesma largura, que eles não se sobrepõe, e que eles cobrem toda a faixa de valores de 0.0 a 1.0.
 
 Esses números estão razoavelmente póximos de 125, o que era o que esperávamos. Pelo menos eles estão próximos o bastante para nos fazer acreditar que o gerador de número aleatórios está funcionando.
 
-  *Como exercício, teste esta função com algumas listas longas, e veja se o número de valores em cada um dos intervalos tendem a uma distribuição nivelada.*
+  Como exercício, teste esta função com algumas listas longas, e veja se o número de valores em cada um dos intervalos tendem a uma distribuição nivelada.
 
 -------------------------------
 9.8 Uma solução em um só passo
 
 Uma lista como ``intervalos`` que contém uma contagem do número de valores em cada intervalo é chamada de **histograma**.
 
-  *Como exercício, escreva uma função chamada ``histograma`` que  receba uma lista e um número de intervalos como argumentos e retorne um histograma com o número de intervalos solicitado.*
+  Como exercício, escreva uma função chamada ``histograma`` que  receba uma lista e um número de intervalos como argumentos e retorne um histograma com o número de intervalos solicitado.
 
 ---------------
 9.9 Glossário
 ---------------
 
+atribuição de tupla (*tuple assignment*)
+   Atribuição a todos os elementos de uma tupla feita num único comando de atribução. A atribuição aos elementos ocorre em paralelo, e não em sequência, tornando esta operação útil para *swap*, ou troca recíproca de valores entre variáveis (ex: a,b=b,a).
+
+casamento de padrão (*pattern matching*)
+   Um programa desenvolvido que envolve identificar um teste padrão computacional familiar e copiar a solução para um problema similar.
+
+determinístico (*deterministic*)
+   Um programa que realiza a mesma coisa sempre que é executado.
+
+histograma (*histogram*)
+   Uma lista de inteiros na qual cada elemento conta o número de vezes que algo acontece.
+
+pseudo-aleatório (*pseudorandom*)
+   Uma sequência de números que parecem ser aleatórios mas são na verdade o resultado de uma operação "determinística"
+
 tipo imutável (*immutable type*)
-   Um tipo de elemento que não pode ser modificado. Atribuições a um elemento ou "fatiamento (slices)" XXX aos tipos imutáveis causarão erro.
+   Um tipo de elemento que não pode ser modificado. Atribuições a um elemento aos tipos imutáveis causam erro.
 
 tipo mutável (*mutable type*)
    Tipo de dados onde os elementos podem ser modificados. Todos os tipos mutáveis, são tipos compostos. Listas e dicionários são exemplos de tipos de dados mutáveis. String e tuplas não são.
 
 tupla (*tuple*)
-   Tipo sequencial similar as listas com exceção de que ele é imutável. Podem ser usadas Tuplas sempre que um tipo imutável for necessário, por exemplo uma "chave (key)" em um dicionário
+   Tipo sequencial similar às listas, com exceção de que tuplas são imutáveis. Podem ser usadas Tuplas sempre que um tipo imutável for necessário, por exemplo uma "chave (key)" em um dicionário
 
-Atribuição a tupla (*tuple assignment*)
-   Atribuição a todos os elementos de uma tupla feita num único comando de atribução. A atribuição aos elementos ocorre em paralelo, e não em sequência, tornando esta operação útil para *swap*, ou troca recíproca de valores entre variáveis (ex: a,b=b,a).
-
-determinístico (*deterministic*)
-   Um programa que realiza a mesma coisa sempre que é executado.
-
-pseudo aleatório (*pseudorandom*)
-   Uma sequência de números que parecem ser aleatórios mas são na verdade o resultado de uma computação "determinística"
-
-histograma (*histogram*)
-   Uma lista de inteiros na qual cada elemento conta o número de vezes que algo acontece.
-
-casamento de padrão XXX (*pattern matching*)
-   Um programa desenvolvido que envolve identificar um teste padrão computacional familiar e copiar a solução para um problema similar.
-   
-