From 29da1cd27e8c87663fea80780fc86371fc401971 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Mon, 3 Apr 2023 23:03:50 +0200 Subject: [PATCH] suite de la revue --- library/stdtypes.po | 280 +++++++++++++++++++++++--------------------- 1 file changed, 147 insertions(+), 133 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 13994818..9bb35b92 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-02-12 11:56+0100\n" -"PO-Revision-Date: 2023-04-02 22:05+0200\n" +"PO-Revision-Date: 2023-04-03 23:00+0200\n" "Last-Translator: Loc Cosnier \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -1470,7 +1470,7 @@ msgstr "(6)(7)" #: library/stdtypes.rst:932 msgid "``s * n`` or ``n * s``" -msgstr "``s * n`` or ``n * s``" +msgstr "``s * n`` ou ``n * s``" #: library/stdtypes.rst:932 msgid "equivalent to adding *s* to itself *n* times" @@ -3517,8 +3517,8 @@ msgid "" msgstr "" "Renvoie ``True`` si la chaîne commence par *prefix*, sinon ``False``. " "*prefix* peut aussi être un *n*-uplet de préfixes à rechercher. Lorsque " -"*start* est donné, la comparaison commence à cette position, et lorsque " -"*end* est donné, la comparaison s'arrête à celle ci." +"*start* est donné, la comparaison commence à cette position et, lorsque " +"*end* est donné, la comparaison s'arrête à celle-ci." #: library/stdtypes.rst:2153 msgid "" @@ -3530,9 +3530,9 @@ msgid "" msgstr "" "Renvoie une copie de la chaîne dont des caractères initiaux et finaux sont " "supprimés. L'argument *chars* est une chaîne spécifiant le jeu de caractères " -"à supprimer. En cas d'omission ou ``None``, les espaces sont supprimés. " -"L'argument *chars* est pas un préfixe ni un suffixe, toutes les combinaisons " -"de ses valeurs sont supprimées ::" +"à supprimer. En cas d'omission ou ``None``, les caractères d'espacement sont " +"supprimés. L'argument *chars* est pas un préfixe ni un suffixe, toutes les " +"combinaisons de ses valeurs sont supprimées ::" #: library/stdtypes.rst:2164 msgid "" @@ -3543,7 +3543,7 @@ msgid "" msgstr "" "Les caractères de *char* sont retirés du début et de la fin de la chaîne. " "Les caractères sont retirés de la gauche jusqu'à atteindre un caractère ne " -"figurant pas dans le jeu de caractères dans *chars*. La même opération à " +"figurant pas dans le jeu de caractères dans *chars*. La même opération a " "lieu par la droite. Par exemple ::" #: library/stdtypes.rst:2177 @@ -3552,17 +3552,17 @@ msgid "" "and vice versa. Note that it is not necessarily true that ``s.swapcase()." "swapcase() == s``." msgstr "" -"Renvoie une copie de la chaîne dont les caractères majuscules sont " -"convertis en minuscules et vice versa. Notez qu'il est pas nécessairement " -"vrai que ``s.swapcase().swapcase() == s``." +"Renvoie une copie de la chaîne dont les caractères majuscules sont convertis " +"en minuscules et vice versa. Notez qu'il est pas nécessairement vrai que ``s." +"swapcase().swapcase() == s``." #: library/stdtypes.rst:2184 msgid "" "Return a titlecased version of the string where words start with an " "uppercase character and the remaining characters are lowercase." msgstr "" -"Renvoie une version en initiales majuscules de la chaîne où les mots " -"commencent par une capitale et les caractères restants sont en minuscules." +"Renvoie une version de la chaîne où les mots commencent par une capitale et " +"les caractères restants sont en minuscules." #: library/stdtypes.rst:3410 msgid "" @@ -3607,11 +3607,11 @@ msgstr "" "Renvoie une copie de la chaîne dans laquelle chaque caractère a été changé " "selon la table de traduction donnée. La table doit être un objet qui " "implémente l'indexation via :meth:`__getitem__`, typiquement un :term:" -"`mapping` ou une :term:`sequence`. Pour un ordinal Unicode (un entier), la " -"table peut donner soit un ordinal Unicode ou une chaîne pour faire " -"correspondre un ou plusieurs caractère au caractère donné, soit ``None`` " -"pour supprimer le caractère de la chaîne de renvoyée soit lever une " -"exception :exc:`LookupError` pour ne pas changer le caractère." +"`tableau de correspondances ` ou une :term:`séquence `. " +"Pour un ordinal Unicode (un entier), la table peut donner un ordinal Unicode " +"ou une chaîne pour faire correspondre un ou plusieurs caractères au " +"caractère donné, ``None`` pour supprimer le caractère de la chaîne renvoyée " +"ou lever une exception :exc:`LookupError` pour ne pas changer le caractère." #: library/stdtypes.rst:2227 msgid "" @@ -3661,8 +3661,8 @@ msgstr "" "Renvoie une copie de la chaîne remplie par la gauche du chiffre (le " "caractère ASCII) ``'0'`` pour faire une chaîne de longueur *width*. Un " "préfixe (``'+'`` / ``'-'``) est permis par l'insertion du caractère de " -"rembourrage *après* le caractère désigne plutôt qu'avant. La chaîne " -"d'origine est renvoyée si *width* est inférieur ou égale à ``len(s)``." +"bourrage *après* le caractère désigné plutôt qu'avant. La chaîne d'origine " +"est renvoyée si *width* est inférieure ou égale à ``len(s)``." #: library/stdtypes.rst:2266 msgid "``printf``-style String Formatting" @@ -3696,7 +3696,7 @@ msgid "" "elements of *values*. The effect is similar to using the :c:func:`sprintf` " "in the C language." msgstr "" -"Les objets *str* n'exposent qu'une opération : L'opérateur ``%`` (modulo). " +"Les objets *str* n'exposent qu'une opération : l'opérateur ``%`` (modulo). " "Aussi connu sous le nom d'opérateur de formatage, ou opérateur " "d'interpolation. Étant donné ``format % values`` (où *format* est une " "chaîne), les marqueurs ``%`` de *format* sont remplacés par zéro ou " @@ -3711,9 +3711,9 @@ msgid "" "example, a dictionary)." msgstr "" "Si *format* ne nécessite qu'un seul argument, *values* peut être un objet " -"unique. [5]_ Si *values* est un *n*-uplet, il doit contenir exactement le " -"nombre d'éléments spécifiés par la chaîne de format, ou un seul objet de " -"correspondances (*mapping object*, par exemple, un dictionnaire)." +"unique [5]_. Si *values* est un *n*-uplet, il doit contenir exactement le " +"nombre d'éléments spécifiés par la chaîne de format, ou un seul objet " +"tableau de correspondances (*mapping object*, par exemple, un dictionnaire)." #: library/stdtypes.rst:3521 msgid "" @@ -3735,7 +3735,7 @@ msgid "" "(for example, ``(somename)``)." msgstr "" "la clé de correspondance (facultative), composée d'une suite de caractères " -"entre parenthèse (par exemple, ``(somename)``) ;" +"entre parenthèses (par exemple, ``(somename)``) ;" # énumération #: library/stdtypes.rst:3529 @@ -3788,18 +3788,18 @@ msgid "" "selects the value to be formatted from the mapping. For example:" msgstr "" "Lorsque l'argument de droite est un dictionnaire (ou un autre type de " -"*mapping*), les marqueurs dans la chaîne *doivent* inclure une clé présente " -"dans le dictionnaire, écrite entre parenthèses, immédiatement après le " -"caractère ``'%'``. La clé indique quelle valeur du dictionnaire doit être " -"formatée. Par exemple :" +"tableau de correspondances), les marqueurs dans la chaîne *doivent* inclure " +"une clé présente dans le dictionnaire, écrite entre parenthèses, " +"immédiatement après le caractère ``'%'``. La clé indique quelle valeur du " +"dictionnaire doit être formatée. Par exemple :" #: library/stdtypes.rst:3554 msgid "" "In this case no ``*`` specifiers may occur in a format (since they require a " "sequential parameter list)." msgstr "" -"Dans ce cas, aucune ``*`` ne peuvent se trouver dans le format (car ces " -"``*`` nécessitent une liste (accès séquentiel) de paramètres)." +"Dans ce cas, aucune ``*`` ne peut se trouver dans le format (car ces ``*`` " +"nécessitent une liste (accès séquentiel) de paramètres)." #: library/stdtypes.rst:3557 msgid "The conversion flag characters are:" @@ -3816,7 +3816,7 @@ msgstr "``'#'``" #: library/stdtypes.rst:3568 msgid "" "The value conversion will use the \"alternate form\" (where defined below)." -msgstr "La conversion utilisera la \"forme alternative\" (définie ci-dessous)." +msgstr "La conversion utilise la « forme alternative » (définie ci-dessous)." #: library/stdtypes.rst:3571 msgid "``'0'``" @@ -3824,7 +3824,7 @@ msgstr "``'0'``" #: library/stdtypes.rst:3571 msgid "The conversion will be zero padded for numeric values." -msgstr "Les valeurs numériques converties seront complétée de zéros." +msgstr "Les valeurs numériques converties sont complétées de zéros." #: library/stdtypes.rst:3573 msgid "``'-'``" @@ -3847,7 +3847,7 @@ msgid "" "(a space) A blank should be left before a positive number (or empty string) " "produced by a signed conversion." msgstr "" -"(un espace) Un espace doit être laissé avant un nombre positif (ou chaîne " +"(une espace) Une espace doit être laissée avant un nombre positif (ou chaîne " "vide) produite par la conversion d'une valeur signée." #: library/stdtypes.rst:3579 @@ -3860,7 +3860,7 @@ msgid "" "a \"space\" flag)." msgstr "" "Un caractère de signe (``'+'`` ou ``'-'``) précède la valeur convertie " -"(remplace le marqueur \"espace\")." +"(remplace le marqueur « espace »)." #: library/stdtypes.rst:3583 msgid "" @@ -3873,7 +3873,7 @@ msgstr "" #: library/stdtypes.rst:3586 msgid "The conversion types are:" -msgstr "Les types utilisables dans les conversion sont :" +msgstr "Les types utilisables dans les conversions sont :" #: library/stdtypes.rst:3589 msgid "Conversion" @@ -4086,20 +4086,22 @@ msgstr "" "Puisque les chaînes Python ont une longueur explicite, les conversions ``" "%s`` ne considèrent pas ``'\\0'`` comme la fin de la chaîne." +# suit un : #: library/stdtypes.rst:2452 msgid "" "``%f`` conversions for numbers whose absolute value is over 1e50 are no " "longer replaced by ``%g`` conversions." msgstr "" -"Les conversions ``%f`` pour nombres dont la valeur absolue est supérieure à " -"``1e50`` ne sont plus remplacés par des conversions ``%g``." +"les conversions ``%f`` des nombres dont la valeur absolue est supérieure à " +"``1e50`` ne sont plus remplacées par des conversions ``%g``." #: library/stdtypes.rst:2463 msgid "" "Binary Sequence Types --- :class:`bytes`, :class:`bytearray`, :class:" "`memoryview`" msgstr "" -"Séquences Binaires — :class:`bytes`, :class:`bytearray`, :class:`memoryview`" +"Séquences Binaires — :class:`bytes`, :class:`bytearray`, :class:`vue mémoire " +"`" #: library/stdtypes.rst:2471 msgid "" @@ -4109,9 +4111,10 @@ msgid "" "objects without needing to make a copy." msgstr "" "Les principaux types natifs pour manipuler des données binaires sont :class:" -"`bytes` et :class:`bytearray`. Ils sont supportés par :class:`memoryview` " -"qui utilise le :ref:`buffer protocol ` pour accéder à la " -"mémoire d'autres objets binaires sans avoir besoin d'en faire une copie." +"`bytes` et :class:`bytearray`. Ils sont gérés par les :class:`vues mémoire " +"` qui utilisent le :ref:`protocole tampon ` pour " +"accéder à la mémoire d'autres objets binaires sans avoir besoin d'en faire " +"une copie." #: library/stdtypes.rst:2476 msgid "" @@ -4149,14 +4152,13 @@ msgstr "" #: library/stdtypes.rst:2496 msgid "Single quotes: ``b'still allows embedded \"double\" quotes'``" msgstr "" -"entre guillemets simples : ``b'autorisent aussi les guillemets \"doubles" -"\"'`` ;" +"entre guillemets simples : ``b'cela autorise les guillemets \"doubles\"'`` ;" # énumération #: library/stdtypes.rst:2497 msgid "Double quotes: ``b\"still allows embedded 'single' quotes\"``" msgstr "" -"entre guillemets (anglais) : ``b\"permettent aussi les guillemets " +"entre guillemets (anglais) : ``b\"cela permet aussi les guillemets " "'simples'\"`` ;" # fin d'énumération @@ -4175,8 +4177,8 @@ msgid "" msgstr "" "Seuls les caractères ASCII sont autorisés dans les littéraux de *bytes* " "(quel que soit l'encodage du code source déclaré). Toutes les valeurs au " -"delà de 127 doivent être entrées dans littéraux de *bytes* en utilisant une " -"séquence d'échappement appropriée." +"delà de 127 doivent être écrites en utilisant une séquence d'échappement " +"appropriée." #: library/stdtypes.rst:2504 msgid "" @@ -4188,7 +4190,7 @@ msgstr "" "utiliser un préfixe ``r`` pour désactiver le traitement des séquences " "d'échappement. Voir :ref:`strings` pour plus d'informations sur les " "différentes formes littérales de *bytes*, y compris les séquences " -"d'échappement supportées." +"d'échappement gérées." #: library/stdtypes.rst:2508 msgid "" @@ -4204,14 +4206,14 @@ msgid "" msgstr "" "Bien que les *bytes* littéraux, et leurs représentation, soient basés sur du " "texte ASCII, les *bytes* se comportent en fait comme des séquences immuables " -"de nombres entiers, dont les valeurs sont restreintes dans ``0 <= x < 256`` " -"(ne pas respecter cette restriction lève une :exc:`ValueError`. Ceci est " -"fait délibérément afin de souligner que, bien que de nombreux encodages " -"binaires soient compatibles avec l'ASCII, et peuvent être manipulés avec des " -"algorithmes orientés texte, ce n'est généralement pas le cas pour les " -"données binaires arbitraires (appliquer aveuglément des algorithmes de texte " -"sur des données binaires qui ne sont pas compatibles ASCII conduit " -"généralement à leur corruption)." +"de nombres entiers, dont les valeurs sont restreintes dans l'intervalle ``0 " +"<= x < 256`` (ne pas respecter cette restriction lève une :exc:" +"`ValueError`). C'est délibéré afin de souligner que, bien que de nombreux " +"encodages binaires soient compatibles avec l'ASCII, et peuvent être " +"manipulés avec des algorithmes orientés texte, ce n'est généralement pas le " +"cas pour les données binaires arbitraires (appliquer aveuglément des " +"algorithmes de texte sur des données binaires qui ne sont pas compatibles " +"ASCII conduit généralement à leur corruption)." #: library/stdtypes.rst:2518 msgid "" @@ -4230,7 +4232,7 @@ msgstr "" # énumération #: library/stdtypes.rst:2522 msgid "From an iterable of integers: ``bytes(range(20))``" -msgstr "d'un itérable d'entiers : ``bytes(range(20))`` ;" +msgstr "un itérable d'entiers : ``bytes(range(20))`` ;" # fin d'énumération #: library/stdtypes.rst:2523 @@ -4271,7 +4273,7 @@ msgid "" "spaces." msgstr "" ":meth:`bytes.fromhex` saute maintenant dans la chaîne tous les caractères " -"ASCII \"blancs\", pas seulement les espaces." +"ASCII d'espacement, pas seulement les espaces." #: library/stdtypes.rst:2544 msgid "" @@ -4286,8 +4288,8 @@ msgid "" "Return a string object containing two hexadecimal digits for each byte in " "the instance." msgstr "" -"Renvoie une chaîne contenant deux chiffres hexadécimaux pour chaque octet du " -"*byte*." +"Renvoie une chaîne contenant deux chiffres hexadécimaux pour chaque octet de " +"l'instance." #: library/stdtypes.rst:2555 msgid "" @@ -4297,7 +4299,7 @@ msgid "" "*bytes_per_sep* parameter controls the spacing. Positive values calculate " "the separator position from the right, negative values from the left." msgstr "" -"Si vous voulez rendre une chaîne hexadécimale plus facile à lire, vous " +"Si vous voulez obtenir une chaîne hexadécimale plus facile à lire, vous " "pouvez spécifier le paramètre *sep* comme « caractère de séparation », à " "inclure dans la sortie. Par défaut, ce caractère est inséré entre chaque " "octet. Un second paramètre optionnel *bytes_per_sep* contrôle l'espacement. " @@ -4321,9 +4323,9 @@ msgid "" "and slicing will produce a string of length 1)" msgstr "" "Comme les objets *bytes* sont des séquences d'entiers (semblables à un *n*-" -"uplet), pour une instance de *bytes* *b*, ``b[0]`` sera un entier, tandis " -"que ``b[0:1]`` sera un objet *bytes* de longueur 1. (Cela contraste avec les " -"chaînes, où l'indexation et le *slicing* donnent une chaîne de longueur 1.)" +"uplet), pour une instance de *bytes* *b*, ``b[0]`` est un entier, tandis que " +"``b[0:1]`` est un objet *bytes* de longueur 1. (Cela contraste avec les " +"chaînes, où un indice et le découpage donnent une chaîne de longueur 1.)" #: library/stdtypes.rst:2581 msgid "" @@ -4355,25 +4357,30 @@ msgstr "" "Il n'y a pas de syntaxe littérale dédiée aux *bytearray*, ils sont toujours " "créés en appelant le constructeur :" +# énumération #: library/stdtypes.rst:2601 msgid "Creating an empty instance: ``bytearray()``" -msgstr "Créer une instance vide: ``bytearray()``" +msgstr "créer une instance vide: ``bytearray()`` ;" +# énumération #: library/stdtypes.rst:2602 msgid "Creating a zero-filled instance with a given length: ``bytearray(10)``" msgstr "" -"Créer une instance remplie de zéros d'une longueur donnée : ``bytearray(10)``" +"crée une instance remplie de zéros d'une longueur donnée : " +"``bytearray(10)`` ;" +# énumération #: library/stdtypes.rst:2603 msgid "From an iterable of integers: ``bytearray(range(20))``" -msgstr "À partir d'un itérable d'entiers : ``bytearray(range(20))``" +msgstr "à partir d'un itérable d'entiers : ``bytearray(range(20))`` ;" +# fin d'énumération #: library/stdtypes.rst:2604 msgid "" "Copying existing binary data via the buffer protocol: ``bytearray(b'Hi!')``" msgstr "" -"Copie des données binaires existantes via le *buffer protocol* : " -"``bytearray(b'Hi!')``" +"copie des données binaires existantes via le protocole tampon : " +"``bytearray(b'Hi!')``." #: library/stdtypes.rst:2606 msgid "" @@ -4382,7 +4389,7 @@ msgid "" "operations described in :ref:`bytes-methods`." msgstr "" "Comme les *bytearray* sont muables, ils prennent en charge les opérations de " -"séquence :ref:`muables ` en plus des opérations communes " +"séquences :ref:`muables ` en plus des opérations communes " "de *bytes* et *bytearray* décrites dans :ref:`bytes-methods`." #: library/stdtypes.rst:2610 @@ -4409,14 +4416,14 @@ msgid "" msgstr "" "Cette méthode de la classe :class:`bytearray` renvoie un objet *bytearray*, " "décodant la chaîne donnée. La chaîne doit contenir deux chiffres " -"hexadécimaux par octet, les espaces ASCII sont ignorés." +"hexadécimaux par octet, les caractères d'espacement ASCII sont ignorés." #: library/stdtypes.rst:2625 msgid "" ":meth:`bytearray.fromhex` now skips all ASCII whitespace in the string, not " "just spaces." msgstr "" -":meth:`bytearray.fromhex` saute maintenant tous les caractères \"blancs\" " +":meth:`bytearray.fromhex` saute maintenant tous les caractères d'espacement " "ASCII dans la chaîne, pas seulement les espaces." #: library/stdtypes.rst:2629 @@ -4427,13 +4434,14 @@ msgstr "" "Une fonction de conversion inverse existe pour transformer un objet " "*bytearray* en sa représentation hexadécimale." +# suit un : #: library/stdtypes.rst:2642 msgid "" "Similar to :meth:`bytes.hex`, :meth:`bytearray.hex` now supports optional " "*sep* and *bytes_per_sep* parameters to insert separators between bytes in " "the hex output." msgstr "" -"Similaire à :meth:`bytes.hex`, :meth:`bytearray.hex` prend désormais en " +"similaire à :meth:`bytes.hex`, :meth:`bytearray.hex` prend désormais en " "charge les paramètres optionnels *sep* et *bytes_per_sep* pour insérer des " "séparateurs entre les octets dans la sortie hexadécimale." @@ -4445,10 +4453,9 @@ msgid "" "both indexing and slicing will produce a string of length 1)" msgstr "" "Comme les *bytearray* sont des séquences d'entiers (semblables à une liste), " -"pour un objet *bytearray* *b*, ``b[0]`` sera un entier, tandis que " -"``b[0:1]`` sera un objet *bytearray* de longueur 1. (Ceci contraste avec les " -"chaînes de texte, où l'indexation et le *slicing* produit une chaîne de " -"longueur 1)" +"pour un objet *bytearray* *b*, ``b[0]`` est un entier, tandis que ``b[0:1]`` " +"est un objet *bytearray* de longueur 1. (Ceci contraste avec les chaînes de " +"texte, où l'indice et le découpage produisent une chaîne de longueur 1)" #: library/stdtypes.rst:2652 msgid "" @@ -4476,18 +4483,19 @@ msgid "" msgstr "" "*bytes* et *bytearray* prennent en charge les opérations :ref:`communes " "` des séquences. Ils interagissent non seulement avec des " -"opérandes de même type, mais aussi avec les :term:`bytes-like object`. En " -"raison de cette flexibilité, ils peuvent être mélangés librement dans des " -"opérations sans provoquer d'erreurs. Cependant, le type du résultat peut " -"dépendre de l'ordre des opérandes." +"opérandes de même type, mais aussi avec les :term:`objets octet-compatibles " +"`. En raison de cette flexibilité, ils peuvent être " +"mélangés librement dans des opérations sans provoquer d'erreurs. Cependant, " +"le type du résultat peut dépendre de l'ordre des opérandes." +# suit un : #: library/stdtypes.rst:2674 msgid "" "The methods on bytes and bytearray objects don't accept strings as their " "arguments, just as the methods on strings don't accept bytes as their " "arguments. For example, you have to write::" msgstr "" -"Les méthodes sur les *bytes* et les *bytearray* n'acceptent pas les chaînes " +"les méthodes sur les *bytes* et les *bytearray* n'acceptent pas les chaînes " "comme arguments, tout comme les méthodes sur les chaînes n'acceptent pas les " "*bytes* comme arguments. Par exemple, vous devez écrire ::" @@ -4506,12 +4514,13 @@ msgstr "" "travaillez avec des données binaires arbitraires. Ces restrictions sont " "couvertes ci-dessous." +# suit un : #: library/stdtypes.rst:2691 msgid "" "Using these ASCII based operations to manipulate binary data that is not " "stored in an ASCII based format may lead to data corruption." msgstr "" -"Utiliser ces opérations basées sur l'ASCII pour manipuler des données " +"utiliser ces opérations basées sur l'ASCII pour manipuler des données " "binaires qui ne sont pas au format ASCII peut les corrompre." #: library/stdtypes.rst:2694 @@ -4530,7 +4539,7 @@ msgid "" msgstr "" "Renvoie le nombre d'occurrences qui ne se chevauchent pas de la sous-" "séquence *sub* dans l'intervalle [*start*, *end*]. Les arguments facultatifs " -"*start* et *end* sont interprétés comme pour un *slice*." +"*start* et *end* sont interprétés comme dans la notation des découpages." #: library/stdtypes.rst:2809 library/stdtypes.rst:2897 #: library/stdtypes.rst:2910 @@ -4538,8 +4547,8 @@ msgid "" "The subsequence to search for may be any :term:`bytes-like object` or an " "integer in the range 0 to 255." msgstr "" -"La sous-séquence à rechercher peut être un quelconque :term:`bytes-like " -"object` ou un nombre entier compris entre 0 et 255." +"La sous-séquence à rechercher peut être un quelconque :term:`objet octet-" +"compatible ` ou un nombre entier compris entre 0 et 255." #: library/stdtypes.rst:2707 msgid "" @@ -4549,11 +4558,12 @@ msgstr "" "Si *sub* est vide, renvoie le nombre de tranches vides entre les caractères " "de début et de fin, ce qui correspond à la longueur de l'objet bytes plus un." +# suit un : #: library/stdtypes.rst:2821 library/stdtypes.rst:2900 #: library/stdtypes.rst:2913 msgid "Also accept an integer in the range 0 to 255 as the subsequence." msgstr "" -"Accepte aussi un nombre entier compris entre 0 et 255 comme sous-séquence." +"accepte aussi un nombre entier compris entre 0 et 255 comme sous-séquence." #: library/stdtypes.rst:2717 msgid "" @@ -4571,6 +4581,7 @@ msgstr "" "Le *prefix* peut être n'importe quel :term:`objet octet-compatible `." +# suit un : #: library/stdtypes.rst:2752 library/stdtypes.rst:2978 #: library/stdtypes.rst:3023 library/stdtypes.rst:3079 #: library/stdtypes.rst:3167 library/stdtypes.rst:3334 @@ -4580,7 +4591,7 @@ msgid "" "The bytearray version of this method does *not* operate in place - it always " "produces a new object, even if no changes were made." msgstr "" -"La version *bytearray* de cette méthode *ne modifie pas* les octets, elle " +"la version *bytearray* de cette méthode *ne modifie pas* les octets, elle " "produit toujours un nouvel objet, même si aucune modification n'a été " "effectuée." @@ -4627,13 +4638,14 @@ msgstr "" "développeur ` ne soit activé ou que Python ait été compilé en :ref:" "`mode débogage `." +# suit un : #: library/stdtypes.rst:2778 msgid "" "Passing the *encoding* argument to :class:`str` allows decoding any :term:" "`bytes-like object` directly, without needing to make a temporary :class:`!" "bytes` or :class:`!bytearray` object." msgstr "" -"Passer l'argument *encoding* à :class:`str` permet de décoder tout :term:" +"passer l'argument *encoding* à :class:`str` permet de décoder tout :term:" "`objet octet-compatible ` directement, sans avoir besoin " "d'utiliser un :class:`!bytes` ou :class:`!bytearray` temporaire." @@ -4653,8 +4665,8 @@ msgstr "" #: library/stdtypes.rst:2798 msgid "The suffix(es) to search for may be any :term:`bytes-like object`." msgstr "" -"Les suffixes à rechercher peuvent être n'importe quel :term:`bytes-like " -"object`." +"Les suffixes à rechercher peuvent être n'importe quel :term:`objet octet-" +"compatible `." #: library/stdtypes.rst:2804 msgid "" @@ -4668,13 +4680,14 @@ msgstr "" "facultatifs *start* et *end* sont interprétés comme dans la notation des " "découpages. Renvoie ``-1`` si *sub* n'est pas trouvé." +# suit un : #: library/stdtypes.rst:2814 msgid "" "The :meth:`~bytes.find` method should be used only if you need to know the " "position of *sub*. To check if *sub* is a substring or not, use the :" "keyword:`in` operator::" msgstr "" -"La méthode :meth:`~bytes.find` ne doit être utilisée que si vous avez besoin " +"la méthode :meth:`~bytes.find` ne doit être utilisée que si vous avez besoin " "de connaître la position de *sub*. Pour vérifier si *sub* est présent ou " "non, utilisez l'opérateur :keyword:`in` ::" @@ -4697,8 +4710,8 @@ msgid "" msgstr "" "Renvoie un *bytes* ou *bytearray* qui est la concaténation des séquences de " "données binaires dans *iterable*. Une exception :exc:`TypeError` est levée " -"si une valeur d'*iterable* n'est pas un :term:`bytes-like objects `, y compris pour des :class:`str`. Le séparateur entre les " +"si une valeur d'*iterable* n'est pas un :term:`objet octet-compatible `, y compris pour des :class:`str`. Le séparateur entre les " "éléments est le contenu du *bytes* ou du *bytearray* depuis lequel cette " "méthode est appelée." @@ -4711,9 +4724,9 @@ msgid "" msgstr "" "Cette méthode statique renvoie une table de traduction utilisable par :meth:" "`bytes.translate` qui permettra de changer chaque caractère de *from* par un " -"caractère à la même position dans *to*; *from* et *to* doivent tous deux " -"être des :term:`bytes-like objects ` et avoir la même " -"longueur." +"caractère à la même position dans *to* ; *from* et *to* doivent tous deux " +"être des :term:`objets octet-compatibles ` et avoir la " +"même longueur." #: library/stdtypes.rst:2863 msgid "" @@ -4726,12 +4739,14 @@ msgstr "" "Divise la séquence à la première occurrence de *sep*, et renvoie un triplet " "contenant la partie précédant le séparateur, le séparateur lui même (ou sa " "copie en *byterray*), et la partie suivant le séparateur. Si le séparateur " -"est pas trouvé, le triplet renvoyé contiendra une copie de la séquence " +"n'est pas trouvé, le triplet renvoyé contient une copie de la séquence " "d'origine, suivi de deux *bytes* ou *bytearray* vides." #: library/stdtypes.rst:2927 msgid "The separator to search for may be any :term:`bytes-like object`." -msgstr "Le séparateur à rechercher peut être tout :term:`bytes-like object`." +msgstr "" +"Le séparateur à rechercher peut être tout :term:`objet octet-compatible " +"`." #: library/stdtypes.rst:2876 msgid "" @@ -4741,15 +4756,15 @@ msgid "" msgstr "" "Renvoie une copie de la séquence dont toutes les occurrences de la sous-" "séquence *old* sont remplacées par *new*. Si l'argument optionnel *count* " -"est donné, seules les *count* premières occurrences de sont remplacés." +"est donné, seules les *count* premières occurrences sont remplacées." #: library/stdtypes.rst:2880 msgid "" "The subsequence to search for and its replacement may be any :term:`bytes-" "like object`." msgstr "" -"La sous-séquence à rechercher et son remplacement peuvent être n'importe " -"quel :term:`bytes-like object`." +"La sous-séquence à rechercher et son remplacement peuvent être n'importe " +"quel :term:`objet octet-compatible `." #: library/stdtypes.rst:2892 msgid "" @@ -4782,7 +4797,7 @@ msgstr "" "Coupe la séquence à la dernière occurrence de *sep*, et renvoie un triplet " "de trois éléments contenant la partie précédent le séparateur, le séparateur " "lui même (ou sa copie, un *bytearray*), et la partie suivant le séparateur. " -"Si le séparateur n'est pas trouvé, le triplet contiendra deux *bytes* ou " +"Si le séparateur n'est pas trouvé, le triplet contient deux *bytes* ou " "*bytesarray* vides suivi d’une copie de la séquence d'origine." #: library/stdtypes.rst:2933 @@ -4801,8 +4816,8 @@ msgstr "" #: library/stdtypes.rst:2938 msgid "The prefix(es) to search for may be any :term:`bytes-like object`." msgstr "" -"Le préfixe(s) à rechercher peuvent être n'importe quel :term:`bytes-like " -"object`." +"Les préfixes à rechercher peuvent être n'importe quels :term:`objets octet-" +"compatibles `." #: library/stdtypes.rst:2944 msgid "" @@ -4841,11 +4856,11 @@ msgid "" "all of the bytearray methods in this section do *not* operate in place, and " "instead produce new objects." msgstr "" -"Les méthodes suivantes sur les *bytes* et *bytearray* supposent par défaut " -"que les données traitées sont compatibles ASCII, mais peuvent toujours être " +"Les méthodes suivantes sur les *bytes* et *bytearray* supposent par défaut " +"que les données traitées sont compatibles ASCII, mais peuvent toujours être " "utilisées avec des données binaires, arbitraires, en passant des arguments " -"appropriés. Notez que toutes les méthodes de *bytearray* de cette section " -"ne travaillent jamais sur l'objet lui même, mais renvoient un nouvel objet." +"appropriés. Notez que toutes les méthodes de *bytearray* de cette section ne " +"travaillent jamais sur l'objet lui-même, mais renvoient un nouvel objet." #: library/stdtypes.rst:2971 msgid "" @@ -4855,9 +4870,9 @@ msgid "" "less than or equal to ``len(s)``." msgstr "" "Renvoie une copie de l'objet centrée dans une séquence de longueur *width*. " -"Le remplissage est fait en utilisant *fillbyte* (qui par défaut est un " +"Le remplissage est fait en utilisant *fillbyte* (qui par défaut est une " "espace ASCII). Pour les objets :class:`bytes`, la séquence initiale est " -"renvoyée si *width* est inférieur ou égal à ``len(s)``." +"renvoyée si *width* est inférieure ou égale à ``len(s)``." #: library/stdtypes.rst:2985 msgid "" @@ -5396,9 +5411,9 @@ msgid "" "an object that supports the :ref:`buffer protocol ` without " "copying." msgstr "" -"Les :class:`memoryview` permettent a du code Python d'accéder sans copie aux " -"données internes d'un objet prenant en charge le :ref:`buffer protocol " -"`." +"Les :class:`vues mémoire ` permettent à du code Python d'accéder " +"sans copie aux données internes d'un objet prenant en charge le :ref:" +"`protocole tampon `." #: library/stdtypes.rst:3697 msgid "" @@ -5406,9 +5421,9 @@ msgid "" "support the buffer protocol. Built-in objects that support the buffer " "protocol include :class:`bytes` and :class:`bytearray`." msgstr "" -"Crée une :class:`memoryview` faisant référence à *object*. *object* doit " -"savoir gérer le protocole tampon. :class:`bytes` et :class:`bytearray` sont " -"des classes natives prenant en charge le protocole tampon." +"Crée une :class:`vue mémoire ` faisant référence à *object*. " +"*object* doit savoir gérer le protocole tampon. :class:`bytes` et :class:" +"`bytearray` sont des classes natives prenant en charge le protocole tampon." #: library/stdtypes.rst:3701 msgid "" @@ -5417,11 +5432,11 @@ msgid "" "as :class:`bytes` and :class:`bytearray`, an element is a single byte, but " "other types such as :class:`array.array` may have bigger elements." msgstr "" -"Une :class:`memoryview` a la notion d'*element*, qui est l'unité de mémoire " -"atomique géré par l'objet *object* d'origine. Pour de nombreux types simples " -"comme :class:`bytes` et :class:`bytearray`, l'élément est l'octet, mais pour " -"d'autres types tels que :class:`array.array` les éléments peuvent être plus " -"grands." +"Une :class:`vue mémoire ` a la notion d'*élement*, qui est " +"l'unité de mémoire atomique gérée par l'objet *object* d'origine. Pour de " +"nombreux types simples comme :class:`bytes` et :class:`bytearray`, l'élément " +"est l'octet, mais pour d'autres types tels que :class:`array.array` les " +"éléments peuvent être plus grands." #: library/stdtypes.rst:3706 msgid "" @@ -5444,8 +5459,8 @@ msgid "" "A :class:`memoryview` supports slicing and indexing to expose its data. One-" "dimensional slicing will result in a subview::" msgstr "" -"Une :class:`memoryview` autorise le découpage et l'indiçage de ses données. " -"Découper sur une dimension donne une sous-vue ::" +"Une :class:`vue mémoire ` autorise le découpage et l'indiçage de " +"ses données. Découper sur une dimension donne une sous-vue ::" #: library/stdtypes.rst:3726 msgid "" @@ -5475,9 +5490,9 @@ msgid "" "If the underlying object is writable, the memoryview supports one-" "dimensional slice assignment. Resizing is not allowed::" msgstr "" -"Si l'objet sous-jacent est accessible en écriture, la *memoryview* " -"autorisera les assignations de tranches à une dimension. Redimensionner " -"n'est cependant pas autorisé ::" +"Si l'objet sous-jacent est accessible en écriture, la vue mémoire autorise " +"les assignations de tranches à une dimension. Redimensionner n'est cependant " +"pas autorisé ::" #: library/stdtypes.rst:3768 msgid "" @@ -5485,16 +5500,16 @@ msgid "" "'b' or 'c' are also hashable. The hash is defined as ``hash(m) == hash(m." "tobytes())``::" msgstr "" -"Les *memoryviews* à une dimension de types hachables (lecture seule) avec " -"les formats 'B', 'b', ou 'c' sont aussi hachables. La fonction de hachage " -"est définie tel que ``hash(m) == hash(m.tobytes())`` ::" +"Les vues mémoire à une dimension de types hachables (lecture seule) avec les " +"formats 'B', 'b', ou 'c' sont aussi hachables. La fonction de hachage est " +"définie tel que ``hash(m) == hash(m.tobytes())`` ::" #: library/stdtypes.rst:3780 msgid "" "One-dimensional memoryviews can now be sliced. One-dimensional memoryviews " "with formats 'B', 'b' or 'c' are now hashable." msgstr "" -"Les *memoryviews* à une dimension peuvent aussi être découpées. Les " +"Les vues mémoire à une dimension peuvent aussi être découpées. Les " "*memoryviews* à une dimension avec les formats 'B', 'b', ou 'c' sont " "maintenant hachables." @@ -5509,8 +5524,7 @@ msgstr "" #: library/stdtypes.rst:3788 msgid "memoryviews can now be indexed with tuple of integers." msgstr "" -"les *memoryviews* peuvent maintenant être indexées par un *n*-uplet " -"d'entiers." +"les vues mémoire peuvent maintenant être indicées par un *n*-uplet d'entiers." #: library/stdtypes.rst:3791 msgid ":class:`memoryview` has several methods:"