datetime.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-10-29 21:40+0100\n"
"PO-Revision-Date: 2023-10-03 21:51+0200\n"
"Last-Translator: Loc Cosnier <loc.cosnier@pm.me>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.3.2\n"

#: library/datetime.rst:2
#, fuzzy
msgid ":mod:`!datetime` --- Basic date and time types"
msgstr ":mod:`datetime` — Types de base pour la date et l'heure"

#: library/datetime.rst:11
msgid "**Source code:** :source:`Lib/datetime.py`"
msgstr "**Code source :** :source:`Lib/datetime.py`"

#: library/datetime.rst:17
#, fuzzy
msgid ""
"The :mod:`!datetime` module supplies classes for manipulating dates and "
"times."
msgstr ""
"Le module :mod:`datetime` fournit des classes permettant de manipuler les "
"dates et les heures."

#: library/datetime.rst:19
msgid ""
"While date and time arithmetic is supported, the focus of the implementation "
"is on efficient attribute extraction for output formatting and manipulation."
msgstr ""
"Bien que les calculs de date et d'heure sont gérés, l'attention lors de "
"l'implémentation s'est essentiellement portée sur l'efficacité de "
"l'extraction des attributs en vue de leur manipulation et formatage pour "
"l'affichage."

#: library/datetime.rst:24
msgid "Skip to :ref:`the format codes <format-codes>`."
msgstr ""

#: library/datetime.rst:28
msgid "Module :mod:`calendar`"
msgstr "Module :mod:`calendar`"

#: library/datetime.rst:29
msgid "General calendar related functions."
msgstr "Fonctions génériques associées au calendrier."

#: library/datetime.rst:31
msgid "Module :mod:`time`"
msgstr "Module :mod:`time`"

#: library/datetime.rst:32
msgid "Time access and conversions."
msgstr "Accès aux données d'horaires et aux conversions associées."

#: library/datetime.rst:34
msgid "Module :mod:`zoneinfo`"
msgstr "Module :mod:`zoneinfo`"

#: library/datetime.rst:35
msgid "Concrete time zones representing the IANA time zone database."
msgstr "Fuseaux horaires concrets représentant la base de données IANA."

#: library/datetime.rst:37
msgid "Package `dateutil <https://dateutil.readthedocs.io/en/stable/>`_"
msgstr "Paquet `dateutil <https://dateutil.readthedocs.io/en/stable/>`_"

#: library/datetime.rst:38
msgid "Third-party library with expanded time zone and parsing support."
msgstr ""
"Bibliothèque tierce avec prise en charge complète du fuseau horaire et de "
"l'analyse de dates sous forme textuelle."

#: library/datetime.rst:40
msgid "Package :pypi:`DateType`"
msgstr ""

#: library/datetime.rst:41
msgid ""
"Third-party library that introduces distinct static types to e.g. allow :"
"term:`static type checkers <static type checker>` to differentiate between "
"naive and aware datetimes."
msgstr ""

#: library/datetime.rst:48
msgid "Aware and Naive Objects"
msgstr "Objets avisés et naïfs"

#: library/datetime.rst:50
#, fuzzy
msgid ""
"Date and time objects may be categorized as \"aware\" or \"naive\" depending "
"on whether or not they include time zone information."
msgstr ""
"Les objets *date* et *time* peuvent être classés comme « avisés » ou "
"« naïfs » selon qu'ils contiennent ou non des informations sur le fuseau "
"horaire."

#: library/datetime.rst:53
msgid ""
"With sufficient knowledge of applicable algorithmic and political time "
"adjustments, such as time zone and daylight saving time information, an "
"**aware** object can locate itself relative to other aware objects. An aware "
"object represents a specific moment in time that is not open to "
"interpretation. [#]_"
msgstr ""
"Un objet **avisé** possède suffisamment de connaissance des règles à "
"appliquer et des politiques d'ajustement de l'heure comme les informations "
"sur les fuseaux horaires et l'heure d'été pour se situer de façon relative "
"par rapport à d'autres objets avisés. Un objet avisé est utilisé pour "
"représenter un instant précis qui n'est pas ouvert à l'interprétation [#]_."

#: library/datetime.rst:59
#, fuzzy
msgid ""
"A **naive** object does not contain enough information to unambiguously "
"locate itself relative to other date/time objects. Whether a naive object "
"represents Coordinated Universal Time (UTC), local time, or time in some "
"other time zone is purely up to the program, just like it is up to the "
"program whether a particular number represents metres, miles, or mass. Naive "
"objects are easy to understand and to work with, at the cost of ignoring "
"some aspects of reality."
msgstr ""
"Un objet **naïf** ne comporte pas assez d'informations pour se situer sans "
"ambiguïté par rapport à d'autres objets *date/time*. Le fait qu'un objet "
"naïf représente un Temps universel coordonné (UTC), une heure locale ou une "
"heure dans un autre fuseau horaire dépend complètement du programme, tout "
"comme un nombre peut représenter une longueur, un poids ou une distance pour "
"le programme. Les objets naïfs sont simples à comprendre et il est aisé de "
"travailler avec, au prix de négliger certains aspects de la réalité."

