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: 2020-05-23 11:38+0200\n"
"PO-Revision-Date: 2020-06-01 17:38+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: Gtranslator 3.36.0\n"

#: library/datetime.rst:2
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
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:25
msgid "Module :mod:`calendar`"
msgstr "Module :mod:`calendar`"

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

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

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

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

#: library/datetime.rst:31
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:36
msgid "Aware and Naive Objects"
msgstr "Objets avisés et naïfs"

#: library/datetime.rst:38
msgid ""
"Date and time objects may be categorized as \"aware\" or \"naive\" depending "
"on whether or not they include timezone 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:41
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:47
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 timezone 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:54
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:60
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 timezones with fixed offsets from UTC, such as UTC itself "
"or North American EST and EDT timezones. Supporting timezones 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:69
msgid "Constants"
msgstr "Constantes"

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

#: library/datetime.rst:75
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:81
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:85
msgid "Available Types"
msgstr "Types disponibles"

#: library/datetime.rst:90
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:98
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:107
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:115
msgid ""
"A duration expressing the difference between two :class:`date`, :class:`."
"time`, or :class:`.datetime` 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:122
#, fuzzy
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 de base 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:130
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 de base abstraite :class:`tzinfo` en "
"tant qu'offset fixe par rapport au temps UTC."

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

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

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

#: library/datetime.rst:150
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:154
msgid ""
"Objects of these types are hashable, meaning that they can be used as "
"dictionary keys."
msgstr ""
"Les objets de ces types sont hachables, ce qui signifie qu'ils peuvent être "
"utilisés comme clés de dictionnaire."

#: library/datetime.rst:156
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:159
msgid "Determining if an Object is Aware or Naive"
msgstr "Catégorisation d'un objet en « avisé » ou « naïf »"

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

#: library/datetime.rst:163
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:165
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:167
msgid "``d.tzinfo`` is not ``None``"
msgstr "``d.tzinfo`` ne vaut pas ``None``"

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

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

#: library/datetime.rst:172
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:174
msgid "``t.tzinfo`` is not ``None``"
msgstr "``t.tzinfo`` ne vaut pas ``None``"

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

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

#: library/datetime.rst:179
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:185
msgid ":class:`timedelta` Objects"
msgstr "Objets :class:`timedelta`"

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

#: library/datetime.rst:192
#, 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 paramètres sont optionnels et ont ``0`` comme valeur par défaut. "
"Les paramètres peuvent être des entiers ou des flottants et ils peuvent être "
"positifs ou négatifs."

#: library/datetime.rst:195
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. Tous les paramètres sont convertis dans ces unités :"

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

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

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

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

#: library/datetime.rst:203
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:206
msgid "``0 <= microseconds < 1000000``"
msgstr "``0 <= microseconds < 1000000``"

#: library/datetime.rst:207
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:208
msgid "``-999999999 <= days <= 999999999``"
msgstr "``-999999999 <= days <= 999999999``"

#: library/datetime.rst:210
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:228
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:235
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:238
#, fuzzy
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:541 library/datetime.rst:1662 library/datetime.rst:2256
msgid "Class attributes:"
msgstr "Attributs de la classe :"

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

#: library/datetime.rst:256
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:262
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:265
msgid ""
"Note that, because of normalization, ``timedelta.max`` > ``-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:559 library/datetime.rst:1682
msgid "Instance attributes (read-only):"
msgstr "Attributs de l'instance (en lecture seule) :"

#: library/datetime.rst:271
msgid "Attribute"
msgstr "Attribut"

#: library/datetime.rst:271
msgid "Value"
msgstr "Valeur"

#: library/datetime.rst:273
msgid "``days``"
msgstr "``days``"

#: library/datetime.rst:273
msgid "Between -999999999 and 999999999 inclusive"
msgstr "Entre -999999999 et 999999999 inclus"

#: library/datetime.rst:275
msgid "``seconds``"
msgstr "``seconds``"

#: library/datetime.rst:275
msgid "Between 0 and 86399 inclusive"
msgstr "Entre 0 et 86399 inclus"

#: library/datetime.rst:277
msgid "``microseconds``"
msgstr "``microseconds``"

#: library/datetime.rst:277
msgid "Between 0 and 999999 inclusive"
msgstr "Entre 0 et 999999 inclus"

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

#: library/datetime.rst:579 library/datetime.rst:1120
msgid "Operation"
msgstr "Opération"

#: library/datetime.rst:579 library/datetime.rst:1120
msgid "Result"
msgstr "Résultat"

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

#: library/datetime.rst:287
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:290
msgid "``t1 = t2 - t3``"
msgstr "``t1 = t2 - t3``"

#: library/datetime.rst:290
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:294
msgid "``t1 = t2 * i or t1 = i * t2``"
msgstr "``t1 = t2 * i or t1 = i * t2``"

#: library/datetime.rst:294
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:298
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:301
msgid "``t1 = t2 * f or t1 = f * t2``"
msgstr "``t1 = t2 * f or t1 = f * t2``"

#: library/datetime.rst:301
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:305
msgid "``f = t2 / t3``"
msgstr "``f = t2 / t3``"

#: library/datetime.rst:305
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:309
msgid "``t1 = t2 / f or t1 = t2 / i``"
msgstr "``t1 = t2 / f or t1 = t2 / i``"

#: library/datetime.rst:309
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:313
msgid "``t1 = t2 // i`` or ``t1 = t2 // t3``"
msgstr "``t1 = t2 // i`` or ``t1 = t2 // t3``"

#: library/datetime.rst:313
#, fuzzy
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:317
msgid "``t1 = t2 % t3``"
msgstr "``t1 = t2 % t3``"

#: library/datetime.rst:317
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:320
msgid "``q, r = divmod(t1, t2)``"
msgstr "``q, r = divmod(t1, t2)``"

#: library/datetime.rst:320
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:325
msgid "``+t1``"
msgstr "``+t1``"

#: library/datetime.rst:325
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:328
msgid "``-t1``"
msgstr "``-t1``"

#: library/datetime.rst:328
msgid ""
"equivalent to :class:`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:333
msgid "``abs(t)``"
msgstr "``abs(t)``"

#: library/datetime.rst:333
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:336
msgid "``str(t)``"
msgstr "``str(t)``"

#: library/datetime.rst:336
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:340
msgid "``repr(t)``"
msgstr "``repr(t)``"

#: library/datetime.rst:340
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:593 library/datetime.rst:2468
msgid "Notes:"
msgstr "Notes :"

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

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

#: library/datetime.rst:355
msgid "Division by 0 raises :exc:`ZeroDivisionError`."
msgstr "Une division par 0 provoque :exc:`ZeroDivisionError`."

#: library/datetime.rst:358
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:361
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 de caractères 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:371
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 lève une ``OverflowError``."

#: library/datetime.rst:375
#, fuzzy
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:379
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:386
msgid ""
"Comparisons of :class:`timedelta` objects are supported, with some caveats."
msgstr ""
"Les comparaisons des objets :class:`timedelta` sont gérées, avec quelques "
"réserves."

#: library/datetime.rst:388
msgid ""
"The comparisons ``==`` or ``!=`` *always* return a :class:`bool`, no matter "
"the type of the compared object::"
msgstr ""
"Les comparaisons ``==`` ou ``!=`` renvoient *toujours* un :class:`bool`, "
"quel que soit le type de l'objet comparé ::"

#: library/datetime.rst:399
msgid ""
"For all other comparisons (such as ``<`` and ``>``), when a :class:"
"`timedelta` object is compared to an object of a different type, :exc:"
"`TypeError` is raised::"
msgstr ""
"Pour toutes les autres comparaisons (telles que ``<`` et ``>``), lorsqu'un "
"objet :class:`timedelta` est comparé à un objet d'un type différent, :exc:"
"`TypeError` est levée ::"

#: library/datetime.rst:410
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:622 library/datetime.rst:1779
msgid "Instance methods:"
msgstr "Méthodes de l'instance :"

#: library/datetime.rst:417
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:421
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:427
msgid "Examples of usage: :class:`timedelta`"
msgstr "Exemples d'utilisation de la classe :class:`timedelta` :"

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

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

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

#: library/datetime.rst:462
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:466
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:471
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:474
msgid "``MINYEAR <= year <= MAXYEAR``"
msgstr "``MINYEAR <= year <= MAXYEAR``"

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

#: library/datetime.rst:476
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:836
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:841
msgid "Other constructors, all class methods:"
msgstr "Autres constructeurs, méthodes de classe :"

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

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

#: library/datetime.rst:491
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 "
"renvoyée par :func:`time.time`."

#: library/datetime.rst:494
msgid ""
"This may raise :exc:`OverflowError`, if the timestamp is out of the range of "
"values supported by the platform C :c:func:`localtime` function, and :exc:"
"`OSError` on :c:func:`localtime` failure. It's common for this to be "
"restricted to years from 1970 through 2038. Note that on non-POSIX systems "
"that include leap seconds in their notion of a timestamp, leap seconds are "
"ignored by :meth:`fromtimestamp`."
msgstr ""
"Elle peut lever une :exc:`OverflowError`, si l'horodatage est en dehors des "
"bornes gérées par la fonction C :c:func:`localtime` de la plateforme, et "
"une :exc:`OSError` en cas d'échec de :c:func:`localtime`. Il est commun "
"d'être restreint aux années entre 1970 et 2038. Notez que sur les systèmes "
"non *POSIX* qui incluent les secondes intercalaires dans leur notion "
"d'horodatage, ces secondes sont ignorées par :meth:`fromtimestamp`."

#: library/datetime.rst:501
msgid ""
"Raise :exc:`OverflowError` instead of :exc:`ValueError` if the timestamp is "
"out of the range of values supported by the platform C :c:func:`localtime` "
"function. Raise :exc:`OSError` instead of :exc:`ValueError` on :c:func:"
"`localtime` failure."
msgstr ""
"Lève une :exc:`OverflowError` plutôt qu'une :exc:`ValueError` si "
"l'horodatage (*timestamp* en anglais) est en dehors des bornes gérées par la "
"fonction C :c:func:`localtime` de la plateforme. Lève une :exc:`OSError` "
"plutôt qu'une :exc:`ValueError` en cas d'échec de :c:func:`localtime`."

#: library/datetime.rst:510
msgid ""
"Return the date corresponding to the proleptic Gregorian ordinal, where "
"January 1 of year 1 has ordinal 1."
msgstr ""
"Renvoie la date correspondant à l'ordinal grégorien proleptique, où le 1er "
"janvier de l'an 1 a l'ordinal 1."

#: library/datetime.rst:513
msgid ""
":exc:`ValueError` is raised unless ``1 <= ordinal <= date.max.toordinal()``. "
"For any date *d*, ``date.fromordinal(d.toordinal()) == d``."
msgstr ""
":exc:`ValueError` est levée à moins que ``1 <= ordinal <= date.max."
"toordinal()``. Pour toute date *d*, ``date.fromordinal(d.toordinal()) == d``."

#: library/datetime.rst:520
#, fuzzy
msgid ""
"Return a :class:`date` corresponding to a *date_string* given in the format "
"``YYYY-MM-DD``::"
msgstr ""
"Renvoie une :class:`date` correspondant à *date_string* dans le format émis "
"par :meth:`date.isoformat`. Spécifiquement, cette fonction gère des chaînes "
"dans le(s) format(s) ``YYYY-MM-DD`` ::"

#: library/datetime.rst:527
msgid ""
"This is the inverse of :meth:`date.isoformat`. It only supports the format "
"``YYYY-MM-DD``."
msgstr ""
"C'est la réciproque de :meth:`date.isoformat`. Elle ne prend en charge que "
"le format ``YYYY-MM-DD``."

#: library/datetime.rst:535
msgid ""
"Return a :class:`date` corresponding to the ISO calendar date specified by "
"year, week and day. This is the inverse of the function :meth:`date."
"isocalendar`."
msgstr ""
"Renvoie une :class:`date` correspondant à la date du calendrier ISO définie "
"par l'année, la semaine et le jour. C'est la réciproque de la fonction :meth:"
"`date.isocalendar`."

#: library/datetime.rst:545
msgid "The earliest representable date, ``date(MINYEAR, 1, 1)``."
msgstr "La plus vieille date représentable, ``date(MINYEAR, 1, 1)``."

#: library/datetime.rst:550
msgid "The latest representable date, ``date(MAXYEAR, 12, 31)``."
msgstr "La dernière date représentable, ``date(MAXYEAR, 12, 31)``."

#: library/datetime.rst:555
msgid ""
"The smallest possible difference between non-equal date objects, "
"``timedelta(days=1)``."
msgstr ""
"La plus petite différence possible entre deux objets dates non-égaux, "
"``timedelta(days=1)``."

#: library/datetime.rst:1068
msgid "Between :const:`MINYEAR` and :const:`MAXYEAR` inclusive."
msgstr "Entre :const:`MINYEAR` et :const:`MAXYEAR` inclus."

#: library/datetime.rst:1073
msgid "Between 1 and 12 inclusive."
msgstr "Entre 1 et 12 inclus."

#: library/datetime.rst:1078
msgid "Between 1 and the number of days in the given month of the given year."
msgstr "Entre 1 et le nombre de jours du mois donné de l'année donnée."

#: library/datetime.rst:581
msgid "``date2 = date1 + timedelta``"
msgstr "``date2 = date1 + timedelta``"

#: library/datetime.rst:581
#, fuzzy
msgid "*date2* is ``timedelta.days`` days removed from *date1*. (1)"
msgstr ""
"*date2* est décalée de ``timedelta.days`` jours par rapport à *date1*.  (1)"

#: library/datetime.rst:584
msgid "``date2 = date1 - timedelta``"
msgstr "``date2 = date1 - timedelta``"

#: library/datetime.rst:584
msgid "Computes *date2* such that ``date2 + timedelta == date1``. (2)"
msgstr "Calcule *date2* de façon à avoir ``date2 + timedelta == date1``. (2)"

#: library/datetime.rst:587
msgid "``timedelta = date1 - date2``"
msgstr "``timedelta = date1 - date2``"

#: library/datetime.rst:1126
msgid "\\(3)"
msgstr "\\(3)"

#: library/datetime.rst:589
msgid "``date1 < date2``"
msgstr "``date1 < date2``"

#: library/datetime.rst:589
msgid ""
"*date1* is considered less than *date2* when *date1* precedes *date2* in "
"time. (4)"
msgstr ""
"*date1* est considérée comme inférieure à *date2* quand *date1* précède "
"*date2* dans le temps. (4)"

#: library/datetime.rst:596
msgid ""
"*date2* is moved forward in time if ``timedelta.days > 0``, or backward if "
"``timedelta.days < 0``. Afterward ``date2 - date1 == timedelta.days``. "
"``timedelta.seconds`` and ``timedelta.microseconds`` are ignored. :exc:"
"`OverflowError` is raised if ``date2.year`` would be smaller than :const:"
"`MINYEAR` or larger than :const:`MAXYEAR`."
msgstr ""
"*date2* est déplacée en avant dans le temps si ``timedelta.days > 0``, ou en "
"arrière si ``timedelta.days < 0``. Après quoi ``date2 - date1 == timedelta."
"days``. ``timedelta.seconds`` et ``timedelta.microseconds`` sont ignorés. "
"Une :exc:`OverflowError` est levée si ``date2.year`` devait être inférieure "
"à :const:`MINYEAR` ou supérieure à :const:`MAXYEAR`."

#: library/datetime.rst:603
msgid "``timedelta.seconds`` and ``timedelta.microseconds`` are ignored."
msgstr "``timedelta.seconds`` et ``timedelta.microseconds`` sont ignorés."

#: library/datetime.rst:606
msgid ""
"This is exact, and cannot overflow. timedelta.seconds and timedelta."
"microseconds are 0, and date2 + timedelta == date1 after."
msgstr ""
"Cela est exact, et ne peut pas provoquer de débordement. ``timedelta."
"seconds`` et ``timedelta.microseconds`` valent ``0``, et ``date2 + timedelta "
"== date1`` après cela."

#: library/datetime.rst:610
msgid ""
"In other words, ``date1 < date2`` if and only if ``date1.toordinal() < date2."
"toordinal()``. Date comparison raises :exc:`TypeError` if the other "
"comparand isn't also a :class:`date` object. However, ``NotImplemented`` is "
"returned instead if the other comparand has a :meth:`timetuple` attribute. "
"This hook gives other kinds of date objects a chance at implementing mixed-"
"type comparison. If not, when a :class:`date` object is compared to an "
"object of a different type, :exc:`TypeError` is raised unless the comparison "
"is ``==`` or ``!=``. The latter cases return :const:`False` or :const:"
"`True`, respectively."
msgstr ""
"En d'autres termes, ``date1 < date2`` si et seulement si ``date1.toordinal() "
"< date2.toordinal()``. La comparaison de dates lève une :exc:`TypeError` si "
"l'autre opérande n'est pas un objet :class:`date`. Cependant, "
"``NotImplemented`` est renvoyé à la place si l'autre opérande a un attribut :"
"meth:`timetuple`. Cela permet à d'autres types d'objets dates d'avoir une "
"chance d'implémenter une comparaison entre types différents. Sinon, quand un "
"objet :class:`date` est comparé à un objet d'un type différent, une :exc:"
"`TypeError` est levée à moins que la comparaison soit ``==`` ou ``!=``. Ces "
"derniers cas renvoient respectivement :const:`False` et :const:`True`."

#: library/datetime.rst:620
msgid ""
"In Boolean contexts, all :class:`date` objects are considered to be true."
msgstr ""
"Dans des contextes booléens, tous les objets :class:`date` sont considérés "
"comme vrai."

#: library/datetime.rst:626
msgid ""
"Return a date with the same value, except for those parameters given new "
"values by whichever keyword arguments are specified."
msgstr ""
"Renvoie une date avec la même valeur, excepté pour les valeurs spécifiées "
"par arguments nommés."

#: library/datetime.rst:1822
#, fuzzy
msgid "Example::"
msgstr "Exemple ::"

#: library/datetime.rst:1304
msgid ""
"Return a :class:`time.struct_time` such as returned by :func:`time."
"localtime`."
msgstr ""
"Renvoie une :class:`time.struct_time` telle que renvoyée par :func:`time."
"localtime`."

#: library/datetime.rst:641
msgid "The hours, minutes and seconds are 0, and the DST flag is -1."
msgstr ""
"Les heures, minutes et secondes sont égales à 0 et le drapeau DST vaut -1."

#: library/datetime.rst:1306
msgid "``d.timetuple()`` is equivalent to::"
msgstr "``d.timetuple()`` est équivalent à ::"

#: library/datetime.rst:647
msgid ""
"where ``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` is the "
"day number within the current year starting with ``1`` for January 1st."
msgstr ""
"où ``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` est le "
"numéro du jour dans l'année courante commençant par ``1`` pour le 1\\ :sup:"
"`er` janvier."

#: library/datetime.rst:653
msgid ""
"Return the proleptic Gregorian ordinal of the date, where January 1 of year "
"1 has ordinal 1. For any :class:`date` object *d*, ``date.fromordinal(d."
"toordinal()) == d``."
msgstr ""
"Renvoie l'ordinal grégorien proleptique de la date, où le 1er janvier de "
"l'an 1 a l'ordinal 1. Pour tout objet :class:`date` *d*, ``date."
"fromordinal(d.toordinal()) == d``."

#: library/datetime.rst:660
msgid ""
"Return the day of the week as an integer, where Monday is 0 and Sunday is 6. "
"For example, ``date(2002, 12, 4).weekday() == 2``, a Wednesday. See also :"
"meth:`isoweekday`."
msgstr ""
"Renvoie le jour de la semaine sous forme de nombre, où lundi vaut 0 et "
"dimanche vaut 6. Par exemple, ``date(2002, 12, 4).weekday() == 2``, un "
"mercredi. Voir aussi :meth:`isoweekday`."

#: library/datetime.rst:667
msgid ""
"Return the day of the week as an integer, where Monday is 1 and Sunday is 7. "
"For example, ``date(2002, 12, 4).isoweekday() == 3``, a Wednesday. See also :"
"meth:`weekday`, :meth:`isocalendar`."
msgstr ""
"Renvoie le jour de la semaine sous forme de nombre, où lundi vaut 1 et "
"dimanche vaut 7. Par exemple, ``date(2002, 12, 4).isoweekday() == 3``, un "
"mercredi. Voir aussi :meth:`weekday`, :meth:`isocalendar`."

#: library/datetime.rst:674
msgid "Return a 3-tuple, (ISO year, ISO week number, ISO weekday)."
msgstr ""
"Renvoie un *tuple* de 3 éléments, (année ISO, numéro de semaine ISO, jour de "
"la semaine ISO)."

#: library/datetime.rst:676
msgid ""
"The ISO calendar is a widely used variant of the Gregorian calendar. [#]_"
msgstr ""
"Le calendrier ISO est une variante largement utilisée du calendrier "
"grégorien. [#]_"

