python
diff --git a/‎library/difflib.po‎
Lines changed: 123 additions & 21 deletions b/‎library/difflib.po‎
Lines changed: 123 additions & 21 deletions
@@ -11,7 +11,7 @@ msgstr ""
 "Project-Id-Version: Python 3.8\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2020-05-05 12:54+0200\n"
-"PO-Revision-Date: 2020-07-26 16:02+0000\n"
+"PO-Revision-Date: 2020-07-26 19:27+0000\n"
 "Language-Team: python-doc-es\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -650,18 +650,25 @@ msgid ""
 "where they occur. All three are reset whenever *b* is reset with :meth:"
 "`set_seqs` or :meth:`set_seq2`."
 msgstr ""
+"Los objetos `SequenceMatcher` reciben tres atributos: *bjunk* es el conjunto "
+"de elementos de *b* para los cuales *isjunk* es ``True``; *bpopular* es el "
+"set de elementos que no son basura considerados populares por la heurística "
+"(si no es que fue deshabilitada); *b2j* es un diccionario que mapea elementos "
+"de *b* a una lista de posiciones donde estos ocurren. Los tres atributos son "
+"reseteados cuando *b* es reseteado mediante :meth:`set_seqs` or :meth:"
+"`set_seq2`."
 
 #: ../Doc/library/difflib.rst:397
 msgid "The *bjunk* and *bpopular* attributes."
-msgstr ""
+msgstr "Los atributos *bjunk* y *bpopular*."
 
 #: ../Doc/library/difflib.rst:400
 msgid ":class:`SequenceMatcher` objects have the following methods:"
-msgstr ""
+msgstr "Los objetos :class:`SequenceMatcher` tienen los siguientes métodos:"
 
 #: ../Doc/library/difflib.rst:404
 msgid "Set the two sequences to be compared."
-msgstr ""
+msgstr "Establece las dos secuencias a ser comparadas."
 
 #: ../Doc/library/difflib.rst:406
 msgid ""
@@ -670,24 +677,36 @@ msgid ""
 "sequences, use :meth:`set_seq2` to set the commonly used sequence once and "
 "call :meth:`set_seq1` repeatedly, once for each of the other sequences."
 msgstr ""
+":class:`SequenceMatcher` calcula y almacena información detallada sobre la "
+"segunda secuencia, con lo cual si quieres comparar una secuencia contra "
+"muchas otras, usa :meth:`set_seq2` para establecer la secuencia común una "
+"sola vez y llamar :meth:`set_seq1` repetidamente, una vez por cada una de las "
+"otras secuencias."
 
 #: ../Doc/library/difflib.rst:414
 msgid ""
 "Set the first sequence to be compared.  The second sequence to be compared is "
 "not changed."
 msgstr ""
+"Establece la primer secuencia a ser comparada. La segunda secuencia a ser "
+"comparada no es modificada."
 
 #: ../Doc/library/difflib.rst:420
 msgid ""
 "Set the second sequence to be compared.  The first sequence to be compared is "
 "not changed."
 msgstr ""
+"Establece la segunda secuencia a ser comparada. La primera secuencia a ser "
+"comparada no es modificada."
 
 #: ../Doc/library/difflib.rst:426
 msgid "Find longest matching block in ``a[alo:ahi]`` and ``b[blo:bhi]``."
 msgstr ""
+"Encuentra el bloque de coincidencia mas largo en ``a[alo:ahi]`` y ``b[blo:"
+"bhi]``."
 
 #: ../Doc/library/difflib.rst:428
+#, fuzzy
 msgid ""
 "If *isjunk* was omitted or ``None``, :meth:`find_longest_match` returns ``(i, "
 "j, k)`` such that ``a[i:i+k]`` is equal to ``b[j:j+k]``, where ``alo <= i <= i"
@@ -698,15 +717,31 @@ msgid ""
 "maximal matching blocks that start earliest in *a*, return the one that "
 "starts earliest in *b*."
 msgstr ""