#: library/datetime.rst:66
msgid ""
"For applications requiring aware objects, :class:`.datetime` and :class:`."
"time` objects have an optional time zone information attribute, :attr:`!"
"tzinfo`, that can be set to an instance of a subclass of the abstract :class:"
"`tzinfo` class. These :class:`tzinfo` objects capture information about the "
"offset from UTC time, the time zone name, and whether daylight saving time "
"is in effect."
msgstr ""
"Pour les applications nécessitant des objets avisés, les objets :class:`."
"datetime` et :class:`.time` ont un attribut facultatif renseignant le fuseau "
"horaire, :attr:`!tzinfo`, qui peut être une instance d'une sous-classe de la "
"classe abstraite :class:`tzinfo`. Ces objets :class:`tzinfo` regroupent des "
"informations sur le décalage par rapport à l'heure UTC, le nom du fuseau "
"horaire, et si l'heure d'été est en vigueur."

#: library/datetime.rst:72
#, fuzzy
msgid ""
"Only one concrete :class:`tzinfo` class, the :class:`timezone` class, is "
"supplied by the :mod:`!datetime` module. The :class:`!timezone` class can "
"represent simple time zones with fixed offsets from UTC, such as UTC itself "
"or North American EST and EDT time zones. Supporting time zones at deeper "
"levels of detail is up to the application. The rules for time adjustment "
"across the world are more political than rational, change frequently, and "
"there is no standard suitable for every application aside from UTC."
msgstr ""
"Notez qu'une seule classe concrète :class:`tzinfo`, la classe :class:"
"`timezone`, est proposée par le module :mod:`datetime`. La classe :class:"
"`timezone` représente des fuseaux horaires simples avec un décalage fixe par "
"rapport à UTC, comme UTC lui-même ou les fuseaux EST et EDT d'Amérique du "
"Nord. Gérer des fuseaux horaires d'un niveau de détails plus avancé est à la "
"charge de l'application. Les règles d'ajustement du temps à travers le monde "
"sont plus politiques que rationnelles, changent fréquemment, et il n'y a pas "
"de standard qui vaille pour toute application, en dehors d'UTC."

#: library/datetime.rst:81
msgid "Constants"
msgstr "Constantes"

#: library/datetime.rst:83
#, fuzzy
msgid "The :mod:`!datetime` module exports the following constants:"
msgstr "Le module :mod:`datetime` exporte les constantes suivantes :"

#: library/datetime.rst:87
#, fuzzy
msgid ""
"The smallest year number allowed in a :class:`date` or :class:`.datetime` "
"object. :const:`MINYEAR` is 1."
msgstr ""
"Le numéro d'année le plus petit autorisé dans un objet :class:`date` ou :"
"class:`datetime`. :const:`MINYEAR` vaut ``1``."

#: library/datetime.rst:93
#, fuzzy
msgid ""
"The largest year number allowed in a :class:`date` or :class:`.datetime` "
"object. :const:`MAXYEAR` is 9999."
msgstr ""
"Le numéro d'année le plus grand autorisé dans un objet :class:`date` ou :"
"class:`datetime`. :const:`MAXYEAR` vaut ``9999``."

#: library/datetime.rst:98
#, fuzzy
msgid "Alias for the UTC time zone singleton :attr:`datetime.timezone.utc`."
msgstr ""
"Alias du singleton de fuseau horaire UTC :attr:`datetime.timezone.utc`."

#: library/datetime.rst:103
msgid "Available Types"
msgstr "Types disponibles"

#: library/datetime.rst:108
msgid ""
"An idealized naive date, assuming the current Gregorian calendar always was, "
"and always will be, in effect. Attributes: :attr:`year`, :attr:`month`, and :"
"attr:`day`."
msgstr ""
"Une date naïve idéalisée, en supposant que le calendrier Grégorien actuel a "
"toujours existé et qu'il existera toujours. Attributs : :attr:`year`, :attr:"
"`month` et :attr:`day`."

#: library/datetime.rst:116
msgid ""
"An idealized time, independent of any particular day, assuming that every "
"day has exactly 24\\*60\\*60 seconds.  (There is no notion of \"leap "
"seconds\" here.) Attributes: :attr:`hour`, :attr:`minute`, :attr:`second`, :"
"attr:`microsecond`, and :attr:`.tzinfo`."
msgstr ""
"Un temps idéalisé, indépendant d'une date particulière, en supposant qu'une "
"journée est composée d'exactement 24\\*60\\*60 secondes (il n'y a pas ici de "
"notion de « seconde intercalaire »). Attributs : :attr:`hour`, :attr:"
"`minute`, :attr:`second`, :attr:`microsecond` et :attr:`tzinfo`."