#: library/datetime.rst:678
msgid ""
"The ISO year consists of 52 or 53 full weeks, and where a week starts on a "
"Monday and ends on a Sunday. The first week of an ISO year is the first "
"(Gregorian) calendar week of a year containing a Thursday. This is called "
"week number 1, and the ISO year of that Thursday is the same as its "
"Gregorian year."
msgstr ""
"Une année ISO est composée de 52 ou 53 semaines pleines, où chaque semaine "
"débute un lundi et se termine un dimanche. La première semaine d'une année "
"ISO est la première semaine calendaire (grégorienne) de l'année comportant "
"un jeudi. Elle est appelée la semaine numéro 1, et l'année ISO de ce jeudi "
"est la même que son année Grégorienne."

#: library/datetime.rst:683
msgid ""
"For example, 2004 begins on a Thursday, so the first week of ISO year 2004 "
"begins on Monday, 29 Dec 2003 and ends on Sunday, 4 Jan 2004::"
msgstr ""
"Par exemple, l'année 2004 débute un jeudi, donc la première semaine de "
"l'année ISO 2004 débute le lundi 29 décembre 2003 et se termine le dimanche "
"4 janvier 2004 ::"

#: library/datetime.rst:694
msgid ""
"Return a string representing the date in ISO 8601 format, ``YYYY-MM-DD``::"
msgstr ""
"Renvoie une chaîne de caractères représentant la date au format ISO 8601, "
"\"YYYY-MM-DD\" ::"

#: library/datetime.rst:700
msgid "This is the inverse of :meth:`date.fromisoformat`."
msgstr "C'est la réciproque de :meth:`date.fromisoformat`."

#: library/datetime.rst:704
msgid "For a date *d*, ``str(d)`` is equivalent to ``d.isoformat()``."
msgstr "Pour une date *d*, ``str(d)`` est équivalent à ``d.isoformat()``."

#: library/datetime.rst:709
msgid "Return a string representing the date::"
msgstr "Renvoie une chaîne de caractères représentant la date ::"

#: library/datetime.rst:1490
msgid "``d.ctime()`` is equivalent to::"
msgstr "``d.ctime()`` est équivalent à ::"

#: library/datetime.rst:719
msgid ""
"on platforms where the native C :c:func:`ctime` function (which :func:`time."
"ctime` invokes, but which :meth:`date.ctime` does not invoke) conforms to "
"the C standard."
msgstr ""
"sur les plateformes où la fonction C native :c:func:`ctime` (que :func:`time."
"ctime` invoque, mais pas :meth:`date.ctime`) est conforme au standard C."

#: library/datetime.rst:726
msgid ""
"Return a string representing the date, controlled by an explicit format "
"string. Format codes referring to hours, minutes or seconds will see 0 "
"values. For a complete list of formatting directives, see :ref:`strftime-"
"strptime-behavior`."
msgstr ""
"Renvoie une chaîne de caractères représentant la date, contrôlée par une "
"chaîne de formatage explicite. Les codes de formatage se référant aux "
"heures, minutes ou secondes auront pour valeur 0. Pour une liste complète "
"des directives de formatage, voir :ref:`strftime-strptime-behavior`."

#: library/datetime.rst:734
msgid ""
"Same as :meth:`.date.strftime`. This makes it possible to specify a format "
"string for a :class:`.date` object in :ref:`formatted string literals <f-"
"strings>` and when using :meth:`str.format`. For a complete list of "
"formatting directives, see :ref:`strftime-strptime-behavior`."
msgstr ""
"Identique à :meth:`.date.strftime`. Cela permet de spécifier une chaîne de "
"formatage pour un objet :class:`.date` dans une :ref:`chaîne de formatage "
"littérale <f-strings>` et à l'utilisation de :meth:`str.format`. Pour une "
"liste complète des directives de formatage, voir :ref:`strftime-strptime-"
"behavior`."

#: library/datetime.rst:741
msgid "Examples of Usage: :class:`date`"
msgstr "Exemple d'utilisation de la classe :class:`date` :"

#: library/datetime.rst:743
msgid "Example of counting days to an event::"
msgstr "Exemple de décompte des jours avant un évènement ::"

#: library/datetime.rst:761
msgid "More examples of working with :class:`date`:"
msgstr "Plus d'exemples avec la classe :class:`date` :"

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

#: library/datetime.rst:812
msgid ""
"A :class:`.datetime` object is a single object containing all the "
"information from a :class:`date` object and a :class:`.time` object."
msgstr ""
"Un objet :class:`.datetime` est un seul et même objet contenant toute "
"l'information d'un objet :class:`date` et d'un objet :class:`time`."

#: library/datetime.rst:815
msgid ""
"Like a :class:`date` object, :class:`.datetime` assumes the current "
"Gregorian calendar extended in both directions; like a :class:`.time` "
"object, :class:`.datetime` assumes there are exactly 3600\\*24 seconds in "
"every day."
msgstr ""
"Comme un objet :class:`date`, un objet :class:`.datetime` utilise le "
"calendrier Grégorien actuel étendu vers le passé et le futur ; comme un "
"objet :class:`.time`, un objet :class:`.datetime` suppose qu'il y a "
"exactement 3600\\*24 secondes chaque jour."

#: library/datetime.rst:819
msgid "Constructor:"
msgstr "Constructeur :"

#: library/datetime.rst:823
msgid ""
"The *year*, *month* and *day* arguments are required. *tzinfo* may be "
"``None``, or an instance of a :class:`tzinfo` subclass. The remaining "
"arguments must be integers in the following ranges:"
msgstr ""
"Les arguments *year*, *month* et *day* sont requis. *tzinfo* peut être "
"``None`` ou une instance d'une sous-classe de :class:`tzinfo`. Les arguments "
"restant doivent être des nombres, dans les intervalles suivants :"

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

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

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

#: library/datetime.rst:1653
msgid "``0 <= hour < 24``,"
msgstr "``0 <= hour < 24``,"

#: library/datetime.rst:1654
msgid "``0 <= minute < 60``,"
msgstr "``0 <= minute < 60``,"

#: library/datetime.rst:1655
msgid "``0 <= second < 60``,"
msgstr "``0 <= second < 60``,"

#: library/datetime.rst:1656
msgid "``0 <= microsecond < 1000000``,"
msgstr "``0 <= microsecond < 1000000``,"

#: library/datetime.rst:1657
msgid "``fold in [0, 1]``."
msgstr "``fold in [0, 1]``."

#: library/datetime.rst:1225 library/datetime.rst:1789
msgid "Added the ``fold`` argument."
msgstr "Ajout de l'argument ``fold``."

#: library/datetime.rst:845
msgid "Return the current local datetime, with :attr:`.tzinfo` ``None``."
msgstr "Renvoie la date locale actuelle, avec :attr:`.tzinfo` ``None``."

#: library/datetime.rst:847
msgid "Equivalent to::"
msgstr "Équivalent à ::"

#: library/datetime.rst:851
msgid "See also :meth:`now`, :meth:`fromtimestamp`."
msgstr "Voir aussi :meth:`now`, :meth:`fromtimestamp`."

#: library/datetime.rst:853
msgid ""
"This method is functionally equivalent to :meth:`now`, but without a ``tz`` "
"parameter."
msgstr ""
"Cette méthode est fonctionnellement équivalente à :meth:`now`, mais sans le "
"paramètre ``tz``."

#: library/datetime.rst:858
msgid "Return the current local date and time."
msgstr "Renvoie la date et l'heure locale actuelle."

#: library/datetime.rst:860
msgid ""
"If optional argument *tz* is ``None`` or not specified, this is like :meth:"
"`today`, but, if possible, supplies more precision than can be gotten from "
"going through a :func:`time.time` timestamp (for example, this may be "
"possible on platforms supplying the C :c:func:`gettimeofday` function)."
msgstr ""
"Si l'argument optionnel *tz* est ``None`` ou n'est pas spécifié, la méthode "
"est similaire à :meth:`today`, mais, si possible, apporte plus de précisions "
"que ce qui peut être trouvé à travers un horodatage :func:`time.time` (par "
"exemple, cela peut être possible sur des plateformes fournissant la fonction "
"C :c:func:`gettimeofday`)."

#: library/datetime.rst:866
msgid ""
"If *tz* is not ``None``, it must be an instance of a :class:`tzinfo` "
"subclass, and the current date and time are converted to *tz*’s time zone."
msgstr ""
"Si *tz* n'est pas ``None``, il doit être une instance d'une sous-classe :"
"class:`tzinfo`, et la date et l'heure courantes sont converties vers le "
"fuseau horaire *tz*."

#: library/datetime.rst:869
msgid "This function is preferred over :meth:`today` and :meth:`utcnow`."
msgstr "Cette fonction est préférée à :meth:`today` et :meth:`utcnow`."

#: library/datetime.rst:874
msgid "Return the current UTC date and time, with :attr:`.tzinfo` ``None``."
msgstr ""
"Renvoie la date et l'heure UTC actuelle, avec :attr:`.tzinfo` ``None``."

#: library/datetime.rst:876
msgid ""
"This is like :meth:`now`, but returns the current UTC date and time, as a "
"naive :class:`.datetime` object. An aware current UTC datetime can be "
"obtained by calling ``datetime.now(timezone.utc)``. See also :meth:`now`."
msgstr ""
"C'est semblable à :meth:`now`, mais renvoie la date et l'heure UTC "
"courantes, comme un objet :class:`.datetime` naïf. Un *datetime* UTC courant "
"avisé peut être obtenu en appelant ``datetime.now(timezone.utc)``. Voir "
"aussi :meth:`now`."

#: library/datetime.rst:882
msgid ""
"Because naive ``datetime`` objects are treated by many ``datetime`` methods "
"as local times, it is preferred to use aware datetimes to represent times in "
"UTC. As such, the recommended way to create an object representing the "
"current time in UTC is by calling ``datetime.now(timezone.utc)``."
msgstr ""
"Parce que les objets naïfs ``datetime`` sont traités par de nombreuses "
"méthodes ``datetime`` comme des heures locales, il est préférable d'utiliser "
"les dates connues pour représenter les heures en UTC. En tant que tel, le "
"moyen recommandé pour créer un objet représentant l'heure actuelle en UTC "
"est d'appeler ``datetime.now(timezone.utc)``."

#: library/datetime.rst:890
msgid ""
"Return the local date and time corresponding to the POSIX timestamp, such as "
"is returned by :func:`time.time`. If optional argument *tz* is ``None`` or "
"not specified, the timestamp is converted to the platform's local date and "
"time, and the returned :class:`.datetime` object is naive."
msgstr ""
"Renvoie la date et l'heure locales correspondant à l'horodatage (*timestamp* "
"en anglais) *POSIX*, comme renvoyé par :func:`time.time`. Si l'argument "
"optionnel *tz* est ``None`` ou n'est pas spécifié, l'horodatage est converti "
"vers la date et l'heure locales de la plateforme, et l'objet :class:`."
"datetime` renvoyé est naïf."

#: library/datetime.rst:895
msgid ""
"If *tz* is not ``None``, it must be an instance of a :class:`tzinfo` "
"subclass, and the timestamp is converted to *tz*’s time zone."
msgstr ""
"Si *tz* n'est pas ``None``, il doit être une instance d'une sous-classe :"
"class:`tzinfo`, et l'horodatage (*timestamp* en anglais) est converti vers "
"le fuseau horaire *tz*."

#: library/datetime.rst:898
msgid ""
":meth:`fromtimestamp` may raise :exc:`OverflowError`, if the timestamp is "
"out of the range of values supported by the platform C :c:func:`localtime` "
"or :c:func:`gmtime` functions, and :exc:`OSError` on :c:func:`localtime` or :"
"c:func:`gmtime` failure. It's common for this to be restricted to years in "
"1970 through 2038. Note that on non-POSIX systems that include leap seconds "
"in their notion of a timestamp, leap seconds are ignored by :meth:"
"`fromtimestamp`, and then it's possible to have two timestamps differing by "
"a second that yield identical :class:`.datetime` objects. This method is "
"preferred over :meth:`utcfromtimestamp`."
msgstr ""
":meth:`fromtimestamp` peut lever une :exc:`OverflowError`, si l'horodatage "
"est en dehors de l'intervalle de valeurs gérées par les fonctions C :c:func:"
"`localtime` ou :c:func:`gmtime` de la plateforme, et une :exc:`OSError` en "
"cas d'échec de :c:func:`localtime` ou :c:func:`gmtime`. Il est courant "
"d'être restreint aux années de 1970 à 2038. Notez que sur les systèmes non "
"*POSIX* qui incluent les secondes intercalaires dans leur notion "
"d'horodatage, les secondes intercalaires sont ignorées par :meth:"
"`fromtimestamp`, et il est alors possible d'avoir deux horodatages différant "
"d'une seconde produisant un objet :class:`.datetime` identique. Cette "
"méthode est préférée à :meth:`utcfromtimestamp`."

#: library/datetime.rst:909
msgid ""
"Raise :exc:`OverflowError` instead of :exc:`ValueError` if the timestamp is "
"out of the range of values supported by the platform C :c:func:`localtime` "
"or :c:func:`gmtime` functions. Raise :exc:`OSError` instead of :exc:"
"`ValueError` on :c:func:`localtime` or :c:func:`gmtime` failure."
msgstr ""
"Lève une :exc:`OverflowError` plutôt qu'une :exc:`ValueError` si "
"l'horodatage est en dehors de l'intervalle de valeurs gérées par les "
"fonctions C :c:func:`localtime` ou :c:func:`gmtime` de la plateforme. Lève "
"une :exc:`OSError` plutôt qu'une :exc:`ValueError` en cas d'échec de :c:func:"
"`localtime` ou :c:func:`gmtime`."

#: library/datetime.rst:916
msgid ":meth:`fromtimestamp` may return instances with :attr:`.fold` set to 1."
msgstr ""
":meth:`fromtimestamp` peut renvoyer des instances avec l'attribut :attr:`."
"fold` à 1."

#: library/datetime.rst:921
msgid ""
"Return the UTC :class:`.datetime` corresponding to the POSIX timestamp, "
"with :attr:`.tzinfo` ``None``.  (The resulting object is naive.)"
msgstr ""
"Renvoie la classe UTC :class:`.datetime` correspondant à l'horodatage POSIX, "
"avec :attr:`.tzinfo` ``None`` (l'objet résultant est naïf)."

#: library/datetime.rst:924
msgid ""
"This may raise :exc:`OverflowError`, if the timestamp is out of the range of "
"values supported by the platform C :c:func:`gmtime` function, and :exc:"
"`OSError` on :c:func:`gmtime` failure. It's common for this to be restricted "
"to years in 1970 through 2038."
msgstr ""
"Cela peut lever une :exc:`OverflowError`, si l'horodatage est en dehors de "
"l'intervalle de valeurs gérées par la fonction C :c:func:`gmtime` de la "
"plateforme, et une :exc:`OSError` en cas d'échec de :c:func:`gmtime`. Il est "
"courant d'être restreint aux années de 1970 à 2038."

#: library/datetime.rst:929
msgid "To get an aware :class:`.datetime` object, call :meth:`fromtimestamp`::"
msgstr ""
"Pour obtenir un objet :class:`.datetime` avisé, appelez :meth:"
"`fromtimestamp` ::"

#: library/datetime.rst:933
msgid ""
"On the POSIX compliant platforms, it is equivalent to the following "
"expression::"
msgstr ""
"Sur les plateformes respectant *POSIX*, cela est équivalent à l'expression "
"suivante ::"

#: library/datetime.rst:938
msgid ""
"except the latter formula always supports the full years range: between :"
"const:`MINYEAR` and :const:`MAXYEAR` inclusive."
msgstr ""
"excepté que la dernière formule gère l'intervalle complet des années entre :"
"const:`MINYEAR` et :const:`MAXYEAR` incluses."

#: library/datetime.rst:943
msgid ""
"Because naive ``datetime`` objects are treated by many ``datetime`` methods "
"as local times, it is preferred to use aware datetimes to represent times in "
"UTC. As such, the recommended way to create an object representing a "
"specific timestamp in UTC is by calling ``datetime.fromtimestamp(timestamp, "
"tz=timezone.utc)``."
msgstr ""
"Parce que les objets naïfs ``datetime`` sont traités par de nombreuses "
"méthodes ``datetime`` comme des heures locales, il est préférable d'utiliser "
"les dates connues pour représenter les heures en UTC. En tant que tel, le "
"moyen recommandé pour créer un objet représentant un horodatage spécifique "
"en UTC est d'appeler ``datetime.fromtimestamp(timestamp, tz=timezone.utc)``."

#: library/datetime.rst:949
msgid ""
"Raise :exc:`OverflowError` instead of :exc:`ValueError` if the timestamp is "
"out of the range of values supported by the platform C :c:func:`gmtime` "
"function. Raise :exc:`OSError` instead of :exc:`ValueError` on :c:func:"
"`gmtime` failure."
msgstr ""
"Lève une :exc:`OverflowError` plutôt qu'une :exc:`ValueError` si "
"l'horodatage est en dehors de l'intervalle de valeurs gérées par la fonction "
"C :c:func:`gmtime` de la plateforme. Lève une :exc:`OSError` plutôt qu'une :"
"exc:`ValueError` en cas d'échec de :c:func:`gmtime`."

#: library/datetime.rst:958
msgid ""
"Return the :class:`.datetime` corresponding to the proleptic Gregorian "
"ordinal, where January 1 of year 1 has ordinal 1. :exc:`ValueError` is "
"raised unless ``1 <= ordinal <= datetime.max.toordinal()``. The hour, "
"minute, second and microsecond of the result are all 0, and :attr:`.tzinfo` "
"is ``None``."
msgstr ""
"Renvoie le :class:`.datetime` correspondant à l'ordinal du calendrier "
"grégorien proleptique, où le 1er janvier de l'an 1 a l'ordinal 1. Une :exc:"
"`ValueError` est levée à moins que ``1 <= ordinal <= datetime.max."
"toordinal()``. Les heures, minutes, secondes et microsecondes du résultat "
"valent toutes 0, et :attr:`.tzinfo` est ``None``."

#: library/datetime.rst:966
msgid ""
"Return a new :class:`.datetime` object whose date components are equal to "
"the given :class:`date` object's, and whose time components are equal to the "
"given :class:`.time` object's. If the *tzinfo* argument is provided, its "
"value is used to set the :attr:`.tzinfo` attribute of the result, otherwise "
"the :attr:`~.time.tzinfo` attribute of the *time* argument is used."
msgstr ""
"Renvoie un nouvel objet :class:`.datetime` dont les composants de date sont "
"égaux à ceux de l'objet :class:`date` donné, et dont les composants de temps "
"sont égaux à ceux de l'objet :class:`time` donné. Si l'argument *tzinfo* est "
"fourni, sa valeur est utilisée pour initialiser l'attribut :attr:`.tzinfo` "
"du résultat, autrement l'attribut :attr:`~.time.tzinfo` de l'argument *time* "
"est utilisé."

#: library/datetime.rst:973
msgid ""
"For any :class:`.datetime` object *d*, ``d == datetime.combine(d.date(), d."
"time(), d.tzinfo)``. If date is a :class:`.datetime` object, its time "
"components and :attr:`.tzinfo` attributes are ignored."
msgstr ""
"Pour tout objet :class:`.datetime` *d*`, ``d == datetime.combine(d.date(), d."
"time(), d.tzinfo)``. Si *date* est un objet :class:`.datetime`, ses "
"composants de temps et attributs :attr:`.tzinfo` sont ignorés."

#: library/datetime.rst:978
msgid "Added the *tzinfo* argument."
msgstr "Ajout de l'argument *tzinfo*."

#: library/datetime.rst:984
#, fuzzy
msgid ""
"Return a :class:`.datetime` corresponding to a *date_string* in one of the "
"formats emitted by :meth:`date.isoformat` and :meth:`datetime.isoformat`."
msgstr ""
"Renvoie une :class:`date` correspondant à *date_string* dans le format émis "
"par :meth:`date.isoformat`. Spécifiquement, cette fonction gère des chaînes "
"dans le(s) format(s) ``YYYY-MM-DD``."

#: library/datetime.rst:987
msgid "Specifically, this function supports strings in the format:"
msgstr ""
"Plus précisément, cette fonction prend en charge les chaînes de caractères "
"dans le format :"

#: library/datetime.rst:993
msgid "where ``*`` can match any single character."
msgstr "où ``*`` peut correspondre à n'importe quel caractère."

#: library/datetime.rst:997
msgid ""
"This does *not* support parsing arbitrary ISO 8601 strings - it is only "
"intended as the inverse operation of :meth:`datetime.isoformat`. A more full-"
"featured ISO 8601 parser, ``dateutil.parser.isoparse`` is available in the "
"third-party package `dateutil <https://dateutil.readthedocs.io/en/stable/"
"parser.html#dateutil.parser.isoparse>`__."
msgstr ""
"Ceci ne prend pas en charge l'analyse arbitraire des chaînes de caractères "
"ISO 8601 - il est uniquement destiné à l'opération réciproque de :meth:"
"`datetime.isoformat`. Un analyseur ISO 8601 plus complet, ``dateutil.parser."
"isoparse`` est disponible dans le paquet tiers `dateutil <https://dateutil."
"readthedocs.io/en/stable/parser.html#dateutil.parser.isoparse>`__."