+"Si *isjunk* fue omitido o es ``None``, :meth:`find_longest_match` devuelve "
+"``(i, j, k)`` tal que ``a[i:i+k]`` es igual a ``b[j:j+k]``, donde ``alo <= i "
+"<= i+k <= ahi`` y ``blo <= j <= j+k <= bhi``. Para todo ``(i', j', k')`` "
+"cumpliendo esas condiciones, las condiciones adicionales ``k >= k'``, ``i <= "
+"i'``, y si ``i == i'``, ``j <= j'`` también se cumplen. En otras palabras, de "
+"todos los bloques coincidentes máximos, devuelve aquel que comienza antes en "
+"*a*, y de todos esos bloques coincidentes máximos que comienzan antes en *a*, "
+"devuelve aquel que comienza antes en *b*."
 
 #: ../Doc/library/difflib.rst:441
+#, fuzzy
 msgid ""
 "If *isjunk* was provided, first the longest matching block is determined as "
 "above, but with the additional restriction that no junk element appears in "
 "the block.  Then that block is extended as far as possible by matching (only) "
 "junk elements on both sides. So the resulting block never matches on junk "
 "except as identical junk happens to be adjacent to an interesting match."
 msgstr ""
+"Si se porporcionó *isjunk*, primero se determina el bloque coincidente mas "
+"largo como fue indicado anteriormente, pero con la restricción adicional de "
+"que no aparezca ningún elemento no deseado en el bloque. Entonces, ese bloque "
+"se extiende tan lejos como sea posible haciendo coincidir (solo) elementos no "
+"deseados de ambos lados. Por lo tanto, el bloque resultante nunca hará "
+"coincidir ningún elemento no deseado, excepto que un elemento no deseado "
+"idéntico pase a ser adyacente a una coincidencia interesante."
 
 #: ../Doc/library/difflib.rst:448
 msgid ""
@@ -715,21 +750,30 @@ msgid ""
 "second sequence directly.  Instead only the ``'abcd'`` can match, and matches "
 "the leftmost ``'abcd'`` in the second sequence:"
 msgstr ""
+"Este es el mismo ejemplo que el mostrado anteriormente, pero considerando "
+"elementos en blanco como no deseados. Esto previene que ``' abcd'`` sea "
+"coincidente con ``' abcd'`` en el final de la segunda secuencia directamente. "
+"En cambio, sólo el ``'abcd'`` puede coincidir, y coincide con el ``'abcd'`` "
+"que se encuentre mas a la izquierda en la segunda secuencia:"
 
 #: ../Doc/library/difflib.rst:457
 msgid "If no blocks match, this returns ``(alo, blo, 0)``."
-msgstr ""
+msgstr "Si no coincide ningún bloque, esto devuelve ``(alo, blo, 0)``."
 
 #: ../Doc/library/difflib.rst:459
 msgid "This method returns a :term:`named tuple` ``Match(a, b, size)``."
-msgstr ""
+msgstr "Este método devuelve un :term:`named tuple` ``Match(a, b, size)``."
 
 #: ../Doc/library/difflib.rst:464
 msgid ""
 "Return list of triples describing non-overlapping matching subsequences. Each "
 "triple is of the form ``(i, j, n)``, and means that ``a[i:i+n] == b[j:j"
 "+n]``.  The triples are monotonically increasing in *i* and *j*."
 msgstr ""
+"Devuelve una lista de triplas (tuplas de tres elementos) describiendo "
+"subsecuencias coincidentes no superpuestas. Cada tripla sigue el formato "
+"``(i, j, n)``, y significa que ``a[i:i+n] == b[j:j+n]``. Las triplas son "
+"monótonamente crecientes en *i* y *j*."
 
 #: ../Doc/library/difflib.rst:469
 msgid ""
@@ -739,6 +783,11 @@ msgid ""
 "list, then ``i+n < i'`` or ``j+n < j'``; in other words, adjacent triples "
 "always describe non-adjacent equal blocks."
 msgstr ""