#: library/datetime.rst:125
msgid ""
"A combination of a date and a time. Attributes: :attr:`year`, :attr:"
"`month`, :attr:`day`, :attr:`hour`, :attr:`minute`, :attr:`second`, :attr:"
"`microsecond`, and :attr:`.tzinfo`."
msgstr ""
"Une combinaison d'une date et d'une heure. Attributs : :attr:`year`, :attr:"
"`month`, :attr:`day`, :attr:`hour`, :attr:`minute`, :attr:`second`, :attr:"
"`microsecond`, et :attr:`tzinfo`."

#: library/datetime.rst:133
#, fuzzy
msgid ""
"A duration expressing the difference between two :class:`.datetime` or :"
"class:`date` instances to microsecond resolution."
msgstr ""
"Une durée qui exprime la différence entre deux instances de :class:`date`, :"
"class:`time` ou :class:`datetime` en microsecondes."

#: library/datetime.rst:140
msgid ""
"An abstract base class for time zone information objects. These are used by "
"the :class:`.datetime` and :class:`.time` classes to provide a customizable "
"notion of time adjustment (for example, to account for time zone and/or "
"daylight saving time)."
msgstr ""
"Une classe mère abstraite pour les objets portants des informations sur les "
"fuseaux horaires. Ceux-ci sont utilisés par les classes :class:`.datetime` "
"et :class:`.time` pour donner une notion personnalisable d'ajustement "
"d'horaire (par exemple la prise en compte d'un fuseau horaire et/ou de "
"l'heure d'été)."

#: library/datetime.rst:148
msgid ""
"A class that implements the :class:`tzinfo` abstract base class as a fixed "
"offset from the UTC."
msgstr ""
"Une classe qui implémente la classe mère abstraite :class:`tzinfo` en tant "
"que décalage fixe par rapport au temps UTC."

#: library/datetime.rst:171
msgid "Objects of these types are immutable."
msgstr "Les objets issus de ces types sont immuables."

#: library/datetime.rst:155
msgid "Subclass relationships::"
msgstr "Relations entre les sous-classes ::"

#: library/datetime.rst:157
msgid ""
"object\n"
"    timedelta\n"
"    tzinfo\n"
"        timezone\n"
"    time\n"
"    date\n"
"        datetime"
msgstr ""

#: library/datetime.rst:166
msgid "Common Properties"
msgstr "Propriétés communes"

#: library/datetime.rst:168
msgid ""
"The :class:`date`, :class:`.datetime`, :class:`.time`, and :class:`timezone` "
"types share these common features:"
msgstr ""
"Les types :class:`date`, :class:`.datetime`, :class:`.time`, et :class:"
"`timezone` partagent les caractéristiques suivantes :"

#: library/datetime.rst:172
msgid ""
"Objects of these types are :term:`hashable`, meaning that they can be used "
"as dictionary keys."
msgstr ""
"Les objets de ces types sont :term:`hachable`, ce qui signifie qu'ils "
"peuvent être utilisés comme clés de dictionnaire."

#: library/datetime.rst:174
msgid ""
"Objects of these types support efficient pickling via the :mod:`pickle` "
"module."
msgstr ""
"Les objets de ces types peuvent être sérialisés efficacement par le module :"
"mod:`pickle`."

#: library/datetime.rst:177
msgid "Determining if an Object is Aware or Naive"
msgstr "Catégorisation d'un objet en « avisé » ou « naïf »"

#: library/datetime.rst:179
msgid "Objects of the :class:`date` type are always naive."
msgstr "Les objets de type :class:`date` sont toujours naïfs."

#: library/datetime.rst:181
msgid ""
"An object of type :class:`.time` or :class:`.datetime` may be aware or naive."
msgstr ""
"Un objet du type :class:`.time` ou :class:`.datetime` peut être avisé ou "
"naïf."

#: library/datetime.rst:183
#, fuzzy
msgid ""
"A :class:`.datetime` object ``d`` is aware if both of the following hold:"
msgstr ""
"Un objet :class:`.datetime` *d* est avisé si les deux conditions suivantes "
"vérifient :"

#: library/datetime.rst:185
msgid "``d.tzinfo`` is not ``None``"
msgstr "``d.tzinfo`` ne vaut pas ``None``"

#: library/datetime.rst:186
msgid "``d.tzinfo.utcoffset(d)`` does not return ``None``"
msgstr "``d.tzinfo.utcoffset(d)`` ne renvoie pas ``None``"

#: library/datetime.rst:188
#, fuzzy
msgid "Otherwise, ``d`` is naive."
msgstr "Autrement, *d* est naïf."

#: library/datetime.rst:190
#, fuzzy
msgid "A :class:`.time` object ``t`` is aware if both of the following hold:"
msgstr ""
"Un objet :class:`.time` *t* est avisé si les deux conditions suivantes "
"vérifient :"

