From ea05afed7fd1a13e1546062dd1a2d51288f66575 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 09:26:18 +0200 Subject: [PATCH 1/9] glue words --- library/stdtypes.po | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index a9500da3..1a6cb482 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-21 13:06+0200\n" +"PO-Revision-Date: 2017-09-22 09:25+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -330,15 +330,7 @@ msgid "" "`TypeError` exception when comparing a complex number with another built-in " "numeric type, when the objects are of different types that cannot be " "compared, or in other cases where there is no defined ordering." -msgstr "" -"Les objets de différents types, à l'exception de différents types " -"numériques, ne peuvent en aucun cas être égaux. En outre, certains types " -"(par exemple, les objets fonction) ne gèrent qu'une une notion dégénérée de " -"la comparaisonoù deux objets de ce type sont inégaux. Les opérateurs ``<``, " -"``<=``, ``>`` et ``>=`` lèvent une exception :exc:`TypeError` lorsqu'on " -"compare un nombre complexe avec un autre type natif numérique, lorsque les " -"objets sont de différents types qui ne peuvent pas être comparés, ou dans " -"d'autres cas où il n'y a pas d'ordre défini." +msgstr "Les objets de différents types, à l'exception de différents types numériques, ne peuvent en aucun cas être égaux. En outre, certains types (par exemple, les objets fonction) ne gèrent qu'une une notion dégénérée de la comparaison où deux objets de ce type sont inégaux. Les opérateurs ``<``, ``<=``, ``>`` et ``>=`` lèvent une exception :exc:`TypeError` lorsqu'on compare un nombre complexe avec un autre type natif numérique, lorsque les objets sont de différents types qui ne peuvent pas être comparés, ou dans d'autres cas où il n'y a pas d'ordre défini." #: ../Doc/library/stdtypes.rst:182 msgid "" From fcd0ab89d0c4247e423bdc4478ab53b194485978 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 09:27:39 +0200 Subject: [PATCH 2/9] french typography --- library/stdtypes.po | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 1a6cb482..8df418b8 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 09:25+0200\n" +"PO-Revision-Date: 2017-09-22 09:27+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -360,10 +360,7 @@ msgid "" "The behavior of the :keyword:`is` and :keyword:`is not` operators cannot be " "customized; also they can be applied to any two objects and never raise an " "exception." -msgstr "" -"Le comportement des opérateurs :keyword:`is` et :keyword:`is not` ne peut " -"pas être personnalisé; aussi ils peuvent être appliqués à deux objets " -"quelconques et ne soulèvent jamais d'exception." +msgstr "Le comportement des opérateurs :keyword:`is` et :keyword:`is not` ne peut pas être personnalisé ; aussi ils peuvent être appliqués à deux objets quelconques et ne soulèvent jamais d'exception." #: ../Doc/library/stdtypes.rst:199 msgid "" From 8fcd5474975a35b71c5c54f35c1a0f1c46dca851 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 09:32:27 +0200 Subject: [PATCH 3/9] =?UTF-8?q?pr=C3=A9cisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 8df418b8..02dd3dbe 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 09:27+0200\n" +"PO-Revision-Date: 2017-09-22 09:32+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -388,20 +388,7 @@ msgid "" "use ``z.real`` and ``z.imag``. (The standard library includes additional " "numeric types, :mod:`fractions` that hold rationals, and :mod:`decimal` that " "hold floating-point numbers with user-definable precision.)" -msgstr "" -"Il existe trois types numériques distincts: :dfn:`integers`, :dfn:`floating " -"point numbers` et :dfn:`complex numbers`. En outre, les booléens sont un " -"sous-type des entiers. Les entiers ont une précision illimitée. Les nombres " -"à virgule flottante sont généralement implémentés en utilisant des :c:type:" -"`double` en C; des informations sur la précision et la représentation " -"interne des nombres à virgule flottante pour la machine sur laquelle le " -"programme est en cours d'exécution est disponible dans :data:`sys." -"float_info`. Les nombres complexes ont une partie réelle et une partie " -"imaginaire, qui sont chacunes des nombres à virgule flottante. Pour extraire " -"ces parties d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag``. (La " -"bibliothèque standard comprend d'autres types numériques, :mod:`fractions` " -"qui stocke des rationnels et :mod:`decimal` qui stocke les nombres à virgule " -"flottante avec une précision définissable par l'utilisateur.)" +msgstr "Il existe trois types numériques distincts: :dfn:`integers` (entiers), :dfn:`floating point numbers` (nombres flottants) et :dfn:`complex numbers` (nombres complexes). En outre, les booléens sont un sous-type des entiers. Les entiers ont une précision illimitée. Les nombres à virgule flottante sont généralement implémentés en utilisant des :c:type:`double` en C; des informations sur la précision et la représentation interne des nombres à virgule flottante pour la machine sur laquelle le programme est en cours d'exécution est disponible dans :data:`sys.float_info`. Les nombres complexes ont une partie réelle et une partie imaginaire, qui sont chacunes des nombres à virgule flottante. Pour extraire ces parties d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag``. (La bibliothèque standard comprend d'autres types numériques, :mod:`fractions` qui stocke des rationnels et :mod:`decimal` qui stocke les nombres à virgule flottante avec une précision définissable par l'utilisateur.)" #: ../Doc/library/stdtypes.rst:238 msgid "" From a1b43de061ad092f90b719fa12740d44f7859f49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 09:38:50 +0200 Subject: [PATCH 4/9] french typography --- library/stdtypes.po | 44 +++++++++----------------------------------- 1 file changed, 9 insertions(+), 35 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 02dd3dbe..918444a5 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 09:32+0200\n" +"PO-Revision-Date: 2017-09-22 10:04+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -388,7 +388,7 @@ msgid "" "use ``z.real`` and ``z.imag``. (The standard library includes additional " "numeric types, :mod:`fractions` that hold rationals, and :mod:`decimal` that " "hold floating-point numbers with user-definable precision.)" -msgstr "Il existe trois types numériques distincts: :dfn:`integers` (entiers), :dfn:`floating point numbers` (nombres flottants) et :dfn:`complex numbers` (nombres complexes). En outre, les booléens sont un sous-type des entiers. Les entiers ont une précision illimitée. Les nombres à virgule flottante sont généralement implémentés en utilisant des :c:type:`double` en C; des informations sur la précision et la représentation interne des nombres à virgule flottante pour la machine sur laquelle le programme est en cours d'exécution est disponible dans :data:`sys.float_info`. Les nombres complexes ont une partie réelle et une partie imaginaire, qui sont chacunes des nombres à virgule flottante. Pour extraire ces parties d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag``. (La bibliothèque standard comprend d'autres types numériques, :mod:`fractions` qui stocke des rationnels et :mod:`decimal` qui stocke les nombres à virgule flottante avec une précision définissable par l'utilisateur.)" +msgstr "Il existe trois types numériques distincts: :dfn:`integers` (entiers), :dfn:`floating point numbers` (nombres flottants) et :dfn:`complex numbers` (nombres complexes). En outre, les booléens sont un sous-type des entiers. Les entiers ont une précision illimitée. Les nombres à virgule flottante sont généralement implémentés en utilisant des :c:type:`double` en C ; des informations sur la précision et la représentation interne des nombres à virgule flottante pour la machine sur laquelle le programme est en cours d'exécution est disponible dans :data:`sys.float_info`. Les nombres complexes ont une partie réelle et une partie imaginaire, qui sont chacunes des nombres à virgule flottante. Pour extraire ces parties d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag``. (La bibliothèque standard comprend d'autres types numériques, :mod:`fractions` qui stocke des rationnels et :mod:`decimal` qui stocke les nombres à virgule flottante avec une précision définissable par l'utilisateur.)" #: ../Doc/library/stdtypes.rst:238 msgid "" @@ -641,10 +641,7 @@ msgid "" "Conversion from floating point to integer may round or truncate as in C; see " "functions :func:`math.floor` and :func:`math.ceil` for well-defined " "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 des " -"conversions bien définies." +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 des conversions bien définies." #: ../Doc/library/stdtypes.rst:341 msgid "" @@ -751,11 +748,7 @@ msgid "" "numeric operations and higher than the comparisons; the unary operation " "``~`` has the same priority as the other unary numeric operations (``+`` and " "``-``)." -msgstr "" -"Les priorités de toutes les opération à deux opérandes sur des bits sont " -"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 ``-``)." +msgstr "Les priorités de toutes les opération à deux opérandes sur des bits sont 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 ``-``)." #: ../Doc/library/stdtypes.rst:407 msgid "This table lists the bitwise operations sorted in ascending priority:" @@ -850,10 +843,7 @@ msgstr "Méthodes supplémentaires sur les entiers" 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:`classe de base abstraite ` :class:`numbers.Integral`. Il fournit aussi quelques autres " -"méthodes :" +msgstr "Le type int implémente la :term:`classe de base abstraite ` :class:`numbers.Integral`. Il fournit aussi quelques autres méthodes :" #: ../Doc/library/stdtypes.rst:450 msgid "" @@ -1126,11 +1116,7 @@ msgid "" "``P`` (but ``m`` is not) then ``n`` has no inverse modulo ``P`` and the rule " "above doesn't apply; in this case define ``hash(x)`` to be the constant " "value ``sys.hash_info.inf``." -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 n'est pas applicable; dans ce cas définir " -"``hash(x)`` comme étant la valeur de la constante ``sys.hash_info.inf``." +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 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 msgid "" @@ -1507,11 +1493,7 @@ msgid "" "sequence of the same type as *s*). Note that items in the sequence *s* are " "not copied; they are referenced multiple times. This often haunts new " "Python programmers; consider::" -msgstr "" -"Les valeurs de *n* plus petites que ``0`` sont traités comme ``0`` (ce qui " -"donne une séquence vide du même type que *s*). Notez que les éléments de *s* " -"ne sont pas copiés; ils sont référencés plusieurs fois. Cela hante souvent " -"de nouveaux développeurs Python, typiquement : ::" +msgstr "Les valeurs de *n* plus petites que ``0`` sont traités comme ``0`` (ce qui donne une séquence vide du même type que *s*). Notez que les éléments de *s* ne sont pas copiés ; ils sont référencés plusieurs fois. Cela hante souvent de nouveaux développeurs Python, typiquement : ::" #: ../Doc/library/stdtypes.rst:911 msgid "" @@ -1888,12 +1870,7 @@ msgid "" "__index__`. Zero and negative values of *n* clear the sequence. Items in " "the sequence are not copied; they are referenced multiple times, as " "explained for ``s * n`` under :ref:`typesseq-common`." -msgstr "" -"La valeur *n* est un entier, ou un objet implémentant :meth:`~object." -"__index__`. Zéro et les valeurs négatives de *n* permettent d'effacer la " -"séquence. Les éléments dans la séquence ne sont pas copiés; ils sont " -"référencés plusieurs fois, comme expliqué pour ``s * n`` dans :ref:`typesseq-" -"common`." +msgstr "La valeur *n* est un entier, ou un objet implémentant :meth:`~object.__index__`. Zéro et les valeurs négatives de *n* permettent d'effacer la séquence. Les éléments dans la séquence ne sont pas copiés ; ils sont référencés plusieurs fois, comme expliqué pour ``s * n`` dans :ref:`typesseq-common`." #: ../Doc/library/stdtypes.rst:1126 msgid "Lists" @@ -1965,10 +1942,7 @@ msgid "" "Lists implement all of the :ref:`common ` and :ref:`mutable " "` sequence operations. Lists also provide the following " "additional method:" -msgstr "" -"Les listes supportent toutes les opérations des séquences :ref:`communes " -"` et :ref:`mutables `. Les listes " -"fournissent également la méthode supplémentaire suivante :" +msgstr "Les listes supportent toutes les opérations des séquences :ref:`communes ` et :ref:`mutables `. Les listes fournissent également la méthode supplémentaire suivante :" #: ../Doc/library/stdtypes.rst:1161 msgid "" From f77ae5ca2dc672c7ccb755b51d07158c23d9f7b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 10:08:01 +0200 Subject: [PATCH 5/9] style --- library/stdtypes.po | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 918444a5..7cd2f8aa 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 10:04+0200\n" +"PO-Revision-Date: 2017-09-22 10:07+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -2101,13 +2101,7 @@ msgid "" "are needed to avoid syntactic ambiguity. For example, ``f(a, b, c)`` is a " "function call with three arguments, while ``f((a, b, c))`` is a function " "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 " -"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." +msgstr "Notez que c'est en fait la virgule qui fait un tuple et non les parenthèses. 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:1236 msgid "" From c1c12051d62eba9bf4688e2516d1cab189318e28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 10:11:29 +0200 Subject: [PATCH 6/9] typography --- library/stdtypes.po | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 7cd2f8aa..e3aa55fa 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 10:07+0200\n" +"PO-Revision-Date: 2017-09-22 10:11+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -2241,11 +2241,7 @@ msgid "" "Range objects implement the :class:`collections.abc.Sequence` ABC, and " "provide features such as containment tests, element index lookup, slicing " "and support for negative indices (see :ref:`typesseq`):" -msgstr "" -"Les *range* implémentent la classe de base abstraite :class:`collections.abc." -"Sequence`, et offrent des fonctionnalités telles que les tests " -"d'appartenance (avec *in*) , de recherche par index, le tranchage et ils " -"gerent les indices négatifs (voir :ref:`typesseq`):" +msgstr "Les *range* implémentent la classe de base abstraite :class:`collections.abc.Sequence` et offrent des fonctionnalités telles que les tests d'appartenance (avec *in*), de recherche par index, le tranchage et ils gerent les indices négatifs (voir :ref:`typesseq`):" #: ../Doc/library/stdtypes.rst:1343 msgid "" From fadcce2971c406f49577cce8468b933d33e9dd05 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 10:13:40 +0200 Subject: [PATCH 7/9] glue words --- library/stdtypes.po | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index e3aa55fa..8c8926bd 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 10:11+0200\n" +"PO-Revision-Date: 2017-09-22 10:13+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -2305,11 +2305,7 @@ msgid "" "Textual data in Python is handled with :class:`str` objects, or :dfn:" "`strings`. Strings are immutable :ref:`sequences ` of Unicode code " "points. String literals are written in a variety of ways:" -msgstr "" -"Les données textuelles en Python est manipulé avec des objets :class:`str` " -"ou :dfn:`strings`. Les chaînes sont des :ref:`séquences ` " -"immuables depoints de code Unicode. Les chaînes littérales peuvent être " -"écrites de différentes manières :" +msgstr "Les données textuelles en Python est manipulé avec des objets :class:`str` ou :dfn:`strings`. Les chaînes sont des :ref:`séquences ` immuables de points de code Unicode. Les chaînes littérales peuvent être écrites de différentes manières :" #: ../Doc/library/stdtypes.rst:1386 msgid "Single quotes: ``'allows embedded \"double\" quotes'``" From 27212e719418a16561af2e4a965b3af065a1d992 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 10:16:23 +0200 Subject: [PATCH 8/9] remove noise ? --- library/stdtypes.po | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 8c8926bd..d06310fd 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-08-01 13:21+0200\n" -"PO-Revision-Date: 2017-09-22 10:13+0200\n" +"PO-Revision-Date: 2017-09-22 10:16+0200\n" "Last-Translator: Julien Palard \n" "Language-Team: \n" "Language: fr\n" @@ -2450,11 +2450,7 @@ msgid "" "`textseq` and the :ref:`string-methods` section below. To output formatted " "strings, see the :ref:`f-strings` and :ref:`formatstrings` sections. In " "addition, see the :ref:`stringservices` section." -msgstr "" -"Pour plus d'informations sur la classe ``str`` et ses méthodes, voir les " -"sections :ref:`textseq` et :ref:`string-methods`. Pour formatter des chaînes " -"de caractères, voir les sections :ref:`f-strings` et :ref:`formatstrings`. " -"La section :ref:`stringservices` contient aussi des informations.-like" +msgstr "Pour plus d'informations sur la classe ``str`` et ses méthodes, voir les sections :ref:`textseq` et :ref:`string-methods`. Pour formatter des chaînes de caractères, voir les sections :ref:`f-strings` et :ref:`formatstrings`. La section :ref:`stringservices` contient aussi des informations." #: ../Doc/library/stdtypes.rst:1470 msgid "String Methods" From 6d3c69ccd803e05258c1f4aaf1a9445808559bd9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cyprien=20Le=20Pann=C3=A9rer?= Date: Fri, 22 Sep 2017 10:30:36 +0200 Subject: [PATCH 9/9] indent --- library/stdtypes.po | 97 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 83 insertions(+), 14 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index d06310fd..b4e26598 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -330,7 +330,15 @@ msgid "" "`TypeError` exception when comparing a complex number with another built-in " "numeric type, when the objects are of different types that cannot be " "compared, or in other cases where there is no defined ordering." -msgstr "Les objets de différents types, à l'exception de différents types numériques, ne peuvent en aucun cas être égaux. En outre, certains types (par exemple, les objets fonction) ne gèrent qu'une une notion dégénérée de la comparaison où deux objets de ce type sont inégaux. Les opérateurs ``<``, ``<=``, ``>`` et ``>=`` lèvent une exception :exc:`TypeError` lorsqu'on compare un nombre complexe avec un autre type natif numérique, lorsque les objets sont de différents types qui ne peuvent pas être comparés, ou dans d'autres cas où il n'y a pas d'ordre défini." +msgstr "" +"Les objets de différents types, à l'exception de différents types " +"numériques, ne peuvent en aucun cas être égaux. En outre, certains types " +"(par exemple, les objets fonction) ne gèrent qu'une une notion dégénérée de " +"la comparaison où deux objets de ce type sont inégaux. Les opérateurs ``<``, " +"``<=``, ``>`` et ``>=`` lèvent une exception :exc:`TypeError` lorsqu'on " +"compare un nombre complexe avec un autre type natif numérique, lorsque les " +"objets sont de différents types qui ne peuvent pas être comparés, ou dans " +"d'autres cas où il n'y a pas d'ordre défini." #: ../Doc/library/stdtypes.rst:182 msgid "" @@ -360,7 +368,10 @@ msgid "" "The behavior of the :keyword:`is` and :keyword:`is not` operators cannot be " "customized; also they can be applied to any two objects and never raise an " "exception." -msgstr "Le comportement des opérateurs :keyword:`is` et :keyword:`is not` ne peut pas être personnalisé ; aussi ils peuvent être appliqués à deux objets quelconques et ne soulèvent jamais d'exception." +msgstr "" +"Le comportement des opérateurs :keyword:`is` et :keyword:`is not` ne peut " +"pas être personnalisé ; aussi ils peuvent être appliqués à deux objets " +"quelconques et ne soulèvent jamais d'exception." #: ../Doc/library/stdtypes.rst:199 msgid "" @@ -388,7 +399,21 @@ msgid "" "use ``z.real`` and ``z.imag``. (The standard library includes additional " "numeric types, :mod:`fractions` that hold rationals, and :mod:`decimal` that " "hold floating-point numbers with user-definable precision.)" -msgstr "Il existe trois types numériques distincts: :dfn:`integers` (entiers), :dfn:`floating point numbers` (nombres flottants) et :dfn:`complex numbers` (nombres complexes). En outre, les booléens sont un sous-type des entiers. Les entiers ont une précision illimitée. Les nombres à virgule flottante sont généralement implémentés en utilisant des :c:type:`double` en C ; des informations sur la précision et la représentation interne des nombres à virgule flottante pour la machine sur laquelle le programme est en cours d'exécution est disponible dans :data:`sys.float_info`. Les nombres complexes ont une partie réelle et une partie imaginaire, qui sont chacunes des nombres à virgule flottante. Pour extraire ces parties d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag``. (La bibliothèque standard comprend d'autres types numériques, :mod:`fractions` qui stocke des rationnels et :mod:`decimal` qui stocke les nombres à virgule flottante avec une précision définissable par l'utilisateur.)" +msgstr "" +"Il existe trois types numériques distincts: :dfn:`integers` (entiers), :dfn:" +"`floating point numbers` (nombres flottants) et :dfn:`complex numbers` " +"(nombres complexes). En outre, les booléens sont un sous-type des entiers. " +"Les entiers ont une précision illimitée. Les nombres à virgule flottante " +"sont généralement implémentés en utilisant des :c:type:`double` en C ; des " +"informations sur la précision et la représentation interne des nombres à " +"virgule flottante pour la machine sur laquelle le programme est en cours " +"d'exécution est disponible dans :data:`sys.float_info`. Les nombres " +"complexes ont une partie réelle et une partie imaginaire, qui sont chacunes " +"des nombres à virgule flottante. Pour extraire ces parties d'un nombre " +"complexe *z*, utilisez ``z.real`` et ``z.imag``. (La bibliothèque standard " +"comprend d'autres types numériques, :mod:`fractions` qui stocke des " +"rationnels et :mod:`decimal` qui stocke les nombres à virgule flottante avec " +"une précision définissable par l'utilisateur.)" #: ../Doc/library/stdtypes.rst:238 msgid "" @@ -641,7 +666,10 @@ msgid "" "Conversion from floating point to integer may round or truncate as in C; see " "functions :func:`math.floor` and :func:`math.ceil` for well-defined " "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 des conversions bien définies." +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 des " +"conversions bien définies." #: ../Doc/library/stdtypes.rst:341 msgid "" @@ -748,7 +776,11 @@ msgid "" "numeric operations and higher than the comparisons; the unary operation " "``~`` has the same priority as the other unary numeric operations (``+`` and " "``-``)." -msgstr "Les priorités de toutes les opération à deux opérandes sur des bits sont 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 ``-``)." +msgstr "" +"Les priorités de toutes les opération à deux opérandes sur des bits sont " +"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 ``-``)." #: ../Doc/library/stdtypes.rst:407 msgid "This table lists the bitwise operations sorted in ascending priority:" @@ -843,7 +875,10 @@ msgstr "Méthodes supplémentaires sur les entiers" 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:`classe de base abstraite ` :class:`numbers.Integral`. Il fournit aussi quelques autres méthodes :" +msgstr "" +"Le type int implémente la :term:`classe de base abstraite ` :class:`numbers.Integral`. Il fournit aussi quelques autres " +"méthodes :" #: ../Doc/library/stdtypes.rst:450 msgid "" @@ -1116,7 +1151,11 @@ msgid "" "``P`` (but ``m`` is not) then ``n`` has no inverse modulo ``P`` and the rule " "above doesn't apply; in this case define ``hash(x)`` to be the constant " "value ``sys.hash_info.inf``." -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 n'est pas applicable ; dans ce cas définir ``hash(x)`` comme étant la valeur de la constante ``sys.hash_info.inf``." +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 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 msgid "" @@ -1493,7 +1532,11 @@ msgid "" "sequence of the same type as *s*). Note that items in the sequence *s* are " "not copied; they are referenced multiple times. This often haunts new " "Python programmers; consider::" -msgstr "Les valeurs de *n* plus petites que ``0`` sont traités comme ``0`` (ce qui donne une séquence vide du même type que *s*). Notez que les éléments de *s* ne sont pas copiés ; ils sont référencés plusieurs fois. Cela hante souvent de nouveaux développeurs Python, typiquement : ::" +msgstr "" +"Les valeurs de *n* plus petites que ``0`` sont traités comme ``0`` (ce qui " +"donne une séquence vide du même type que *s*). Notez que les éléments de *s* " +"ne sont pas copiés ; ils sont référencés plusieurs fois. Cela hante souvent " +"de nouveaux développeurs Python, typiquement : ::" #: ../Doc/library/stdtypes.rst:911 msgid "" @@ -1870,7 +1913,12 @@ msgid "" "__index__`. Zero and negative values of *n* clear the sequence. Items in " "the sequence are not copied; they are referenced multiple times, as " "explained for ``s * n`` under :ref:`typesseq-common`." -msgstr "La valeur *n* est un entier, ou un objet implémentant :meth:`~object.__index__`. Zéro et les valeurs négatives de *n* permettent d'effacer la séquence. Les éléments dans la séquence ne sont pas copiés ; ils sont référencés plusieurs fois, comme expliqué pour ``s * n`` dans :ref:`typesseq-common`." +msgstr "" +"La valeur *n* est un entier, ou un objet implémentant :meth:`~object." +"__index__`. Zéro et les valeurs négatives de *n* permettent d'effacer la " +"séquence. Les éléments dans la séquence ne sont pas copiés ; ils sont " +"référencés plusieurs fois, comme expliqué pour ``s * n`` dans :ref:`typesseq-" +"common`." #: ../Doc/library/stdtypes.rst:1126 msgid "Lists" @@ -1942,7 +1990,10 @@ msgid "" "Lists implement all of the :ref:`common ` and :ref:`mutable " "` sequence operations. Lists also provide the following " "additional method:" -msgstr "Les listes supportent toutes les opérations des séquences :ref:`communes ` et :ref:`mutables `. Les listes fournissent également la méthode supplémentaire suivante :" +msgstr "" +"Les listes supportent toutes les opérations des séquences :ref:`communes " +"` et :ref:`mutables `. Les listes " +"fournissent également la méthode supplémentaire suivante :" #: ../Doc/library/stdtypes.rst:1161 msgid "" @@ -2101,7 +2152,13 @@ msgid "" "are needed to avoid syntactic ambiguity. For example, ``f(a, b, c)`` is a " "function call with three arguments, while ``f((a, b, c))`` is a function " "call with a 3-tuple as the sole argument." -msgstr "Notez que c'est en fait la virgule qui fait un tuple et non les parenthèses. 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." +msgstr "" +"Notez que c'est en fait la virgule qui fait un tuple et non les parenthèses. " +"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:1236 msgid "" @@ -2241,7 +2298,11 @@ msgid "" "Range objects implement the :class:`collections.abc.Sequence` ABC, and " "provide features such as containment tests, element index lookup, slicing " "and support for negative indices (see :ref:`typesseq`):" -msgstr "Les *range* implémentent la classe de base abstraite :class:`collections.abc.Sequence` et offrent des fonctionnalités telles que les tests d'appartenance (avec *in*), de recherche par index, le tranchage et ils gerent les indices négatifs (voir :ref:`typesseq`):" +msgstr "" +"Les *range* implémentent la classe de base abstraite :class:`collections.abc." +"Sequence` et offrent des fonctionnalités telles que les tests d'appartenance " +"(avec *in*), de recherche par index, le tranchage et ils gerent les indices " +"négatifs (voir :ref:`typesseq`):" #: ../Doc/library/stdtypes.rst:1343 msgid "" @@ -2305,7 +2366,11 @@ msgid "" "Textual data in Python is handled with :class:`str` objects, or :dfn:" "`strings`. Strings are immutable :ref:`sequences ` of Unicode code " "points. String literals are written in a variety of ways:" -msgstr "Les données textuelles en Python est manipulé avec des objets :class:`str` ou :dfn:`strings`. Les chaînes sont des :ref:`séquences ` immuables de points de code Unicode. Les chaînes littérales peuvent être écrites de différentes manières :" +msgstr "" +"Les données textuelles en Python est manipulé avec des objets :class:`str` " +"ou :dfn:`strings`. Les chaînes sont des :ref:`séquences ` " +"immuables de points de code Unicode. Les chaînes littérales peuvent être " +"écrites de différentes manières :" #: ../Doc/library/stdtypes.rst:1386 msgid "Single quotes: ``'allows embedded \"double\" quotes'``" @@ -2450,7 +2515,11 @@ msgid "" "`textseq` and the :ref:`string-methods` section below. To output formatted " "strings, see the :ref:`f-strings` and :ref:`formatstrings` sections. In " "addition, see the :ref:`stringservices` section." -msgstr "Pour plus d'informations sur la classe ``str`` et ses méthodes, voir les sections :ref:`textseq` et :ref:`string-methods`. Pour formatter des chaînes de caractères, voir les sections :ref:`f-strings` et :ref:`formatstrings`. La section :ref:`stringservices` contient aussi des informations." +msgstr "" +"Pour plus d'informations sur la classe ``str`` et ses méthodes, voir les " +"sections :ref:`textseq` et :ref:`string-methods`. Pour formatter des chaînes " +"de caractères, voir les sections :ref:`f-strings` et :ref:`formatstrings`. " +"La section :ref:`stringservices` contient aussi des informations." #: ../Doc/library/stdtypes.rst:1470 msgid "String Methods"