+"La última tripla es un objeto ficticio (dummy), y tiene el valor ``(len(a), "
+"len(b), 0)``. Es la única tripla con ``n == 0``.  Si ``(i, j, n)`` y ``(i', "
+"j', n')`` son triplas adyacentes en la lista, y la segunda no es el último "
+"elemento de la lista, entonces ``i+n < i'`` or ``j+n < j'``; en otras "
+"palabras, las triplas adyacentes describen bloques iguales no adyacentes."
 
 #: ../Doc/library/difflib.rst:486
 msgid ""
@@ -747,100 +796,122 @@ msgid ""
 "and remaining tuples have *i1* equal to the *i2* from the preceding tuple, "
 "and, likewise, *j1* equal to the previous *j2*."
 msgstr ""
+"Devuelve una lista de quíntuplas (tuplas de cinco elementos) describiendo "
+"como convertir *a* en *b*. Cada tupla tiene la forma ``(tag, i1, i2, j1, "
+"j2)``. En la primer tupla se cumple que ``i1 == j1 == 0``, y las tuplas "
+"restantes tienen *i1* igual al *i2* de la tupla precedente, y de igual "
+"manera, *j1* igual al *j2* de la tupla anterior."
 
 #: ../Doc/library/difflib.rst:491
 msgid "The *tag* values are strings, with these meanings:"
 msgstr ""
+"Los valores de *tag* son cadenas de texto, con el siguiente significado:"
 
 #: ../Doc/library/difflib.rst:494
 msgid "Value"
-msgstr ""
+msgstr "Valor"
 
 #: ../Doc/library/difflib.rst:496
 msgid "``'replace'``"
-msgstr ""
+msgstr "``'replace'``"
 
 #: ../Doc/library/difflib.rst:496
 msgid "``a[i1:i2]`` should be replaced by ``b[j1:j2]``."
-msgstr ""
+msgstr "``a[i1:i2]`` debe ser reemplazado por ``b[j1:j2]``."
 
 #: ../Doc/library/difflib.rst:499
 msgid "``'delete'``"
-msgstr ""
+msgstr "``'delete'``"
 
 #: ../Doc/library/difflib.rst:499
 msgid "``a[i1:i2]`` should be deleted.  Note that ``j1 == j2`` in this case."
-msgstr ""
+msgstr "``a[i1:i2]`` debe ser eliminado.  Nótese que en este caso ``j1 == j2``."
 
 #: ../Doc/library/difflib.rst:502
 msgid "``'insert'``"
-msgstr ""
+msgstr "``'insert'``"
 
 #: ../Doc/library/difflib.rst:502
 msgid ""
 "``b[j1:j2]`` should be inserted at ``a[i1:i1]``. Note that ``i1 == i2`` in "
 "this case."
 msgstr ""
+"``b[j1:j2]`` debe ser insertado en ``a[i1:i1]``. Nótese que en este caso ``i1 "
+"== i2``."
 
 #: ../Doc/library/difflib.rst:506
 msgid "``'equal'``"
-msgstr ""
+msgstr "``'equal'``"
 
 #: ../Doc/library/difflib.rst:506
 msgid "``a[i1:i2] == b[j1:j2]`` (the sub-sequences are equal)."
-msgstr ""
+msgstr "``a[i1:i2] == b[j1:j2]`` (las subsecuencias son iguales)."
 
 #: ../Doc/library/difflib.rst:510
 msgid "For example::"
-msgstr ""
+msgstr "Por ejemplo:"
 
 #: ../Doc/library/difflib.rst:527
 msgid "Return a :term:`generator` of groups with up to *n* lines of context."
 msgstr ""
+"Devuelve un :term:`generator` de grupos de hasta *n* líneas de contexto."
 
 #: ../Doc/library/difflib.rst:529
 msgid ""
 "Starting with the groups returned by :meth:`get_opcodes`, this method splits "
 "out smaller change clusters and eliminates intervening ranges which have no "
 "changes."
 msgstr ""
