Proofreading stdtypes.html

library.po

@@ -104892,7 +104892,7 @@ msgid ""
 msgstr ""
 "Les instances d'une classe ne peuvent pas être ordonnées par rapport à "
 "d'autres instances de la même classe, ou d'autres types d'objets, à moins "
-"que la classe définisse suffisamment de méthodes parmis :meth:`__lt__`, :"
+"que la classe ne définisse suffisamment de méthodes parmi :meth:`__lt__`, :"
 "meth:`__le__`, :meth:`__gt__` et :meth:`__ge__` (en général, :meth:`__lt__` "
 "et :meth:`__eq__` sont suffisantes, si vous voulez les significations "
 "classiques des opérateurs de comparaison)."
@@ -104904,7 +104904,7 @@ msgid ""
 "exception."
 msgstr ""
 "Le comportement des opérateurs :keyword:`is` et :keyword:`is not` ne peut "
-"pas être personnalisé; aussi ils peuvent être appliqués a deux objets "
+"pas être personnalisé; aussi ils peuvent être appliqués à deux objets "
 "quelconques et ne soulèvent jamais d'exception."
 
 #: ../Doc/library/stdtypes.rst:204
@@ -104913,7 +104913,7 @@ msgid ""
 "keyword:`not in`, are supported only by sequence types (below)."
 msgstr ""
 "Deux autres opérations avec la même priorité syntaxique, :keyword:`in` et :"
-"keyword:`not in`, sont pris en charge uniquement par des types séquence(ci-"
+"keyword:`not in`, sont pris en charge uniquement par des types séquence (ci-"
 "dessous)."
 
 #: ../Doc/library/stdtypes.rst:211
@@ -104977,13 +104977,14 @@ msgid ""
 "`float`, and :func:`complex` can be used to produce numbers of a specific "
 "type."
 msgstr ""
-"Python gère pleinement l'arithmétique mixte: quand un opérateur arithmétique "
-"binaire a des opérandes de types numériques différents, l'opérande avec le "
-"type \"le plus étroit\" est élargie au type de l'autre, où l'entier est plus "
-"étroit que la virgule flottante, qui est plus étroite que les complexes. Les "
-"comparaisons entre des nombres de type mixte utilisent la même règle. [2]_ "
-"Les constructeurs :func:`int`, :func:`float` et :func:`complex` peuvent être "
-"utilisé pour produire des nombres d'un type spécifique."
+"Python gère pleinement l'arithmétique mixte : quand un opérateur "
+"arithmétique binaire a des opérandes de types numériques différents, "
+"l'opérande avec le type \"le plus étroit\" est élargie au type de l'autre, "
+"où l'entier est plus étroit que la virgule flottante, qui est plus étroite "
+"que les complexes. Les comparaisons entre des nombres de type mixte "
+"utilisent la même règle. [2]_ Les constructeurs :func:`int`, :func:`float` "
+"et :func:`complex` peuvent être utilisé pour produire des nombres d'un type "
+"spécifique."
 
 #: ../Doc/library/stdtypes.rst:271
 msgid ""
@@ -105143,7 +105144,7 @@ msgid ""
 "``-1``, ``1//(-2)`` is ``-1``, and ``(-1)//(-2)`` is ``0``."
 msgstr ""
 "Également appelé division entière. La valeur résultante est un nombre "
-"entier, bien que le type du résultat ne soit nécessairement *int*. Le "
+"entier, bien que le type du résultat ne soit pas nécessairement *int*. Le "
 "résultat est toujours arrondi vers moins l'infini : ``1//2`` vaut ``0``, "
 "``(-1)//2`` vaut ``-1``, ``1//(-2)`` vaut ``-1``, et ``(-1)//(-2)`` vaut "
 "``0``."
@@ -105163,7 +105164,7 @@ msgid ""
 "conversions."
 msgstr ""
 "La conversion de virgule flottante en entier peut arrondir ou tronquer comme "
-"en C; voir les fonctions :func:`math.floor` et :func:`math.ceil` pour les "
+"en C; voir les fonctions :func:`math.floor` et :func:`math.ceil` pour des "
 "conversions bien définies."
 
 #: ../Doc/library/stdtypes.rst:346
