Corrigir erros de sintaxe .rst #21
Description
Os arquivos abaixo contém erros de sintaxe não detectada na compilação, acrescentando espaço antes as crases, o que certamente renderiza incorretamente a sintaxe. Isto é:
`` termo``
quando deveria ser
``termo``
Na minha análise, seguem os arquivos com problema seguidos pelas quantidades
$ gtgrep -Cs ' `` ' *.po **/*.po | grep -v ':0'
c-api/arg.po:2
c-api/unicode.po:1
faq/programming.po:1
howto/functional.po:4
library/email.util.po:1
library/email.utils.po:1
library/functools.po:2
library/stdtypes.po:4
Segue lista completa de strings para corrigir:
$ gtgrep -s ' `` ' *.po **/*.po
#: ../../c-api/arg.rst:345
msgid ""
"If the *converter* returns ``Py_CLEANUP_SUPPORTED``, it may get called a "
"second time if the argument parsing eventually fails, giving the converter a "
"chance to release any memory that it had already allocated. In this second "
"call, the *object* parameter will be ``NULL``; *address* will have the same "
"value as in the original call."
msgstr ""
"Se o * converter * retornar `` Py_CLEANUP_SUPPORTED``, ele poderá ser "
"chamado uma segunda vez se a análise do argumento eventualmente falhar, "
"dando ao conversor a chance de liberar qualquer memória que já havia "
"alocado. Nesta segunda chamada, o parâmetro * object * será `` NULL``; * "
"endereço * terá o mesmo valor que na chamada original."
#: ../../c-api/arg.rst:351
msgid "``Py_CLEANUP_SUPPORTED`` was added."
msgstr "109 `` Py_CLEANUP_SUPPORTED`` foi adicionado."
#: ../../c-api/unicode.rst:496
msgid ""
"The hex representation of a C pointer. Mostly equivalent to "
"``printf(\"%p\")`` except that it is guaranteed to start with the literal "
"``0x`` regardless of what the platform's ``printf`` yields."
msgstr ""
"A representação hexadecimal de um ponteiro C. Principalmente equivalente a "
"`` printf (\"% p\") `` exceto que é garantido que comece com o literal `` "
"0x`` independentemente do que o `` printf`` da plataforma ceda."
#: ../../faq/programming.rst:399
msgid ""
"Collect the arguments using the ``*`` and ``**`` specifiers in the "
"function's parameter list; this gives you the positional arguments as a "
"tuple and the keyword arguments as a dictionary. You can then pass these "
"arguments when calling another function by using ``*`` and ``**``::"
msgstr ""
"Preceda os argumentos com o uso de especificadores (asteriscos) ``* `` ou "
"``** `` na lista de parâmetros da função; Isso faz com que os argumentos "
"posicionais como uma tupla e os keyword arguments sejam passados como um "
"dicionário. Poderás, também, passar esses argumentos ao invocar outra função "
"usando ``* `` e `` **``::"
#: ../../howto/functional.rst:1131
msgid ""
"One reason for my preference is that ``lambda`` is quite limited in the "
"functions it can define. The result has to be computable as a single "
"expression, which means you can't have multiway ``if... elif... else`` "
"comparisons or ``try... except`` statements. If you try to do too much in a "
"``lambda`` statement, you'll end up with an overly complicated expression "
"that's hard to read. Quick, what's the following code doing? ::"
msgstr ""
"Um dos motivos da minha preferência é que `` lambda`` é bastante limitado "
"nas funções que pode definir. O resultado deve ser computável como uma única "
"expressão, o que significa que você não pode ter comparações multi-canais `` "
"if ... elif ... else`` ou `` try ... except``. Se você tentar fazer muito em "
"uma declaração `` lambda``, você acabará com uma expressão excessivamente "
"complicada que é difícil de ler. Rápido, o que o seguinte código está "
"fazendo? ::"
#: ../../howto/functional.rst:1151
msgid "But it would be best of all if I had simply used a ``for`` loop::"
msgstr ""
"Mas seria o melhor de tudo se eu tivesse usado simplesmente um bucle `` "
"for`` ::"
#: ../../howto/functional.rst:1163
msgid ""
"Fredrik Lundh once suggested the following set of rules for refactoring uses "
"of ``lambda``:"
msgstr ""
"Fredrik Lundh sugeriu uma vez o seguinte conjunto de regras para refatoração "
"de usos de `` lambda``:"
#: ../../howto/functional.rst:1194
msgid ""
"Version 0.30: Adds a section on the ``functional`` module written by Collin "
"Winter; adds short section on the operator module; a few other edits."
msgstr ""
"Versão 0.30: Adiciona uma seção no módulo `` functional`` escrito por Collin "
"Winter; Adiciona seção curta no módulo do operador; Algumas outras edições."
#: ../../library/email.util.rst:16
msgid ""
"Return local time as an aware datetime object. If called without arguments, "
"return current time. Otherwise *dt* argument should be a "
":class:`~datetime.datetime` instance, and it is converted to the local time "
"zone according to the system time zone database. If *dt* is naive (that is, "
"``dt.tzinfo`` is ``None``), it is assumed to be in local time. In this "
"case, a positive or zero value for *isdst* causes ``localtime`` to presume "
"initially that summer time (for example, Daylight Saving Time) is or is not "
"(respectively) in effect for the specified time. A negative value for "
"*isdst* causes the ``localtime`` to attempt to divine whether summer time is "
"in effect for the specified time."
msgstr ""
"Retorna a hora local como um objeto datetime com reconhecimento. Se chamado "
"sem argumentos, retorne a hora atual. Caso contrário, o argumento * dt * "
"deve ser uma instância: class: `~ datetime.datetime` e é convertido para o "
"fuso horário local de acordo com o banco de dados de fuso horário do "
"sistema. Se * dt * é ingênuo (isto é, `` dt.tzinfo`` é `` None``), "
"presume-se que seja na hora local. Neste caso, um valor positivo ou zero "
"para * isdst * faz com que `` localtime`` presuma inicialmente que o horário "
"de verão (por exemplo, horário de verão) esteja ou não (respectivamente) em "
"vigor pelo tempo especificado. Um valor negativo para * isdst * faz com que "
"o `` localtime`` tente adivinhar se o horário de verão está em vigor pelo "
"tempo especificado."
#: ../../library/email.utils.rst:16
msgid ""
"Return local time as an aware datetime object. If called without arguments, "
"return current time. Otherwise *dt* argument should be a "
":class:`~datetime.datetime` instance, and it is converted to the local time "
"zone according to the system time zone database. If *dt* is naive (that is, "
"``dt.tzinfo`` is ``None``), it is assumed to be in local time. In this "
"case, a positive or zero value for *isdst* causes ``localtime`` to presume "
"initially that summer time (for example, Daylight Saving Time) is or is not "
"(respectively) in effect for the specified time. A negative value for "
"*isdst* causes the ``localtime`` to attempt to divine whether summer time is "
"in effect for the specified time."
msgstr ""
"Retorna a hora local como um objeto datetime com reconhecimento. Se chamado "
"sem argumentos, retorne a hora atual. Caso contrário, o argumento *dt* deve "
"ser uma instância: :class:`~datetime.datetime` e é convertido para o fuso "
"horário local de acordo com o banco de dados de fuso horário do sistema. Se "
"*dt* é ingênuo (isto é, ``dt.tzinfo`` é ``None``), presume-se que seja na "
"hora local. Neste caso, um valor positivo ou zero para * isdst * faz com que "
"`` localtime`` presuma inicialmente que o horário de verão (por exemplo, "
"horário de verão) esteja ou não (respectivamente) em vigor pelo tempo "
"especificado. Um valor negativo para *isdst* faz com que o ``localtime`` "
"tente adivinhar se o horário de verão está em vigor pelo tempo especificado."
#: ../../library/functools.rst:103
msgid ""
"If *maxsize* is set to ``None``, the LRU feature is disabled and the cache "
"can grow without bound. The LRU feature performs best when *maxsize* is a "
"power-of-two."
msgstr ""
"Se * maxsize * estiver configurado para `` None``, o recurso LRU está "
"desabilitado e o cache pode crescer sem ligação. O recurso LRU funciona "
"melhor quando * maxsize * é um poder de dois."
#: ../../library/functools.rst:107
msgid ""
"If *typed* is set to true, function arguments of different types will be "
"cached separately. For example, ``f(3)`` and ``f(3.0)`` will be treated as "
"distinct calls with distinct results."
msgstr ""
"Se *tipo* for definido como verdadeiro, os argumentos de função de "
"diferentes tipos serão armazenados em cache separadamente. Por exemplo, `` f "
"(3) `` e `` f (3.0) `` serão tratados como chamadas distintas com resultados "
"distintos."
#: ../../library/stdtypes.rst:928
msgid ""
"What has happened is that ``[[]]`` is a one-element list containing an empty "
"list, so all three elements of ``[[]] * 3`` are references to this single "
"empty list. Modifying any of the elements of ``lists`` modifies this single "
"list. You can create a list of different lists this way::"
msgstr ""
"O que aconteceu é que ``[[]] `` é uma lista de um elemento contendo uma "
"lista vazia, então todos os três elementos de ``[[]] * 3`` são referências a "
"esta única lista vazia. Modificar qualquer um dos elementos de ``lists`` "
"modifica a lista vazia. Podemos criar uma lista de listas diferentes dessa "
"maneira::"
#: ../../library/stdtypes.rst:944
msgid ""
"If *i* or *j* is negative, the index is relative to the end of sequence *s*: "
"``len(s) + i`` or ``len(s) + j`` is substituted. But note that ``-0`` is "
"still ``0``."
msgstr ""
"Se *i* ou *j* forem negativo, o índice será relativo ao fim da sequência "
"*s*: `` len(s) + i`` ou ``len(s) + j`` será substituído. Mas note que ``-0`` "
"ainda será ``0``."
#: ../../library/stdtypes.rst:956
msgid ""
"The slice of *s* from *i* to *j* with step *k* is defined as the sequence of "
"items with index ``x = i + n*k`` such that ``0 <= n < (j-i)/k``. In other "
"words, the indices are ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` and so on, "
"stopping when *j* is reached (but never including *j*). When *k* is "
"positive, *i* and *j* are reduced to ``len(s)`` if they are greater. When "
"*k* is negative, *i* and *j* are reduced to ``len(s) - 1`` if they are "
"greater. If *i* or *j* are omitted or ``None``, they become \"end\" values "
"(which end depends on the sign of *k*). Note, *k* cannot be zero. If *k* is "
"``None``, it is treated like ``1``."
msgstr ""
"A fatia *s* de *i* para *j* com passo *k* é definida como sendo a sequência "
"de itens com índice ``x = i + n * k`` tal que ``0 <= n <(j-i)/k``. Em outras "
"palavras, os índices são ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` e assim por "
"diante, parando quando *j* for atingiu (mas nunca incluindo *j*). Quando *k* "
"for positivo, *i* e *j* serão reduzidos a ``len(s)`` se forem maiores. "
"Quando *k* for negativo, *i* e *j* são reduzidos para ``len(s)-1`` se forem "
"maiores. Se *i* ou *j* forem omitidos ou `` None`, eles se tornam valores "
"\"finais\" (cujo final depende de *k*). Nota: *k* não pode ser zero. Se *k* "
"for ``None``, o mesmo será tratado como sendo igual a ``1```."
#: ../../library/stdtypes.rst:2144
msgid ""
"String objects have one unique built-in operation: the ``%`` operator "
"(modulo). This is also known as the string *formatting* or *interpolation* "
"operator. Given ``format % values`` (where *format* is a string), ``%`` "
"conversion specifications in *format* are replaced with zero or more "
"elements of *values*. The effect is similar to using the :c:func:`sprintf` "
"in the C language."
msgstr ""
"Os objetos String possuem um única operador built-in: o operador ``% `` "
"(modulo). O mesmo também é conhecido como o *formatador* de String ou como "
"operador *interpolador*. Dado ``format % values`` (onde *format* é uma "
"String), as especificações de conversão ``%`` em *format* são substituídas "
"por zero ou mais elementos de *valores*. O efeito é semelhante ao uso da "
"função :c:func:`sprintf` na linguagem C."