+"Empezando con los grupos devueltos por :meth:`get_opcodes`, este método "
+"separa grupos con cambios menores y elimina los rangos intermedios que no "
+"tienen cambios."
 
 #: ../Doc/library/difflib.rst:533
 msgid "The groups are returned in the same format as :meth:`get_opcodes`."
-msgstr ""
+msgstr "Los grupos son devueltos en el mismo formato que :meth:`get_opcodes`."
 
 #: ../Doc/library/difflib.rst:538
 msgid ""
 "Return a measure of the sequences' similarity as a float in the range [0, 1]."
 msgstr ""
+"Devuelve una medida de la similitud de las secuencias como un flotante en el "
+"rango [0, 1]."
 
 #: ../Doc/library/difflib.rst:541
 msgid ""
 "Where T is the total number of elements in both sequences, and M is the "
 "number of matches, this is 2.0\\*M / T. Note that this is ``1.0`` if the "
 "sequences are identical, and ``0.0`` if they have nothing in common."
 msgstr ""
+"Donde T es el número total de elementos en ambas secuencias y M es el número "
+"de coincidencias, esto es 2.0\\*M / T. Nótese que esto es ``1.0`` si las "
+"secuencias son idénticas y ``0.0`` si no tienen nada en común."
 
 #: ../Doc/library/difflib.rst:545
 msgid ""
 "This is expensive to compute if :meth:`get_matching_blocks` or :meth:"
 "`get_opcodes` hasn't already been called, in which case you may want to try :"
 "meth:`quick_ratio` or :meth:`real_quick_ratio` first to get an upper bound."
 msgstr ""
+"Esto es computacionalmente costoso si :meth:`get_matching_blocks` o :meth:"
+"`get_opcodes` no fueron ejecutados, in tal caso deberías considerar primero :"
+"meth:`quick_ratio` o :meth:`real_quick_ratio` para obtener un límite superior."
 
 #: ../Doc/library/difflib.rst:552
 msgid ""
 "Caution: The result of a :meth:`ratio` call may depend on the order of the "
 "arguments. For instance::"
 msgstr ""
+"Precaución: El resultado de una llamada a :meth:`ratio` puede depender del "
+"orden de los argumentos. Por ejemplo::"
 
 #: ../Doc/library/difflib.rst:563
 msgid "Return an upper bound on :meth:`ratio` relatively quickly."
-msgstr ""
+msgstr "Devuelve un límite superior en :meth:`ratio` relativamente rápido."
 
 #: ../Doc/library/difflib.rst:568
 msgid "Return an upper bound on :meth:`ratio` very quickly."
-msgstr ""
+msgstr "Devuelve un límite superior en :meth:`ratio` muy rápido."
 
 #: ../Doc/library/difflib.rst:571
 msgid ""
@@ -849,69 +920,100 @@ msgid ""
 "meth:`quick_ratio` and :meth:`real_quick_ratio` are always at least as large "
 "as :meth:`ratio`:"
 msgstr ""
+"Los tres métodos que devuelven la proporción de coincidencias con el total de "
+"caracteres pueden dar diferentes resultados debido a los distintos niveles de "
+"aproximación, a pesar de que :meth:`quick_ratio` y :meth:`real_quick_ratio` "
+"son siempre al menos tan grandes como :meth:`ratio`:"
 
 #: ../Doc/library/difflib.rst:588
 msgid "SequenceMatcher Examples"
-msgstr ""
+msgstr "SequenceMatcher Ejemplos"
 
 #: ../Doc/library/difflib.rst:590
 msgid "This example compares two strings, considering blanks to be \"junk\":"
 msgstr ""
+"Este ejemplo compara dos cadenas de texto, considerando los espacios en "
+"blanco como caracteres no deseados:"
 
 #: ../Doc/library/difflib.rst:596
 msgid ""
 ":meth:`ratio` returns a float in [0, 1], measuring the similarity of the "
 "sequences.  As a rule of thumb, a :meth:`ratio` value over 0.6 means the "
 "sequences are close matches:"
 msgstr ""