#: library/datetime.rst:1419 library/datetime.rst:1766
msgid "Examples::"
msgstr "Exemples ::"

#: library/datetime.rst:1021
msgid ""
"Return a :class:`.datetime` corresponding to the ISO calendar date specified "
"by year, week and day. The non-date components of the datetime are populated "
"with their normal default values. This is the inverse of the function :meth:"
"`datetime.isocalendar`."
msgstr ""
"Renvoie une classe :class:`.datetime` correspondant à la date du calendrier "
"ISO spécifiée par année, semaine et jour. Les composantes ne relevant pas de "
"la date de *datetime* sont renseignées avec leurs valeurs par défaut "
"normales. C'est la réciproque de la fonction :meth:`datetime.isocalendar`."

#: library/datetime.rst:1030
msgid ""
"Return a :class:`.datetime` corresponding to *date_string*, parsed according "
"to *format*."
msgstr ""
"Renvoie une classe :class:`.datetime` correspondant à *date_string*, "
"analysée selon *format*."

#: library/datetime.rst:1033
msgid "This is equivalent to::"
msgstr "C’est équivalent à ::"

#: library/datetime.rst:1037
msgid ""
":exc:`ValueError` is raised if the date_string and format can't be parsed "
"by :func:`time.strptime` or if it returns a value which isn't a time tuple. "
"For a complete list of formatting directives, see :ref:`strftime-strptime-"
"behavior`."
msgstr ""
"Une :exc:`ValueError` est levée si *date_string* et *format* ne peuvent être "
"analysés par :func:`time.strptime` ou si elle renvoie une valeur qui n'est "
"pas un *n*-uplet de temps. Pour une liste complète des directives de "
"formatage, voir :ref:`strftime-strptime-behavior`."

#: library/datetime.rst:1048
msgid ""
"The earliest representable :class:`.datetime`, ``datetime(MINYEAR, 1, 1, "
"tzinfo=None)``."
msgstr ""
"Le plus ancien :class:`.datetime` représentable, ``datetime(MINYEAR, 1, 1, "
"tzinfo=None)``."

#: library/datetime.rst:1054
msgid ""
"The latest representable :class:`.datetime`, ``datetime(MAXYEAR, 12, 31, 23, "
"59, 59, 999999, tzinfo=None)``."
msgstr ""
"Le dernier :class:`.datetime` représentable, ``datetime(MAXYEAR, 12, 31, 23, "
"59, 59, 999999, tzinfo=None)``."

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

#: library/datetime.rst:1686
msgid "In ``range(24)``."
msgstr "Dans ``range(24)``."

#: library/datetime.rst:1093 library/datetime.rst:1696
msgid "In ``range(60)``."
msgstr "Dans ``range(60)``."

#: library/datetime.rst:1701
msgid "In ``range(1000000)``."
msgstr "Dans ``range(1000000)``."

#: library/datetime.rst:1103
msgid ""
"The object passed as the *tzinfo* argument to the :class:`.datetime` "
"constructor, or ``None`` if none was passed."
msgstr ""
"L'objet passé en tant que paramètre *tzinfo* du constructeur de la classe :"
"class:`.datetime` ou ``None`` si aucun n'a été donné."

#: library/datetime.rst:1712
msgid ""
"In ``[0, 1]``. Used to disambiguate wall times during a repeated interval. "
"(A repeated interval occurs when clocks are rolled back at the end of "
"daylight saving time or when the UTC offset for the current zone is "
"decreased for political reasons.) The value 0 (1) represents the earlier "
"(later) of the two moments with the same wall time representation."
msgstr ""
"Dans ``[0, 1]``. Utilisé pour désambiguïser les heures dans un intervalle "
"répété. (Un intervalle répété apparaît quand l'horloge est retardée à la fin "
"de l'heure d'été ou quand le décalage horaire UTC du fuseau courant est "
"décrémenté pour des raisons politiques.) La valeur 0 (1) représente le plus "
"ancien (récent) des deux moments représentés par la même heure."

#: library/datetime.rst:1122
msgid "``datetime2 = datetime1 + timedelta``"
msgstr "``datetime2 = datetime1 + timedelta``"

#: library/datetime.rst:2304 library/datetime.rst:2321
#: library/datetime.rst:2386 library/datetime.rst:2395
msgid "\\(1)"
msgstr "\\(1)"

#: library/datetime.rst:1124
msgid "``datetime2 = datetime1 - timedelta``"
msgstr "``datetime2 = datetime1 - timedelta``"

#: library/datetime.rst:2337
msgid "\\(2)"
msgstr "\\(2)"

#: library/datetime.rst:1126
msgid "``timedelta = datetime1 - datetime2``"
msgstr "``timedelta = datetime1 - datetime2``"

#: library/datetime.rst:1128
msgid "``datetime1 < datetime2``"
msgstr "``datetime1 < datetime2``"

#: library/datetime.rst:1128
msgid "Compares :class:`.datetime` to :class:`.datetime`. (4)"
msgstr "Compare :class:`.datetime` à :class:`.datetime`. (4)"

#: library/datetime.rst:1133
#, fuzzy
msgid ""
"datetime2 is a duration of timedelta removed from datetime1, moving forward "
"in time if ``timedelta.days`` > 0, or backward if ``timedelta.days`` < 0. "
"The result has the same :attr:`~.datetime.tzinfo` attribute as the input "
"datetime, and datetime2 - datetime1 == timedelta after. :exc:`OverflowError` "
"is raised if datetime2.year would be smaller than :const:`MINYEAR` or larger "
"than :const:`MAXYEAR`. Note that no time zone adjustments are done even if "
"the input is an aware object."
msgstr ""
"*datetime2* est décalé d'une durée *timedelta* par rapport à *datetime1*, en "
"avant dans le temps si ``timedelta.days > 0``, ou en arrière si ``timedelta."
"days < 0``.  Le résultat a le même attribut :attr:`~.datetime.tzinfo` que le "
"*datetime* d'entrée, et *datetime2 - datetime1 == timedelta* après "
"l'opération. Une :exc:`OverflowError` est levée si *datetime2.year* devait "
"être inférieure à :const:`MINYEAR` ou supérieure à :const:`MAXYEAR`. Notez "
"qu'aucun ajustement de fuseau horaire n'est réalisé même si l'entrée est "
"avisée."

#: library/datetime.rst:1142
msgid ""
"Computes the datetime2 such that datetime2 + timedelta == datetime1. As for "
"addition, the result has the same :attr:`~.datetime.tzinfo` attribute as the "
"input datetime, and no time zone adjustments are done even if the input is "
"aware."
msgstr ""
"Calcule *datetime2* tel que ``datetime2 + timedelta == datetime1``. Comme "
"pour l'addition, le résultat a le même attribut :attr:`~.datetime.tzinfo` "
"que le *datetime* d'entrée, et aucun ajustement de fuseau horaire n'est "
"réalisé même si l'entrée est avisée."

#: library/datetime.rst:1147
#, fuzzy
msgid ""
"Subtraction of a :class:`.datetime` from a :class:`.datetime` is defined "
"only if both operands are naive, or if both are aware. If one is aware and "
"the other is naive, :exc:`TypeError` is raised."
msgstr ""
"La soustraction d'un :class:`.datetime` à un autre :class:`.datetime` n'est "
"définie que si les deux opérandes sont naïfs, ou s'ils sont les deux "
"avisés.  Si l'un est avisé et que l'autre est naïf, une :exc:`TypeError` est "
"levée."

#: library/datetime.rst:1151
#, fuzzy
msgid ""
"If both are naive, or both are aware and have the same :attr:`~.datetime."
"tzinfo` attribute, the :attr:`~.datetime.tzinfo` attributes are ignored, and "
"the result is a :class:`timedelta` object *t* such that ``datetime2 + t == "
"datetime1``. No time zone adjustments are done in this case."
msgstr ""
"Si les deux sont naïfs, ou que les deux sont avisés et ont le même attribut :"
"attr:`~.datetime.tzinfo`, les attributs :attr:`~.datetime.tzinfo` sont "
"ignorés, et le résultat est un objet :class:`timedelta` *t* tel que "
"``datetime2 + t == datetime1``.  Aucun ajustement de fuseau horaire n'a lieu "
"dans ce cas."

#: library/datetime.rst:1156
#, fuzzy
msgid ""
"If both are aware and have different :attr:`~.datetime.tzinfo` attributes, "
"``a-b`` acts as if *a* and *b* were first converted to naive UTC datetimes "
"first. The result is ``(a.replace(tzinfo=None) - a.utcoffset()) - (b."
"replace(tzinfo=None) - b.utcoffset())`` except that the implementation never "
"overflows."
msgstr ""
"Si les deux sont avisés mais ont des attributs :attr:`~.datetime.tzinfo` "
"différents, ``a-b`` agit comme si *a* et *b* étaient premièrement convertis "
"vers des *datetimes* UTC naïfs.  Le résultat est ``(a.replace(tzinfo=None) - "
"a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())`` à l'exception "
"que l'implémentation ne produit jamais de débordement."

#: library/datetime.rst:1162
msgid ""
"*datetime1* is considered less than *datetime2* when *datetime1* precedes "
"*datetime2* in time."
msgstr ""
"*datetime1* est considéré inférieur à *datetime2* quand il le précède dans "
"le temps."

#: library/datetime.rst:1165
#, fuzzy
msgid ""
"If one comparand is naive and the other is aware, :exc:`TypeError` is raised "
"if an order comparison is attempted. For equality comparisons, naive "
"instances are never equal to aware instances."
msgstr ""
"Si un opérande est naïf et l'autre avisé, une :exc:`TypeError` est levée si "
"une comparaison d'ordre est attendue.  Pour les comparaisons d'égalité, les "
"instances naïves ne sont jamais égales aux instances avisées."

#: library/datetime.rst:1169
#, fuzzy
msgid ""
"If both comparands are aware, and have the same :attr:`~.datetime.tzinfo` "
"attribute, the common :attr:`~.datetime.tzinfo` attribute is ignored and the "
"base datetimes are compared. If both comparands are aware and have "
"different :attr:`~.datetime.tzinfo` attributes, the comparands are first "
"adjusted by subtracting their UTC offsets (obtained from ``self."
"utcoffset()``)."
msgstr ""
"Si les deux opérandes sont avisés, et ont le même attribut :attr:`~.datetime."
"tzinfo`, l'attribut commun :attr:`~.datetime.tzinfo` est ignoré et les "
"*datetimes* de base sont comparés.  Si les deux opérandes sont avisés et ont "
"des attributs :attr:`~.datetime.tzinfo` différents, les opérandes sont "
"premièrement ajustés en soustrayant leurs décalages UTC (obtenus depuis "
"``self.utcoffset()``)."

#: library/datetime.rst:1175
#, fuzzy
msgid ""
"Equality comparisons between aware and naive :class:`.datetime` instances "
"don't raise :exc:`TypeError`."
msgstr ""
"Les comparaisons d'égalité entre des instances :class:`.datetime` naïves et "
"avisées ne lèvent pas de :exc:`TypeError`."

#: library/datetime.rst:1181
#, fuzzy
msgid ""
"In order to stop comparison from falling back to the default scheme of "
"comparing object addresses, datetime comparison normally raises :exc:"
"`TypeError` if the other comparand isn't also a :class:`.datetime` object. "
"However, ``NotImplemented`` is returned instead if the other comparand has "
"a :meth:`timetuple` attribute. This hook gives other kinds of date objects a "
"chance at implementing mixed-type comparison. If not, when a :class:`."
"datetime` object is compared to an object of a different type, :exc:"
"`TypeError` is raised unless the comparison is ``==`` or ``!=``. The latter "
"cases return :const:`False` or :const:`True`, respectively."
msgstr ""
"Afin d'empêcher la comparaison de retomber sur le schéma par défaut de "
"comparaison des adresses des objets, la comparaison *datetime* lève "
"normalement une :exc:`TypeError` si l'autre opérande n'est pas aussi un "
"objet :class:`.datetime`.  Cependant, ``NotImplemented`` est renvoyé à la "
"place si l'autre opérande a un attribut :meth:`timetuple`.  Cela permet à "
"d'autres types d'objets dates d'implémenter la comparaison entre types "
"mixtes.  Sinon, quand un objet :class:`.datetime` est comparé à un objet "
"d'un type différent, une :exc:`TypeError` est levée à moins que la "
"comparaison soit ``==`` ou ``!=``.  Ces derniers cas renvoient "
"respectivement :const:`False` et :const:`True`."

#: library/datetime.rst:1195
msgid "Return :class:`date` object with same year, month and day."
msgstr "Renvoie un objet :class:`date` avec les mêmes année, mois et jour."

#: library/datetime.rst:1200
#, fuzzy
msgid ""
"Return :class:`.time` object with same hour, minute, second, microsecond and "
"fold. :attr:`.tzinfo` is ``None``. See also method :meth:`timetz`."
msgstr ""
"Renvoie un objet :class:`.time` avec les mêmes heure, minute, seconde, "
"microseconde et *fold*. :attr:`.tzinfo` est ``None``.  Voir aussi la "
"méthode :meth:`timetz`."

#: library/datetime.rst:1212
msgid "The fold value is copied to the returned :class:`.time` object."
msgstr "La valeur *fold* est copiée vers l'objet :class:`.time` renvoyé."

#: library/datetime.rst:1209
#, fuzzy
msgid ""
"Return :class:`.time` object with same hour, minute, second, microsecond, "
"fold, and tzinfo attributes. See also method :meth:`time`."
msgstr ""
"Renvoie un objet :class:`.time` avec les mêmes attributs heure, minute, "
"seconde, microseconde, *fold* et *tzinfo*.  Voir aussi la méthode :meth:"
"`time`."

#: library/datetime.rst:1220
#, fuzzy
msgid ""
"Return a datetime with the same attributes, except for those attributes "
"given new values by whichever keyword arguments are specified. Note that "
"``tzinfo=None`` can be specified to create a naive datetime from an aware "
"datetime with no conversion of date and time data."
msgstr ""
"Renvoie un *datetime* avec les mêmes attributs, exceptés ceux dont de "
"nouvelles valeurs sont données par les arguments nommés correspondant.  "
"Notez que ``tzinfo=None`` peut être spécifié pour créer un *datetime* naïf "
"depuis un *datetime* avisé sans conversion de la date ou de l'heure."

#: library/datetime.rst:1231
msgid ""
"Return a :class:`.datetime` object with new :attr:`.tzinfo` attribute *tz*, "
"adjusting the date and time data so the result is the same UTC time as "
"*self*, but in *tz*'s local time."
msgstr ""
"Renvoie un objet :class:`.datetime` avec un nouvel attribut :attr:`.tzinfo` "
"valant *tz*, ajustant la date et l'heure pour que le résultat soit le même "
"temps UTC que *self*, mais dans le temps local au fuseau *tz*."

#: library/datetime.rst:1235
#, fuzzy
msgid ""
"If provided, *tz* must be an instance of a :class:`tzinfo` subclass, and "
"its :meth:`utcoffset` and :meth:`dst` methods must not return ``None``. If "
"*self* is naive, it is presumed to represent time in the system timezone."
msgstr ""
"Si fourni, *tz* doit être une instance d'une sous-classe :class:`tzinfo`, et "
"ses méthodes :meth:`utcoffset` et :meth:`dst` ne doivent pas renvoyer "
"``None``.  Si *self* est naïf, Python considère que le temps est exprimé "
"dans le fuseau horaire du système."

#: library/datetime.rst:1239
#, fuzzy
msgid ""
"If called without arguments (or with ``tz=None``) the system local timezone "
"is assumed for the target timezone. The ``.tzinfo`` attribute of the "
"converted datetime instance will be set to an instance of :class:`timezone` "
"with the zone name and offset obtained from the OS."
msgstr ""
"Si appelé sans arguments (ou si ``tz=None``) le fuseau horaire local du "
"système est utilisé comme fuseau horaire cible.  L'attribut ``.tzinfo`` de "
"l'instance *datetime* convertie aura pour valeur une instance de :class:"
"`timezone` avec le nom de fuseau et le décalage obtenus depuis l'OS."

#: library/datetime.rst:1244
msgid ""
"If ``self.tzinfo`` is *tz*, ``self.astimezone(tz)`` is equal to *self*:  no "
"adjustment of date or time data is performed. Else the result is local time "
"in the timezone *tz*, representing the same UTC time as *self*:  after "
"``astz = dt.astimezone(tz)``, ``astz - astz.utcoffset()`` will have the same "
"date and time data as ``dt - dt.utcoffset()``."
msgstr ""
"Si ``self.tzinfo`` est *tz*, ``self.astimezone(tz)`` est égal à *self* : "
"aucun ajustement de date ou d'heure n'est réalisé. Sinon le résultat est le "
"temps local dans le fuseau *tz* représentant le même temps UTC que *self* : "
"après ``astz = dt.astimezone(tz)``, ``astz - astz.utcoffset()`` aura les "
"mêmes données de date et d'heure que ``dt - dt.utcoffset()``."

#: library/datetime.rst:1250
#, fuzzy
msgid ""
"If you merely want to attach a time zone object *tz* to a datetime *dt* "
"without adjustment of date and time data, use ``dt.replace(tzinfo=tz)``. If "
"you merely want to remove the time zone object from an aware datetime *dt* "
"without conversion of date and time data, use ``dt.replace(tzinfo=None)``."
msgstr ""
"Si vous voulez seulement associer un fuseau horaire *tz* à un *datetime* "
"*dt* sans ajustement des données de date et d'heure, utilisez ``dt."
"replace(tzinfo=tz)``.  Si vous voulez seulement supprimer le fuseau horaire "
"d'un *datetime* *dt* avisé sans conversion des données de date et d'heure, "
"utilisez ``dt.replace(tzinfo=None)``."

#: library/datetime.rst:1255
msgid ""
"Note that the default :meth:`tzinfo.fromutc` method can be overridden in a :"
"class:`tzinfo` subclass to affect the result returned by :meth:`astimezone`. "
"Ignoring error cases, :meth:`astimezone` acts like::"
msgstr ""
"Notez que la méthode par défaut :meth:`tzinfo.fromutc` peut être redéfinie "
"dans une sous-classe :class:`tzinfo` pour affecter le résultat renvoyé par :"
"meth:`astimezone`. En ignorant les cas d'erreurs, :meth:`astimezone` se "
"comporte comme ::"

#: library/datetime.rst:1267
msgid "*tz* now can be omitted."
msgstr "*tz* peut maintenant être omis."

#: library/datetime.rst:1270
msgid ""
"The :meth:`astimezone` method can now be called on naive instances that are "
"presumed to represent system local time."
msgstr ""
"La méthode :meth:`astimezone` peut maintenant être appelée sur des instances "
"naïves qui sont supposées représenter un temps local au système."

#: library/datetime.rst:1277
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"utcoffset(self)``, and raises an exception if the latter doesn't return "
"``None`` or a :class:`timedelta` object with magnitude less than one day."
msgstr ""
"Si :attr:`.tzinfo` est ``None``, renvoie ``None``, sinon renvoie ``self."
"tzinfo.utcoffset(self)``, et lève une exception si l'expression précédente "
"ne renvoie pas ``None`` ou un objet :class:`timedelta` d'une magnitude "
"inférieure à un jour."

#: library/datetime.rst:1864 library/datetime.rst:2216
#: library/datetime.rst:2524
msgid "The UTC offset is not restricted to a whole number of minutes."
msgstr "Le décalage UTC peut aussi être autre chose qu'un ensemble de minutes."

#: library/datetime.rst:1287
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"dst(self)``, and raises an exception if the latter doesn't return ``None`` "
"or a :class:`timedelta` object with magnitude less than one day."
msgstr ""
"Si :attr:`.tzinfo` est ``None``, renvoie ``None``, sinon renvoie ``self."
"tzinfo.dst(self)``, et lève une exception si l'expression précédente ne "
"renvoie pas ``None`` ou un objet :class:`timedelta` d'une magnitude "
"inférieure à un jour."

#: library/datetime.rst:1874 library/datetime.rst:2024
msgid "The DST offset is not restricted to a whole number of minutes."
msgstr "Le décalage DST n'est pas restreint à des minutes entières."

#: library/datetime.rst:1297
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"tzname(self)``, raises an exception if the latter doesn't return ``None`` or "
"a string object,"
msgstr ""
"Si :attr:`.tzinfo` est ``None``, renvoie ``None``, sinon renvoie ``self."
"tzinfo.tzname(self)``, lève une exception si l'expression précédente ne "
"renvoie pas ``None`` ou une chaîne de caractères,"