@@ -105171,8 +105172,8 @@ msgid ""
 "float also accepts the strings \"nan\" and \"inf\" with an optional prefix "
 "\"+\" or \"-\" for Not a Number (NaN) and positive or negative infinity."
 msgstr ""
-"float accepte aussi les chauves \"nan\" et \"inf\" avec un préfixe optionnel "
-"\"+\" ou \"-\" pour Not a Number (NaN) et l'infini positif ou négatif."
+"float accepte aussi les chaînes \"nan\" et \"inf\" avec un préfixe optionnel "
+"\"+\" ou \"-\" pour *Not a Number* (NaN) et les infinis positif ou négatif."
 
 #: ../Doc/library/stdtypes.rst:350
 msgid ""
@@ -105180,7 +105181,7 @@ msgid ""
 "programming languages."
 msgstr ""
 "Python définit ``pow(0, 0)`` et ``0 ** 0`` valant ``1``, ​puisque c'est "
-"courant pour les langages de programmation."
+"courant pour les langages de programmation, et logique."
 
 #: ../Doc/library/stdtypes.rst:354
 msgid ""
@@ -105261,7 +105262,7 @@ msgid ""
 "number of bits that no overflow occurs during the operation)."
 msgstr ""
 "Les opérations sur les bits n'ont de sens que pour les entiers. Les nombres "
-"négatifssont traités comme leur complément à 2 (ce qui suppose un assez "
+"négatifs sont traités comme leur complément à 2 (ce qui suppose un assez "
 "grand nombre de bits afin qu'aucun débordement ne se produise pendant "
 "l'opération)."
 
@@ -105273,7 +105274,7 @@ msgid ""
 "``-``)."
 msgstr ""
 "Les priorités de toutes les opération à deux opérandes sur des bits sont "
-"inférieures auxopérations numériques et plus élevées que les comparaisons; "
+"inférieures aux opérations numériques et plus élevées que les comparaisons; "
 "l'opération unaire ``~`` a la même priorité que les autres opérations "
 "numériques unaires (``+`` et ``-``)."
 
@@ -105289,7 +105290,7 @@ msgstr "``x | y``"
 
 #: ../Doc/library/stdtypes.rst:412
 msgid "bitwise :dfn:`or` of *x* and *y*"
-msgstr "dfn:`ou <or>` binaire de *x* et *y*"
+msgstr ":dfn:`ou <or>` binaire de *x* et *y*"
 
 #: ../Doc/library/stdtypes.rst:415
 msgid "``x ^ y``"
@@ -105371,15 +105372,16 @@ msgid ""
 "The int type implements the :class:`numbers.Integral` :term:`abstract base "
 "class`. In addition, it provides a few more methods:"
 msgstr ""
-"Le type int implémente la :term:`abstract base class` :class:`numbers."
-"Integral`. En outre, il fournit quelques autres méthodes :"
+"Le type int implémente la :term:`classe de base abstraite <abstract base "
+"class>` :class:`numbers.Integral`. Il fournit aussi quelques autres "
+"méthodes :"
 
 #: ../Doc/library/stdtypes.rst:450
 msgid ""
 "Return the number of bits necessary to represent an integer in binary, "
 "excluding the sign and leading zeros::"
 msgstr ""
-"Retourne le nombre de bits nécessaires pour représenter un nombre entier en "
+"Renvoie le nombre de bits nécessaires pour représenter un nombre entier en "
 "binaire, à l'exclusion du signe et des zéros non significatifs : ::"
 
 #: ../Doc/library/stdtypes.rst:459
@@ -105394,7 +105396,7 @@ msgstr ""
 "nombre entier positif unique, ``k`` tel que ``2**(k-1) <= abs(x) < 2**k``. "
 "Équivalemment, quand ``abs(x)`` est assez petit pour avoir un logarithme "
 "correctement arrondi, ``k = 1 + int(log(abs(x), 2))``. Si ``x`` est nul, "
