python
diff --git a/‎c-api/veryhigh.po
Lines changed: 176 additions & 5 deletions b/‎c-api/veryhigh.po
Lines changed: 176 additions & 5 deletions
diff --git a/‎howto/regex.po
Lines changed: 115 additions & 30 deletions b/‎howto/regex.po
Lines changed: 115 additions & 30 deletions
diff --git a/‎library/bdb.po
Lines changed: 1 addition & 1 deletion b/‎library/bdb.po
Lines changed: 1 addition & 1 deletion
@@ -1437,6 +1437,23 @@ msgid ""
 "matching is already enabled by default in Python 3 for Unicode (str) "
 "patterns, and it is able to handle different locales/languages."
 msgstr ""
+"Localidades são um recurso da biblioteca C destinado a ajudar na escrita de "
+"programas que levam em conta as diferenças de idioma. Por exemplo, se você "
+"estiver processando texto codificado em francês, você gostaria de ser capaz "
+"de escrever ``\\w+`` para corresponder a palavras, mas ``\\w`` corresponde "
+"apenas à classe de caracteres ``[A-Za-z]`` em padrões de bytes; ele não "
+"corresponderá a bytes correspondentes a ``é`` ou ``ç``. Se seu sistema "
+"estiver configurado corretamente e uma localidade francesa for selecionada, "
+"certas funções C dirão ao programa que o byte correspondente a ``é`` também "
+"deve ser considerado uma letra. Definir o sinalizador :const:`LOCALE` ao "
+"compilar uma expressão regular fará com que o objeto compilado resultante "
+"use essas funções C para ``\\w``; isso é mais lento, mas também permite que "
+"``\\w+`` corresponda a palavras francesas como você esperaria. O uso deste "
+"sinalizador é desencorajado no Python 3, pois o mecanismo de localidade é "
+"muito pouco confiável, ele só manipula uma \"cultura\" por vez e só funciona "
+"com localidades de 8 bits. A correspondência Unicode já está habilitada por "
+"padrão no Python 3 para padrões Unicode (str), e é capaz de manipular "
+"diferentes localidades/idiomas."
 
 #: ../../howto/regex.rst:606
 msgid ""
@@ -1621,6 +1638,12 @@ msgid ""
 "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and "
 "``'ervo'``."
 msgstr ""
+"Alternância, ou operador \"or\". Se *A* e *B* são expressões regulares, ``A|"
+"B`` irá corresponder com qualquer string que corresponder com *A* ou *B*. ``|"
+"`` tem uma prioridade muito baixa, a fim de fazê-lo funcionar razoavelmente "
+"quando você está alternando entre strings de vários caracteres. ``Crow|"
+"Servo`` irá corresponder tanto com ``'Crow'`` quanto com ``'Servo'``, e não "
+"com ``'Cro'``, ``'w'`` ou ``'S'``, e ``'ervo'``."
 
 #: ../../howto/regex.rst:703
 msgid ""
@@ -1661,10 +1684,14 @@ msgid ""
 ">>> print(re.search('^From', 'Reciting From Memory'))\n"
 "None"
 msgstr ""
+">>> print(re.search('^From', 'From Here to Eternity'))  \n"
+"<re.Match object; span=(0, 4), match='From'>\n"
+">>> print(re.search('^From', 'Reciting From Memory'))\n"
+"None"
 
 #: ../../howto/regex.rst:719
 msgid "To match a literal ``'^'``, use ``\\^``."
-msgstr ""
+msgstr "Para corresponder a um ``'^'`` literal, use ``\\^``."
 
 #: ../../howto/regex.rst:721
 msgid "``$``"
@@ -1687,13 +1714,19 @@ msgid ""
 ">>> print(re.search('}$', '{block}\\n'))  \n"
 "<re.Match object; span=(6, 7), match='}'>"
 msgstr ""
+">>> print(re.search('}$', '{block}'))  \n"
+"<re.Match object; span=(6, 7), match='}'>\n"
+">>> print(re.search('}$', '{block} '))\n"
+"None\n"
+">>> print(re.search('}$', '{block}\\n'))  \n"
+"<re.Match object; span=(6, 7), match='}'>"
 
 #: ../../howto/regex.rst:732
 msgid ""
 "To match a literal ``'$'``, use ``\\$`` or enclose it inside a character "
 "class, as in  ``[$]``."
 msgstr ""