#: library/datetime.rst:192
msgid "``t.tzinfo`` is not ``None``"
msgstr "``t.tzinfo`` ne vaut pas ``None``"

#: library/datetime.rst:193
msgid "``t.tzinfo.utcoffset(None)`` does not return ``None``."
msgstr "``t.tzinfo.utcoffset(None)`` ne renvoie pas ``None``."

#: library/datetime.rst:195
#, fuzzy
msgid "Otherwise, ``t`` is naive."
msgstr "Autrement, *t* est naïf."

#: library/datetime.rst:197
msgid ""
"The distinction between aware and naive doesn't apply to :class:`timedelta` "
"objects."
msgstr ""
"La distinction entre avisé et naïf ne s'applique pas aux objets de type :"
"class:`timedelta`."

#: library/datetime.rst:203
msgid ":class:`timedelta` Objects"
msgstr "Objets :class:`timedelta`"

#: library/datetime.rst:205
#, fuzzy
msgid ""
"A :class:`timedelta` object represents a duration, the difference between "
"two :class:`.datetime` or :class:`date` instances."
msgstr ""
"Un objet :class:`timedelta` représente une durée, c'est-à-dire la différence "
"entre deux dates ou heures."

#: library/datetime.rst:210
#, fuzzy
msgid ""
"All arguments are optional and default to 0. Arguments may be integers or "
"floats, and may be positive or negative."
msgstr ""
"Tous les arguments sont optionnels et ont ``0`` comme valeur par défaut. Les "
"arguments peuvent être des entiers ou des flottants et ils peuvent être "
"positifs ou négatifs."

#: library/datetime.rst:213
msgid ""
"Only *days*, *seconds* and *microseconds* are stored internally. Arguments "
"are converted to those units:"
msgstr ""
"Seuls les *jours*, les *secondes* et les *microsecondes* sont stockés en "
"interne. Les arguments sont convertis dans ces unités :"

#: library/datetime.rst:216
msgid "A millisecond is converted to 1000 microseconds."
msgstr "Une milliseconde est convertie en 1000 microsecondes."

#: library/datetime.rst:217
msgid "A minute is converted to 60 seconds."
msgstr "Une minute est convertie en 60 secondes."

#: library/datetime.rst:218
msgid "An hour is converted to 3600 seconds."
msgstr "Une heure est convertie en 3600 secondes."

#: library/datetime.rst:219
msgid "A week is converted to 7 days."
msgstr "Une semaine est convertie en 7 jours."

#: library/datetime.rst:221
msgid ""
"and days, seconds and microseconds are then normalized so that the "
"representation is unique, with"
msgstr ""
"et ensuite les jours, secondes et microsecondes sont normalisés pour que la "
"représentation soit unique avec"

#: library/datetime.rst:224
msgid "``0 <= microseconds < 1000000``"
msgstr "``0 <= microseconds < 1000000``"

#: library/datetime.rst:225
msgid "``0 <= seconds < 3600*24`` (the number of seconds in one day)"
msgstr "``0 <= secondes < 3600*24`` (le nombre de secondes dans une journée)"

#: library/datetime.rst:226
msgid "``-999999999 <= days <= 999999999``"
msgstr "``-999999999 <= days <= 999999999``"

#: library/datetime.rst:228
msgid ""
"The following example illustrates how any arguments besides *days*, "
"*seconds* and *microseconds* are \"merged\" and normalized into those three "
"resulting attributes::"
msgstr ""
"L'exemple suivant illustre comment tous les arguments autres que *days*, "
"*seconds* et *microseconds* sont « fusionnés » et normalisés dans ces trois "
"attributs résultants ::"

#: library/datetime.rst:232
msgid ""
">>> from datetime import timedelta\n"
">>> delta = timedelta(\n"
"...     days=50,\n"
"...     seconds=27,\n"
"...     microseconds=10,\n"
"...     milliseconds=29000,\n"
"...     minutes=5,\n"
"...     hours=8,\n"
"...     weeks=2\n"
"... )\n"
">>> # Only days, seconds, and microseconds remain\n"
">>> delta\n"
"datetime.timedelta(days=64, seconds=29156, microseconds=10)"
msgstr ""

#: library/datetime.rst:246
msgid ""
"If any argument is a float and there are fractional microseconds, the "
"fractional microseconds left over from all arguments are combined and their "
"sum is rounded to the nearest microsecond using round-half-to-even "
"tiebreaker. If no argument is a float, the conversion and normalization "
"processes are exact (no information is lost)."
msgstr ""
"Si l'un des arguments est un flottant et qu'il y a des microsecondes "
"décimales, les microsecondes décimales laissées par les arguments sont "
"combinées et leur somme est arrondie à la microseconde la plus proche en "
"arrondissant les demis vers le nombre pair. Si aucun argument n'est "
"flottant, les processus de conversion et de normalisation seront exacts (pas "
"d'informations perdues)."