-"alors ``x.bit_length()`` retourne ``0``."
+"alors ``x.bit_length()`` donne ``0``."
 
 #: ../Doc/library/stdtypes.rst:476
 msgid "Return an array of bytes representing an integer."
@@ -105423,7 +105425,7 @@ msgstr ""
 "significatif est au début du tableau d'octets. Si *byteorder* est ``\"little"
 "\"``, l'octet le plus significatif est à la fin du tableau d'octets. Pour "
 "demander l'ordre natif des octets du système hôte, donnez :data:`sys."
-"byteorder` en temps que *byteorder*."
+"byteorder` comme *byteorder*."
 
 #: ../Doc/library/stdtypes.rst:499
 msgid ""
@@ -105434,7 +105436,7 @@ msgid ""
 msgstr ""
 "L'argument *signed* détermine si le complément à deux est utilisé pour "
 "représenter le nombre entier. Si *signed* est ``False`` et qu'un entier "
-"négatifest donné, une exception :exc:`OverflowError` est levée. La valeur "
+"négatif est donné, une exception :exc:`OverflowError` est levée. La valeur "
 "par défaut pour *signed* est ``False``."
 
 #: ../Doc/library/stdtypes.rst:508
@@ -105447,7 +105449,7 @@ msgid ""
 "iterable producing bytes."
 msgstr ""
 "L'argument *bytes* doit être soit un :term:`bytes-like object` soit un "
-"itérable produisant des *bytes*"
+"itérable produisant des *bytes*."
 
 #: ../Doc/library/stdtypes.rst:531
 msgid ""
@@ -105466,8 +105468,8 @@ msgid ""
 "The float type implements the :class:`numbers.Real` :term:`abstract base "
 "class`. float also has the following additional methods."
 msgstr ""
-"Le type *float* implémente la :term:`abstract base class` :class:`numbers."
-"Real` et a également les méthodes suivantes."
+"Le type *float* implémente la :term:`classe de base abstraite <abstract base "
+"class>` :class:`numbers.Real` et a également les méthodes suivantes."
 
 #: ../Doc/library/stdtypes.rst:545
 msgid ""
@@ -105475,7 +105477,7 @@ msgid ""
 "and with a positive denominator.  Raises :exc:`OverflowError` on infinities "
 "and a :exc:`ValueError` on NaNs."
 msgstr ""
-"Retourne une paire de nombres entiers dont le rappot est exactement égal au "
+"Renvoie une paire de nombres entiers dont le rapport est exactement égal au "
 "nombre d'origine et avec un dénominateur positif. Lève :exc:`OverflowError` "
 "avec un infini et :exc:`ValueError` avec un NaN."
 
@@ -105513,7 +105515,7 @@ msgstr ""
 "Donne une représentation d'un nombre à virgule flottante sous forme de "
 "chaîne hexadécimale. Pour les nombres à virgule flottante finis, cette "
 "représentation comprendra toujours un préfixe ``0x``, un suffixe ``p``, et "
-"exposant."
+"un exposant."
 
 #: ../Doc/library/stdtypes.rst:579
 msgid ""
@@ -105549,16 +105551,16 @@ msgid ""
 "by C's ``%a`` format character or Java's ``Double.toHexString`` are accepted "
 "by :meth:`float.fromhex`."
 msgstr ""