+":meth:`ratio` devuelve un flotante en el rango [0, 1], cuantificando la "
+"similitud entre las secuencias. Siguiendo la regla del pulgar, un :meth:"
+"`ratio` por encima de 0.6 significa que las secuencias son coincidencias "
+"cercanas:"
 
 #: ../Doc/library/difflib.rst:603
 msgid ""
 "If you're only interested in where the sequences match, :meth:"
 "`get_matching_blocks` is handy:"
 msgstr ""
+"Si solamente estás interesado en verificar cuando las secuencias son "
+"coincidentes, :meth:`get_matching_blocks` es útil:"
 
 #: ../Doc/library/difflib.rst:612
 msgid ""
 "Note that the last tuple returned by :meth:`get_matching_blocks` is always a "
 "dummy, ``(len(a), len(b), 0)``, and this is the only case in which the last "
 "tuple element (number of elements matched) is ``0``."
 msgstr ""
+"Nótese que la última tupla devuelta por :meth:`get_matching_blocks` es "
+"siempre un objeto ficticio (dummy), ``(len(a), len(b), 0)``, y este es el "
+"único caso en el cual el último elemento de la tupla (el número de elementos "
+"coincidentes) es ``0``."
 
 #: ../Doc/library/difflib.rst:616
 msgid ""
 "If you want to know how to change the first sequence into the second, use :"
 "meth:`get_opcodes`:"
 msgstr ""
+"Si quieres saber como cambiar la primer secuencia con la segunda, usa :meth:"
+"`get_opcodes`:"
 
 #: ../Doc/library/difflib.rst:627
 msgid ""
 "The :func:`get_close_matches` function in this module which shows how simple "
 "code building on :class:`SequenceMatcher` can be used to do useful work."
 msgstr ""
+"La función :func:`get_close_matches` en este módulo que muestra lo simple que "
+"es el código que construye :class:`SequenceMatcher` puede ser utilizada para "
+"hacer un trabajo útil:"
 
 #: ../Doc/library/difflib.rst:631
 msgid ""
 "`Simple version control recipe <https://code.activestate.com/recipes/576729/"
 ">`_ for a small application built with :class:`SequenceMatcher`."
 msgstr ""
+"`Una receta simple de un controlador de versiones <https://code.activestate."
+"com/recipes/576729/>`_ para una aplicación pequeña construida con :class:"
+"`SequenceMatcher`."
 
 #: ../Doc/library/difflib.rst:639
 msgid "Differ Objects"
-msgstr ""
+msgstr "Objetos Differ"
 
 #: ../Doc/library/difflib.rst:641
+#, fuzzy
 msgid ""
 "Note that :class:`Differ`\\ -generated deltas make no claim to be **minimal** "
 "diffs. To the contrary, minimal diffs are often counter-intuitive, because "
 "they synch up anywhere possible, sometimes accidental matches 100 pages "
 "apart. Restricting synch points to contiguous matches preserves some notion "
 "of locality, at the occasional cost of producing a longer diff."
 msgstr ""
+"Nótese que los deltas generados por :class:`Differ` no dicen ser diferencias "
+"**mínimas**. Todo lo contrario, las diferencias mínimas suelen ser contra-"
+"intuitivas, ya que se sincronizan en cualquier lugar posible, a veces "
+"coinciden accidentalmente con 100 páginas de diferencia. Restringiendo los "
+"puntos de sincronización a coincidencias contiguas se preserva cierta noción "
+"de cercanía, con el costo adicional de producir diferencias mas largas."
 
 #: ../Doc/library/difflib.rst:647
 msgid "The :class:`Differ` class has this constructor:"
-msgstr ""
+msgstr "La clase :class:`Differ` tiene el siguiente constructor:"
 
 #: ../Doc/library/difflib.rst:652
 msgid ""