#: library/datetime.rst:253
msgid ""
"If the normalized value of days lies outside the indicated range, :exc:"
"`OverflowError` is raised."
msgstr ""
"Si la valeur normalisée des jours déborde de l'intervalle indiqué, une :exc:"
"`OverflowError` est levée."

#: library/datetime.rst:256
msgid ""
"Note that normalization of negative values may be surprising at first. For "
"example::"
msgstr ""
"Notez que la normalisation de valeurs négatives peut être surprenante au "
"premier abord. Par exemple ::"

#: library/datetime.rst:259
msgid ""
">>> from datetime import timedelta\n"
">>> d = timedelta(microseconds=-1)\n"
">>> (d.days, d.seconds, d.microseconds)\n"
"(-1, 86399, 999999)"
msgstr ""

#: library/datetime.rst:566 library/datetime.rst:1720 library/datetime.rst:2322
msgid "Class attributes:"
msgstr "Attributs de la classe :"

#: library/datetime.rst:269
msgid "The most negative :class:`timedelta` object, ``timedelta(-999999999)``."
msgstr "L'objet :class:`timedelta` le plus négatif, ``timedelta(-999999999)``."

#: library/datetime.rst:274
msgid ""
"The most positive :class:`timedelta` object, ``timedelta(days=999999999, "
"hours=23, minutes=59, seconds=59, microseconds=999999)``."
msgstr ""
"L'objet :class:`timedelta` le plus positif, ``timedelta(days=999999999, "
"hours=23, minutes=59, seconds=59, microseconds=999999)``."

#: library/datetime.rst:280
msgid ""
"The smallest possible difference between non-equal :class:`timedelta` "
"objects, ``timedelta(microseconds=1)``."
msgstr ""
"La plus petite différence entre des objets :class:`timedelta` non égaux, "
"``timedelta(microseconds=1)``."

#: library/datetime.rst:283
#, fuzzy
msgid ""
"Note that, because of normalization, ``timedelta.max`` is greater than ``-"
"timedelta.min``. ``-timedelta.max`` is not representable as a :class:"
"`timedelta` object."
msgstr ""
"Il est à noter, du fait de la normalisation, que ``timedelta.max`` > ``-"
"timedelta.min``. ``-timedelta.max`` n'est pas représentable sous la forme "
"d'un objet :class:`timedelta`."

#: library/datetime.rst:584 library/datetime.rst:1740
msgid "Instance attributes (read-only):"
msgstr "Attributs de l'instance (en lecture seule) :"

#: library/datetime.rst:291
#, fuzzy
msgid "Between -999,999,999 and 999,999,999 inclusive."
msgstr "Entre ``-999999999`` et ``999999999`` inclus"

#: library/datetime.rst:296
#, fuzzy
msgid "Between 0 and 86,399 inclusive."
msgstr "Entre 0 et 86399 inclus"

#: library/datetime.rst:300
msgid ""
"It is a somewhat common bug for code to unintentionally use this attribute "
"when it is actually intended to get a :meth:`~timedelta.total_seconds` value "
"instead:"
msgstr ""

#: library/datetime.rst:304
msgid ""
">>> from datetime import timedelta\n"
">>> duration = timedelta(seconds=11235813)\n"
">>> duration.days, duration.seconds\n"
"(130, 3813)\n"
">>> duration.total_seconds()\n"
"11235813.0"
msgstr ""

#: library/datetime.rst:315
#, fuzzy
msgid "Between 0 and 999,999 inclusive."
msgstr "Entre 0 et 999999 inclus"

#: library/datetime.rst:601 library/datetime.rst:1162
msgid "Supported operations:"
msgstr "Opérations gérées :"

#: library/datetime.rst:604 library/datetime.rst:1165
msgid "Operation"
msgstr "Opération"

#: library/datetime.rst:604 library/datetime.rst:1165
msgid "Result"
msgstr "Résultat"

#: library/datetime.rst:325
msgid "``t1 = t2 + t3``"
msgstr "``t1 = t2 + t3``"

#: library/datetime.rst:325
#, fuzzy
msgid ""
"Sum of ``t2`` and ``t3``. Afterwards ``t1 - t2 == t3`` and ``t1 - t3 == t2`` "
"are true. (1)"
msgstr ""
"Somme de *t2* et *t3*. Ensuite ``t1 - t2 == t3`` et ``t1 - t3 == t2`` sont "
"des expressions vraies. (1)"

#: library/datetime.rst:329
msgid "``t1 = t2 - t3``"
msgstr "``t1 = t2 - t3``"

#: library/datetime.rst:329
#, fuzzy
msgid ""
"Difference of ``t2``  and ``t3``. Afterwards ``t1 == t2 - t3`` and ``t2 == "
"t1 + t3`` are true. (1)(6)"
msgstr ""
"Différence entre *t2* et *t3*. Ensuite ``t1 == t2 - t3`` et ``t2 == t1 + "
"t3`` sont des expressions vraies. (1)(6)"