#: library/datetime.rst:1312
#, fuzzy
msgid ""
"where ``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` is the "
"day number within the current year starting with ``1`` for January 1st. The :"
"attr:`tm_isdst` flag of the result is set according to the :meth:`dst` "
"method: :attr:`.tzinfo` is ``None`` or :meth:`dst` returns ``None``, :attr:"
"`tm_isdst` is set to ``-1``; else if :meth:`dst` returns a non-zero value, :"
"attr:`tm_isdst` is set to ``1``; else :attr:`tm_isdst` is set to ``0``."
msgstr ""
"Renvoie un :class:`time.struct_time` comme renvoyé par :func:`time."
"localtime`. ``d.timetuple()`` est équivalent à ``time.struct_time((d.year, d."
"month, d.day, d.hour, d.minute, d.second, d.weekday(), yday, dst))``, où "
"``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` est le numéro "
"de jour dans l'année courante commençant avec ``1`` pour le 1er janvier. "
"L'option :attr:`tm_isdist` du résultat est attribuée selon la méthode :meth:"
"`dst` : si :attr:`.tzinfo` est ``None`` ou que :meth:`dst` renvoie "
"``None``, :attr:`tm_isdst` est mise à ``-1`` ; sinon, si :meth:`dst` renvoie "
"une valeur non-nulle, :attr:`tm_isdst` est mise à ``1`` ; sinon :attr:"
"`tm_isdst` est mise à ``0``."

#: library/datetime.rst:1323
#, fuzzy
msgid ""
"If :class:`.datetime` instance *d* is naive, this is the same as ``d."
"timetuple()`` except that :attr:`tm_isdst` is forced to 0 regardless of what "
"``d.dst()`` returns. DST is never in effect for a UTC time."
msgstr ""
"Si l'instance de :class:`.datetime` *d* est naïve, cela est équivalent à ``d."
"timetuple()``, excepté que :attr:`tm_isdst` est forcé à 0 sans tenir compte "
"de ce que renvoie ``d.dst()``.  L'heure d'été n'est jamais effective pour un "
"temps UTC."

#: library/datetime.rst:1327
#, fuzzy
msgid ""
"If *d* is aware, *d* is normalized to UTC time, by subtracting ``d."
"utcoffset()``, and a :class:`time.struct_time` for the normalized time is "
"returned. :attr:`tm_isdst` is forced to 0. Note that an :exc:`OverflowError` "
"may be raised if *d*.year was ``MINYEAR`` or ``MAXYEAR`` and UTC adjustment "
"spills over a year boundary."
msgstr ""
"Si *d* est avisé, il est normalisé vers un temps UTC, en lui soustrayant ``d."
"utcoffset()``, et un :class:`time.struct_time` est renvoyé pour le temps "
"normalisé.  :attr:`tm_isdst` est forcé à 0. Notez qu'une :exc:"
"`OverflowError` peut être levée si *d.year* vaut ``MINYEAR``ou ``MAXYEAR`` "
"et que l'ajustement UTC fait dépasser les bornes."

#: library/datetime.rst:1336
msgid ""
"Because naive ``datetime`` objects are treated by many ``datetime`` methods "
"as local times, it is preferred to use aware datetimes to represent times in "
"UTC; as a result, using ``utcfromtimetuple`` may give misleading results. If "
"you have a naive ``datetime`` representing UTC, use ``datetime."
"replace(tzinfo=timezone.utc)`` to make it aware, at which point you can use :"
"meth:`.datetime.timetuple`."
msgstr ""
"Comme les objets ``datetime`` naïfs sont traités par de nombreuses méthodes "
"``datetime`` comme des heures locales, il est préférable d'utiliser les "
"``datetime`` avisés pour représenter les heures en UTC ; par conséquent, "
"l'utilisation de ``utcfromtimetuple`` peut donner des résultats trompeurs. "
"Si vous disposez d'une ``datetime`` naïve représentant l'heure UTC, utilisez "
"``datetime.replace(tzinfo=timezone.utc)`` pour la rendre avisée, puis vous "
"pouvez utiliser :meth:`.datetime.timetuple`."

#: library/datetime.rst:1345
msgid ""
"Return the proleptic Gregorian ordinal of the date. The same as ``self."
"date().toordinal()``."
msgstr ""
"Renvoie l'ordinal du calendrier grégorien proleptique de cette date.  "
"Identique à ``self.date().toordinal()``."

#: library/datetime.rst:1350
msgid ""
"Return POSIX timestamp corresponding to the :class:`.datetime` instance. The "
"return value is a :class:`float` similar to that returned by :func:`time."
"time`."
msgstr ""
"Renvoie l'horodatage *POSIX* correspondant à l'instance :class:`.datetime`.  "
"La valeur renvoyée est un :class:`float` similaire à ceux renvoyés par :func:"
"`time.time`."

#: library/datetime.rst:1354
#, fuzzy
msgid ""
"Naive :class:`.datetime` instances are assumed to represent local time and "
"this method relies on the platform C :c:func:`mktime` function to perform "
"the conversion. Since :class:`.datetime` supports wider range of values "
"than :c:func:`mktime` on many platforms, this method may raise :exc:"
"`OverflowError` for times far in the past or far in the future."
msgstr ""
"Les instances naïves de :class:`.datetime` sont supposées représenter un "
"temps local et cette méthode se base sur la fonction C :c:func:`mktime` de "
"la plateforme pour opérer la conversion.  Comme :class:`.datetime` gère un "
"intervalle de valeurs plus large que :c:func:`mktime` sur beaucoup de "
"plateformes, cette méthode peut lever une :exc:`OverflowError` pour les "
"temps trop éloignés dans le passé ou le futur."

#: library/datetime.rst:1361
msgid ""
"For aware :class:`.datetime` instances, the return value is computed as::"
msgstr ""
"Pour les instances :class:`.datetime` avisées, la valeur renvoyée est "
"calculée comme suit ::"

#: library/datetime.rst:1368
msgid ""
"The :meth:`timestamp` method uses the :attr:`.fold` attribute to "
"disambiguate the times during a repeated interval."
msgstr ""
"La méthode :meth:`timestamp` utilise l'attribut :attr:`.fold` pour "
"désambiguïser le temps dans un intervalle répété."

#: library/datetime.rst:1374
#, fuzzy
msgid ""
"There is no method to obtain the POSIX timestamp directly from a naive :"
"class:`.datetime` instance representing UTC time. If your application uses "
"this convention and your system timezone is not set to UTC, you can obtain "
"the POSIX timestamp by supplying ``tzinfo=timezone.utc``::"
msgstr ""
"Il n'y a pas de méthode pour obtenir l'horodatage (*timestamp* en anglais) "
"*POSIX* directement depuis une instance :class:`.datetime` naïve "
"représentant un temps UTC.  Si votre application utilise cette convention et "
"que le fuseau horaire de votre système est UTC, vous pouvez obtenir "
"l'horodatage *POSIX* en fournissant ``tzinfo=timezone.utc`` ::"

#: library/datetime.rst:1382
msgid "or by calculating the timestamp directly::"
msgstr "ou en calculant l'horodatage (*timestamp* en anglais) directement ::"

#: library/datetime.rst:1388
msgid ""
"Return the day of the week as an integer, where Monday is 0 and Sunday is 6. "
"The same as ``self.date().weekday()``. See also :meth:`isoweekday`."
msgstr ""
"Renvoie le jour de la semaine sous forme de nombre, où lundi vaut 0 et "
"dimanche vaut 6. Identique à ``self.date().weekday()``. Voir aussi :meth:"
"`isoweekday`."

#: library/datetime.rst:1394
msgid ""
"Return the day of the week as an integer, where Monday is 1 and Sunday is 7. "
"The same as ``self.date().isoweekday()``. See also :meth:`weekday`, :meth:"
"`isocalendar`."
msgstr ""
"Renvoie le jour de la semaine sous forme de nombre, où lundi vaut 1 et "
"dimanche vaut 7. Identique à ``self.date().isoweekday()``. Voir aussi :meth:"
"`weekday`, :meth:`isocalendar`."

#: library/datetime.rst:1401
#, fuzzy
msgid ""
"Return a 3-tuple, (ISO year, ISO week number, ISO weekday). The same as "
"``self.date().isocalendar()``."
msgstr ""
"Renvoie un *tuple* de 3 éléments, (année ISO, numéro de semaine ISO, jour de "
"la semaine ISO).  Identique à ``self.date().isocalendar()``."

#: library/datetime.rst:1407
msgid "Return a string representing the date and time in ISO 8601 format:"
msgstr ""
"Renvoie une chaîne représentant la date et l'heure au format ISO 8601 :"

#: library/datetime.rst:1409
msgid "``YYYY-MM-DDTHH:MM:SS.ffffff``, if :attr:`microsecond` is not 0"
msgstr "``YYYY-MM-DDTHH:MM:SS.ffffff``, si :attr:`microsecond` ne vaut pas 0"

#: library/datetime.rst:1410
msgid "``YYYY-MM-DDTHH:MM:SS``, if :attr:`microsecond` is 0"
msgstr "``YYYY-MM-DDTHH:MM:SS``, si :attr:`microsecond` vaut 0"

#: library/datetime.rst:1412
msgid ""
"If :meth:`utcoffset` does not return ``None``, a string is appended, giving "
"the UTC offset:"
msgstr ""
"Si :meth:`utcoffset` ne renvoie pas ``None``, une chaîne est ajoutée, "
"donnant le décalage UTC :"

#: library/datetime.rst:1415
msgid ""
"``YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``, if :attr:`microsecond` "
"is not 0"
msgstr ""
"``YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``, si :attr:`microsecond` "
"ne vaut pas 0"

#: library/datetime.rst:1417
msgid ""
"``YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]``,  if :attr:`microsecond` is 0"
msgstr ""
"``YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]``,  si :attr:`microsecond` vaut 0"

#: library/datetime.rst:1427
msgid ""
"The optional argument *sep* (default ``'T'``) is a one-character separator, "
"placed between the date and time portions of the result. For example::"
msgstr ""
"L'argument optionnel *sep* (par défaut ``'T'``) est un séparateur d'un "
"caractère, placé entre les portions du résultat correspondant à la date et à "
"l'heure. Par exemple ::"

#: library/datetime.rst:1802
msgid ""
"The optional argument *timespec* specifies the number of additional "
"components of the time to include (the default is ``'auto'``). It can be one "
"of the following:"
msgstr ""
"L'argument optionnel *timespec* spécifie le nombre de composants "
"additionnels de temps à inclure (par défaut ``'auto'``). Il peut valoir "
"l'une des valeurs suivantes :"

#: library/datetime.rst:1806
msgid ""
"``'auto'``: Same as ``'seconds'`` if :attr:`microsecond` is 0, same as "
"``'microseconds'`` otherwise."
msgstr ""
"``'auto'`` : Identique à ``'seconds'`` si :attr:`microsecond` vaut 0, à "
"``'microseconds'`` sinon."

#: library/datetime.rst:1808
msgid "``'hours'``: Include the :attr:`hour` in the two-digit ``HH`` format."
msgstr "``'hours'`` : Inclut :attr:`hour` au format à deux chiffres ``HH``."

#: library/datetime.rst:1809
msgid ""
"``'minutes'``: Include :attr:`hour` and :attr:`minute` in ``HH:MM`` format."
msgstr ""
"``'minutes'`` : Inclut :attr:`hour` et :attr:`minute` au format ``HH:MM``."

#: library/datetime.rst:1810
#, fuzzy
msgid ""
"``'seconds'``: Include :attr:`hour`, :attr:`minute`, and :attr:`second` in "
"``HH:MM:SS`` format."
msgstr ""
"``'seconds'`` : Inclut :attr:`hour`, :attr:`minute` et :attr:`second` au "
"format ``HH:MM:SS``."

#: library/datetime.rst:1812
#, fuzzy
msgid ""
"``'milliseconds'``: Include full time, but truncate fractional second part "
"to milliseconds. ``HH:MM:SS.sss`` format."
msgstr ""
"``'milliseconds'`` : Inclut le temps complet, mais tronque la partie "
"fractionnaire des millisecondes, au format ``HH:MM:SS.sss``."

#: library/datetime.rst:1814
#, fuzzy
msgid "``'microseconds'``: Include full time in ``HH:MM:SS.ffffff`` format."
msgstr ""
"``'microseconds'`` : Inclut le temps complet, au format ``HH:MM:SS.ffffff``."

#: library/datetime.rst:1818
msgid "Excluded time components are truncated, not rounded."
msgstr "Les composants de temps exclus sont tronqués et non arrondis."

#: library/datetime.rst:1459
msgid ":exc:`ValueError` will be raised on an invalid *timespec* argument::"
msgstr ""
"Une :exc:`ValueError` est levée en cas d'argument *timespec* invalide ::"

#: library/datetime.rst:1833
msgid "Added the *timespec* argument."
msgstr "Ajout de l'argument *timespec*."

#: library/datetime.rst:1475
msgid ""
"For a :class:`.datetime` instance *d*, ``str(d)`` is equivalent to ``d."
"isoformat(' ')``."
msgstr ""
"Pour une instance *d* de :class:`.datetime`, ``str(d)`` est équivalent à ``d."
"isoformat(' ')``."

#: library/datetime.rst:1481
msgid "Return a string representing the date and time::"
msgstr "Renvoie une chaîne de caractères représentant la date et l'heure ::"

#: library/datetime.rst:1487
msgid ""
"The output string will *not* include time zone information, regardless of "
"whether the input is aware or naive."
msgstr ""
"La chaîne de caractères en sortie n'inclura *pas* d'informations sur le "
"fuseau horaire, que l'entrée soit avisée ou naïve."

#: library/datetime.rst:1494
#, fuzzy
msgid ""
"on platforms where the native C :c:func:`ctime` function (which :func:`time."
"ctime` invokes, but which :meth:`datetime.ctime` does not invoke) conforms "
"to the C standard."
msgstr ""
"Renvoie une chaîne de caractères représentant la date, par exemple "
"``date(2002, 12, 4).ctime() == 'Wed Dec 4 00:00:00 2002'``. ``d.ctime()`` "
"est équivalent à ``time.ctime(time.mktime(d.timetuple()))`` sur les "
"plateformes où la fonction C native :c:func:`ctime` (que :func:`time.ctime` "
"invoque, mais pas :meth:`date.ctime`) est conforme au standard C."

#: library/datetime.rst:1500
#, fuzzy
msgid ""
"Return a string representing the date and time, controlled by an explicit "
"format string. For a complete list of formatting directives, see :ref:"
"`strftime-strptime-behavior`."
msgstr ""
"Renvoie une chaîne représentant la date et l'heure, contrôlée par une chaîne "
"de format explicite.  Pour une liste complète des directives de formatage, "
"voir :ref:`strftime-strptime-behavior`."

#: library/datetime.rst:1507
#, fuzzy
msgid ""
"Same as :meth:`.datetime.strftime`. This makes it possible to specify a "
"format string for a :class:`.datetime` object in :ref:`formatted string "
"literals <f-strings>` and when using :meth:`str.format`. For a complete list "
"of formatting directives, see :ref:`strftime-strptime-behavior`."
msgstr ""
"Identique à :meth:`.datetime.strftime`.  Cela permet de spécifier une chaîne "
"de format pour un objet :class:`.datetime` dans une :ref:`chaîne de "
"formatage littérale <f-strings>` et en utilisant :meth:`str.format`.  Pour "
"une liste complète des directives de formatage, voir :ref:`strftime-strptime-"
"behavior`."

#: library/datetime.rst:1514
msgid "Examples of Usage: :class:`.datetime`"
msgstr "Exemple d'utilisation de la classe :class:`.datetime` :"

#: library/datetime.rst:1516
msgid "Examples of working with :class:`~datetime.datetime` objects:"
msgstr "Exemples d'utilisation des objets :class:`~datetime.datetime` :"

#: library/datetime.rst:1569
msgid ""
"The example below defines a :class:`tzinfo` subclass capturing time zone "
"information for Kabul, Afghanistan, which used +4 UTC until 1945 and then "
"+4:30 UTC thereafter::"
msgstr ""
"L'exemple ci-dessous définit une sous-classe :class:`tzinfo` qui regroupe "
"des informations sur les fuseaux horaires pour Kaboul, en Afghanistan, qui a "
"utilisé +4 UTC jusqu'en 1945, puis +4:30 UTC par la suite ::"

#: library/datetime.rst:1616
msgid "Usage of ``KabulTz`` from above::"
msgstr "Utilisation de ``KabulTz`` cité plus haut ::"

#: library/datetime.rst:1642
msgid ":class:`.time` Objects"
msgstr "Objets :class:`.time`"

#: library/datetime.rst:1644
#, fuzzy
msgid ""
"A :class:`time` object represents a (local) time of day, independent of any "
"particular day, and subject to adjustment via a :class:`tzinfo` object."
msgstr ""
"Un objet *time* représente une heure (locale) du jour, indépendante de tout "
"jour particulier, et sujette à des ajustements par un objet :class:`tzinfo`."

#: library/datetime.rst:1649
#, fuzzy
msgid ""
"All arguments are optional. *tzinfo* may be ``None``, or an instance of a :"
"class:`tzinfo` subclass. The remaining arguments must be integers in the "
"following ranges:"
msgstr ""
"Tous les arguments sont optionnels. *tzinfo* peut être ``None`` ou une "
"instance d'une sous-classe :class:`tzinfo`.  Les autres arguments doivent "
"être des nombres entiers, dans les intervalles suivants :"

#: library/datetime.rst:1659
#, fuzzy
msgid ""
"If an argument outside those ranges is given, :exc:`ValueError` is raised. "
"All default to ``0`` except *tzinfo*, which defaults to :const:`None`."
msgstr ""
"Si un argument est fourni en dehors de ces bornes, une :exc:`ValueError` est "
"levée.  Ils valent tous ``0`` par défaut, à l'exception de *tzinfo* qui "
"vaut :const:`None`."

#: library/datetime.rst:1667
msgid "The earliest representable :class:`.time`, ``time(0, 0, 0, 0)``."
msgstr ""
"Le plus petit objet :class:`.time` représentable, ``time(0, 0, 0, 0)``."

#: library/datetime.rst:1672
msgid "The latest representable :class:`.time`, ``time(23, 59, 59, 999999)``."
msgstr ""
"Le plus grand objet :class:`.time` représentable, ``time(23, 59, 59, "
"999999)``."

#: library/datetime.rst:1677
msgid ""
"The smallest possible difference between non-equal :class:`.time` objects, "
"``timedelta(microseconds=1)``, although note that arithmetic on :class:`."
"time` objects is not supported."
msgstr ""
"La plus petite différence possible entre deux objets :class:`.time` non-"
"égaux, ``timedelta(microseconds=1)``, notez cependant que les objets :class:"
"`.time` n'implémentent pas d'opérations arithmétiques."

#: library/datetime.rst:1706
msgid ""
"The object passed as the tzinfo argument to the :class:`.time` constructor, "
"or ``None`` if none was passed."
msgstr ""
"L'objet passé comme argument *tzinfo* au constructeur de :class:`.time`, ou "
"``None`` si aucune valeur n'a été passée."

#: library/datetime.rst:1720
#, fuzzy
msgid ""
":class:`.time` objects support comparison of :class:`.time` to :class:`."
"time`, where *a* is considered less than *b* when *a* precedes *b* in time. "
"If one comparand is naive and the other is aware, :exc:`TypeError` is raised "
"if an order comparison is attempted. For equality comparisons, naive "
"instances are never equal to aware instances."
msgstr ""
"comparaison d'un :class:`.time` avec un autre :class:`.time`, où *a* est "
"considéré inférieur à *b* s'il le précède dans le temps.  Si un opérande est "
"naïf et l'autre avisé, et qu'une relation d'ordre est attendue, une :exc:"
"`TypeError` est levée. Pour les égalités, les instances naïves ne sont "
"jamais égales aux instances avisées."

#: library/datetime.rst:1726
#, fuzzy
msgid ""
"If both comparands are aware, and have the same :attr:`~time.tzinfo` "
"attribute, the common :attr:`~time.tzinfo` attribute is ignored and the base "
"times are compared. If both comparands are aware and have different :attr:"
"`~time.tzinfo` attributes, the comparands are first adjusted by subtracting "
"their UTC offsets (obtained from ``self.utcoffset()``). In order to stop "
"mixed-type comparisons from falling back to the default comparison by object "
"address, when a :class:`.time` object is compared to an object of a "
"different type, :exc:`TypeError` is raised unless the comparison is ``==`` "
"or ``!=``. The latter cases return :const:`False` or :const:`True`, "
"respectively."
msgstr ""
"Si les deux opérandes sont avisés, et ont le même attribut :attr:`~time."
"tzinfo`, l'attribut commun :attr:`~time.tzinfo` est ignoré et les temps de "
"base sont comparés.  Si les deux opérandes sont avisés et ont des attributs :"
"attr:`~time.tzinfo` différents, ils sont d'abord ajustés en leur soustrayant "
"leurs décalages UTC (obtenus à l'aide de ``self.utcoffset()``). Afin "
"d'empêcher les comparaisons de types mixtes de retomber sur la comparaison "
"par défaut par l'adresse de l'objet, quand un objet :class:`.time` est "
"comparé à un objet de type différent, une :exc:`TypeError` est levée à moins "
"que la comparaison soit ``==`` ou ``!=``.  Ces derniers cas renvoient "
"respectivement :const:`False` et :const:`True`."