-"Para corresponder com um ``$`` literal, use ``\\$`` ou coloque-o dentro de "
+"Para corresponder com um ``'$'`` literal, use ``\\$`` ou coloque-o dentro de "
 "uma classe de caracteres, como em ``[$]``."
 
 #: ../../howto/regex.rst:735
@@ -1733,10 +1766,10 @@ msgid ""
 "characters, so the end of a word is indicated by whitespace or a non-"
 "alphanumeric character."
 msgstr ""
-"Borda de palavra. Esta é uma afirmação de ``largura zero`` que corresponde "
-"apenas ao início ou ao final de uma palavra. Uma palavra é definida como uma "
-"sequência de caracteres alfanuméricos, de modo que o fim de uma palavra é "
-"indicado por espaços em branco ou um caractere não alfanumérico."
+"Borda de palavra. Esta é uma asserção de largura zero que corresponde apenas "
+"ao início ou ao fim de uma palavra. Uma palavra é definida como uma "
+"sequência de caracteres alfanuméricos, então o fim de uma palavra é indicado "
+"por espaço em branco ou um caractere não alfanumérico."
 
 #: ../../howto/regex.rst:750
 msgid ""
@@ -1756,6 +1789,13 @@ msgid ""
 ">>> print(p.search('one subclass is'))\n"
 "None"
 msgstr ""
+">>> p = re.compile(r'\\bclass\\b')\n"
+">>> print(p.search('no class at all'))\n"
+"<re.Match object; span=(3, 8), match='class'>\n"
+">>> print(p.search('the declassified algorithm'))\n"
+"None\n"
+">>> print(p.search('one subclass is'))\n"
+"None"
 
 #: ../../howto/regex.rst:761
 msgid ""
@@ -1771,9 +1811,9 @@ msgstr ""
 "primeiro lugar, esta é a pior colisão entre strings literais do Python e "
 "sequências de expressão regular. Nas strings literais do Python, ``\\b`` é o "
 "caractere backspace, o valor ASCII 8. Se você não estiver usando strings "
-"cruas (raw), então Python irá converter o ``\\b`` em um backspace e sua RE "
-"não irá funcionar da maneira que você espera. O exemplo a seguir parece "
-"igual a nossa RE anterior, mas omite o ``r`` na frente da string RE. ::"
+"brutas, então Python irá converter o ``\\b`` em um backspace e sua RE não "
+"irá funcionar da maneira que você espera. O exemplo a seguir parece igual a "
+"nossa RE anterior, mas omite o ``'r'`` na frente da string RE. ::"
 
 #: ../../howto/regex.rst:769
 msgid ""
@@ -1783,6 +1823,11 @@ msgid ""
 ">>> print(p.search('\\b' + 'class' + '\\b'))\n"
 "<re.Match object; span=(0, 7), match='\\x08class\\x08'>"
 msgstr ""
+">>> p = re.compile('\\bclass\\b')\n"
+">>> print(p.search('no class at all'))\n"
+"None\n"
+">>> print(p.search('\\b' + 'class' + '\\b'))\n"
+"<re.Match object; span=(0, 7), match='\\x08class\\x08'>"
 
 #: ../../howto/regex.rst:775
 msgid ""
@@ -1803,9 +1848,8 @@ msgid ""
 "Another zero-width assertion, this is the opposite of ``\\b``, only matching "
 "when the current position is not at a word boundary."
 msgstr ""
-"Outra afirmação de ``largura zero``; isto é o oposto de ``\\b``, "
-"correspondendo apenas quando a posição corrente não é de uma borda de "
-"palavra."
+"Outra afirmação de largura zero; isto é o oposto de ``\\b``, correspondendo "
+"apenas quando a posição corrente não é de uma borda de palavra."
 
 #: ../../howto/regex.rst:785
 msgid "Grouping"
@@ -1833,6 +1877,10 @@ msgid ""
 "MIME-Version: 1.0\n"
 "To: [email protected]"
 msgstr ""
+"From: [email protected]\n"
+"User-Agent: Thunderbird 1.5.0.9 (X11/20061227)\n"
+"MIME-Version: 1.0\n"
+"To: [email protected]"
 
 #: ../../howto/regex.rst:800
 msgid ""
@@ -1842,13 +1890,7 @@ msgid ""
 msgstr ""
 "Isto pode ser gerenciado ao escrever uma expressão regular que corresponde "
 "com uma linha inteira de cabeçalho, e tem um grupo que corresponde ao nome "