-"où l'option ``sign`` peut être soit ``+`` soit ``-``, ``integer`` et "
-"``fraction`` sont des chaînes de chiffres hexadécimales, et ``exponent`` est "
-"un entier décimal facultativement signé. La casse n'est pas significative, "
-"et il doit y avoir au moins un chiffre hexadécimal soit le nombre entier "
-"soit dans la fraction. Cette syntaxe est similaire à la syntaxe spécifiée "
-"dans la section 6.4.4.2 de la norme C99, et aussi à la syntaxe utilisée à "
-"partir de Java 1.5. En particulier, la sortie de :meth:`float.hex` est "
-"utilisable comme valeur hexadécimal à virgule flottante littérale en C ou "
-"Java, et des chaînes hexadécimales produites en C via un format ``%a`` ou "
-"Java via ``Double.toHexString`` sont acceptées par :meth:`float.fromhex`."
+"où ``sign`` peut être soit ``+`` soit ``-``, ``integer`` et ``fraction`` "
+"sont des chaînes de chiffres hexadécimales, et ``exponent`` est un entier "
+"décimal facultativement signé. La casse n'est pas significative, et il doit "
+"y avoir au moins un chiffre hexadécimal soit dans le nombre entier soit dans "
+"la fraction. Cette syntaxe est similaire à la syntaxe spécifiée dans la "
+"section 6.4.4.2 de la norme C99, et est aussi la syntaxe utilisée à partir "
+"de Java 1.5. En particulier, la sortie de :meth:`float.hex` est utilisable "
+"comme valeur hexadécimale à virgule flottante littérale en C ou Java, et des "
+"chaînes hexadécimales produites en C via un format ``%a`` ou Java via "
+"``Double.toHexString`` sont acceptées par :meth:`float.fromhex`."
 
 #: ../Doc/library/stdtypes.rst:604
 msgid ""
@@ -105599,12 +105601,12 @@ msgid ""
 "is made available to Python as the :attr:`modulus` attribute of :data:`sys."
 "hash_info`."
 msgstr ""
-"Pour deux nombres ``x`` et ``y``, pouvant être de différents types, il est "
-"une requis que ``hash(x) == hash(y)`` lorsque ``x == y`` (voir la "
+"Pour deux nombres égaux ``x`` et ``y`` (``x == y``), pouvant être de "
+"différents types, il est une requis que ``hash(x) == hash(y)`` (voir la "
 "documentation de :meth:`__hash__`). Pour faciliter la mise en œuvre et "
 "l'efficacité à travers une variété de types numériques (y compris :class:"
 "`int`, :class:`float`, :class:`decimal.Decimal` et :class:`fractions."
-"Fraction`) le hachage en Python pour les types numérique estbasé sur une "
+"Fraction`) le hachage en Python pour les types numérique est basé sur une "
 "fonction mathématique unique qui est définie pour tout nombre rationnel, et "
 "donc s'applique à toutes les instances de :class:`int` et :class:`fractions."
 "Fraction`, et toutes les instances finies de :class:`float` et :class:"
@@ -105644,7 +105646,7 @@ msgid ""
 msgstr ""
 "Si ``x = m / n`` est un nombre rationnel non négatif et ``n`` est divisible "
 "par ``P`` (mais ``m`` ne l'est pas), alors ``n`` n'a pas de modulo inverse "
-"``P`` et la règle ci-dessus ne sont pas applicables; dans ce cas définir "
+"``P`` et la règle ci-dessus n'est pas applicable; dans ce cas définir "
 "``hash(x)`` comme étant la valeur de la constante ``sys.hash_info.inf``."
 
 #: ../Doc/library/stdtypes.rst:655
@@ -105663,7 +105665,7 @@ msgid ""
 "hash value.)"
 msgstr ""
 "Les valeurs particulières ``sys.hash_info.inf``, ``-sys.hash_info.inf`` et "
-"``sys.hash_info.nan`` sont utilisés comme valeurs de hachage pour l'infini "
+"``sys.hash_info.nan`` sont utilisées comme valeurs de hachage pour l'infini "
 "positif, l'infini négatif, ou *nans* (respectivement). (Tous les *nans* "
 "hachables ont la même valeur de hachage.)"
 
@@ -105675,12 +105677,12 @@ msgid ""
 "lies in ``range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - "
 "1))``.  Again, if the result is ``-1``, it's replaced with ``-2``."
 msgstr ""