#: library/datetime.rst:1736
#, fuzzy
msgid ""
"Equality comparisons between aware and naive :class:`~datetime.time` "
"instances don't raise :exc:`TypeError`."
msgstr ""
"Les comparaisons d'égalité entre instances de :class:`~datetime.time` naïves "
"et avisées ne lèvent pas de :exc:`TypeError`."

#: library/datetime.rst:1740
#, fuzzy
msgid ""
"In Boolean contexts, a :class:`.time` object is always considered to be true."
msgstr ""
"Dans un contexte booléen, un objet :class:`.time` est toujours considéré "
"comme vrai."

#: library/datetime.rst:1742
#, fuzzy
msgid ""
"Before Python 3.5, a :class:`.time` object was considered to be false if it "
"represented midnight in UTC. This behavior was considered obscure and error-"
"prone and has been removed in Python 3.5. See :issue:`13936` for full "
"details."
msgstr ""
"Avant Python 3.5, un objet :class:`.time` était considéré comme faux s'il "
"représentait minuit en UTC.  Ce comportement était considéré comme obscur et "
"propice aux erreurs, il a été supprimé en Python 3.5.  Voir :issue:`13936` "
"pour les détails complets."

#: library/datetime.rst:1749
msgid "Other constructor:"
msgstr "Autre constructeur :"

#: library/datetime.rst:1753
#, fuzzy
msgid ""
"Return a :class:`.time` corresponding to a *time_string* in one of the "
"formats emitted by :meth:`time.isoformat`. Specifically, this function "
"supports strings in the format:"
msgstr ""
"Renvoie une :class:`date` correspondant à *date_string* dans le format émis "
"par :meth:`date.isoformat`. Spécifiquement, cette fonction gère des chaînes "
"dans le(s) format(s) ``YYYY-MM-DD``."

#: library/datetime.rst:1763
#, fuzzy
msgid ""
"This does *not* support parsing arbitrary ISO 8601 strings. It is only "
"intended as the inverse operation of :meth:`time.isoformat`."
msgstr ""
"Ceci ne gère pas l'analyse arbitraire de chaînes ISO 8601, ceci est "
"seulement destiné à l'opération inverse de :meth:`time.isoformat`."

#: library/datetime.rst:1784
#, fuzzy
msgid ""
"Return a :class:`.time` with the same value, except for those attributes "
"given new values by whichever keyword arguments are specified. Note that "
"``tzinfo=None`` can be specified to create a naive :class:`.time` from an "
"aware :class:`.time`, without conversion of the time data."
msgstr ""
"Renvoie un objet :class:`.time` avec la même valeur, à l'exception des "
"attributs dont une nouvelle valeur est spécifiée par les arguments nommés.  "
"Notez que ``tzinfo=None`` peut être spécifié pour créer une instance :class:"
"`.time` naïve à partir d'une instance :class:`.time` avisée, sans conversion "
"des données de temps."

#: library/datetime.rst:1795
msgid "Return a string representing the time in ISO 8601 format, one of:"
msgstr ""
"Renvoie une chaîne de caractères représentant la date au format ISO 8601 :"

#: library/datetime.rst:1797
msgid "``HH:MM:SS.ffffff``, if :attr:`microsecond` is not 0"
msgstr "``HH:MM:SS.ffffff``, si :attr:`microsecond` ne vaut pas 0"

#: library/datetime.rst:1798
msgid "``HH:MM:SS``, if :attr:`microsecond` is 0"
msgstr "``HH:MM:SS``, si :attr:`microsecond` vaut 0"

#: library/datetime.rst:1799
msgid ""
"``HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``, if :meth:`utcoffset` does not "
"return ``None``"
msgstr ""
"``HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``, si :meth:`utcoffset` ne renvoie pas "
"``None``"

#: library/datetime.rst:1800
msgid ""
"``HH:MM:SS+HH:MM[:SS[.ffffff]]``, if :attr:`microsecond` is 0 and :meth:"
"`utcoffset` does not return ``None``"
msgstr ""
"``HH:MM:SS+HH:MM[:SS[.ffffff]]``, si :attr:`microsecond` vaut 0 et :meth:"
"`utcoffset` ne renvoie pas ``None``"

#: library/datetime.rst:1820
msgid ":exc:`ValueError` will be raised on an invalid *timespec* argument."
msgstr ""
"Une :exc:`ValueError` sera levée en cas d'argument *timespec* invalide."

#: library/datetime.rst:1839
msgid "For a time *t*, ``str(t)`` is equivalent to ``t.isoformat()``."
msgstr "Pour un temps *t*, ``str(t)`` est équivalent à ``t.isoformat()``."

#: library/datetime.rst:1844
#, fuzzy
msgid ""
"Return a string representing the time, controlled by an explicit format "
"string. For a complete list of formatting directives, see :ref:`strftime-"
"strptime-behavior`."
msgstr ""
"Renvoie une chaîne de caractères représentant la date, contrôlée par une "
"chaîne de formatage explicite.  Pour une liste complète des directives de "
"formatage, voir :ref:`strftime-strptime-behavior`."

#: library/datetime.rst:1851
#, fuzzy
msgid ""
"Same as :meth:`.time.strftime`. This makes it possible to specify a format "
"string for a :class:`.time` object in :ref:`formatted string literals <f-"
"strings>` and when using :meth:`str.format`. For a complete list of "
"formatting directives, see :ref:`strftime-strptime-behavior`."
msgstr ""
"Identique à :meth:`.time.strftime`. Cela permet de spécifier une chaîne de "
"formatage pour un objet :class:`.time` dans une :ref:`chaîne de formatage "
"littérale <f-strings>` et à l'utilisation de :meth:`str.format`. Pour une "
"liste complète des directives de formatage, voir :ref:`strftime-strptime-"
"behavior`."

#: library/datetime.rst:1860
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"utcoffset(None)``, and raises an exception if the latter doesn't return "
"``None`` or a :class:`timedelta` object with magnitude less than one day."
msgstr ""
"Si :attr:`.tzinfo` est ``None``, renvoie ``None``, sinon renvoie ``self."
"tzinfo.utcoffset(None)``, et lève une exception si l'expression précédente "
"ne renvoie pas ``None`` ou un objet :class:`timedelta` d'une magnitude "
"inférieure à un jour."

#: library/datetime.rst:1870
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"dst(None)``, and raises an exception if the latter doesn't return ``None``, "
"or a :class:`timedelta` object with magnitude less than one day."
msgstr ""
"Si :attr:`.tzinfo` est ``None``, renvoie ``None``, sinon renvoie ``self."
"tzinfo.dst(None)``, et lève une exception si l'expression précédente ne "
"renvoie pas ``None`` ou un objet :class:`timedelta` d'une magnitude "
"inférieure à un jour."

#: library/datetime.rst:1879
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"tzname(None)``, or raises an exception if the latter doesn't return ``None`` "
"or a string object."
msgstr ""
"Si :attr:`.tzinfo` est ``None``, renvoie ``None``, sinon renvoie ``self."
"tzinfo.tzname(None)``, et lève une exception si l'expression précédente ne "
"renvoie pas ``None`` ou une chaîne de caractères."

#: library/datetime.rst:1884
msgid "Examples of Usage: :class:`.time`"
msgstr "Exemples d'utilisation de :class:`.time`"

#: library/datetime.rst:1886
msgid "Examples of working with a :class:`.time` object::"
msgstr "Exemples d'utilisation de l'objet :class:`.time` ::"

#: library/datetime.rst:1917
msgid ":class:`tzinfo` Objects"
msgstr "Objets :class:`tzinfo`"

#: library/datetime.rst:1921
msgid ""
"This is an abstract base class, meaning that this class should not be "
"instantiated directly.  Define a subclass of :class:`tzinfo` to capture "
"information about a particular time zone."
msgstr ""
"Il s'agit d'une classe de base abstraite, ce qui signifie que cette classe "
"ne doit pas être instanciée directement.  Définissez une sous-classe de :"
"class:`tzinfo` pour capturer des informations sur un fuseau horaire "
"particulier."

#: library/datetime.rst:1925
msgid ""
"An instance of (a concrete subclass of) :class:`tzinfo` can be passed to the "
"constructors for :class:`.datetime` and :class:`.time` objects. The latter "
"objects view their attributes as being in local time, and the :class:"
"`tzinfo` object supports methods revealing offset of local time from UTC, "
"the name of the time zone, and DST offset, all relative to a date or time "
"object passed to them."
msgstr ""
"Une instance (d'une sous-classe concrète) de :class:`tzinfo` peut être "
"passée aux constructeurs des objets :class:`.datetime` et :class:`.time`. "
"Les objets en question voient leurs attributs comme étant en temps local, et "
"l'objet :class:`.tzinfo` contient des méthodes pour obtenir le décalage du "
"temps local par rapport à UTC, le nom du fuseau horaire, le décalage d'heure "
"d'été, tous relatifs à un objet de date ou d'heure qui leur est passé."

#: library/datetime.rst:1931
#, fuzzy
msgid ""
"You need to derive a concrete subclass, and (at least) supply "
"implementations of the standard :class:`tzinfo` methods needed by the :class:"
"`.datetime` methods you use. The :mod:`datetime` module provides :class:"
"`timezone`, a simple concrete subclass of :class:`tzinfo` which can "
"represent timezones with fixed offset from UTC such as UTC itself or North "
"American EST and EDT."
msgstr ""
"Cette classe est une classe abstraite, signifiant qu'elle ne doit pas être "
"instanciée directement.  Vous devez en dériver une sous-classe concrète, et "
"(au minimum) fournir des implémentations aux méthodes standard :class:"
"`tzinfo` requises par les méthodes de :class:`.datetime` que vous utilisez.  "
"Le module :mod:`datetime` fournit une simple sous-classe concrète de :class:"
"`tzinfo`, :class:`timezone`, qui peut peut représenter des fuseaux horaires "
"avec des décalages fixes par rapport à UTC, tels qu'UTC lui-même ou les nord-"
"américains EST et EDT."

#: library/datetime.rst:1938
#, fuzzy
msgid ""
"Special requirement for pickling:  A :class:`tzinfo` subclass must have an :"
"meth:`__init__` method that can be called with no arguments, otherwise it "
"can be pickled but possibly not unpickled again. This is a technical "
"requirement that may be relaxed in the future."
msgstr ""
"Prérequis spécifique au *picklng* : Une sous-classe :class:`tzinfo` doit "
"avoir une méthode :meth:`__init__` qui peut être appelée sans arguments, "
"sans quoi un objet sérialisé ne pourrait pas toujours être désérialisé.  "
"C'est un prérequis technique qui pourrait être assoupli dans le futur."

#: library/datetime.rst:1943
#, fuzzy
msgid ""
"A concrete subclass of :class:`tzinfo` may need to implement the following "
"methods. Exactly which methods are needed depends on the uses made of aware :"
"mod:`datetime` objects. If in doubt, simply implement all of them."
msgstr ""
"Une sous-classe concrète de :class:`tzinfo` peut devoir implémenter les "
"méthodes suivantes.  Les méthodes réellement nécessaires dépendent de "
"l'utilisation qui est faite des objets :mod:`datetime` avisés.  Dans le "
"doute, implémentez-les toutes."

#: library/datetime.rst:1950
msgid ""
"Return offset of local time from UTC, as a :class:`timedelta` object that is "
"positive east of UTC. If local time is west of UTC, this should be negative."
msgstr ""
"Renvoie le décalage de l'heure locale par rapport à UTC, sous la forme d'un "
"objet :class:`timedelta` qui est positif à l'est de UTC. Si l'heure locale "
"est à l'ouest de UTC, il doit être négatif."

#: library/datetime.rst:1953
#, fuzzy
msgid ""
"This represents the *total* offset from UTC; for example, if a :class:"
"`tzinfo` object represents both time zone and DST adjustments, :meth:"
"`utcoffset` should return their sum. If the UTC offset isn't known, return "
"``None``. Else the value returned must be a :class:`timedelta` object "
"strictly between ``-timedelta(hours=24)`` and ``timedelta(hours=24)`` (the "
"magnitude of the offset must be less than one day). Most implementations of :"
"meth:`utcoffset` will probably look like one of these two::"
msgstr ""
"Renvoie le décalage entre le temps local et UTC, comme un objet :class:"
"`timedelta` qui est positif à l'est d'UTC.  Si le temps local se situe à "
"l'ouest d'UTC, le décalage doit être négatif.  Notez que cela est prévu pour "
"être le décalage total par rapport à UTC ; par exemple, si un objet :class:"
"`tzinfo` représente à la fois un fuseau horaire et son ajustement à l'heure "
"d'été, :meth:`utcoffset` devrait renvoyer leur somme.  Si le décalage UTC "
"n'est pas connu, renvoie ``None``.  Sinon, la valeur renvoyée doit être un "
"objet :class:`timedelta` compris strictement entre ``-timedelta(hours=24)`` "
"et ``timedelta(hours=24)`` (la magnitude du décalage doit être inférieure à "
"un jour).  La plupart des implémentations de :meth:`utcoffset` ressembleront "
"probablement à l'une des deux suivantes ::"

#: library/datetime.rst:1964
msgid ""
"If :meth:`utcoffset` does not return ``None``, :meth:`dst` should not return "
"``None`` either."
msgstr ""
"Si :meth:`utcoffset` ne renvoie pas ``None``, :meth:`dst` ne doit pas non "
"plus renvoyer ``None``."

#: library/datetime.rst:1967
msgid ""
"The default implementation of :meth:`utcoffset` raises :exc:"
"`NotImplementedError`."
msgstr ""
"L'implémentation par défaut de :meth:`utcoffset` lève une :exc:"
"`NotImplementedError`."

#: library/datetime.rst:1976
msgid ""
"Return the daylight saving time (DST) adjustment, as a :class:`timedelta` "
"object or ``None`` if DST information isn't known."
msgstr ""
"Renvoie le réglage de l'heure d'été (DST), sous la forme d'un objet :class:"
"`timedelta` ou ``None`` si l'information DST n'est pas connue."

#: library/datetime.rst:1980
#, fuzzy
msgid ""
"Return ``timedelta(0)`` if DST is not in effect. If DST is in effect, return "
"the offset as a :class:`timedelta` object (see :meth:`utcoffset` for "
"details). Note that DST offset, if applicable, has already been added to the "
"UTC offset returned by :meth:`utcoffset`, so there's no need to consult :"
"meth:`dst` unless you're interested in obtaining DST info separately. For "
"example, :meth:`datetime.timetuple` calls its :attr:`~.datetime.tzinfo` "
"attribute's :meth:`dst` method to determine how the :attr:`tm_isdst` flag "
"should be set, and :meth:`tzinfo.fromutc` calls :meth:`dst` to account for "
"DST changes when crossing time zones."
msgstr ""
"Renvoie l'ajustement d'heure d'été (DST, *daylight saving time*), comme un "
"objet :class:`timedelta` ou ``None`` si l'information n'est pas connue.  "
"Renvoie ``timedelta(0)`` si l'heure d'été n'est pas effective. Si elle est "
"effective, renvoie un décalage sous forme d'un objet :class:`timedelta` "
"(voir :meth:`utcoffset` pour les détails). Notez que ce décalage, si "
"applicable, est déjà compris dans le décalage UTC renvoyé par :meth:"
"`utcoffset`, il n'est donc pas nécessaire de faire appel à :meth:`dst` à "
"moins que vous ne souhaitiez obtenir les informations séparément.  Par "
"exemple, :meth:`datetime.timetuple` appelle la méthode :meth:`dst` de son "
"attribut :attr:`~.datetime.tzinfo` pour déterminer si l'option :attr:"
"`tm_isdst` doit être activée, et :meth:`tzinfo.fromutc` fait appel à :meth:"
"`dst` pour tenir compte des heures d'été quand elle traverse des fuseaux "
"horaires."

#: library/datetime.rst:1990
msgid ""
"An instance *tz* of a :class:`tzinfo` subclass that models both standard and "
"daylight times must be consistent in this sense:"
msgstr ""
"Une instance *tz* d'une sous-classe :class:`tzinfo` convenant à la fois pour "
"une heure standard et une heure d'été doit être cohérente :"

#: library/datetime.rst:1993
msgid "``tz.utcoffset(dt) - tz.dst(dt)``"
msgstr "``tz.utcoffset(dt) - tz.dst(dt)``"

#: library/datetime.rst:1995
#, fuzzy
msgid ""
"must return the same result for every :class:`.datetime` *dt* with ``dt."
"tzinfo == tz``  For sane :class:`tzinfo` subclasses, this expression yields "
"the time zone's \"standard offset\", which should not depend on the date or "
"the time, but only on geographic location. The implementation of :meth:"
"`datetime.astimezone` relies on this, but cannot detect violations; it's the "
"programmer's responsibility to ensure it. If a :class:`tzinfo` subclass "
"cannot guarantee this, it may be able to override the default implementation "
"of :meth:`tzinfo.fromutc` to work correctly with :meth:`astimezone` "
"regardless."
msgstr ""
"doit renvoyer le même résultat pour tout objet :class:`.datetime` *dt* avec "
"``dt.tzinfo == tz``  Pour les sous-classes saines de :class:`tzinfo`, cette "
"expression calcule le « décalage standard » du fuseau horaire, qui ne doit "
"pas dépendre de la date ou de l'heure, mais seulement de la position "
"géographique.  L'implémentation de :meth:`datetime.astimezone` se base là-"
"dessus, mais ne peut pas détecter les violations ; il est de la "
"responsabilité du programmeur de l'assurer.  Si une sous-classe :class:"
"`tzinfo` ne le garantit pas, il doit être possible de redéfinir "
"l'implémentation par défaut de :meth:`tzinfo.fromutc` pour tout de même "
"fonctionner correctement avec :meth:`astimezone`."

#: library/datetime.rst:2004
msgid ""
"Most implementations of :meth:`dst` will probably look like one of these "
"two::"
msgstr ""
"La plupart des implémentations de :meth:`dst` ressembleront probablement à "
"l'une des deux suivantes ::"

#: library/datetime.rst:2010
msgid "or::"
msgstr "ou ::"

#: library/datetime.rst:2022
msgid ""
"The default implementation of :meth:`dst` raises :exc:`NotImplementedError`."
msgstr ""
"L'implémentation par défaut de :meth:`dst` lève une :exc:"
"`NotImplementedError`."

#: library/datetime.rst:2030
#, fuzzy
msgid ""
"Return the time zone name corresponding to the :class:`.datetime` object "
"*dt*, as a string. Nothing about string names is defined by the :mod:"
"`datetime` module, and there's no requirement that it mean anything in "
"particular. For example, \"GMT\", \"UTC\", \"-500\", \"-5:00\", \"EDT\", "
"\"US/Eastern\", \"America/New York\" are all valid replies. Return ``None`` "
"if a string name isn't known. Note that this is a method rather than a fixed "
"string primarily because some :class:`tzinfo` subclasses will wish to return "
"different names depending on the specific value of *dt* passed, especially "
"if the :class:`tzinfo` class is accounting for daylight time."
msgstr ""
"Renvoie le nom du fuseau horaire correspondant à l'objet :class:`.datetime` "
"*dt*, sous forme d'une chaîne de caractères. rien n'est défini sur les noms "
"par le module :mod:`datetime`, et il n'est pas nécessaire que ces noms "
"signifient quelque chose en particulier.  Par exemple, « *GMT* », « *UTC* », "
"« *-500* », « *-5:00* », « *EDT* », « *US/Eastern* » et « *America/New "
"York* » sont toutes des valeurs de retour valides.  Renvoie ``None`` si un "
"nom est inconnu.  Notez qu'il s'agit d'une méthode et non d'une chaîne fixée "
"en amont, parce que les sous-classes de :class:`tzinfo` peuvent souhaiter "
"renvoyer des noms différents en fonction de valeurs de *dt* spécifiques, en "
"particulier si la classe :class:`tzinfo` tient compte de l'heure d'été."

#: library/datetime.rst:2040
msgid ""
"The default implementation of :meth:`tzname` raises :exc:"
"`NotImplementedError`."
msgstr ""
"L'implémentation par défaut de :meth:`tzname` lève une :exc:"
"`NotImplementedError`."

#: library/datetime.rst:2043
#, fuzzy
msgid ""
"These methods are called by a :class:`.datetime` or :class:`.time` object, "
"in response to their methods of the same names. A :class:`.datetime` object "
"passes itself as the argument, and a :class:`.time` object passes ``None`` "
"as the argument. A :class:`tzinfo` subclass's methods should therefore be "
"prepared to accept a *dt* argument of ``None``, or of class :class:`."
"datetime`."
msgstr ""
"Ces méthodes sont appelées par les objets :class:`.datetime` et :class:`."
"time`, en réponse à leurs méthodes aux mêmes noms.  Un objet :class:`."
"datetime` se passe lui-même en tant qu'argument, et un objet :class:`.time` "
"passe ``None``.  Les méthodes des sous-classes :class:`tzinfo` doivent alors "
"être prêtes à recevoir un argument ``None`` pour *dt*, ou une instance de :"
"class:`.datetime`."

