sed -i 's/\([^m]\)muable/\1mutable/' *.po */*.po (#258)

Closes #123

Reviewed-on: AFPy/python-docs-fr#258
Reviewed-by: Christophe Nanteuil <christophenan@noreply.localhost>
Co-authored-by: Julien Palard <julien@palard.fr>
Co-committed-by: Julien Palard <julien@palard.fr>

CONTRIBUTING.rst

@@ -604,7 +604,7 @@ list comprehension         liste en compréhension (liste en intension est
 little-endian, big-endian  `petit-boutiste, gros-boutiste
                            <https://fr.wikipedia.org/wiki/Endianness>`_
 mixin type                 type de mélange
-mutable                    muable
+mutable                    `mutable <https://git.afpy.org/AFPy/python-docs-fr/issues/123>`_
 namespace                  espace de nommage
                            (sauf pour le XML où c'est espace de noms)
 parameter                  paramètre

c-api/arg.po

@@ -102,7 +102,7 @@ msgstr ""
 "Néanmoins, quand une structure :c:type:`Py_buffer` est en cours de "
 "remplissage, le tampon sous-jacent est verrouillé pour permettre à "
 "l'appelant d'utiliser le tampon par la suite, même à l'intérieur d'un bloc :"
-"c:type:`Py_BEGIN_ALLOW_THREADS`, sans risques de voir des données muables se "
+"c:type:`Py_BEGIN_ALLOW_THREADS`, sans risques de voir des données mutables se "
 "faire redimensionner ou supprimer. En conséquence, **il vous appartient "
 "d'appeler** :c:func:`PyBuffer_Release` après avoir terminé de traiter les "
 "données (ou après une interruption prématurée du traitement de ces données)."
@@ -229,7 +229,7 @@ msgid ""
 "null bytes. Unicode objects are converted to C strings using ``'utf-8'`` "
 "encoding."
 msgstr ""
-"La même chose que ``s*``, mais n'accepte pas les objets muables. Le résultat "
+"La même chose que ``s*``, mais n'accepte pas les objets mutables. Le résultat "
 "est stocké dans deux variables C, la première est un pointeur vers une "
 "chaîne de caractères C, la seconde contient sa taille. La chaîne de "
 "caractères peut contenir des octets NULL. Les objets Unicode sont convertis "
@@ -1373,7 +1373,7 @@ msgstr ""
 #~ "d'octets <bytes-like object>` en lecture seule, et définissent un "
 #~ "pointeur à la place d'une structure tampon. Ils fonctionnent en vérifiant "
 #~ "que le champ :c:member:`PyBufferProcs.bf_releasebuffer` de l'objet est "
-#~ "*NULL*, ce qui n'autorise pas les objets muables tels que :class:"
+#~ "*NULL*, ce qui n'autorise pas les objets mutables tels que :class:"
 #~ "`bytearray`."
 
 #~ msgid ""

dict

@@ -122,8 +122,6 @@ mersenne
 mertz
 Monty
 muabilité
-muable
-muables
 multiensemble
 multiensembles
 mutex

faq/design.po

@@ -820,7 +820,7 @@ msgid ""
 msgstr ""
 "Les *n*-uplets sont immuables, ce qui signifie que lorsqu'un *n*-uplet a été "
 "créé, vous ne pouvez remplacer aucun de ses éléments par une nouvelle "
-"valeur. Les listes sont muables, ce qui signifie que vous pouvez toujours "
+"valeur. Les listes sont mutables, ce qui signifie que vous pouvez toujours "
 "modifier les éléments d'une liste. Seuls des éléments immuables peuvent être "
 "utilisés comme clés de dictionnaires, et donc de ``tuple`` et ``list`` seul "
 "des *n*-uplets peuvent être utilisés comme clés."
@@ -922,7 +922,7 @@ msgid ""
 msgstr ""
 "L'implémentation de la table de hachage des dictionnaires utilise une valeur "
 "de hachage calculée à partir de la valeur de la clé pour trouver la clé elle-"
-"même.  Si la clé était un objet muable, sa valeur peut changer, et donc son "
+"même.  Si la clé était un objet mutable, sa valeur peut changer, et donc son "
 "hachage pourrait également changer.  Mais toute personne modifiant l'objet "
 "clé ne peut pas dire qu'elle a été utilisée comme une clé de dictionnaire. "
 "Il ne peut déplacer l'entrée dans le dictionnaire.  Ainsi, lorsque vous "
@@ -975,7 +975,7 @@ msgid ""
 "copying code would run into an infinite loop."
 msgstr ""
 "Faire une copie lors de l'utilisation d'une liste en tant que clé.  Cela ne "
-"fonctionne pas puisque la liste, étant un objet muable, pourrait contenir "
+"fonctionne pas puisque la liste, étant un objet mutable, pourrait contenir "
 "une référence à elle-même ou avoir une boucle infinie au niveau du code "
 "copié."
 

faq/programming.po

@@ -798,7 +798,7 @@ msgstr ""
 msgid ""
 "Lists are :term:`mutable`, which means that you can change their content."
 msgstr ""
-"Les listes sont des :term:`muable`, ce qui signifie que leur contenu peut "
+"Les listes sont des :term:`mutable`, ce qui signifie que leur contenu peut "
 "être modifié."
 
 #: faq/programming.rst:457
@@ -807,7 +807,7 @@ msgid ""
 "has changed from ``[]`` to ``[10]``.  Since both the variables refer to the "
 "same object, using either name accesses the modified value ``[10]``."
 msgstr ""
-"Après l'appel de :meth:`~list.append`, le contenu de l'objet muable est "
+"Après l'appel de :meth:`~list.append`, le contenu de l'objet mutable est "
 "passé de ``[]`` à ``[10]``. Vu que les deux variables font référence au même "
 "objet, il est possible d'accéder à la valeur modifiée ``[10]`` avec chacun "
 "des noms."
@@ -881,7 +881,7 @@ msgid ""
 "etc.), we can use some specific operations to mutate it and all the "
 "variables that refer to it will see the change."
 msgstr ""
-"Il est possible d'appliquer des opérations qui modifient un objet muable (:"
+"Il est possible d'appliquer des opérations qui modifient un objet mutable (:"
 "class:`list`, :class:`dict`, :class:`set`, etc.) et toutes les variables qui "
 "y font référence verront le changement."
 
@@ -942,7 +942,7 @@ msgstr ""
 
 #: faq/programming.rst:532
 msgid "By passing a mutable (changeable in-place) object::"
-msgstr "En passant un objet muable (modifiable sur place) ::"
+msgstr "En passant un objet mutable (modifiable sur place) ::"
 
 #: faq/programming.rst:543
 msgid "By passing in a dictionary that gets mutated::"
@@ -2060,7 +2060,7 @@ msgid ""
 msgstr ""
 "Ceci est dû à la combinaison de deux facteurs : le fait que les opérateurs "
 "d'affectation incrémentaux sont des opérateurs d'*affectation* et à la "
-"différence entre les objets muables et immuables en Python."
+"différence entre les objets mutables et immuables en Python."
 
 #: faq/programming.rst:1352
 msgid ""
@@ -2070,7 +2070,7 @@ msgid ""
 msgstr ""
 "Cette discussion est valable, en général, quand des opérateurs d'affectation "
 "incrémentale sont appliqués aux éléments d'un *n*-uplet qui pointe sur des "
-"objets muables, mais on prendra ``list`` et ``+=`` comme exemple."
+"objets mutables, mais on prendra ``list`` et ``+=`` comme exemple."
 
 #: faq/programming.rst:1356
 msgid "If you wrote::"
@@ -2167,7 +2167,7 @@ msgid ""
 msgstr ""
 "L'appel à :meth:`!__iadd__` réussit et la liste est étendue, mais bien que "
 "``result`` pointe sur le même objet que ``a_tuple[0]``, l'affectation finale "
-"échoue car les *n*-uplets ne sont pas muables."
+"échoue car les *n*-uplets ne sont pas mutables."
 
 #: faq/programming.rst:1433
 msgid ""
@@ -2811,7 +2811,7 @@ msgstr ""
 #: faq/programming.rst:1871
 msgid "Likewise, new instances of mutable containers are never identical::"
 msgstr ""
-"De même, deux instances fraîchement créées d'un type de conteneurs muables "
+"De même, deux instances fraîchement créées d'un type de conteneurs mutables "
 "ne sont jamais identiques ::"
 
 #: faq/programming.rst:1878

glossary.po

@@ -1388,7 +1388,7 @@ msgid ""
 "value is derived from their :func:`id`."
 msgstr ""
 "La plupart des types immuables natifs de Python sont hachables, mais les "
-"conteneurs muables (comme les listes ou les dictionnaires) ne le sont pas ; "
+"conteneurs mutables (comme les listes ou les dictionnaires) ne le sont pas ; "
 "les conteneurs immuables (comme les n-uplets ou les ensembles figés) ne sont "
 "hachables que si leurs éléments sont hachables. Les instances de classes "
 "définies par les utilisateurs sont hachables par défaut. Elles sont toutes "
@@ -1841,7 +1841,7 @@ msgstr ""
 "Conteneur permettant de rechercher des éléments à partir de clés et "
 "implémentant les méthodes spécifiées dans les classes mères abstraites des :"
 "class:`tableaux de correspondances <collections.abc.Mapping>` (immuables) "
-"ou :class:`tableaux de correspondances muables <collections.abc."
+"ou :class:`tableaux de correspondances mutables <collections.abc."
 "MutableMapping>` (voir les :ref:`classes mères abstraites <collections-"
 "abstract-base-classes>`). Les classes suivantes sont des exemples de "
 "tableaux de correspondances : :class:`dict`, :class:`collections."
@@ -1977,14 +1977,14 @@ msgstr "Voir :term:`ordre de résolution des méthodes`."
 
 #: glossary.rst:814
 msgid "mutable"
-msgstr "muable"
+msgstr "mutable"
 
 #: glossary.rst:816
 msgid ""
 "Mutable objects can change their value but keep their :func:`id`.  See also :"
 "term:`immutable`."
 msgstr ""
-"Un objet muable peut changer de valeur tout en gardant le même :func:`id`. "
+"Un objet mutable peut changer de valeur tout en gardant le même :func:`id`. "
 "Voir aussi :term:`immuable`."
 
 #: glossary.rst:818

library/collections.abc.po

@@ -526,7 +526,7 @@ msgstr ""
 
 #: library/collections.abc.rst:260
 msgid "ABCs for read-only and mutable :term:`sequences <sequence>`."
-msgstr "ABC pour les :term:`séquences <sequence>` immuables et muables."
+msgstr "ABC pour les :term:`séquences <sequence>` immuables et mutables."
 
 #: library/collections.abc.rst:262
 msgid ""
@@ -553,13 +553,13 @@ msgstr ""
 
 #: library/collections.abc.rst:278
 msgid "ABCs for read-only and mutable sets."
-msgstr "ABC pour les ensembles immuables et muables."
+msgstr "ABC pour les ensembles immuables et mutables."
 
 #: library/collections.abc.rst:283
 msgid "ABCs for read-only and mutable :term:`mappings <mapping>`."
 msgstr ""
 "ABC pour les :term:`tables de correspondances <mapping>` immuables et "
-"muables."
+"mutables."
 
 #: library/collections.abc.rst:290
 msgid ""

library/collections.po

@@ -1436,7 +1436,7 @@ msgid ""
 "See :meth:`types.SimpleNamespace` for a mutable namespace based on an "
 "underlying dictionary instead of a tuple."
 msgstr ""
-"Voir :meth:`types.SimpleNamespace` pour un espace de nommage muable basé sur "
+"Voir :meth:`types.SimpleNamespace` pour un espace de nommage mutable basé sur "
 "un dictionnaire sous-jacent à la place d'un *n*-uplet."
 
 #: library/collections.rst:1075
@@ -1753,7 +1753,7 @@ msgid ""
 "In addition to supporting the methods and operations of mutable sequences, :"
 "class:`UserList` instances provide the following attribute:"
 msgstr ""
-"En plus de gérer les méthodes et opérations des séquences muables, les "
+"En plus de gérer les méthodes et opérations des séquences mutables, les "
 "instances de :class:`UserList` possèdent l'attribut suivant :"
 
 #: library/collections.rst:1351

library/copy.po

@@ -33,7 +33,7 @@ msgid ""
 msgstr ""
 "Les instructions d'affectation en Python ne copient pas les objets, elles "
 "créent des liens entre la cible et l'objet. Concernant les collections qui "
-"sont muables ou contiennent des éléments muables, une copie est parfois "
+"sont mutables ou contiennent des éléments mutables, une copie est parfois "
 "nécessaire, pour pouvoir modifier une copie sans modifier l'autre. Ce module "
 "met à disposition des opérations de copie génériques superficielle et "
 "récursive (comme expliqué ci-dessous)."

library/ctypes.po

@@ -551,7 +551,7 @@ msgstr ""
 msgid ""
 "Since these types are mutable, their value can also be changed afterwards::"
 msgstr ""
-"Ces types étant des muables, leur valeur peut aussi être modifiée après "
+"Ces types étant des mutables, leur valeur peut aussi être modifiée après "
 "coup ::"
 
 #: library/ctypes.rst:291

library/dataclasses.po

@@ -484,7 +484,7 @@ msgstr ""
 "*default_factory* : s'il est fourni, ce doit être un objet appelable sans "
 "argument. Il est alors appelé à chaque fois qu'il faut une valeur par défaut "
 "pour le champ. Ceci permet, entre autres choses, de définir des champs dont "
-"les valeurs par défaut sont muables. Une erreur se produit si *default* et "
+"les valeurs par défaut sont mutables. Une erreur se produit si *default* et "
 "*default_factory* sont donnés tous les deux."
 
 #: library/dataclasses.rst:258
@@ -1161,7 +1161,7 @@ msgstr ""
 
 #: library/dataclasses.rst:691
 msgid "Mutable default values"
-msgstr "Valeurs par défaut muables"
+msgstr "Valeurs par défaut mutables"
 
 #: library/dataclasses.rst:693
 msgid ""
@@ -1216,7 +1216,7 @@ msgid ""
 "Using default factory functions is a way to create new instances of mutable "
 "types as default values for fields::"
 msgstr ""
-"Pour qu'un champ d'un type muable soit par défaut initialisé à un nouvel "
+"Pour qu'un champ d'un type mutable soit par défaut initialisé à un nouvel "
 "objet pour chaque instance, utilisez une fonction de fabrique ::"
 
 # suit un ':'

library/functions.po

@@ -573,7 +573,7 @@ msgid ""
 "as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`."
 msgstr ""
 "Renvoie un nouveau tableau d'octets. La classe :class:`bytearray` est une "
-"séquence muable de nombres entiers dans l'intervalle 0 ≤ x < 256. Il possède "
+"séquence mutable de nombres entiers dans l'intervalle 0 ≤ x < 256. Il possède "
 "la plupart des méthodes des séquences variables, décrites dans :ref:"
 "`typesseq-mutable`, ainsi que la plupart des méthodes de la classe :class:"
 "`bytes`, voir :ref:`bytes-methods`."
@@ -2031,7 +2031,7 @@ msgid ""
 "type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
 msgstr ""
 "Contrairement aux apparences, :class:`list` n'est pas une fonction mais un "
-"type séquentiel muable, comme décrit dans :ref:`typesseq-list` et :ref:"
+"type séquentiel mutable, comme décrit dans :ref:`typesseq-list` et :ref:"
 "`typesseq`."
 
 #: library/functions.rst:1029

library/inspect.po

@@ -1403,7 +1403,7 @@ msgid ""
 "explicitly bound arguments.  Changes in :attr:`arguments` will reflect in :"
 "attr:`args` and :attr:`kwargs`."
 msgstr ""
-"Une correspondance muable entre les noms de paramètres et les valeurs des "
+"Une correspondance mutable entre les noms de paramètres et les valeurs des "
 "arguments. Contient seulement les arguments liés explicitement. Les "
 "changements dans :attr:`arguments` sont reflétés dans :attr:`args` et :attr:"
 "`kwargs`."

library/multiprocessing.shared_memory.po

@@ -312,7 +312,7 @@ msgid ""
 "support the dynamic creation of new :class:`ShareableList` instances via "
 "slicing."
 msgstr ""
-"Construit un objet muable compatible avec le type liste dont toutes les "
+"Construit un objet mutable compatible avec le type liste dont toutes les "
 "valeurs sont stockées dans un bloc de mémoire partagée. Ceci limite le type "
 "des valeurs pouvant être stockées aux types natifs ``int``, ``float``, "
 "``bool``, ``str`` (de moins de 10 Mo chacune), ``bytes`` (de moins de 10 Mo "

library/os.po

@@ -1779,7 +1779,7 @@ msgid ""
 "move on to the next buffer in the sequence to hold the rest of the data."
 msgstr ""
 "Lit depuis un descripteur de fichier *fd*, à la position *offset* dans des :"
-"term:`objets bytes-compatibles <bytes-like object>` muables *buffers*, sans "
+"term:`objets bytes-compatibles <bytes-like object>` mutables *buffers*, sans "
 "modifier la position dans le fichier. Les données sont transférées dans "
 "chaque tampon, jusqu'à ce qu'il soit plein, tour à tour."
 
@@ -2132,7 +2132,7 @@ msgid ""
 "rest of the data."
 msgstr ""
 "Lit depuis un descripteur de fichier *fd* dans une séquence d':term:`objets "
-"bytes-compatibles <bytes-like object>` muables : *buffers*. Les données sont "
+"bytes-compatibles <bytes-like object>` mutables : *buffers*. Les données sont "
 "transférées dans chaque tampon, jusqu'à ce qu'il soit plein, tour à tour."
 
 #: library/os.rst:1560

library/pickle.po

@@ -134,7 +134,7 @@ msgstr ""
 "pointent dessus, depuis différents endroits dans la hiérarchie sérialisée. "
 "Le module :mod:`pickle` repère ces partages et ne stocke ces objets qu'une "
 "seule fois. Les objets partagés restent ainsi partagés, ce qui peut être "
-"très important pour les objets muables."
+"très important pour les objets mutables."
 
 #: library/pickle.rst:72
 msgid ""

library/shelve.po

@@ -82,7 +82,7 @@ msgid ""
 "mutated)."
 msgstr ""
 "À cause de la sémantique de Python, une étagère ne peut pas savoir "
-"lorsqu'une entrée muable de dictionnaire persistant est modifiée. Par défaut "
+"lorsqu'une entrée mutable de dictionnaire persistant est modifiée. Par défaut "
 "les objets modifiés sont écrits *seulement* lorsqu'ils sont assignés à une "
 "étagère (voir :ref:`shelve-example`). Si le paramètre optionnel *writeback* "
 "est mis à ``True``, toutes les entrées déjà accédées sont aussi mises en "
@@ -244,7 +244,7 @@ msgstr ""
 "Si le paramètre *writeback* est ``True``, l'objet garde en cache toutes les "
 "entrées accédées et les écrit dans le *dict* aux moments de synchronisation "
 "et de fermeture. Cela permet des opérations naturelles sur les entrées "
-"muables, mais peut consommer beaucoup plus de mémoire et rendre les temps de "
+"mutables, mais peut consommer beaucoup plus de mémoire et rendre les temps de "
 "synchronisation et de fermeture très longs."
 
 #: library/shelve.rst:132

library/stdtypes.po

@@ -42,7 +42,7 @@ msgid ""
 "rearrange their members in place, and don't return a specific item, never "
 "return the collection instance itself but ``None``."
 msgstr ""
-"Certaines classes de collection sont muables. Les méthodes qui ajoutent, "
+"Certaines classes de collection sont mutables. Les méthodes qui ajoutent, "
 "retirent, ou réorganisent leurs éléments sur place, et qui ne renvoient pas "
 "un élément spécifique, ne renvoient jamais l'instance de la collection elle-"
 "même, mais ``None``."
@@ -1726,7 +1726,7 @@ msgstr ""
 "si vous concaténez des :class:`bytes`, vous pouvez aussi utiliser :meth:"
 "`bytes.join` ou :class:`io.BytesIO`, ou vous pouvez faire les concaténations "
 "sur place avec un objet :class:`bytearray`. Les objets :class:`bytearray` "
-"sont muables et ont un mécanisme de sur-allocation efficace ;"
+"sont mutables et ont un mécanisme de sur-allocation efficace ;"
 
 # énumération
 #: library/stdtypes.rst:1050
@@ -1779,7 +1779,7 @@ msgid ""
 "`hash` built-in."
 msgstr ""
 "La seule opération que les types de séquences immuables implémentent et qui "
-"n'est pas implémentée par les types de séquences muables est la fonction "
+"n'est pas implémentée par les types de séquences mutables est la fonction "
 "native :func:`hash`."
 
 #: library/stdtypes.rst:1083
@@ -1802,7 +1802,7 @@ msgstr ""
 
 #: library/stdtypes.rst:1094
 msgid "Mutable Sequence Types"
-msgstr "Types de séquences muables"
+msgstr "Types de séquences mutables"
 
 #: library/stdtypes.rst:1101
 msgid ""
@@ -1811,7 +1811,7 @@ msgid ""
 "easier to correctly implement these operations on custom sequence types."
 msgstr ""
 "Les opérations dans le tableau ci-dessous sont définies sur les types de "
-"séquences muables. La classe mère abstraite :class:`collections.abc."
+"séquences mutables. La classe mère abstraite :class:`collections.abc."
 "MutableSequence` est prévue pour faciliter l'implémentation correcte de ces "
 "opérations sur les types de séquences personnalisées."
 
@@ -1823,7 +1823,7 @@ msgid ""
 "integers that meet the value restriction ``0 <= x <= 255``)."
 msgstr ""
 "Dans le tableau ci-dessosus, *s* est une instance d'un type de séquence "
-"muable, *t* est un objet itérable et *x* est un objet arbitraire qui répond "
+"mutable, *t* est un objet itérable et *x* est un objet arbitraire qui répond "
 "à toutes les restrictions de type et de valeur imposées par *s* (par "
 "exemple, :class:`bytearray` accepte uniquement des nombres entiers qui "
 "répondent à la restriction de la valeur ``0 <= x <= 255``)."
@@ -1986,7 +1986,7 @@ msgid ""
 "classes provide it."
 msgstr ""
 ":meth:`clear` et :meth:`!copy` sont incluses pour la compatibilité avec les "
-"interfaces des conteneurs muables qui ne gèrent pas les opérations de "
+"interfaces des conteneurs mutables qui ne gèrent pas les opérations de "
 "découpage (comme :class:`dict` et :class:`set`). :meth:`!copy` ne fait pas "
 "partie des classes mères abstraites (*ABC*) de :class:`collections.abc."
 "MutableSequence`, mais la plupart des classes implémentées gérant des "
@@ -2019,7 +2019,7 @@ msgid ""
 "homogeneous items (where the precise degree of similarity will vary by "
 "application)."
 msgstr ""
-"Les listes sont des séquences muables, généralement utilisées pour stocker "
+"Les listes sont des séquences mutables, généralement utilisées pour stocker "
 "des collections d'éléments homogènes (le degré de similitude varie selon "
 "l'usage)."
 
@@ -2085,7 +2085,7 @@ msgid ""
 "additional method:"
 msgstr ""
 "Les listes gèrent toutes les opérations des séquences :ref:`communes "
-"<typesseq-common>` et :ref:`muables <typesseq-mutable>`. Les listes "
+"<typesseq-common>` et :ref:`mutables <typesseq-mutable>`. Les listes "
 "fournissent également la méthode supplémentaire suivante :"
 
 #: library/stdtypes.rst:1249
@@ -2554,7 +2554,7 @@ msgid ""
 "StringIO` can be used to efficiently construct strings from multiple "
 "fragments."
 msgstr ""
-"Il n'y a aucun type de chaîne muable, mais :meth:`str.join` ou :class:`io."
+"Il n'y a aucun type de chaîne mutable, mais :meth:`str.join` ou :class:`io."
 "StringIO` peuvent être utilisées pour construire efficacement des chaînes à "
 "partir de plusieurs fragments."
 
@@ -4362,7 +4362,7 @@ msgid ""
 ":class:`bytearray` objects are a mutable counterpart to :class:`bytes` "
 "objects."
 msgstr ""
-"Les objets :class:`bytearray` sont l'équivalent muable des objets :class:"
+"Les objets :class:`bytearray` sont l'équivalent mutable des objets :class:"
 "`bytes`."
 
 #: library/stdtypes.rst:2599
@@ -4404,8 +4404,8 @@ msgid ""
 "mutable>` sequence operations in addition to the common bytes and bytearray "
 "operations described in :ref:`bytes-methods`."
 msgstr ""
-"Comme les *bytearray* sont muables, ils prennent en charge les opérations de "
+"Comme les *bytearray* sont mutables, ils prennent en charge les opérations de "
-"séquences :ref:`muables <typesseq-mutable>` en plus des opérations communes "
+"séquences :ref:`mutables <typesseq-mutable>` en plus des opérations communes "
 "de *bytes* et *bytearray* décrites dans :ref:`bytes-methods`."
 
 #: library/stdtypes.rst:2611
@@ -5894,9 +5894,9 @@ msgid ""
 "of another set."
 msgstr ""
 "Il existe actuellement deux types natifs pour les ensembles, :class:`set` "
-"et :class:`frozenset`. Le type :class:`set` est muable — son contenu peut "
+"et :class:`frozenset`. Le type :class:`set` est mutable — son contenu peut "
 "changer en utilisant des méthodes comme :meth:`~set.add` et :meth:`~set."
-"remove`. Puisqu'il est muable, il n'a pas de valeur de hachage et ne peut "
+"remove`. Puisqu'il est mutable, il n'a pas de valeur de hachage et ne peut "
 "donc pas être utilisé ni comme clé de dictionnaire ni comme élément d'un "
 "autre ensemble. Le type :class:`frozenset` est immuable et :term:`hachable "
 "<hashable>` — son contenu ne peut être modifié après sa création, il peut "
@@ -6218,7 +6218,7 @@ msgid ""
 msgstr ""
 "Un objet :term:`tableau de correspondances <mapping>` (*mapping*) fait "
 "correspondre des valeurs :term:`hachables <hashable>` à des objets "
-"arbitraires. Les tableaux de correspondances sont des objets muables. Il "
+"arbitraires. Les tableaux de correspondances sont des objets mutables. Il "
 "n'existe pour le moment qu'un type de tableau de correspondances standard, "
 "le :dfn:`dictionary`.  (Pour les autres conteneurs, voir les types natifs :"
 "class:`liste <list>`, :class:`ensemble <set>` et :class:`n-uplet <tuple>`, "
@@ -6234,7 +6234,7 @@ msgid ""
 msgstr ""
 "Les clés d'un dictionnaire sont *presque* des données arbitraires. Les "
 "valeurs qui ne sont pas :term:`hachables <hashable>`, c'est-à-dire les "
-"valeurs contenant des listes, dictionnaires ou autres types muables (qui "
+"valeurs contenant des listes, dictionnaires ou autres types mutables (qui "
 "sont comparés à l'aide de leurs valeurs plutôt que par l'identité de "
 "l'objet) ne peuvent pas être utilisées comme clés. Des valeurs qui sont "
 "considérées égales lors d'une comparaison (comme ``1``, ``1.0`` et ``True``) "
@@ -8781,7 +8781,7 @@ msgstr ""
 #: library/stdtypes.rst:1461
 #, fuzzy
 msgid "text sequence type"
-msgstr "Types de séquences muables"
+msgstr "Types de séquences mutables"
 
 #: library/stdtypes.rst:1510 library/stdtypes.rst:1528
 #, fuzzy
@@ -8872,7 +8872,7 @@ msgstr ""
 #: library/stdtypes.rst:2458
 #, fuzzy
 msgid "binary sequence types"
-msgstr "Types de séquences muables"
+msgstr "Types de séquences mutables"
 
 #: library/stdtypes.rst:2466
 #, fuzzy

reference/datamodel.po

@@ -6,7 +6,7 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2023-07-23 14:38+0200\n"
-"PO-Revision-Date: 2022-11-20 21:56+0100\n"
+"PO-Revision-Date: 2023-12-05 16:21+0100\n"
 "Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n"
 "Language: fr\n"
@@ -82,17 +82,17 @@ msgid ""
 "lists are mutable."
 msgstr ""
 "La *valeur* de certains objets peut changer. Les objets dont la valeur peut "
-"changer sont dits *muables* (*mutable* en anglais) ; les objets dont la "
+"changer sont dits mutables ; les objets dont la valeur est définitivement "
-"valeur est définitivement fixée à leur création sont dits *immuables* "
+"fixée à leur création sont dits *immuables* (*immutable* en anglais). La "
-"(*immutable* en anglais). La valeur d'un objet conteneur immuable qui "
+"valeur d'un objet conteneur immuable qui contient une référence vers un "
-"contient une référence vers un objet muable peut varier lorsque la valeur de "
+"objet mutable peut varier lorsque la valeur de l'objet mutable change ; "
-"l'objet muable change ; cependant, le conteneur est quand même considéré "
+"cependant, le conteneur est quand même considéré comme immuable parce que "
-"comme immuable parce que l'ensemble des objets qu'il contient ne peut pas "
+"l'ensemble des objets qu'il contient ne peut pas être modifié. Ainsi, "
-"être modifié. Ainsi, l'immuabilité n'est pas strictement équivalente au fait "
+"l'immuabilité n'est pas strictement équivalente au fait d'avoir une valeur "
-"d'avoir une valeur non modifiable, c'est plus subtil. La muabilité d'un "
+"non modifiable, c'est plus subtil. La muabilité d'un objet est définie par "
-"objet est définie par son type ; par exemple, les nombres, les chaînes de "
+"son type ; par exemple, les nombres, les chaînes de caractères et les *n*-"
-"caractères et les *n*-uplets sont immuables alors que les dictionnaires et "
+"uplets sont immuables alors que les dictionnaires et les listes sont "
-"les listes sont muables."
+"mutables."
 
 #: reference/datamodel.rst:65
 msgid ""
@@ -182,8 +182,8 @@ msgstr ""
 "identifiants des objets contenus ; cependant, lorsque nous parlons de la "
 "muabilité d'un conteneur, seuls les identifiants des objets immédiatement "
 "contenus sont concernés. Ainsi, si un conteneur immuable (comme un *n*-"
-"uplet) contient une référence à un objet muable, sa valeur change si cet "
+"uplet) contient une référence à un objet mutable, sa valeur change si cet "
-"objet muable est modifié."
+"objet mutable est modifié."
 
 #: reference/datamodel.rst:106
 msgid ""
@@ -201,7 +201,7 @@ msgstr ""
 "son identifiant est concerné dans un certain sens : pour les types "
 "immuables, les opérations qui calculent de nouvelles valeurs peuvent en fait "
 "renvoyer une référence à n'importe quel objet existant avec le même type et "
-"la même valeur, alors que pour les objets muables cela n'est pas autorisé. "
+"la même valeur, alors que pour les objets mutables cela n'est pas autorisé. "
 "Par exemple, après ``a = 1 ; b = 1``, ``a`` et ``b`` peuvent ou non se "
 "référer au même objet avec la valeur un, en fonction de l'implémentation. "
 "Mais après ``c = [] ; d = []``, il est garanti que ``c`` et ``d`` font "
@@ -545,8 +545,8 @@ msgid ""
 msgstr ""
 "Un objet de type de séquence immuable ne peut pas être modifié une fois "
 "qu'il a été créé. Si l'objet contient des références à d'autres objets, ces "
-"autres objets peuvent être muables et peuvent être modifiés ; cependant, les "
+"autres objets peuvent être mutables et peuvent être modifiés ; cependant, "
-"objets directement référencés par un objet immuable ne peuvent pas être "
+"les objets directement référencés par un objet immuable ne peuvent pas être "
 "modifiés."
 
 #: reference/datamodel.rst:304
@@ -626,7 +626,7 @@ msgstr ""
 
 #: reference/datamodel.rst:383
 msgid "Mutable sequences"
-msgstr "Séquences muables"
+msgstr "Séquences mutables"
 
 #: reference/datamodel.rst:359
 msgid ""
@@ -634,14 +634,14 @@ msgid ""
 "and slicing notations can be used as the target of assignment and :keyword:"
 "`del` (delete) statements."
 msgstr ""
-"Les séquences muables peuvent être modifiées après leur création. Les "
+"Les séquences mutables peuvent être modifiées après leur création. Les "
 "notations de tranches et de sous-ensembles peuvent être utilisées en tant "
 "que cibles d'une affectation ou de l'instruction :keyword:`del` "
 "(suppression)."
 
 #: reference/datamodel.rst:363
 msgid "There are currently two intrinsic mutable sequence types:"
-msgstr "Il existe aujourd'hui deux types intrinsèques de séquences muables :"
+msgstr "Il existe aujourd'hui deux types intrinsèques de séquences mutables :"
 
 #: reference/datamodel.rst:370
 msgid "Lists"
@@ -669,9 +669,9 @@ msgid ""
 "unhashable), byte arrays otherwise provide the same interface and "
 "functionality as immutable :class:`bytes` objects."
 msgstr ""
-"Un objet *bytearray* est un tableau muable. Il est créé par la fonction "
+"Un objet *bytearray* est un tableau mutable. Il est créé par la fonction "
-"native constructeur :func:`bytearray`. À part la propriété d'être muable (et "
+"native constructeur :func:`bytearray`. À part la propriété d'être mutable "
-"donc de ne pas pouvoir calculer son empreinte par hachage), un tableau "
+"(et donc de ne pas pouvoir calculer son empreinte par hachage), un tableau "
 "d'octets possède la même interface et les mêmes fonctionnalités qu'un objet "
 "immuable :class:`bytes`."
 
@@ -681,7 +681,7 @@ msgid ""
 "mutable sequence type, as does the :mod:`collections` module."
 msgstr ""
 "Le module d'extension :mod:`array` fournit un autre exemple de type de "
-"séquence muable, de même que le module :mod:`collections`."
+"séquence mutable, de même que le module :mod:`collections`."
 
 #: reference/datamodel.rst:417
 msgid "Set types"
@@ -731,9 +731,9 @@ msgid ""
 "constructor and can be modified afterwards by several methods, such as :meth:"
 "`~set.add`."
 msgstr ""
-"Ils représentent les ensembles muables. Un ensemble est créé par la fonction "
+"Ils représentent les ensembles mutables. Un ensemble est créé par la "
-"native constructeur :func:`set` et peut être modifié par la suite à l'aide "
+"fonction native constructeur :func:`set` et peut être modifié par la suite à "
-"de différentes méthodes, par exemple :meth:`~set.add`."
+"l'aide de différentes méthodes, par exemple :meth:`~set.add`."
 
 #: reference/datamodel.rst:417
 msgid "Frozen sets"
@@ -793,7 +793,7 @@ msgstr ""
 "Ils représentent les ensembles finis d'objets indicés par des valeurs "
 "presque arbitraires. Les seuls types de valeurs non reconnus comme clés sont "
 "les valeurs contenant des listes, des dictionnaires ou les autres types "
-"muables qui sont comparés par valeur plutôt que par l'identifiant de "
+"mutables qui sont comparés par valeur plutôt que par l'identifiant de "
 "l'objet. La raison de cette limitation est qu'une implémentation efficace de "
 "dictionnaire requiert que l'empreinte par hachage des clés reste constante "
 "dans le temps. Les types numériques obéissent aux règles normales pour les "
@@ -818,8 +818,8 @@ msgid ""
 "Dictionaries are mutable; they can be created by the ``{...}`` notation (see "
 "section :ref:`dict`)."
 msgstr ""
-"Les dictionnaires sont muables : ils peuvent être créés par la notation ``{…}"
+"Les dictionnaires sont mutables : ils peuvent être créés par la notation "
-"`` (reportez-vous à la section :ref:`dict`)."
+"``{…}`` (reportez-vous à la section :ref:`dict`)."
 
 #: reference/datamodel.rst:457
 msgid ""
@@ -1686,7 +1686,7 @@ msgstr ""
 "dans l'objet code (parce que ce sont des valeurs calculées au moment de "
 "l'exécution). Contrairement aux objets fonctions, les objets codes sont "
 "immuables et ne contiennent aucune référence (directe ou indirecte) à des "
-"objets muables."
+"objets mutables."
 
 #: reference/datamodel.rst:975
 #, fuzzy
@@ -4286,7 +4286,7 @@ msgstr ""
 "abc.MutableMapping` pour aider à la création de ces méthodes à partir d'un "
 "ensemble de base composé de :meth:`~object.__getitem__`, :meth:`~object."
 "__setitem__`, :meth:`~object.__delitem__` et :meth:`keys`. Les séquences "
-"muables doivent fournir les méthodes :meth:`append`, :meth:`count`, :meth:"
+"mutables doivent fournir les méthodes :meth:`append`, :meth:`count`, :meth:"
 "`index`, :meth:`extend`, :meth:`insert`, :meth:`pop`, :meth:`remove`, :meth:"
 "`reverse` et :meth:`sort`, comme les objets :class:`listes <list>` standards "
 "de Python. Enfin, les types séquences doivent implémenter l'addition (dans "

reference/expressions.po

@@ -425,7 +425,7 @@ msgid ""
 "supplied, the set is constructed from the elements resulting from the "
 "comprehension."
 msgstr ""
-"Un agencement d'ensemble produit un nouvel objet ensemble muable, le contenu "
+"Un agencement d'ensemble produit un nouvel objet ensemble mutable, le contenu "
 "étant spécifié soit par une séquence d'expression, soit par une "
 "compréhension. Quand une liste (dont les éléments sont séparés par des "
 "virgules) est fournie, ses éléments sont évalués de la gauche vers la droite "
@@ -520,7 +520,7 @@ msgid ""
 msgstr ""
 "Les restrictions relatives aux types des clés sont données dans la section :"
 "ref:`types` (pour résumer, le type de la clé doit être :term:`hachable "
-"<hashable>`, ce qui exclut tous les objets muables). Les collisions entre "
+"<hashable>`, ce qui exclut tous les objets mutables). Les collisions entre "
 "les clés dupliquées ne sont pas détectées ; la dernière valeur (celle qui "
 "apparaît le plus à droite dans l'agencement) stockée prévaut pour une clé "
 "donnée."

reference/simple_stmts.po

@@ -78,7 +78,7 @@ msgid ""
 "attributes or items of mutable objects:"
 msgstr ""
 "Les assignations sont utilisées pour lier ou relier des noms à des valeurs "
-"et modifier des attributs ou des éléments d'objets muables :"
+"et modifier des attributs ou des éléments d'objets mutables :"
 
 #: reference/simple_stmts.rst:96
 msgid ""
@@ -111,8 +111,8 @@ msgid ""
 "section :ref:`types`)."
 msgstr ""
 "Une assignation est définie récursivement en fonction de la forme de la "
-"cible (une liste). Quand la cible est une partie d'un objet muable (une "
+"cible (une liste). Quand la cible est une partie d'un objet mutable (une "
-"référence à un attribut, une sélection ou une tranche), l'objet muable doit "
+"référence à un attribut, une sélection ou une tranche), l'objet mutable doit "
 "effectuer l'assignation au final et décider de sa validité, voire lever une "
 "exception si l'assignation n'est pas acceptable. Les règles suivies par les "
 "différents types et les exceptions levées sont données dans les définitions "

tutorial/classes.po

@@ -124,7 +124,7 @@ msgstr ""
 "pas au premier coup d'œil en Python et il peut être ignoré tant qu'on "
 "travaille avec des types de base immuables (nombres, chaînes, *n*-uplets). "
 "Cependant, les alias peuvent produire des effets surprenants sur la "
-"sémantique d'un code Python mettant en jeu des objets muables comme les "
+"sémantique d'un code Python mettant en jeu des objets mutables comme les "
 "listes, les dictionnaires et la plupart des autres types. En général, leur "
 "utilisation est bénéfique au programme car les alias se comportent, d'un "
 "certain point de vue, comme des pointeurs. Par exemple, transmettre un objet "
@@ -771,7 +771,7 @@ msgid ""
 "by all *Dog* instances::"
 msgstr ""
 "Comme nous l'avons vu dans :ref:`tut-object`, les données partagées :term:"
-"`muable <muable>` (telles que les listes, dictionnaires, etc.) peuvent avoir "
+"`mutable <muable>` (telles que les listes, dictionnaires, etc.) peuvent avoir "
 "des effets surprenants. Par exemple, la liste *tricks* dans le code suivant "
 "ne devrait pas être utilisée en tant que variable de classe car, dans ce "
 "cas, une seule liste est partagée par toutes les instances de *Dog* ::"

tutorial/controlflow.po

@@ -772,7 +772,7 @@ msgid ""
 msgstr ""
 "**Avertissement important :** la valeur par défaut n'est évaluée qu'une "
 "seule fois. Ceci fait une différence lorsque cette valeur par défaut est un "
-"objet muable tel qu'une liste, un dictionnaire ou des instances de la "
+"objet mutable tel qu'une liste, un dictionnaire ou des instances de la "
 "plupart des classes. Par exemple, la fonction suivante accumule les "
 "arguments qui lui sont passés au fil des appels successifs ::"
 
@@ -1422,7 +1422,7 @@ msgid ""
 "to it (items inserted into a list)."
 msgstr ""
 "En fait, *appels par référence d'objets* serait sans doute une description "
-"plus juste dans la mesure où, si un objet muable est passé en argument, "
+"plus juste dans la mesure où, si un objet mutable est passé en argument, "
 "l'appelant verra toutes les modifications qui lui auront été apportées par "
 "l'appelé (insertion d'éléments dans une liste…)."
 

tutorial/datastructures.po

@@ -148,7 +148,7 @@ msgstr ""
 "Vous avez probablement remarqué que les méthodes qui ne font que modifier la "
 "liste, comme ``insert``, ``remove`` ou ``sort``, n'affichent pas de valeur "
 "de retour (elles renvoient ``None``) [#]_. C'est un principe respecté par "
-"toutes les structures de données muables en Python."
+"toutes les structures de données mutables en Python."
 
 #: tutorial/datastructures.rst:128
 msgid ""
@@ -424,7 +424,7 @@ msgstr ""
 "celles-ci sont souvent nécessaires (notamment lorsqu'un *n*-uplet fait "
 "partie d'une expression plus longue). Il n'est pas possible d'affecter de "
 "valeur à un élément d'un *n*-uplet ; par contre, il est en revanche possible "
-"de créer des *n*-uplets contenant des objets muables, comme des listes."
+"de créer des *n*-uplets contenant des objets mutables, comme des listes."
 
 #: tutorial/datastructures.rst:408
 msgid ""
@@ -442,7 +442,7 @@ msgstr ""
 "séquences hétérogènes d'éléments auxquelles on accède par "
 "« dissociation » (*unpacking* en anglais, voir plus loin) ou par indice (ou "
 "même par attribut dans le cas des :func:`namedtuples <collections."
-"namedtuple>`). Les listes sont souvent :term:`muables <muable>` et "
+"namedtuple>`). Les listes sont souvent :term:`mutables <muable>` et "
 "contiennent des éléments généralement homogènes auxquels on accède en "
 "itérant sur la liste."
 
@@ -555,7 +555,7 @@ msgstr ""
 "n'importe quel type immuable ; les chaînes de caractères et les nombres "
 "peuvent toujours être des clés. Des *n*-uplets peuvent être utilisés comme "
 "clés s'ils ne contiennent que des chaînes, des nombres ou des *n*-uplets ; "
-"si un *n*-uplet contient un objet muable, de façon directe ou indirecte, il "
+"si un *n*-uplet contient un objet mutable, de façon directe ou indirecte, il "
 "ne peut pas être utilisé comme une clé. Vous ne pouvez pas utiliser des "
 "listes comme clés, car les listes peuvent être modifiées en place en "
 "utilisant des affectations par position, par tranches ou via des méthodes "

tutorial/introduction.po

@@ -528,7 +528,7 @@ msgid ""
 "type, i.e. it is possible to change their content::"
 msgstr ""
 "Mais à la différence des chaînes qui sont :term:`immuables <immutable>`, les "
-"listes sont :term:`muables <mutable>` : il est possible de modifier leur "
+"listes sont :term:`mutables <mutable>` : il est possible de modifier leur "
 "contenu ::"
 
 #: tutorial/introduction.rst:430

whatsnew/3.9.po

@@ -3105,7 +3105,7 @@ msgstr ""
 "Les objets ``Literal`` lèvent maintenant une exception :exc:`TypeError` lors "
 "des comparaisons d'égalités si n'importe quel de leurs paramètres n'est pas :"
 "term:`immuable <immutable>`. Prenez-note que déclarer un ``Literal`` avec un "
-"paramètre muable ne lève pas une erreur ::"
+"paramètre mutable ne lève pas une erreur ::"
 
 #: whatsnew/3.9.rst:1519
 msgid "(Contributed by Yurii Karabas in :issue:`42345`.)"