-"Pour un nombre :class:`complex` ``z``, les valeurs de hachage des parties "
-"réelles et imaginaires sont combinés en calculant ``hash(z.real) + sys."
-"hash_info.imag * hash(z.imag)``, réduit au modulo ``2**sys.hash_info.width`` "
-"de sorte qu'il se trouve dans ``range(-2**(sys.hash_info.width - 1), 2**(sys."
-"hash_info.width - 1))``. Encore une fois, si le résultat est ``-1``, il est "
-"remplacé par ``-2``."
+"Pour un nombre :class:`complexe <complex>` ``z``, les valeurs de hachage des "
+"parties réelles et imaginaires sont combinées en calculant ``hash(z.real) + "
+"sys.hash_info.imag * hash(z.imag)``, réduit au modulo ``2**sys.hash_info."
+"width`` de sorte qu'il se trouve dans ``range(-2**(sys.hash_info.width - 1), "
+"2**(sys.hash_info.width - 1))``. Encore une fois, si le résultat est ``-1``, "
+"il est remplacé par ``-2``."
 
 #: ../Doc/library/stdtypes.rst:672
 msgid ""
@@ -105689,8 +105691,8 @@ msgid ""
 "`float`, or :class:`complex`::"
 msgstr ""
 "Afin de clarifier les règles ci-dessus, voici quelques exemples de code "
-"Python, équivalent a la fonction de hachage native, pour calculer le hachage "
-"d'un nombrerationnel,  d'un :class:`float`, ou d'un :class:`complex` ::"
+"Python, équivalent à la fonction de hachage native, pour calculer le hachage "
+"d'un nombre rationnel,  d'un :class:`float`, ou d'un :class:`complex` ::"
 
 #: ../Doc/library/stdtypes.rst:727
 msgid "Iterator Types"
@@ -105742,7 +105744,7 @@ msgid ""
 "methods, which together form the :dfn:`iterator protocol`:"
 msgstr ""
 "Les itérateurs eux-mêmes doivent implémenter les deux méthodes suivantes, "
-"qui forment ensemble le :dfn:`iterator protocol` :"
+"qui forment ensemble le :dfn:`protocole d'itérateur <iterator protocol>` :"
 
 #: ../Doc/library/stdtypes.rst:762
 msgid ""
@@ -105789,7 +105791,8 @@ msgid ""
 msgstr ""
 "Dès que la méthode :meth:`~iterator .__next__` lève une  exception :exc:"
 "`StopIteration`, elle doit continuer à le faire lors des appels ultérieurs."
-"Implémentations qui ne respectent pas cette propriété sont réputées cassées."
+"Implémentations qui ne respectent pas cette propriété sont considérées "
+"cassées."
 
 #: ../Doc/library/stdtypes.rst:788
 msgid "Generator Types"
@@ -105806,11 +105809,11 @@ msgid ""
 msgstr ""
 "Les :term:`generator`\\s offrent un moyen pratique d'implémenter le "
 "protocole d'itération. Si la méthode :meth:`__iter__` d'un objet conteneur "
-"est implémentée comme un générateur, elle retournera automatiquement un "
-"objet *iterator* (techniquement, un objet générateur) fournissant les "
-"méthodes :meth:`__iter__`  et :meth:`~generator.__next__`. Plus "
-"d'informationssur les générateurs peuvent être trouvés dans :ref:`la "
-"documentation de l'expression yield <yieldexpr>`."
+"est implémentée comme un générateur, elle renverra automatiquement un objet "
+"*iterator* (techniquement, un objet générateur) fournissant les méthodes :"
+"meth:`__iter__`  et :meth:`~generator.__next__`. Plus d'informations sur les "
+"générateurs peuvent être trouvés dans :ref:`la documentation de l'expression "
+"yield <yieldexpr>`."
 
 #: ../Doc/library/stdtypes.rst:802
 msgid "Sequence Types --- :class:`list`, :class:`tuple`, :class:`range`"
@@ -105913,7 +105916,7 @@ msgstr "``s[i]``"
 
 #: ../Doc/library/stdtypes.rst:860
 msgid "*i*\\ th item of *s*, origin 0"
-msgstr "*i*ème élément de *s* en commençant par 0"
+msgstr "*i*\\ ème élément de *s* en commençant par 0"
 
 #: ../Doc/library/stdtypes.rst:862
 msgid "``s[i:j]``"
@@ -105999,7 +106002,7 @@ msgstr ""
 "particulier, les *tuples* et les listes sont comparées lexicographiquement "
 "en comparant les éléments correspondants. Cela signifie que pour être "
 "égales, chaques éléments doivent être égaux deux à deux et les deux "