-"do cabeçalho, e um outro grupo, que corresponde ao valor do cabeçalho. Os "
-"grupos são marcados pelos metacaracteres ``(`` e ``)``. ``(`` e ``)`` têm "
-"muito do mesmo significado que eles têm em expressões matemáticas; eles "
-"agrupam as expressões contidas dentro deles, e você pode repetir o conteúdo "
-"de um grupo com um qualificador de repetição, como ``*``, ``+``, ``?``, ou "
-"``{m,n}``. Por exemplo, ``(ab)*`` irá corresponder a zero ou mais repetições "
-"de ``ab``."
+"do cabeçalho, e um outro grupo, que corresponde ao valor do cabeçalho."
 
 #: ../../howto/regex.rst:804
 msgid ""
@@ -1859,13 +1901,22 @@ msgid ""
 "``, or ``{m,n}``.  For example, ``(ab)*`` will match zero or more "
 "repetitions of ``ab``. ::"
 msgstr ""
+"Os grupos são marcados pelos metacaracteres ``'('`` e ``')'``. ``'('`` e "
+"``')'`` têm muito do mesmo significado que eles têm em expressões "
+"matemáticas; eles agrupam as expressões contidas dentro deles, e você pode "
+"repetir o conteúdo de um grupo com um qualificador de repetição, como ``*``, "
+"``+``, ``?``, ou ``{m,n}``. Por exemplo, ``(ab)*`` irá corresponder a zero "
+"ou mais repetições de ``ab``."
 
 #: ../../howto/regex.rst:811
 msgid ""
 ">>> p = re.compile('(ab)*')\n"
 ">>> print(p.match('ababababab').span())\n"
 "(0, 10)"
 msgstr ""
+">>> p = re.compile('(ab)*')\n"
+">>> print(p.match('ababababab').span())\n"
+"(0, 10)"
 
 #: ../../howto/regex.rst:815
 msgid ""
@@ -1878,6 +1929,14 @@ msgid ""
 "we'll see how to express groups that don't capture the span of text that "
 "they match. ::"
 msgstr ""
+"Grupos indicados com ``'('`` e ``')'`` também capturam o índice inicial e "
+"final do texto que eles correspondem; isso pode ser obtido por meio da "
+"passagem de um argumento para :meth:`~re.Match.group`, :meth:`~re.Match."
+"start`, :meth:`~re.Match.end` e :meth:`~re.Match.span`. Os grupos são "
+"numerados começando com 0. O grupo 0 está sempre presente; é toda a RE, de "
+"forma que os métodos de :ref:`objeto de correspondência <match-objects>` têm "
+"todos o grupo 0 como seu argumento padrão. Mais tarde veremos como expressar "
+"grupos que não capturam a extensão de texto com a qual eles correspondem, ::"
 
 #: ../../howto/regex.rst:824
 msgid ""
@@ -1888,6 +1947,12 @@ msgid ""
 ">>> m.group(0)\n"
 "'ab'"
 msgstr ""
+">>> p = re.compile('(a)b')\n"
+">>> m = p.match('ab')\n"
+">>> m.group()\n"
+"'ab'\n"
+">>> m.group(0)\n"
+"'ab'"
 
 #: ../../howto/regex.rst:831
 msgid ""
@@ -1897,7 +1962,7 @@ msgid ""
 msgstr ""
 "Subgrupos são numerados a partir da esquerda para a direita, de forma "
 "crescente a partir de 1. Os grupos podem ser aninhados; para determinar o "
-"número, basta contar os caracteres de abertura de parêntese - ``(``, indo da "
+"número, basta contar os caracteres de abertura de parêntese ``(``, indo da "
 "esquerda para a direita. ::"
 
 #: ../../howto/regex.rst:835
@@ -1911,6 +1976,14 @@ msgid ""
 ">>> m.group(2)\n"
 "'b'"
 msgstr ""
+">>> p = re.compile('(a(b)c)d')\n"
+">>> m = p.match('abcd')\n"
+">>> m.group(0)\n"
+"'abcd'\n"
+">>> m.group(1)\n"
+"'abc'\n"
+">>> m.group(2)\n"
+"'b'"
 
 #: ../../howto/regex.rst:844
 msgid ""