#: library/datetime.rst:333
msgid "``t1 = t2 * i or t1 = i * t2``"
msgstr "``t1 = t2 * i or t1 = i * t2``"

#: library/datetime.rst:333
#, fuzzy
msgid ""
"Delta multiplied by an integer. Afterwards ``t1 // i == t2`` is true, "
"provided ``i != 0``."
msgstr ""
"Delta multiplié par un entier. Ensuite ``t1 // i == t2`` est vrai, en "
"admettant que ``i != 0``."

#: library/datetime.rst:337
#, fuzzy
msgid "In general, ``t1  * i == t1 * (i-1) + t1`` is true. (1)"
msgstr "De manière générale, ``t1 \\ i == t1 \\ (i-1) + t1`` est vrai. (1)"

#: library/datetime.rst:340
msgid "``t1 = t2 * f or t1 = f * t2``"
msgstr "``t1 = t2 * f or t1 = f * t2``"

#: library/datetime.rst:340
msgid ""
"Delta multiplied by a float. The result is rounded to the nearest multiple "
"of timedelta.resolution using round-half-to-even."
msgstr ""
"Delta multiplié par un flottant. Le résultat est arrondi au multiple le plus "
"proche de ``timedelta.resolution`` en utilisant la règle de l'arrondi au "
"pair le plus proche."

#: library/datetime.rst:344
msgid "``f = t2 / t3``"
msgstr "``f = t2 / t3``"

#: library/datetime.rst:344
#, fuzzy
msgid ""
"Division (3) of overall duration ``t2`` by interval unit ``t3``. Returns a :"
"class:`float` object."
msgstr ""
"Division (3) de la durée totale *t2* par l'unité d'intervalle *t3*. Renvoie "
"un objet :class:`float`."

#: library/datetime.rst:348
msgid "``t1 = t2 / f or t1 = t2 / i``"
msgstr "``t1 = t2 / f or t1 = t2 / i``"

#: library/datetime.rst:348
msgid ""
"Delta divided by a float or an int. The result is rounded to the nearest "
"multiple of timedelta.resolution using round-half-to-even."
msgstr ""
"Delta divisé par un flottant ou un entier. Le résultat est arrondi au "
"multiple le plus proche de ``timedelta.resolution`` en utilisant la règle de "
"l'arrondi au pair le plus proche."

#: library/datetime.rst:352
msgid "``t1 = t2 // i`` or ``t1 = t2 // t3``"
msgstr "``t1 = t2 // i`` or ``t1 = t2 // t3``"

#: library/datetime.rst:352
msgid ""
"The floor is computed and the remainder (if any) is thrown away. In the "
"second case, an integer is returned. (3)"
msgstr ""
"Le quotient est calculé et le reste (s'il y en a un) est ignoré. Dans le "
"second cas, un entier est renvoyé. (3)"

#: library/datetime.rst:356
msgid "``t1 = t2 % t3``"
msgstr "``t1 = t2 % t3``"

#: library/datetime.rst:356
msgid "The remainder is computed as a :class:`timedelta` object. (3)"
msgstr "Le reste est calculé comme un objet de type :class:`timedelta`. (3)"

#: library/datetime.rst:359
msgid "``q, r = divmod(t1, t2)``"
msgstr "``q, r = divmod(t1, t2)``"

#: library/datetime.rst:359
#, fuzzy
msgid ""
"Computes the quotient and the remainder: ``q = t1 // t2`` (3) and ``r = t1 % "
"t2``. ``q`` is an integer and ``r`` is a :class:`timedelta` object."
msgstr ""
"Calcule le quotient et le reste : ``q = t1 // t2`` (3) et ``r = t1 % t2``. q "
"est un entier et r est un objet :class:`timedelta`."

#: library/datetime.rst:364
msgid "``+t1``"
msgstr "``+t1``"

#: library/datetime.rst:364
msgid "Returns a :class:`timedelta` object with the same value. (2)"
msgstr "Renvoie un objet :class:`timedelta` avec la même valeur. (2)"

#: library/datetime.rst:367
msgid "``-t1``"
msgstr "``-t1``"

#: library/datetime.rst:367
#, fuzzy
msgid ""
"Equivalent to ``timedelta(-t1.days, -t1.seconds, -t1.microseconds)``, and to "
"``t1 * -1``. (1)(4)"
msgstr ""
"équivalent à :class:`timedelta`\\ (*-t1.days*, *-t1.seconds*, *-t1."
"microseconds*), et à ``t1 * -1``. (1)(4)"

#: library/datetime.rst:371
msgid "``abs(t)``"
msgstr "``abs(t)``"

#: library/datetime.rst:371
#, fuzzy
msgid ""
"Equivalent to ``+t`` when ``t.days >= 0``, and to ``-t`` when ``t.days < "
"0``. (2)"
msgstr ""
"équivalent à ``+t`` quand ``t.days >= 0``, et à ``-t`` quand ``t.days < 0``. "
"(2)"