-"séquences doivent être dumême type et de la même longueur. (Pour plus de "
+"séquences doivent être du même type et de la même longueur. (Pour plus de "
 "détails voir :ref:`comparisons` dans la référence du langage.)"
 
 #: ../Doc/library/stdtypes.rst:890
@@ -106010,7 +106013,7 @@ msgid ""
 "subsequence testing::"
 msgstr ""
 "Bien que les opérations ``in`` et ``not in`` ne soient généralement "
-"utilisées que pourles tests d'appartenance simple, certaines séquences "
+"utilisées que pour les tests d'appartenance simple, certaines séquences "
 "spécialisées (telles que :class:`str`, :class:`bytes` et :class:`bytearray`) "
 "les utilisent aussi pour tester l'existence de sous-séquences : ::"
 
@@ -106053,7 +106056,7 @@ msgid ""
 "``len(s) + i`` or ``len(s) + j`` is substituted.  But note that ``-0`` is "
 "still ``0``."
 msgstr ""
-"Si *i* ou *j* est négatifs, l'indice est relatif à la fin de la chaîne : "
+"Si *i* ou *j* sont négatifs, l'indice est relatif à la fin de la chaîne : "
 "``len(s) + i`` ou ``len(s) + j`` est substitué. Mais notez que ``-0`` est "
 "toujours ``0``."
 
@@ -106083,7 +106086,7 @@ msgid ""
 "``1``."
 msgstr ""
 "La tranche de *s* de *i* à *j* avec un pas de *k* est définie comme la "
-"séquenced'éléments d'indice ``x = i + n*k`` tels que ``0 <= n < (j-i)/k``. "
+"séquence d'éléments d'indice ``x = i + n*k`` tels que ``0 <= n < (j-i)/k``. "
 "En d'autres termes, les indices sont ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` et "
 "ainsi de suite, en arrêtant lorsque *j* est atteint (mais jamais inclus). Si "
 "*i* ou *j* est supérieur à ``len(s)``, ``len(s)`` est utilisé. Si *i* ou *j* "
@@ -106098,7 +106101,7 @@ msgid ""
 "quadratic runtime cost in the total sequence length.  To get a linear "
 "runtime cost, you must switch to one of the alternatives below:"
 msgstr ""
-"Concaténer des séquences immuables donne d toujours un nouvel objet. Cela "
+"Concaténer des séquences immuables donne toujours un nouvel objet. Cela "
 "signifie que la construction d'une séquence par concaténations répétées aura "
 "une durée d'exécution quadratique par rapport à la longueur de la séquence "
 "totale. Pour obtenir un temps d'exécution linéaire, vous devez utiliser "
@@ -106157,7 +106160,7 @@ msgid ""
 "rather than the start of the slice."
 msgstr ""
 "``index`` lève une exception :exc:`ValueError` quand *x* ne se trouve pas "
-"dans *s*.Lorsqu'ils sont supportés, les arguments supplémentaires de la "
+"dans *s*. Lorsqu'ils sont supportés, les arguments supplémentaires de la "
 "méthode ``index`` permettent une recherche efficace des sous-sequences dans "
 "la séquence. Donner ces arguments est plus ou moins équivalent à ``s[i:j]."
 "index(x)``, sans copier les données, et dont l'indice retourné est relatif "
@@ -106173,9 +106176,9 @@ msgid ""
 "not also implemented by mutable sequence types is support for the :func:"
 "`hash` built-in."
 msgstr ""
-"La seule opération que les types de séquences immutables implémentent qui ne "
-"sont pas également implémentés par les types de séquences mutables est le "
-"support pour la fonction native :func:`hash`."
+"La seule opération que les types de séquences immutables implémentent qui "
+"n'est pas implémentée par les types de séquences mutables est le support de "
+"la fonction native :func:`hash`."
 
 #: ../Doc/library/stdtypes.rst:995
 msgid ""
@@ -106193,7 +106196,7 @@ msgid ""
 "will result in :exc:`TypeError`."
 msgstr ""
 "Essayer de hacher une séquence immuable qui contient des valeurs non-"