@@ -1920,22 +1993,23 @@ msgid ""
 msgstr ""
 ":meth:`~re.Match.group` pode receber vários números de grupos de uma vez, e "
 "nesse caso ele irá retornar uma tupla contendo os valores correspondentes "
-"desses grupos."
+"desses grupos. ::"
 
 #: ../../howto/regex.rst:847
 msgid ""
 ">>> m.group(2,1,2)\n"
 "('b', 'abc', 'b')"
 msgstr ""
+">>> m.group(2,1,2)\n"
+"('b', 'abc', 'b')"
 
 #: ../../howto/regex.rst:850
 msgid ""
 "The :meth:`~re.Match.groups` method returns a tuple containing the strings "
 "for all the subgroups, from 1 up to however many there are. ::"
 msgstr ""
-"O método  :meth:`~re.Match.groups` retorna uma tupla contendo as strings de "
-"todos os subgrupos, de 1 até o último. Independente da quantidade de "
-"subgrupos informada. ::"
+"O método :meth:`~re.Match.groups` retorna uma tupla contendo as strings de "
+"todos os subgrupos, de 1 até o último. ::"
 
 #: ../../howto/regex.rst:853
 msgid ""
@@ -1957,10 +2031,10 @@ msgstr ""
 "conteúdo de um grupo capturado anteriormente também deve ser encontrado na "
 "posição atual na sequência. Por exemplo, ``\\1`` terá sucesso se o conteúdo "
 "exato do grupo 1 puder ser encontrado na posição atual, e falhar caso "
-"contrário. Lembre-se que as strings literais do Python também usam a barra "
-"invertida seguida por números para permitir a inclusão de caracteres "
-"arbitrários em uma string, por isso certifique-se de usar strings cruas "
-"(raw) ao incorporar referências anteriores em uma RE."
+"contrário. Lembre-se que as strings literais do Python também usam a "
+"contrabarra seguida por números para permitir a inclusão de caracteres "
+"arbitrários em uma string, por isso certifique-se de usar strings brutas ao "
+"incorporar referências anteriores em uma RE."
 
 #: ../../howto/regex.rst:864
 msgid "For example, the following RE detects doubled words in a string. ::"
@@ -1973,6 +2047,9 @@ msgid ""
 ">>> p.search('Paris in the the spring').group()\n"
 "'the the'"
 msgstr ""
+">>> p = re.compile(r'\\b(\\w+)\\s+\\1\\b')\n"
+">>> p.search('Paris in the the spring').group()\n"
+"'the the'"
 
 #: ../../howto/regex.rst:870
 msgid ""
@@ -1982,8 +2059,8 @@ msgid ""
 "substitutions."
 msgstr ""
 "Referências anteriores como esta não são, geralmente, muito úteis apenas "
-"para fazer pesquisa percorrendo uma string — existem alguns formatos de "
-"texto que repetem dados dessa forma — mas em breve você irá descobrir que "
+"para fazer pesquisa percorrendo uma string --- existem alguns formatos de "
+"texto que repetem dados dessa forma --- mas em breve você irá descobrir que "
 "elas são muito úteis para realizar substituições de strings."
 
 #: ../../howto/regex.rst:876
@@ -2015,6 +2092,14 @@ msgid ""
 "expressions would be assuming that ``&`` was a regular character and "
 "wouldn't have escaped it by writing ``\\&`` or ``[&]``."
 msgstr ""
+"O Perl 5 é bem conhecido por suas poderosas adições às expressões regulares "
+"padrão. Para esses novos recursos, os desenvolvedores do Perl não podiam "
+"escolher novos metacaracteres de pressionamento de tecla único ou novas "
+"sequências especiais começando com ``\\`` sem tornar as expressões regulares "
+"do Perl confusamente diferentes das REs padrão. Se eles escolhessem ``&`` "
+"como um novo metacaractere, por exemplo, as expressões antigas estariam "
+"presumindo que ``&`` era um caractere regular e não teriam escapado dele "
+"escrevendo ``\\&`` ou ``[&]``."
 
 #: ../../howto/regex.rst:891
 msgid ""
 
@@ -39,7 +39,7 @@ msgstr ""
 
 #: ../../library/bdb.rst:14
 msgid "The following exception is defined:"
-msgstr ""
+msgstr "A seguinte exceção é definida:"
 
 #: ../../library/bdb.rst:18
 msgid "Exception raised by the :class:`Bdb` class for quitting the debugger."