#: library/datetime.rst:2049
#, fuzzy
msgid ""
"When ``None`` is passed, it's up to the class designer to decide the best "
"response. For example, returning ``None`` is appropriate if the class wishes "
"to say that time objects don't participate in the :class:`tzinfo` protocols. "
"It may be more useful for ``utcoffset(None)`` to return the standard UTC "
"offset, as there is no other convention for discovering the standard offset."
msgstr ""
"Quand ``None`` est passé, il est de la responsabilité du *designer* de la "
"classe de choisir la meilleure réponse.  Par exemple, renvoyer ``None`` est "
"approprié si la classe souhaite signaler que les objets de temps ne "
"participent pas au protocole :class:`tzinfo`.  Il peut être plus utile pour "
"``utcoffset(None)`` de renvoyer le décalage UTC standard, comme il n'existe "
"aucune autre convention pour obtenir ce décalage."

#: library/datetime.rst:2055
#, fuzzy
msgid ""
"When a :class:`.datetime` object is passed in response to a :class:`."
"datetime` method, ``dt.tzinfo`` is the same object as *self*. :class:"
"`tzinfo` methods can rely on this, unless user code calls :class:`tzinfo` "
"methods directly. The intent is that the :class:`tzinfo` methods interpret "
"*dt* as being in local time, and not need worry about objects in other "
"timezones."
msgstr ""
"Quand un objet :class:`.datetime` est passé en réponse à une méthode de :"
"class:`.datetime`, ``dt.tzinfo`` est le même objet que *self*.  Les méthodes "
"de :class:`tzinfo` peuvent se baser là-dessus, à moins que le code "
"utilisateur appelle directement des méthodes de :class:`tzinfo`.  "
"L'intention est que les méthodes de :class:`tzinfo` interprètent *dt* comme "
"étant le temps local, et n'aient pas à se soucier des objets dans d'autres "
"fuseaux horaires."

#: library/datetime.rst:2061
msgid ""
"There is one more :class:`tzinfo` method that a subclass may wish to "
"override:"
msgstr ""
"Il y a une dernière méthode de :class:`tzinfo` que les sous-classes peuvent "
"vouloir redéfinir :"

#: library/datetime.rst:2066
#, fuzzy
msgid ""
"This is called from the default :class:`datetime.astimezone()` "
"implementation. When called from that, ``dt.tzinfo`` is *self*, and *dt*'s "
"date and time data are to be viewed as expressing a UTC time. The purpose "
"of :meth:`fromutc` is to adjust the date and time data, returning an "
"equivalent datetime in *self*'s local time."
msgstr ""
"Elle est appelée par l'implémentation par défaut de :class:`datetime."
"astimezone()`.  Quand appelée depuis cette méthode, ``dt.tzinfo`` est "
"*self*, et les données de date et d'heure de *dt* sont vues comme exprimant "
"un temps UTC.  Le rôle de :meth:`fromutc` est d'ajuster les données de date "
"et d'heure, renvoyant un objet *datetime* équivalent à *self*, dans le temps "
"local."

#: library/datetime.rst:2072
#, fuzzy
msgid ""
"Most :class:`tzinfo` subclasses should be able to inherit the default :meth:"
"`fromutc` implementation without problems. It's strong enough to handle "
"fixed-offset time zones, and time zones accounting for both standard and "
"daylight time, and the latter even if the DST transition times differ in "
"different years. An example of a time zone the default :meth:`fromutc` "
"implementation may not handle correctly in all cases is one where the "
"standard offset (from UTC) depends on the specific date and time passed, "
"which can happen for political reasons. The default implementations of :meth:"
"`astimezone` and :meth:`fromutc` may not produce the result you want if the "
"result is one of the hours straddling the moment the standard offset changes."
msgstr ""
"La plupart des sous-classes :class:`tzinfo` doivent être en mesure d'hériter "
"sans problème de l'implémentation par défaut de :meth:`fromutc`.  Elle est "
"suffisamment robuste pour gérer les fuseaux horaires à décalage fixe, et les "
"fuseaux représentant à la fois des heures standards et d'été, et ce même si "
"le décalage de l'heure d'été est différent suivant les années.  Un exemple "
"de fuseau horaire qui ne serait pas géré correctement dans tous les cas par "
"l'implémentation par défaut de :meth:`fromutc` en est un où le décalage "
"standard (par rapport à UTC) dépend de valeurs spécifiques de date et "
"d'heure passées, ce qui peut arriver pour des raisons politiques. Les "
"implémentations par défaut de :meth:`astimezone` et :meth:`fromutc` peuvent "
"ne pas produire les résultats attendus si le résultat est l'une des heures "
"affectées par le changement d'heure."

#: library/datetime.rst:2083
msgid ""
"Skipping code for error cases, the default :meth:`fromutc` implementation "
"acts like::"
msgstr ""
"En omettant le code des cas d'erreurs, l'implémentation par défaut de :meth:"
"`fromutc` se comporte comme suit ::"

#: library/datetime.rst:2101
msgid ""
"In the following :download:`tzinfo_examples.py <../includes/tzinfo_examples."
"py>` file there are some examples of :class:`tzinfo` classes:"
msgstr ""
"Dans le fichier :download:`tzinfo_examples.py <../includes/tzinfo_examples."
"py>` il y a des exemples de :class:`tzinfo` classes:"

#: library/datetime.rst:2107
#, fuzzy
msgid ""
"Note that there are unavoidable subtleties twice per year in a :class:"
"`tzinfo` subclass accounting for both standard and daylight time, at the DST "
"transition points. For concreteness, consider US Eastern (UTC -0500), where "
"EDT begins the minute after 1:59 (EST) on the second Sunday in March, and "
"ends the minute after 1:59 (EDT) on the first Sunday in November::"
msgstr ""
"Notez que, deux fois par an, on rencontre des subtilités inévitables dans "
"les sous-classes de :class:`tzinfo` représentant à la fois des heures "
"standard et d'été, au passage de l'une à l'autre.  Concrètement, considérez "
"le fuseau de l'est des États-Unis (UTC -0500), où EDT (heure d'été) débute à "
"la minute qui suit 1:59 (EST) le second dimanche de mars, et se termine à la "
"minute qui suit 1:59 (EDT) le premier dimanche de novembre ::"

#: library/datetime.rst:2121
#, fuzzy
msgid ""
"When DST starts (the \"start\" line), the local wall clock leaps from 1:59 "
"to 3:00. A wall time of the form 2:MM doesn't really make sense on that day, "
"so ``astimezone(Eastern)`` won't deliver a result with ``hour == 2`` on the "
"day DST begins. For example, at the Spring forward transition of 2016, we "
"get::"
msgstr ""
"Quand l'heure d'été débute (la ligne « *start* »), l'horloge locale passe de "
"1:59 à 3:00.  Une heure de la forme 2:MM n'a pas vraiment de sens ce jour "
"là, donc  ``astimezone(Eastern)`` ne délivrera pas de résultat avec ``hour "
"== 2`` pour le jour où débute l'heure d'été.  Par exemple, lors de la "
"transition du printemps 2016, nous obtenons ::"

#: library/datetime.rst:2140
#, fuzzy
msgid ""
"When DST ends (the \"end\" line), there's a potentially worse problem: "
"there's an hour that can't be spelled unambiguously in local wall time: the "
"last hour of daylight time. In Eastern, that's times of the form 5:MM UTC on "
"the day daylight time ends. The local wall clock leaps from 1:59 (daylight "
"time) back to 1:00 (standard time) again. Local times of the form 1:MM are "
"ambiguous. :meth:`astimezone` mimics the local clock's behavior by mapping "
"two adjacent UTC hours into the same local hour then. In the Eastern "
"example, UTC times of the form 5:MM and 6:MM both map to 1:MM when converted "
"to Eastern, but earlier times have the :attr:`~datetime.fold` attribute set "
"to 0 and the later times have it set to 1. For example, at the Fall back "
"transition of 2016, we get::"
msgstr ""
"Quand l'heure d'été se termine (la ligne « *end* »), il y a potentiellement "
"un problème pire que cela : il y a une heure qui ne peut pas être exprimée "
"sans ambiguïté en temps local : la dernière heure de l'heure d'été.  Dans "
"l'est des États-Unis, l'heure d'été se termine sur les heures de la forme 5:"
"MM UTC.  L'horloge locale passe de 1:59 (heure d'été) à 1:00 (heure "
"standard) à nouveau. Les heures locales de la forme 1:MM sont ambiguës. :"
"meth:`astimezone` imite le comportement des horloges locales en associant "
"deux heures UTC adjacentes à la même heure locale.  Dans notre exemple, les "
"temps UTC de la forme 5:MM et 6:MM sont tous deux associés à 1:MM quand "
"convertis vers ce fuseau, mais les heures les plus anciennes ont l'attribut :"
"attr:`~datetime.fold` à 0 et les plus récentes l'ont à 1. Par exemple, lors "
"de la transition de l'automne 2016, nous obtenons ::"

#: library/datetime.rst:2162
#, fuzzy
msgid ""
"Note that the :class:`.datetime` instances that differ only by the value of "
"the :attr:`~datetime.fold` attribute are considered equal in comparisons."
msgstr ""
"Notez que deux instances :class:`datetime` qui ne diffèrent que par la "
"valeur de leur attribut :attr:`~datetime.fold` sont considérées égales dans "
"les comparaisons."

#: library/datetime.rst:2165
msgid ""
"Applications that can't bear wall-time ambiguities should explicitly check "
"the value of the :attr:`~datetime.fold` attribute or avoid using hybrid :"
"class:`tzinfo` subclasses; there are no ambiguities when using :class:"
"`timezone`, or any other fixed-offset :class:`tzinfo` subclass (such as a "
"class representing only EST (fixed offset -5 hours), or only EDT (fixed "
"offset -4 hours))."
msgstr ""
"Les applications qui ne peuvent pas gérer ces ambiguïtés doivent vérifier "
"explicitement la valeur de l'attribut :attr:`~datetime.fold` ou éviter "
"d'utiliser des sous-classes :class:`tzinfo` hybrides ; il n'y a aucune "
"ambiguïté lors de l'utilisation de la classe :class:`timezone`, ou toute "
"autre sous-classe de :class:`tzinfo` à décalage fixe (comme une classe "
"représentant uniquement le fuseau EST (de décalage fixe *-5h*) ou uniquement "
"EDT (*-4h*))."

#: library/datetime.rst:2180
msgid "`dateutil.tz <https://dateutil.readthedocs.io/en/stable/tz.html>`_"
msgstr "`dateutil.tz <https://dateutil.readthedocs.io/en/stable/tz.html>`_"

#: library/datetime.rst:2174
#, fuzzy
msgid ""
"The :mod:`datetime` module has a basic :class:`timezone` class (for handling "
"arbitrary fixed offsets from UTC) and its :attr:`timezone.utc` attribute (a "
"UTC timezone instance)."
msgstr ""
"La bibliothèque standard contient la classe :class:`timezone` pour gérer des "
"décalages fixes par rapport à UTC et :attr:`timezone.utc` comme instance du "
"fuseau horaire UTC."

#: library/datetime.rst:2178
#, fuzzy
msgid ""
"*dateutil.tz* library brings the *IANA timezone database* (also known as the "
"Olson database) to Python, and its usage is recommended."
msgstr ""
"La bibliothèque *dateutils.tz* apporte à Python la *base de données de "
"fuseaux horaires IANA* (*IANA timezone database*, aussi appelée base de "
"données Olson) , et son utilisation est recommandée."

#: library/datetime.rst:2186
msgid "`IANA timezone database <https://www.iana.org/time-zones>`_"
msgstr ""
"`Base de données des fuseaux horaires de l'IANA <https://www.iana.org/time-"
"zones>`_"

#: library/datetime.rst:2183
msgid ""
"The Time Zone Database (often called tz, tzdata or zoneinfo) contains code "
"and data that represent the history of local time for many representative "
"locations around the globe. It is updated periodically to reflect changes "
"made by political bodies to time zone boundaries, UTC offsets, and daylight-"
"saving rules."
msgstr ""
"La *Time Zone Database* (souvent appelée *tz*, *tzdata* ou *zoneinfo*) "
"contient les codes et les données représentant l'historique du temps local "
"pour un grand nombre d'emplacements représentatifs autour du globe. Elle est "
"mise à jour périodiquement, pour refléter les changements opérés par des "
"politiques sur les bornes du fuseau, les décalages UTC, et les règles de "
"passage à l'heure d'été."

#: library/datetime.rst:2193
msgid ":class:`timezone` Objects"
msgstr "Objets :class:`timezone`"

#: library/datetime.rst:2195
msgid ""
"The :class:`timezone` class is a subclass of :class:`tzinfo`, each instance "
"of which represents a timezone defined by a fixed offset from UTC."
msgstr ""
"La classe :class:`timezone` est une sous-classe de :class:`tzinfo`, dont "
"chaque instance représente un fuseau horaire défini par un décalage fixe par "
"rapport à UTC."

#: library/datetime.rst:2199
#, fuzzy
msgid ""
"Objects of this class cannot be used to represent timezone information in "
"the locations where different offsets are used in different days of the year "
"or where historical changes have been made to civil time."
msgstr ""
"La classe :class:`timezone` est une sous-classe de :class:`tzinfo`, où "
"chaque instance représente un fuseau horaire défini par un décalage fixe par "
"rapport à UTC.  Notez que les que les objets de cette classe ne peuvent pas "
"être utilisés pour représenter les informations de fuseaux horaires dans des "
"emplacements où plusieurs décalages sont utilisés au cours de l'année ou où "
"des changements historiques ont été opérés sur le temps civil."

#: library/datetime.rst:2206
#, fuzzy
msgid ""
"The *offset* argument must be specified as a :class:`timedelta` object "
"representing the difference between the local time and UTC. It must be "
"strictly between ``-timedelta(hours=24)`` and ``timedelta(hours=24)``, "
"otherwise :exc:`ValueError` is raised."
msgstr ""
"L'argument *offset* doit être spécifié comme un objet :class:`timedelta` "
"représentant la différence entre le temps local et UTC.  Il doit être "
"strictement compris entre ``-timedelta(hours=24)`` et "
"``timedelta(hours=24)``, autrement une :exc:`ValueError` est levée."

#: library/datetime.rst:2211
#, fuzzy
msgid ""
"The *name* argument is optional. If specified it must be a string that will "
"be used as the value returned by the :meth:`datetime.tzname` method."
msgstr ""
"L'argument *name* est optionnel.  Si spécifié, il doit être une chaîne de "
"caractères qui sera utilisée comme valeur de retour de la méthode :meth:"
"`datetime.tzname`."

#: library/datetime.rst:2233
msgid ""
"Return the fixed value specified when the :class:`timezone` instance is "
"constructed."
msgstr ""
"Renvoie la valeur fixe spécifiée lorsque l'instance :class:`timezone` est "
"construite."

#: library/datetime.rst:2225
#, fuzzy
msgid ""
"The *dt* argument is ignored. The return value is a :class:`timedelta` "
"instance equal to the difference between the local time and UTC."
msgstr ""
"Renvoie la valeur fixe spécifiée à la création de l'instance de :class:"
"`timezone`.  L'argument *dt* est ignoré.  La valeur de retour est une "
"instance :class:`timedelta` égale à la différence entre le temps local et "
"UTC."

#: library/datetime.rst:2236
#, fuzzy
msgid ""
"If *name* is not provided in the constructor, the name returned by "
"``tzname(dt)`` is generated from the value of the ``offset`` as follows. If "
"*offset* is ``timedelta(0)``, the name is \"UTC\", otherwise it is a string "
"in the format ``UTC±HH:MM``, where ± is the sign of ``offset``, HH and MM "
"are two digits of ``offset.hours`` and ``offset.minutes`` respectively."
msgstr ""
"Renvoie la valeur fixe spécifiée à la création de l'instance de :class:"
"`timezone`.  Si *name* n'est pas fourni au constructeur, le nom renvoyé par "
"``tzname(dt)`` est généré comme suit à partir de la valeur de ``offset``.  "
"Si *offset* vaut ``timedelta(0)``, le nom sera « UTC », autrement le nom "
"sera une chaîne de la forme \"UTC±HH:MM\", où ± est le signe d'``offset``, "
"et HH et MM sont respectivement les représentations à deux chiffres de "
"``offset.hours`` et ``offset.minutes``."

#: library/datetime.rst:2242
#, fuzzy
msgid ""
"Name generated from ``offset=timedelta(0)`` is now plain `'UTC'`, not "
"``'UTC+00:00'``."
msgstr ""
"Le nom généré à partir de ``offset=timedelta(0)`` est maintenant \"UTC\" "
"plutôt que \"UTC+00:00\"."

#: library/datetime.rst:2249
msgid "Always returns ``None``."
msgstr "Renvoie toujours ``None``."

#: library/datetime.rst:2253
msgid ""
"Return ``dt + offset``. The *dt* argument must be an aware :class:`."
"datetime` instance, with ``tzinfo`` set to ``self``."
msgstr ""
"Renvoie ``dt + offset``. L'argument *dt* doit être une instance avisée de :"
"class:`.datetime`, avec ``tzinfo`` valant ``self``."

#: library/datetime.rst:2260
msgid "The UTC timezone, ``timezone(timedelta(0))``."
msgstr "Le fuseau horaire UTC, ``timezone(timedelta(0))``."

#: library/datetime.rst:2269
msgid ":meth:`strftime` and :meth:`strptime` Behavior"
msgstr "Comportement de :meth:`strftime` et :meth:`strptime`"

#: library/datetime.rst:2271
#, fuzzy
msgid ""
":class:`date`, :class:`.datetime`, and :class:`.time` objects all support a "
"``strftime(format)`` method, to create a string representing the time under "
"the control of an explicit format string."
msgstr ""
"Les objets :class:`date`, :class:`.datetime` et :class:`.time` comportent "
"tous une méthode ``strftime(format)``, pour créer une représentation du "
"temps sous forme d'une chaîne de caractères, contrôlée par une chaîne de "
"formatage explicite.  Grossièrement, ``d.strftime(fmt)`` se comporte comme "
"la fonction ``time.strftime(fmt, d.timetuple())`` du module :mod:`time`, "
"bien que tous les objets ne comportent pas de méthode :meth:`timetuple`."

#: library/datetime.rst:2275
msgid ""
"Conversely, the :meth:`datetime.strptime` class method creates a :class:`."
"datetime` object from a string representing a date and time and a "
"corresponding format string."
msgstr ""
"Inversement, la méthode de classe :meth:`datetime.strptime` crée un objet :"
"class:`.datetime` à partir d'une chaîne représentant une date et une heure, "
"et une chaîne de format correspondante."

#: library/datetime.rst:2279
msgid ""
"The table below provides a high-level comparison of :meth:`strftime` versus :"
"meth:`strptime`:"
msgstr ""
"Le tableau ci-dessous fournit une comparaison de haut niveau entre :meth:"
"`strftime` et :meth:`strptime` :"

#: library/datetime.rst:2283
msgid "``strftime``"
msgstr "``strftime``"

#: library/datetime.rst:2283
msgid "``strptime``"
msgstr "``strptime``"

#: library/datetime.rst:2285
msgid "Usage"
msgstr "Utilisation"

#: library/datetime.rst:2285
msgid "Convert object to a string according to a given format"
msgstr "Convertit un objet en une chaîne de caractères selon un format donné"

#: library/datetime.rst:2285
msgid ""
"Parse a string into a :class:`.datetime` object given a corresponding format"
msgstr ""
"Analyse une chaîne de caractères dans un objet :class:`.datetime` en "
"fonction du format de correspondance donné"

#: library/datetime.rst:2287
msgid "Type of method"
msgstr "Type de méthode"

#: library/datetime.rst:2287
msgid "Instance method"
msgstr "Méthode d'instance"

#: library/datetime.rst:2287
msgid "Class method"
msgstr "Méthode de classe"

#: library/datetime.rst:2289
msgid "Method of"
msgstr "Méthode de"

#: library/datetime.rst:2289
msgid ":class:`date`; :class:`.datetime`; :class:`.time`"
msgstr ":class:`date` ; :class:`.datetime` ; :class:`.time`"

#: library/datetime.rst:2289
msgid ":class:`.datetime`"
msgstr ":class:`.datetime`"

#: library/datetime.rst:2291
msgid "Signature"
msgstr "Signature"

#: library/datetime.rst:2291
msgid "``strftime(format)``"
msgstr "``strftime(format)``"

#: library/datetime.rst:2291
msgid "``strptime(date_string, format)``"
msgstr "``strptime(date_string, format)``"