-"hashables entraînera la levée d'une :exc:`TypeError`."
+"hachables lèvera une :exc:`TypeError`."
 
 #: ../Doc/library/stdtypes.rst:1006
 msgid "Mutable Sequence Types"
@@ -106353,13 +106356,13 @@ msgid ""
 "item is removed and returned."
 msgstr ""
 "L'argument optionnel *i* vaut ``-1`` par défaut, afin que, par défaut, le "
-"dernier élément est retiré et retourné."
+"dernier élément soit retiré et renvoyé."
 
 #: ../Doc/library/stdtypes.rst:1099
 msgid "``remove`` raises :exc:`ValueError` when *x* is not found in *s*."
 msgstr ""
-"``remove`` soulève une exception :exc:`ValueError` quand *x* ne se trouve "
-"pas dans *s*."
+"``remove`` lève une exception :exc:`ValueError` si *x* ne se trouve pas dans "
+"*s*."
 
 #: ../Doc/library/stdtypes.rst:1102
 msgid ""
@@ -106369,7 +106372,7 @@ msgid ""
 msgstr ""
 "La méthode :meth:`reverse` modifie les séquence sur place pour économiser de "
 "l'espace lors du traitement de grandes séquences. Pour rappeler aux "
-"utilisateurs qu'elle a un effet de bord, elle ne retourne pas la séquence "
+"utilisateurs qu'elle a un effet de bord, elle ne renvoie pas la séquence "
 "inversée."
 
 #: ../Doc/library/stdtypes.rst:1107
@@ -106378,9 +106381,9 @@ msgid ""
 "interfaces of mutable containers that don't support slicing operations (such "
 "as :class:`dict` and :class:`set`)"
 msgstr ""
-":meth:`clear` et :meth:`!copy` sont inclurs pour la compatibilité avec les "
+":meth:`clear` et :meth:`!copy` sont inclues pour la compatibilité avec les "
 "interfaces des conteneurs mutables qui ne supportent pas les opérations de "
-"tranchage (comme :class:`dict` et :class:`set`)"
+"découpage (comme :class:`dict` et :class:`set`)"
 
 #: ../Doc/library/stdtypes.rst:1111
 msgid ":meth:`clear` and :meth:`!copy` methods."
@@ -106415,27 +106418,28 @@ msgstr ""
 
 #: ../Doc/library/stdtypes.rst:1134
 msgid "Lists may be constructed in several ways:"
-msgstr "Les listes peuvent être construites de différentes manières:"
+msgstr "Les listes peuvent être construites de différentes manières :"
 
 #: ../Doc/library/stdtypes.rst:1136
 msgid "Using a pair of square brackets to denote the empty list: ``[]``"
 msgstr ""
-"En utilisant une paire de crochets pour indiquer une liste vide: ``[]``"
+"En utilisant une paire de crochets pour indiquer une liste vide : ``[]``"
 
 #: ../Doc/library/stdtypes.rst:1137
 msgid ""
 "Using square brackets, separating items with commas: ``[a]``, ``[a, b, c]``"
 msgstr ""
-"Au moyen de crochets, séparant les éléments par des virgules: ``[a]``, ``[a, "
-"b, c]``"
+"Au moyen de crochets, séparant les éléments par des virgules : ``[a]``, "
+"``[a, b, c]``"
 
 #: ../Doc/library/stdtypes.rst:1138
 msgid "Using a list comprehension: ``[x for x in iterable]``"
-msgstr "En utilisant une liste en compréhension: ``[x for x in iterable]``"
+msgstr "En utilisant une liste en compréhension : ``[x for x in iterable]``"
 
 #: ../Doc/library/stdtypes.rst:1139
 msgid "Using the type constructor: ``list()`` or ``list(iterable)``"
-msgstr "En utilisant le constructeur du type: ``list()`` ou ``list(iterable)``"
+msgstr ""
+"En utilisant le constructeur du type : ``list()`` ou ``list(iterable)``"
 
 #: ../Doc/library/stdtypes.rst:1141
 msgid ""