#: library/datetime.rst:374
msgid "``str(t)``"
msgstr "``str(t)``"

#: library/datetime.rst:374
msgid ""
"Returns a string in the form ``[D day[s], ][H]H:MM:SS[.UUUUUU]``, where D is "
"negative for negative ``t``. (5)"
msgstr ""
"Renvoie une chaîne de la forme ``[D day[s], ][H]H:MM:SS[.UUUUUU]``, où D est "
"négatif pour ``t`` négatif. (5)"

#: library/datetime.rst:378
msgid "``repr(t)``"
msgstr "``repr(t)``"

#: library/datetime.rst:378
msgid ""
"Returns a string representation of the :class:`timedelta` object as a "
"constructor call with canonical attribute values."
msgstr ""
"Renvoie une chaîne de la forme objet :class:`timedelta` comme un appel "
"construit avec des valeurs d'attributs canoniques."

#: library/datetime.rst:623 library/datetime.rst:2553
msgid "Notes:"
msgstr "Notes :"

#: library/datetime.rst:387
msgid "This is exact but may overflow."
msgstr "Ceci est exact, mais peut provoquer un débordement."

#: library/datetime.rst:390
msgid "This is exact and cannot overflow."
msgstr "Ceci est exact, et ne peut pas provoquer un débordement."

#: library/datetime.rst:393
#, fuzzy
msgid "Division by zero raises :exc:`ZeroDivisionError`."
msgstr "Une division par 0 lève une :exc:`ZeroDivisionError`."

#: library/datetime.rst:396
#, fuzzy
msgid "``-timedelta.max`` is not representable as a :class:`timedelta` object."
msgstr ""
"*-timedelta.max* n'est pas représentable avec un objet :class:`timedelta`."

#: library/datetime.rst:399
msgid ""
"String representations of :class:`timedelta` objects are normalized "
"similarly to their internal representation. This leads to somewhat unusual "
"results for negative timedeltas. For example::"
msgstr ""
"La représentation en chaîne des objets :class:`timedelta` est normalisée "
"similairement à leur représentation interne. Cela amène à des résultats "
"inhabituels pour des *timedeltas* négatifs. Par exemple ::"

#: library/datetime.rst:403
msgid ""
">>> timedelta(hours=-5)\n"
"datetime.timedelta(days=-1, seconds=68400)\n"
">>> print(_)\n"
"-1 day, 19:00:00"
msgstr ""

#: library/datetime.rst:409
msgid ""
"The expression ``t2 - t3`` will always be equal to the expression ``t2 + (-"
"t3)`` except when t3 is equal to ``timedelta.max``; in that case the former "
"will produce a result while the latter will overflow."
msgstr ""
"L'expression ``t2 - t3`` est toujours égale à l'expression ``t2 + (-t3)`` "
"sauf si ``t3`` vaut ``timedelta.max`` ; dans ce cas, la première expression "
"produit une valeur alors que la seconde produit un débordement."

#: library/datetime.rst:413
msgid ""
"In addition to the operations listed above, :class:`timedelta` objects "
"support certain additions and subtractions with :class:`date` and :class:`."
"datetime` objects (see below)."
msgstr ""
"En plus des opérations listées ci-dessus, les objets :class:`timedelta` "
"implémentent certaines additions et soustractions avec des objets :class:"
"`date` et :class:`datetime` (voir ci-dessous)."

#: library/datetime.rst:417
msgid ""
"Floor division and true division of a :class:`timedelta` object by another :"
"class:`timedelta` object are now supported, as are remainder operations and "
"the :func:`divmod` function. True division and multiplication of a :class:"
"`timedelta` object by a :class:`float` object are now supported."
msgstr ""
"La division entière et la vraie division d'un objet :class:`timedelta` par "
"un autre :class:`timedelta` sont maintenant gérées, comme le sont les "
"opérations de reste euclidien et la fonction :func:`divmod`. La vraie "
"division et la multiplication d'un objet :class:`timedelta` par un :class:"
"`float` sont maintenant implémentées."

#: library/datetime.rst:423
#, fuzzy
msgid ":class:`timedelta` objects support equality and order comparisons."
msgstr ""
"Les comparaisons des objets :class:`timedelta` sont gérées, avec quelques "
"réserves."

#: library/datetime.rst:425
msgid ""
"In Boolean contexts, a :class:`timedelta` object is considered to be true if "
"and only if it isn't equal to ``timedelta(0)``."
msgstr ""
"Dans les contextes booléens, un objet :class:`timedelta` est considéré comme "
"vrai si et seulement s'il n'est pas égal à ``timedelta(0)``."

#: library/datetime.rst:649 library/datetime.rst:1847
msgid "Instance methods:"
msgstr "Méthodes de l'instance :"