#: library/datetime.rst:2296
msgid ":meth:`strftime` and :meth:`strptime` Format Codes"
msgstr "Codes de formatage de :meth:`strftime` et :meth:`strptime`"

#: library/datetime.rst:2298
msgid ""
"The following is a list of all the format codes that the 1989 C standard "
"requires, and these work on all platforms with a standard C implementation."
msgstr ""
"La liste suivante est la liste de tous les codes de formatage requis par le "
"standard C (version 1989), ils fonctionnent sur toutes les plateformes "
"possédant une implémentation de C standard."

#: library/datetime.rst:2405
msgid "Directive"
msgstr "Directive"

#: library/datetime.rst:2405
msgid "Meaning"
msgstr "Signification"

#: library/datetime.rst:2405
msgid "Example"
msgstr "Exemple"

#: library/datetime.rst:2405
msgid "Notes"
msgstr "Notes"

#: library/datetime.rst:2304
msgid "``%a``"
msgstr "``%a``"

#: library/datetime.rst:2304
msgid "Weekday as locale's abbreviated name."
msgstr "Jour de la semaine abrégé dans la langue locale."

#: library/datetime.rst:0
msgid "Sun, Mon, ..., Sat (en_US);"
msgstr "Sun, Mon, ..., Sat (en_US);"

#: library/datetime.rst:0
msgid "So, Mo, ..., Sa (de_DE)"
msgstr "Lu, Ma, ..., Di (*fr_FR*)"

#: library/datetime.rst:2309
msgid "``%A``"
msgstr "``%A``"

#: library/datetime.rst:2309
msgid "Weekday as locale's full name."
msgstr "Jour de la semaine complet dans la langue locale."

#: library/datetime.rst:0
msgid "Sunday, Monday, ..., Saturday (en_US);"
msgstr "*Sunday*, *Monday*, ..., *Saturday* (*en_US*);"

#: library/datetime.rst:0
msgid "Sonntag, Montag, ..., Samstag (de_DE)"
msgstr "Lundi, Mardi, ..., Dimanche (*fr_FR*)"

#: library/datetime.rst:2314
msgid "``%w``"
msgstr "``%w``"

#: library/datetime.rst:2314
msgid "Weekday as a decimal number, where 0 is Sunday and 6 is Saturday."
msgstr ""
"Jour de la semaine en chiffre, avec 0 pour le dimanche et 6 pour le samedi."

#: library/datetime.rst:2314
msgid "0, 1, ..., 6"
msgstr "0, 1, ..., 6"

#: library/datetime.rst:2318
msgid "``%d``"
msgstr "``%d``"

#: library/datetime.rst:2318
msgid "Day of the month as a zero-padded decimal number."
msgstr "Jour du mois sur deux chiffres."

#: library/datetime.rst:2318
msgid "01, 02, ..., 31"
msgstr "01, 02, ..., 31"

#: library/datetime.rst:2331 library/datetime.rst:2340
#: library/datetime.rst:2349 library/datetime.rst:2367
msgid "\\(9)"
msgstr "\\(9)"

#: library/datetime.rst:2321
msgid "``%b``"
msgstr "``%b``"

#: library/datetime.rst:2321
msgid "Month as locale's abbreviated name."
msgstr "Nom du mois abrégé dans la langue locale."

#: library/datetime.rst:0
msgid "Jan, Feb, ..., Dec (en_US);"
msgstr "Jan, Feb, ..., Dec (*en_US*);"

#: library/datetime.rst:0
msgid "Jan, Feb, ..., Dez (de_DE)"
msgstr "janv., févr., ..., déc. (*fr_FR*)"

#: library/datetime.rst:2326
msgid "``%B``"
msgstr "``%B``"

#: library/datetime.rst:2326
msgid "Month as locale's full name."
msgstr "Nom complet du mois dans la langue locale."

#: library/datetime.rst:0
msgid "January, February, ..., December (en_US);"
msgstr "*January*, *February*, ..., *December* (*en_US*);"

#: library/datetime.rst:0
msgid "Januar, Februar, ..., Dezember (de_DE)"
msgstr "janvier, février, ..., décembre (*fr_FR*)"

#: library/datetime.rst:2331
msgid "``%m``"
msgstr "``%m``"

#: library/datetime.rst:2331
msgid "Month as a zero-padded decimal number."
msgstr "Numéro du mois sur deux chiffres."

#: library/datetime.rst:2343
msgid "01, 02, ..., 12"
msgstr "01, 02, ..., 12"

#: library/datetime.rst:2334
msgid "``%y``"
msgstr "``%y``"

#: library/datetime.rst:2334
msgid "Year without century as a zero-padded decimal number."
msgstr "Année sur deux chiffres (sans le siècle)."

#: library/datetime.rst:2334
msgid "00, 01, ..., 99"
msgstr "00, 01, ..., 99"

#: library/datetime.rst:2337
msgid "``%Y``"
msgstr "``%Y``"

#: library/datetime.rst:2337
msgid "Year with century as a decimal number."
msgstr "Année complète sur quatre chiffres."

#: library/datetime.rst:2407
msgid "0001, 0002, ..., 2013, 2014, ..., 9998, 9999"
msgstr "0001, 0002, ..., 2013, 2014, ..., 9998, 9999"

#: library/datetime.rst:2340
msgid "``%H``"
msgstr "``%H``"

#: library/datetime.rst:2340
msgid "Hour (24-hour clock) as a zero-padded decimal number."
msgstr "Heure à deux chiffres de 00 à 23."

#: library/datetime.rst:2340
msgid "00, 01, ..., 23"
msgstr "00, 01, ..., 23"

#: library/datetime.rst:2343
msgid "``%I``"
msgstr "``%I``"

#: library/datetime.rst:2343
msgid "Hour (12-hour clock) as a zero-padded decimal number."
msgstr "Heure à deux chiffres pour les horloges 12h (01 à 12)."

#: library/datetime.rst:2346
msgid "``%p``"
msgstr "``%p``"

#: library/datetime.rst:2346
msgid "Locale's equivalent of either AM or PM."
msgstr "Équivalent local à AM/PM."

#: library/datetime.rst:0
msgid "AM, PM (en_US);"
msgstr "AM, PM (en_US);"

#: library/datetime.rst:0
msgid "am, pm (de_DE)"
msgstr "am, pm (de_DE)"

#: library/datetime.rst:2346
msgid "\\(1), \\(3)"
msgstr "\\(1), \\(3)"

#: library/datetime.rst:2349
msgid "``%M``"
msgstr "``%M``"

#: library/datetime.rst:2349
msgid "Minute as a zero-padded decimal number."
msgstr "Minutes sur deux chiffres."

#: library/datetime.rst:2352
msgid "00, 01, ..., 59"
msgstr "00, 01, ..., 59"

#: library/datetime.rst:2352
msgid "``%S``"
msgstr "``%S``"

#: library/datetime.rst:2352
msgid "Second as a zero-padded decimal number."
msgstr "Secondes sur deux chiffres."

#: library/datetime.rst:2352
msgid "\\(4), \\(9)"
msgstr "\\(4), \\(9)"

#: library/datetime.rst:2355
msgid "``%f``"
msgstr "``%f``"

#: library/datetime.rst:2355
msgid "Microsecond as a decimal number, zero-padded on the left."
msgstr "Microsecondes sur 6 chiffres."

#: library/datetime.rst:2355
msgid "000000, 000001, ..., 999999"
msgstr "000000, 000001, ..., 999999"

#: library/datetime.rst:2355
msgid "\\(5)"
msgstr "\\(5)"

#: library/datetime.rst:2522
msgid "``%z``"
msgstr "``%z``"

#: library/datetime.rst:2359
msgid ""
"UTC offset in the form ``±HHMM[SS[.ffffff]]`` (empty string if the object is "
"naive)."
msgstr ""
"Décalage horaire UTC sous la forme ``±HHMM[SS[.ffffff]]`` (chaîne vide si "
"l'instance est naïve)."

#: library/datetime.rst:2359
msgid "(empty), +0000, -0400, +1030, +063415, -030712.345216"
msgstr "(vide), +0000, -0400, +1030, +063415, -030712.345216"

#: library/datetime.rst:2359
msgid "\\(6)"
msgstr "\\(6)"

#: library/datetime.rst:2537
msgid "``%Z``"
msgstr "``%Z``"

#: library/datetime.rst:2364
msgid "Time zone name (empty string if the object is naive)."
msgstr "Nom du fuseau horaire (chaîne vide si l'instance est naïve)."

#: library/datetime.rst:2364
msgid "(empty), UTC, EST, CST"
msgstr "(vide), UTC, EST, CST"

#: library/datetime.rst:2367
msgid "``%j``"
msgstr "``%j``"

#: library/datetime.rst:2367
msgid "Day of the year as a zero-padded decimal number."
msgstr "Numéro du jour dans l'année sur trois chiffres."

#: library/datetime.rst:2367
msgid "001, 002, ..., 366"
msgstr "001, 002, ..., 366"

#: library/datetime.rst:2370
msgid "``%U``"
msgstr "``%U``"

#: library/datetime.rst:2370
msgid ""
"Week number of the year (Sunday as the first day of the week) as a zero "
"padded decimal number. All days in a new year preceding the first Sunday are "
"considered to be in week 0."
msgstr ""
"Numéro de la semaine à deux chiffres (où dimanche est considéré comme le "
"premier jour de la semaine). Tous les jours de l'année précédent le premier "
"dimanche sont considérés comme appartenant à la semaine 0."

#: library/datetime.rst:2378
msgid "00, 01, ..., 53"
msgstr "00, 01, ..., 53"

#: library/datetime.rst:2378
msgid "\\(7), \\(9)"
msgstr "\\(7), \\(9)"

#: library/datetime.rst:2378
msgid "``%W``"
msgstr "``%W``"

#: library/datetime.rst:2378
msgid ""
"Week number of the year (Monday as the first day of the week) as a decimal "
"number. All days in a new year preceding the first Monday are considered to "
"be in week 0."
msgstr ""
"Numéro de la semaine à deux chiffres (où lundi est considéré comme le "
"premier jour de la semaine). Tous les jours de l'année précédent le premier "
"lundi sont considérés comme appartenant à la semaine 0."

#: library/datetime.rst:2386
msgid "``%c``"
msgstr "``%c``"

#: library/datetime.rst:2386
msgid "Locale's appropriate date and time representation."
msgstr "Représentation locale de la date et de l'heure."

#: library/datetime.rst:0
msgid "Tue Aug 16 21:30:00 1988 (en_US);"
msgstr "Tue Aug 16 21:30:00 1988 (*en_US*);"

#: library/datetime.rst:0
msgid "Di 16 Aug 21:30:00 1988 (de_DE)"
msgstr "mar. 16 août 1988 21:30:00 (*fr_FR*)"

#: library/datetime.rst:2391
msgid "``%x``"
msgstr "``%x``"

#: library/datetime.rst:2391
msgid "Locale's appropriate date representation."
msgstr "Représentation locale de la date."

#: library/datetime.rst:0
msgid "08/16/88 (None);"
msgstr "08/16/88 (None);"

#: library/datetime.rst:0
msgid "08/16/1988 (en_US);"
msgstr "08/16/1988 (*en_US*);"

#: library/datetime.rst:0
msgid "16.08.1988 (de_DE)"
msgstr "16/08/1988 (*fr_FR*)"

#: library/datetime.rst:2395
msgid "``%X``"
msgstr "``%X``"

#: library/datetime.rst:2395
msgid "Locale's appropriate time representation."
msgstr "Représentation locale de l'heure."

#: library/datetime.rst:0
msgid "21:30:00 (en_US);"
msgstr "21:30:00 (*en_US*) ;"

#: library/datetime.rst:0
msgid "21:30:00 (de_DE)"
msgstr "21:30:00 (*fr_FR*)"

#: library/datetime.rst:2398
msgid "``%%``"
msgstr "``%%``"

#: library/datetime.rst:2398
msgid "A literal ``'%'`` character."
msgstr "Un caractère ``'%'`` littéral."

#: library/datetime.rst:2398
msgid "%"
msgstr "%"

#: library/datetime.rst:2401
msgid ""
"Several additional directives not required by the C89 standard are included "
"for convenience. These parameters all correspond to ISO 8601 date values."
msgstr ""
"Plusieurs directives supplémentaires non requises par la norme C89 sont "
"incluses pour des raisons de commodité. Ces paramètres correspondent tous "
"aux valeurs de date de la norme ISO 8601."

#: library/datetime.rst:2407
msgid "``%G``"
msgstr "``%G``"

#: library/datetime.rst:2407
msgid ""
"ISO 8601 year with century representing the year that contains the greater "
"part of the ISO week (``%V``)."
msgstr ""
"Année complète ISO 8601 représentant l'année contenant la plus grande partie "
"de la semaine ISO (``%V``)."

#: library/datetime.rst:2407
msgid "\\(8)"
msgstr "\\(8)"

#: library/datetime.rst:2412
msgid "``%u``"
msgstr "``%u``"

#: library/datetime.rst:2412
msgid "ISO 8601 weekday as a decimal number where 1 is Monday."
msgstr "Jour de la semaine ISO 8601 où 1 correspond au lundi."

#: library/datetime.rst:2412
msgid "1, 2, ..., 7"
msgstr "1, 2, ..., 7"

#: library/datetime.rst:2415
msgid "``%V``"
msgstr "``%V``"

#: library/datetime.rst:2415
msgid ""
"ISO 8601 week as a decimal number with Monday as the first day of the week. "
"Week 01 is the week containing Jan 4."
msgstr ""
"Numéro de la semaine ISO 8601, avec lundi étant le premier jour de la "
"semaine. La semaine 01 est la semaine contenant le 4 janvier."

#: library/datetime.rst:2415
msgid "01, 02, ..., 53"
msgstr "01, 02, ..., 53"

#: library/datetime.rst:2415
msgid "\\(8), \\(9)"
msgstr "\\(8), \\(9)"

#: library/datetime.rst:2422
#, fuzzy
msgid ""
"These may not be available on all platforms when used with the :meth:"
"`strftime` method. The ISO 8601 year and ISO 8601 week directives are not "
"interchangeable with the year and week number directives above. Calling :"
"meth:`strptime` with incomplete or ambiguous ISO 8601 directives will raise "
"a :exc:`ValueError`."
msgstr ""
"Plusieurs directives additionnelles non requises par le standard *C89* sont "
"incluses par commodité. Ces paramètres correspondent tous aux valeurs de "
"dates ISO 8601. Ils peuvent ne pas être disponibles sur toutes les "
"plateformes quand utilisés avec la méthode :meth:`strftime`. Les directives "
"ISO 8601 d'année et de semaine ne sont pas interchangeables avec les "
"directives d'année et de semaine précédentes. Appeler :meth:`strptime` avec "
"des directives ISO 8601 incomplètes ou ambiguës lèvera une :exc:`ValueError`."

#: library/datetime.rst:2427
#, fuzzy
msgid ""
"The full set of format codes supported varies across platforms, because "
"Python calls the platform C library's :func:`strftime` function, and "
"platform variations are common. To see the full set of format codes "
"supported on your platform, consult the :manpage:`strftime(3)` documentation."
msgstr ""
"L'ensemble complet des codes de formatage implémentés varie selon les "
"plateformes, parce que Python appelle la fonction :func:`strftime` de la "
"bibliothèque C de la plateforme, et les variations sont courantes.  Pour "
"voir un ensemble complet des codes de formatage implémentés par votre "
"plateforme, consultez la documentation de :manpage:`strftime(3)`."

#: library/datetime.rst:2432
msgid "``%G``, ``%u`` and ``%V`` were added."
msgstr "``%G``, ``%u`` et ``%V`` ont été ajoutés."

#: library/datetime.rst:2436
msgid "Technical Detail"
msgstr "Détail technique"

#: library/datetime.rst:2438
#, fuzzy
msgid ""
"Broadly speaking, ``d.strftime(fmt)`` acts like the :mod:`time` module's "
"``time.strftime(fmt, d.timetuple())`` although not all objects support a :"
"meth:`timetuple` method."
msgstr ""
"Les objets :class:`date`, :class:`.datetime` et :class:`.time` comportent "
"tous une méthode ``strftime(format)``, pour créer une représentation du "
"temps sous forme d'une chaîne de caractères, contrôlée par une chaîne de "
"formatage explicite.  Grossièrement, ``d.strftime(fmt)`` se comporte comme "
"la fonction ``time.strftime(fmt, d.timetuple())`` du module :mod:`time`, "
"bien que tous les objets ne comportent pas de méthode :meth:`timetuple`."

#: library/datetime.rst:2442
msgid ""
"For the :meth:`datetime.strptime` class method, the default value is "
"``1900-01-01T00:00:00.000``: any components not specified in the format "
"string will be pulled from the default value. [#]_"
msgstr ""
"Pour la méthode :meth:`datetime.strptime`, la valeur par défaut est "
"``1900-01-01T00:00:00.000`` : tous les composants non spécifiés dans la "
"chaîne de formatage seront retirés de la valeur par défaut. [#]_"

#: library/datetime.rst:2446
msgid "Using ``datetime.strptime(date_string, format)`` is equivalent to::"
msgstr ""
"L'utilisation de ``datetime.strptime(date_string, format)`` équivaut à ::"

#: library/datetime.rst:2450
msgid ""
"except when the format includes sub-second components or timezone offset "
"information, which are supported in ``datetime.strptime`` but are discarded "
"by ``time.strptime``."
msgstr ""
"sauf lorsque le format inclut des composantes de sous-secondes ou des "
"informations de décalage de fuseau horaire, qui sont prises en charge dans "
"``datetime.strptime`` mais pas par ``time.strptime``."

#: library/datetime.rst:2454
#, fuzzy
msgid ""
"For :class:`.time` objects, the format codes for year, month, and day should "
"not be used, as :class:`time` objects have no such values. If they're used "
"anyway, ``1900`` is substituted for the year, and ``1`` for the month and "
"day."
msgstr ""
"Pour les objets :class:`.time`, les codes de formatage pour l'année, le mois "
"et le jour ne devraient pas être utilisés, puisque les objets de temps ne "
"possèdent pas de telles valeurs.  S'ils sont tout de même utilisés, ``1900`` "
"est substitué à l'année, et ``1`` au mois et au jour."

#: library/datetime.rst:2458
#, fuzzy
msgid ""
"For :class:`date` objects, the format codes for hours, minutes, seconds, and "
"microseconds should not be used, as :class:`date` objects have no such "
"values. If they're used anyway, ``0`` is substituted for them."
msgstr ""
"Pour les objets :class:`date`, les codes de formatage pour les heures, "
"minutes, secondes et microsecondes ne devraient pas être utilisés, puisque "
"les objets :class:`date` ne possèdent pas de telles valeurs.  S'ils sont "
"tous de même utilisés, ils sont substitués par ``0``."

#: library/datetime.rst:2462
msgid ""
"For the same reason, handling of format strings containing Unicode code "
"points that can't be represented in the charset of the current locale is "
"also platform-dependent. On some platforms such code points are preserved "
"intact in the output, while on others ``strftime`` may raise :exc:"
"`UnicodeError` or return an empty string instead."
msgstr ""
"Pour la même raison, la gestion des chaînes contenant des caractères (ou "
"points) Unicode qui ne peuvent pas être représentés dans la *locale* "
"actuelle dépend aussi de la plateforme. Sur certaines plateformes, ces "
"caractères sont conservés tels quels dans la sortie, alors que sur d'autres "
"plateformes ``strftime`` lève une :exc:`UnicodeError` ou renvoie une chaîne "
"vide."

#: library/datetime.rst:2471
msgid ""
"Because the format depends on the current locale, care should be taken when "
"making assumptions about the output value. Field orderings will vary (for "
"example, \"month/day/year\" versus \"day/month/year\"), and the output may "
"contain Unicode characters encoded using the locale's default encoding (for "
"example, if the current locale is ``ja_JP``, the default encoding could be "
"any one of ``eucJP``, ``SJIS``, or ``utf-8``; use :meth:`locale.getlocale` "
"to determine the current locale's encoding)."
msgstr ""
"Comme le format dépend de la locale courante, les assomptions sur la valeur "
"de retour doivent être prises soigneusement. L'ordre des champs variera (par "
"exemple, « mois/jour/année » versus « année/mois/jour »), et le retour "
"pourrait contenir des caractères Unicode encodés en utilisant l'encodage par "
"défaut de la locale (par exemple, si la locale courante est ``ja_JP``, "
"l'encodage par défaut pourrait être ``eucJP``, ``SJIS`` ou ``utf-8`` ; "
"utilisez :meth:`locale.getlocale` pour déterminer l'encodage de la locale "
"courante)."

#: library/datetime.rst:2480
msgid ""
"The :meth:`strptime` method can parse years in the full [1, 9999] range, but "
"years < 1000 must be zero-filled to 4-digit width."
msgstr ""
"La méthode :meth:`strptime` peut analyser toutes les années de l'intervalle "
"[1, 9999], mais toutes les années < 1000 doivent être représentées sur "
"quatre chiffres."