@@ -106471,7 +106475,7 @@ msgid ""
 msgstr ""
 "Les listes supportent toutes les opérations des séquences :ref:`communes "
 "<typesseq-common>` et :ref:`mutables <typesseq-mutable>`. Les listes "
-"fournissent également la méthode supplémentaire suivante:"
+"fournissent également la méthode supplémentaire suivante :"
 
 #: ../Doc/library/stdtypes.rst:1159
 msgid ""
@@ -106503,8 +106507,8 @@ msgid ""
 msgstr ""
 "*key* spécifie une fonction d'un argument utilisée pour extraire une clé de "
 "comparaison de chaque élément de la liste (par exemple, ``key=str.lower``). "
-"La clé correspondant à chaque élément de la liste est calculée une seule "
-"fois, puis utilisée durant tout le processus. La valeur par défaut, "
+"La clé correspondant à chaque élément de la liste n'est calculée qu'une "
+"seule fois, puis utilisée durant tout le processus. La valeur par défaut, "
 "``None``, signifie que les éléments sont triés directement sans en calculer "
 "une valeur \"clé\" séparée."
 
@@ -106525,7 +106529,7 @@ msgid ""
 msgstr ""
 "Cette méthode modifie la séquence sur place pour économiser de l'espace lors "
 "du tri de grandes séquences. Pour rappeler aux utilisateurs cet effet de "
-"bord, elle ne retourne pas la séquence triée (utilisez :func:`sorted` pour "
+"bord, elle ne renvoie pas la séquence triée (utilisez :func:`sorted` pour "
 "demander explicitement une nouvelle instance de liste triée)."
 
 #: ../Doc/library/stdtypes.rst:1185
@@ -106578,7 +106582,7 @@ msgstr "Les tuples peuvent être construits de différentes façons :"
 #: ../Doc/library/stdtypes.rst:1215
 msgid "Using a pair of parentheses to denote the empty tuple: ``()``"
 msgstr ""
-"En utilisant une paire de parenthèses pour désigner le tuple vide: ``()``"
+"En utilisant une paire de parenthèses pour désigner le tuple vide : ``()``"
 
 #: ../Doc/library/stdtypes.rst:1216
 msgid "Using a trailing comma for a singleton tuple: ``a,`` or ``(a,)``"
@@ -106610,7 +106614,7 @@ msgstr ""
 "Le constructeur construit un tuple dont les éléments sont les mêmes et dans "
 "le même ordre que les éléments de *iterable*. *iterable* peut être soit une "
 "séquence, un conteneur qui supporte l'itération, soit un itérateur. Si "
-"*iterable* est déjà un tuple, il est retourné inchangé. Par exemple, "
+"*iterable* est déjà un tuple, il est renvoyé inchangé. Par exemple, "
 "``tuple('abc')`` retourne ``('a', 'b', 'c')`` et ``tuple( [1, 2, 3] )`` "
 "retourne ``(1, 2, 3)``. Si aucun argument est donné, le constructeur crée un "
 "nouveau tuple vide, ``()``."
@@ -106624,11 +106628,11 @@ msgid ""
 "call with a 3-tuple as the sole argument."
 msgstr ""
 "Notez que c'est en fait la virgule qui fait un tuple, pas les parenthèses. "
-"Les parenthèses sont facultatives, sauf dans le cas du tuple vide, ou quand "
-"ils sont nécessaires pour éviter l'ambiguïté syntaxique. Par exemple, ``f(a, "
-"b, c)`` est un appel de fonction avec trois arguments, alors que ``f((a, b, "
-"c))`` est un appel de fonction avec un tuple de trois éléments comme unique "
-"argument."
+"Les parenthèses sont facultatives, sauf dans le cas du tuple vide, ou "
+"lorsqu'elles sont nécessaires pour éviter l'ambiguïté syntaxique. Par "
+"exemple, ``f(a, b, c)`` est un appel de fonction avec trois arguments, alors "
+"que ``f((a, b, c))`` est un appel de fonction avec un tuple de trois "
+"éléments comme unique argument."
 
 #: ../Doc/library/stdtypes.rst:1234
 msgid ""