#: library/datetime.rst:432
msgid ""
"Return the total number of seconds contained in the duration. Equivalent to "
"``td / timedelta(seconds=1)``. For interval units other than seconds, use "
"the division form directly (e.g. ``td / timedelta(microseconds=1)``)."
msgstr ""
"Renvoie le nombre total de secondes contenues dans la durée. Équivalent à "
"``td / timedelta(seconds=1)``. Pour un intervalle dont l'unité n'est pas la "
"seconde, utilisez directement la division (par exemple, ``td / "
"timedelta(microseconds=1)``)."

#: library/datetime.rst:436
msgid ""
"Note that for very large time intervals (greater than 270 years on most "
"platforms) this method will lose microsecond accuracy."
msgstr ""
"Notez que pour des intervalles de temps très larges (supérieurs à 270 ans "
"sur la plupart des plateformes), cette méthode perdra la précision des "
"microsecondes."

#: library/datetime.rst:442
msgid "Examples of usage: :class:`timedelta`"
msgstr "Exemples d'utilisation de la classe :class:`timedelta` :"

#: library/datetime.rst:444
msgid "An additional example of normalization::"
msgstr "Un exemple supplémentaire de normalisation ::"

#: library/datetime.rst:446
msgid ""
">>> # Components of another_year add up to exactly 365 days\n"
">>> from datetime import timedelta\n"
">>> year = timedelta(days=365)\n"
">>> another_year = timedelta(weeks=40, days=84, hours=23,\n"
"...                          minutes=50, seconds=600)\n"
">>> year == another_year\n"
"True\n"
">>> year.total_seconds()\n"
"31536000.0"
msgstr ""

#: library/datetime.rst:456
msgid "Examples of :class:`timedelta` arithmetic::"
msgstr "Exemples d'arithmétique avec la classe :class:`timedelta` ::"

#: library/datetime.rst:458
msgid ""
">>> from datetime import timedelta\n"
">>> year = timedelta(days=365)\n"
">>> ten_years = 10 * year\n"
">>> ten_years\n"
"datetime.timedelta(days=3650)\n"
">>> ten_years.days // 365\n"
"10\n"
">>> nine_years = ten_years - year\n"
">>> nine_years\n"
"datetime.timedelta(days=3285)\n"
">>> three_years = nine_years // 3\n"
">>> three_years, three_years.days // 365\n"
"(datetime.timedelta(days=1095), 3)"
msgstr ""

#: library/datetime.rst:475
msgid ":class:`date` Objects"
msgstr "Objets :class:`date`"

#: library/datetime.rst:477
msgid ""
"A :class:`date` object represents a date (year, month and day) in an "
"idealized calendar, the current Gregorian calendar indefinitely extended in "
"both directions."
msgstr ""
"Un objet :class:`date` représente une date (année, mois et jour) dans un "
"calendrier idéal, le calendrier grégorien actuel étant indéfiniment étendu "
"dans les deux sens."

#: library/datetime.rst:481
msgid ""
"January 1 of year 1 is called day number 1, January 2 of year 1 is called "
"day number 2, and so on. [#]_"
msgstr ""
"Le 1 :sup:`er` janvier de l'année 1 est appelé jour numéro 1, le 2 janvier "
"de l'année 1 est appelé jour numéro 2, et ainsi de suite. [#]_"

#: library/datetime.rst:486
msgid ""
"All arguments are required. Arguments must be integers, in the following "
"ranges:"
msgstr ""
"Tous les arguments sont requis. Les arguments peuvent être des entiers, dans "
"les intervalles suivants :"

#: library/datetime.rst:489
msgid "``MINYEAR <= year <= MAXYEAR``"
msgstr "``MINYEAR <= year <= MAXYEAR``"

#: library/datetime.rst:490
msgid "``1 <= month <= 12``"
msgstr "``1 <= month <= 12``"

#: library/datetime.rst:491
msgid "``1 <= day <= number of days in the given month and year``"
msgstr "``1 <= day <= nombre de jours dans le mois et l'année donnés``"

#: library/datetime.rst:864
msgid ""
"If an argument outside those ranges is given, :exc:`ValueError` is raised."
msgstr ""
"Si un argument est donné en dehors de ces intervalles, une :exc:`ValueError` "
"est levée."

#: library/datetime.rst:869
msgid "Other constructors, all class methods:"
msgstr "Autres constructeurs, méthodes de classe :"

#: library/datetime.rst:500
msgid "Return the current local date."
msgstr "Renvoie la date locale courante."

#: library/datetime.rst:502
msgid "This is equivalent to ``date.fromtimestamp(time.time())``."
msgstr "Cela est équivalent à ``date.fromtimestamp(time.time())``."

#: library/datetime.rst:506
msgid ""
"Return the local date corresponding to the POSIX timestamp, such as is "
"returned by :func:`time.time`."
msgstr ""
"Renvoie la date locale correspondant à l'horodatage POSIX, telle que "