#: library/datetime.rst:2483
msgid ""
"In previous versions, :meth:`strftime` method was restricted to years >= "
"1900."
msgstr ""
"Dans les versions précédentes, la méthode :meth:`strftime` était limitée aux "
"années >= 1900."

#: library/datetime.rst:2487
msgid ""
"In version 3.2, :meth:`strftime` method was restricted to years >= 1000."
msgstr ""
"En version 3.2, la méthode :meth:`strftime` était limitée aux années >= 1000."

#: library/datetime.rst:2492
msgid ""
"When used with the :meth:`strptime` method, the ``%p`` directive only "
"affects the output hour field if the ``%I`` directive is used to parse the "
"hour."
msgstr ""
"Quand utilisée avec la méthode :meth:`strptime`, la directive ``%p`` "
"n'affecte l'heure extraite que si la directive ``%I`` est utilisée pour "
"analyser l'heure."

#: library/datetime.rst:2496
msgid ""
"Unlike the :mod:`time` module, the :mod:`datetime` module does not support "
"leap seconds."
msgstr ""
"À l'inverse du module :mod:`time`, le module :mod:`datetime` ne gère pas les "
"secondes intercalaires."

#: library/datetime.rst:2500
#, fuzzy
msgid ""
"When used with the :meth:`strptime` method, the ``%f`` directive accepts "
"from one to six digits and zero pads on the right. ``%f`` is an extension to "
"the set of format characters in the C standard (but implemented separately "
"in datetime objects, and therefore always available)."
msgstr ""
"Quand utilisée avec la méthode :meth:`strptime`, la directive ``%f`` accepte "
"un nombre de 1 à 6 chiffres, où des zéros seront ajoutés à droite jusqu'à "
"former un nombre de 6 chiffres.  ``%f`` est une extension de l'ensemble des "
"caractères de formatage du standard C (mais implémentée séparément dans les "
"objets *datetime*, la rendant ainsi toujours disponible)."

#: library/datetime.rst:2507
msgid ""
"For a naive object, the ``%z`` and ``%Z`` format codes are replaced by empty "
"strings."
msgstr ""
"Pour les objets naïfs, les codes de formatage ``%z`` et ``%Z`` sont "
"remplacés par des chaînes vides."

#: library/datetime.rst:2510
msgid "For an aware object:"
msgstr "Pour un objet avisé :"

#: library/datetime.rst:2513
#, fuzzy
msgid ""
":meth:`utcoffset` is transformed into a string of the form ``±HHMM[SS[."
"ffffff]]``, where ``HH`` is a 2-digit string giving the number of UTC offset "
"hours, ``MM`` is a 2-digit string giving the number of UTC offset minutes, "
"``SS`` is a 2-digit string giving the number of UTC offset seconds and "
"``ffffff`` is a 6-digit string giving the number of UTC offset microseconds. "
"The ``ffffff`` part is omitted when the offset is a whole number of seconds "
"and both the ``ffffff`` and the ``SS`` part is omitted when the offset is a "
"whole number of minutes. For example, if :meth:`utcoffset` returns "
"``timedelta(hours=-3, minutes=-30)``, ``%z`` is replaced with the string "
"``'-0330'``."
msgstr ""
"Le résultat de :meth:`utcoffset` est transformé en une chaîne sous la forme "
"``±HHMM[SS[.uuuuuu]]``, où ``HH`` est une chaîne de deux chiffres donnant le "
"nombre d'heures du décalage UTC, où ``MM`` est une chaîne de deux chiffres "
"donnant le nombre de minutes du décalage UTC, où ``SS`` est une chaîne de "
"deux chiffres donnant le nombre de secondes du décalage UTC et où ``ffffff`` "
"est une chaîne de six chiffres donnant le nombre en micro-secondes du "
"décalage UTC. Par exemple, si :meth:`utcoffset` renvoie "
"``timedelta(hours=-3, minutes=-30)``, ``%z`` est remplacé par la chaîne "
"`'-0330'``."

#: library/datetime.rst:2527
msgid ""
"When the ``%z`` directive is provided to the  :meth:`strptime` method, the "
"UTC offsets can have a colon as a separator between hours, minutes and "
"seconds. For example, ``'+01:00:00'`` will be parsed as an offset of one "
"hour. In addition, providing ``'Z'`` is identical to ``'+00:00'``."
msgstr ""
"Quand la directive ``%z`` est soumise à la méthode :meth:`strptime`, le "
"décalage UTC peut avoir une colonne comme séparateur entre les heures, "
"minutes et secondes. Par exemple, ``'+01:00:00'``, est analysé comme un "
"décalage d'une heure. Par ailleurs, ``'Z'`` est identique à ``'+00:00'``."

#: library/datetime.rst:2535
#, fuzzy
msgid ""
"If :meth:`tzname` returns ``None``, ``%Z`` is replaced by an empty string. "
"Otherwise ``%Z`` is replaced by the returned value, which must be a string."
msgstr ""
"Si :meth:`tzname` renvoie ``None``, ``%Z`` est remplacé par une chaîne "
"vide.  Autrement ``%Z`` est remplacé par la valeur renvoyée, qui doit être "
"une chaîne."

#: library/datetime.rst:2539
#, fuzzy
msgid ""
"When the ``%z`` directive is provided to the :meth:`strptime` method, an "
"aware :class:`.datetime` object will be produced. The ``tzinfo`` of the "
"result will be set to a :class:`timezone` instance."
msgstr ""
"Quand la directive ``%z`` est fournie à la méthode :meth:`strptime`, un "
"objet :class:`.datetime` avisé est construit.  L'attribut ``tzinfo`` du "
"résultat aura pour valeur une instance de :class:`timezone`."

#: library/datetime.rst:2545
msgid ""
"When used with the :meth:`strptime` method, ``%U`` and ``%W`` are only used "
"in calculations when the day of the week and the calendar year (``%Y``) are "
"specified."
msgstr ""
"Quand ces directives sont utilisées avec la méthode :meth:`strptime`, ``%U`` "
"et ``%W`` ne sont utilisées dans les calculs que si le jour de la semaine et "
"l'année calendaire (``%Y``) sont spécifiés."

#: library/datetime.rst:2550
msgid ""
"Similar to ``%U`` and ``%W``, ``%V`` is only used in calculations when the "
"day of the week and the ISO year (``%G``) are specified in a :meth:"
"`strptime` format string. Also note that ``%G`` and ``%Y`` are not "
"interchangeable."
msgstr ""
"De façon similaire à ``%U`` et ``%W``, ``%v`` n'est utilisé dans les calculs "
"que lorsque le jour de la semaine et l'année ISO (``%G``) sont spécifiés "
"dans la chaîne de formatage :meth:`strptime`. Notez aussi que ``%G`` et "
"``%Y`` ne sont pas interchangeables."

#: library/datetime.rst:2556
msgid ""
"When used with the :meth:`strptime` method, the leading zero is optional "
"for  formats ``%d``, ``%m``, ``%H``, ``%I``, ``%M``, ``%S``, ``%J``, ``%U``, "
"``%W``, and ``%V``. Format ``%y`` does require a leading zero."
msgstr ""
"Quand cette directive est utilisée avec la méthode :meth:`strptime`, le zéro "
"d'entête est optionnel pour les formats ``%d``, ``%m``, ``%H``, ``%I``, "
"``%M``, ``%S``, ``%J``, ``%U``, ``%W`` et ``%V``. Le format ``%y`` requiert "
"un zéro en entête."

#: library/datetime.rst:2561
msgid "Footnotes"
msgstr "Notes"

#: library/datetime.rst:2562
msgid "If, that is, we ignore the effects of Relativity"
msgstr "Si on ignore les effets de la Relativité"

#: library/datetime.rst:2564
#, fuzzy
msgid ""
"This matches the definition of the \"proleptic Gregorian\" calendar in "
"Dershowitz and Reingold's book *Calendrical Calculations*, where it's the "
"base calendar for all computations. See the book for algorithms for "
"converting between proleptic Gregorian ordinals and many other calendar "
"systems."
msgstr ""
"Un objet :class:`date` représente une date (année, mois et jour) dans un "
"calendrier idéal, l'actuel calendrier grégorien étendu indéfiniment dans les "
"deux directions.  Le 1er janvier de l'an 1 est appelé le jour numéro 1, le 2 "
"janvier de l'an 1 est appelé le jour numéro 2, et ainsi de suite.  Cela "
"correspond à la définition du calendrier « grégorien proleptique » dans le "
"livre *Calendrical Calculations* de Dershowitz et Reingold, où il est la "
"base de tous les calculs.  Référez-vous au livre pour les algorithmes de "
"conversion entre calendriers grégorien proleptique et les autres systèmes."

#: library/datetime.rst:2570
#, fuzzy
msgid ""
"See R. H. van Gent's `guide to the mathematics of the ISO 8601 calendar "
"<https://www.staff.science.uu.nl/~gent0113/calendar/isocalendar.htm>`_ for a "
"good explanation."
msgstr ""
"Le calendrier ISO est une variante largement utilisée du calendrier "
"grégorien. Voir https://www.staff.science.uu.nl/~gent0113/calendar/"
"isocalendar.htm pour une bonne explication."

#: library/datetime.rst:2574
msgid ""
"Passing ``datetime.strptime('Feb 29', '%b %d')`` will fail since ``1900`` is "
"not a leap year."
msgstr ""
"Passer ``datetime.strptime(‘Feb 29’, ‘%b %d’)`` ne marchera pas car ``1900`` "
"n’est pas une année bissextile."

#~ msgid ""
#~ "There are two kinds of date and time objects: \"naive\" and \"aware\"."
#~ msgstr ""
#~ "Il y a deux sortes d'objets *date* et *time* : les \"naïfs\" et les "
#~ "\"avisés\"."

#~ msgid ""
#~ "An object of type :class:`.time` or :class:`.datetime` may be naive or "
#~ "aware. A :class:`.datetime` object *d* is aware if ``d.tzinfo`` is not "
#~ "``None`` and ``d.tzinfo.utcoffset(d)`` does not return ``None``.  If ``d."
#~ "tzinfo`` is ``None``, or if ``d.tzinfo`` is not ``None`` but ``d.tzinfo."
#~ "utcoffset(d)`` returns ``None``, *d* is naive.  A :class:`.time` object "
#~ "*t* is aware if ``t.tzinfo`` is not ``None`` and ``t.tzinfo."
#~ "utcoffset(None)`` does not return ``None``.  Otherwise, *t* is naive."
#~ msgstr ""
#~ "Un objet de type :class:`.time` ou :class:`.datetime` peut être naïf ou "
#~ "avisé. Un objet :class:`.datetime` *d* est avisé si ``d.tzinfo`` ne vaut "
#~ "pas ``None`` et que ``d.tzinfo.utcoffset(d)`` ne renvoie pas ``None``. Si "
#~ "``d.tzinfo`` vaut ``None`` ou que ``d.tzinfo`` ne vaut pas ``None`` mais "
#~ "que ``d.tzinfo.utcoffset(d)`` renvoie ``None``, alors *d* est naïf. Un "
#~ "objet :class:`.time` *t* est avisé si ``t.tzinfo`` ne vaut pas ``None`` "
#~ "et que ``t.tzinfo.utcoffset(None)`` ne renvoie pas ``None``. Sinon, *t* "
#~ "est naïf."

#~ msgid "Class attributes are:"
#~ msgstr "Les attributs de la classe sont :"

#~ msgid ""
#~ "Comparisons of :class:`timedelta` objects are supported with the :class:"
#~ "`timedelta` object representing the smaller duration considered to be the "
#~ "smaller timedelta. In order to stop mixed-type comparisons from falling "
#~ "back to the default comparison by object address, when a :class:"
#~ "`timedelta` object is compared to an object of a different type, :exc:"
#~ "`TypeError` is raised unless the comparison is ``==`` or ``!=``.  The "
#~ "latter cases return :const:`False` or :const:`True`, respectively."
#~ msgstr ""
#~ "Les comparaisons entre objets :class:`timedelta` sont maintenant gérées "
#~ "avec le :class:`timedelta` représentant la plus courte durée considéré "
#~ "comme le plus petit. Afin d'empêcher les comparaisons de types mixtes de "
#~ "retomber sur la comparaison par défaut par l'adresse de l'objet, quand un "
#~ "objet :class:`timedelta` est comparé à un objet de type différent, une :"
#~ "exc:`TypeError` est levée à moins que la comparaison soit ``==`` ou ``!"
#~ "=``.  Ces derniers cas renvoient respectivement :const:`False` et :const:"
#~ "`True`."

#~ msgid "Example usage:"
#~ msgstr "Exemple d'utilisation :"

#~ msgid ""
#~ "This does not support parsing arbitrary ISO 8601 strings - it is only "
#~ "intended as the inverse operation of :meth:`date.isoformat`."
#~ msgstr ""
#~ "Ceci n'implémente pas l'analyse de chaînes ISO 8601 arbitraires, ceci est "
#~ "seulement destiné à réaliser l'opération inverse de :meth:`date."
#~ "isoformat`."

#~ msgid ""
#~ "Dates can be used as dictionary keys. In Boolean contexts, all :class:"
#~ "`date` objects are considered to be true."
#~ msgstr ""
#~ "Les dates peuvent être utilisées en tant que clés de dictionnaires. Dans "
#~ "un contexte booléen, tous les objets :class:`date` sont considérés comme "
#~ "vrais."

#~ msgid ""
#~ "Return a :class:`time.struct_time` such as returned by :func:`time."
#~ "localtime`. The hours, minutes and seconds are 0, and the DST flag is -1. "
#~ "``d.timetuple()`` is equivalent to ``time.struct_time((d.year, d.month, d."
#~ "day, 0, 0, 0, d.weekday(), yday, -1))``, where ``yday = d.toordinal() - "
#~ "date(d.year, 1, 1).toordinal() + 1`` is the day number within the current "
#~ "year starting with ``1`` for January 1st."
#~ msgstr ""
#~ "Renvoie une :class:`time.struct_time` telle que renvoyée par :func:`time."
#~ "localtime`. Les heures, minutes et secondes valent 0, et le *flag* *DST* "
#~ "(heure d'été) est ``-1``. ``d.timetuple()`` est équivalent à ``time."
#~ "struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))``, "
#~ "où ``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` est le "
#~ "numéro du jour dans l'année courante, commençant avec ``1`` pour le 1er "
#~ "janvier."

#~ msgid ""
#~ "Return the current local datetime, with :attr:`.tzinfo` ``None``. This is "
#~ "equivalent to ``datetime.fromtimestamp(time.time())``. See also :meth:"
#~ "`now`, :meth:`fromtimestamp`."
#~ msgstr ""
#~ "Renvoie le *datetime* local courant, avec :attr:`.tzinfo` à ``None``. "
#~ "Cela est équivalent à ``datetime.fromtimestamp(time.time())``. Voir "
#~ "aussi :meth:`now`, :meth:`fromtimestamp`."

#~ msgid ""
#~ "Return a :class:`datetime` corresponding to a *date_string* in one of the "
#~ "formats emitted by :meth:`date.isoformat` and :meth:`datetime.isoformat`. "
#~ "Specifically, this function supports strings in the format(s) ``YYYY-MM-"
#~ "DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]]``, where ``*`` can "
#~ "match any single character."
#~ msgstr ""
#~ "Renvoie une :class:`datetime` correspondant à *date_string* dans un des "
#~ "formats émis par :meth:`date.isoformat` et :meth:`datetime.isoformat`. "
#~ "Plus spécifiquement, cette fonction supporte des chaînes dans les "
#~ "format(s) ``YYYY-MM-DD[*HH[:MM[:SS[.mmm[mmm]]]][+HH:MM[:SS[.ffffff]]]]``, "
#~ "où ``*`` peut égaler n'importe quel caractère."

#~ msgid ""
#~ "If :meth:`utcoffset` does not return ``None``, a string is appended, "
#~ "giving the UTC offset: YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]] or, "
#~ "if :attr:`microsecond` is 0 YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]."
#~ msgstr ""
#~ "Si :meth:`utcoffset` ne renvoie pas ``None``, une chaîne est ajoutée, "
#~ "donnant le décalage UTC : *YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[."
#~ "ffffff]]* ou, si :attr:`microsecond` vaut 0, *YYYY-MM-DDTHH:MM:SS+HH:MM[:"
#~ "SS[.ffffff]]*."

#~ msgid ""
#~ "Return a string representing the date and time, for example "
#~ "``datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec  4 20:30:40 "
#~ "2002'``. ``d.ctime()`` is equivalent to ``time.ctime(time.mktime(d."
#~ "timetuple()))`` on platforms where the native C :c:func:`ctime` function "
#~ "(which :func:`time.ctime` invokes, but which :meth:`datetime.ctime` does "
#~ "not invoke) conforms to the C standard."
#~ msgstr ""
#~ "Renvoie une chaîne représentant la date et l'heure, par exemple "
#~ "``datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec  4 20:30:40 "
#~ "2002'``. ``d.ctime()`` est équivalent à ``time.ctime(time.mktime(d."
#~ "timetuple()))`` sur les plateformes où la fonction C native :c:func:"
#~ "`ctime` (invoquée par :func:`time.ctime` mais pas par :meth:`datetime."
#~ "ctime`) est conforme au standard C."

#~ msgid "Using datetime with tzinfo:"
#~ msgstr "Utilisation de *datetime* avec *tzinfo* :"

#~ msgid "hash, use as dict key"
#~ msgstr "hachage, utilisation comme clef de dictionnaire"

#~ msgid "efficient pickling"
#~ msgstr "sérialisation (*pickling*) efficace"

#~ msgid ""
#~ "Return a :class:`time` corresponding to a *time_string* in one of the "
#~ "formats emitted by :meth:`time.isoformat`. Specifically, this function "
#~ "supports strings in the format(s) ``HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[."
#~ "ffffff]]]``."
#~ msgstr ""
#~ "Renvoie une :class:`time` correspondant à *time_string* dans l'un des "
#~ "formats émis par :meth:`time.isoformat`. Plus spécifiquement, cette "
#~ "fonction est compatible avec des chaînes dans le(s) format(s) ``HH[:MM[:"
#~ "SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]``."

#~ msgid ""
#~ "Return a string representing the time in ISO 8601 format, HH:MM:SS.ffffff "
#~ "or, if :attr:`microsecond` is 0, HH:MM:SS If :meth:`utcoffset` does not "
#~ "return ``None``, a string is appended, giving the UTC offset: HH:MM:SS."
#~ "ffffff+HH:MM[:SS[.ffffff]] or, if self.microsecond is 0, HH:MM:SS+HH:MM[:"
#~ "SS[.ffffff]]."
#~ msgstr ""
#~ "Renvoie une chaîne représentant l'heure au format ISO 8601, ``HH:MM:SS."
#~ "ffffff`` ou, si :attr:`microsecond` vaut 0, ``HH:MM:SS`` Si :meth:"
#~ "`utcoffset` ne renvoie pas ``None``, une chaîne est ajoutée, donnant le "
#~ "décalage UTC : ``HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]`` ou, si ``self."
#~ "microsecond`` vaut 0, ``HH:MM:SS+HH:MM[:SS[.ffffff]]``."

#~ msgid "or ::"
#~ msgstr "ou ::"

#~ msgid ""
#~ "Conversely, the :meth:`datetime.strptime` class method creates a :class:`."
#~ "datetime` object from a string representing a date and time and a "
#~ "corresponding format string. ``datetime.strptime(date_string, format)`` "
#~ "is equivalent to ``datetime(*(time.strptime(date_string, format)"
#~ "[0:6]))``, except when the format includes sub-second components or "
#~ "timezone offset information, which are supported in ``datetime.strptime`` "
#~ "but are discarded by ``time.strptime``."
#~ msgstr ""
#~ "Inversement, la méthode de classe :meth:`datetime.strptime` crée un "
#~ "objet :class:`.datetime` à partir d'une représentation de date et heure "
#~ "et d'une chaîne de formatage correspondante. ``datetime."
#~ "strptime(date_string, format)`` est équivalent à ``datetime(*(time."
#~ "strptime(date_string, format)[0:6]))``, sauf quand le format inclut une "
#~ "composante en-dessous de la seconde ou une information de fuseau "
#~ "horaire ; ces composantes sont gérées par ``datetime.strptime`` mais sont "
#~ "ignorées par ``time.strptime``."

#~ msgid ""
#~ "This does not support parsing arbitrary ISO 8601 strings - it is only "
#~ "intended as the inverse operation of :meth:`datetime.isoformat`."
#~ msgstr ""
#~ "Elle ne gère pas l'analyse de chaînes ISO 8601 arbitraires, elle est "
#~ "seulement destinée à être utilisée comme opération inverse de :meth:"
#~ "`datetime.isoformat`."

#~ msgid "\\(4)"
#~ msgstr "\\(4)"

#~ msgid "\\(7)"
#~ msgstr "\\(7)"