2111 lines
97 KiB
Plaintext
2111 lines
97 KiB
Plaintext
# 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: 2023-07-21 14:55+0200\n"
|
||
"PO-Revision-Date: 2024-03-15 22:32+0100\n"
|
||
"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\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"
|
||
"X-Generator: Poedit 3.2.2\n"
|
||
|
||
#: library/xml.etree.elementtree.rst:2
|
||
msgid ":mod:`xml.etree.ElementTree` --- The ElementTree XML API"
|
||
msgstr ":mod:`xml.etree.ElementTree` — L'API *ElementTree* XML"
|
||
|
||
#: library/xml.etree.elementtree.rst:9
|
||
msgid "**Source code:** :source:`Lib/xml/etree/ElementTree.py`"
|
||
msgstr "**Code Source:** :source:`Lib/xml/etree/ElementTree.py`"
|
||
|
||
#: library/xml.etree.elementtree.rst:13
|
||
msgid ""
|
||
"The :mod:`xml.etree.ElementTree` module implements a simple and efficient "
|
||
"API for parsing and creating XML data."
|
||
msgstr ""
|
||
"Le module :mod:`xml.etree.ElementTree` implémente une API simple et "
|
||
"efficace pour analyser et créer des données XML."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:16
|
||
msgid "This module will use a fast implementation whenever available."
|
||
msgstr ""
|
||
"ce module utilise une implémentation rapide chaque fois que c'est possible."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:19
|
||
msgid "The :mod:`xml.etree.cElementTree` module is deprecated."
|
||
msgstr "le module :mod:`xml.etree.cElementTree` est obsolète."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:25
|
||
msgid ""
|
||
"The :mod:`xml.etree.ElementTree` module is not secure against maliciously "
|
||
"constructed data. If you need to parse untrusted or unauthenticated data "
|
||
"see :ref:`xml-vulnerabilities`."
|
||
msgstr ""
|
||
"le module :mod:`xml.sax` n'est pas sécurisé contre les données construites "
|
||
"de façon malveillante. Si vous avez besoin d'analyser des données non "
|
||
"sécurisées ou non authentifiées, référez-vous à :ref:`xml-vulnerabilities`."
|
||
|
||
#: library/xml.etree.elementtree.rst:30
|
||
msgid "Tutorial"
|
||
msgstr "Tutoriel"
|
||
|
||
#: library/xml.etree.elementtree.rst:32
|
||
msgid ""
|
||
"This is a short tutorial for using :mod:`xml.etree.ElementTree` (``ET`` in "
|
||
"short). The goal is to demonstrate some of the building blocks and basic "
|
||
"concepts of the module."
|
||
msgstr ""
|
||
"Ceci est un petit tutoriel pour utiliser :mod:`xml.etree.ElementTree` "
|
||
"(``ET``). Le but est de montrer quelques composants et les concepts basiques "
|
||
"du module."
|
||
|
||
#: library/xml.etree.elementtree.rst:37
|
||
msgid "XML tree and elements"
|
||
msgstr "Arborescence et éléments XML"
|
||
|
||
#: library/xml.etree.elementtree.rst:39
|
||
msgid ""
|
||
"XML is an inherently hierarchical data format, and the most natural way to "
|
||
"represent it is with a tree. ``ET`` has two classes for this purpose - :"
|
||
"class:`ElementTree` represents the whole XML document as a tree, and :class:"
|
||
"`Element` represents a single node in this tree. Interactions with the "
|
||
"whole document (reading and writing to/from files) are usually done on the :"
|
||
"class:`ElementTree` level. Interactions with a single XML element and its "
|
||
"sub-elements are done on the :class:`Element` level."
|
||
msgstr ""
|
||
"XML est un format de données fondamentalement hiérarchique et la façon la "
|
||
"plus naturelle de le représenter est avec un arbre. ``ET`` a deux classes "
|
||
"pour ce but : :class:`ElementTree` représente l'ensemble du document XML "
|
||
"comme un arbre et :class:`Element` représente un simple nœud dans cet arbre. "
|
||
"Les interactions (lire et écrire vers et depuis des fichiers) sur le "
|
||
"document sont habituellement effectuées au niveau de :class:`ElementTree`. "
|
||
"Les interactions sur un seul élément XML et ses sous-éléments sont "
|
||
"effectuées au niveau de :class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:50
|
||
msgid "Parsing XML"
|
||
msgstr "Analyse XML"
|
||
|
||
#: library/xml.etree.elementtree.rst:52
|
||
msgid ""
|
||
"We'll be using the following XML document as the sample data for this "
|
||
"section:"
|
||
msgstr ""
|
||
"Nous utilisons le document XML suivant comme exemple pour cette section :"
|
||
|
||
#: library/xml.etree.elementtree.rst:80
|
||
msgid "We can import this data by reading from a file::"
|
||
msgstr "Nous pouvons importer ces données en lisant un fichier ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:86
|
||
msgid "Or directly from a string::"
|
||
msgstr "Ou depuis une chaîne de caractères ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:90
|
||
msgid ""
|
||
":func:`fromstring` parses XML from a string directly into an :class:"
|
||
"`Element`, which is the root element of the parsed tree. Other parsing "
|
||
"functions may create an :class:`ElementTree`. Check the documentation to be "
|
||
"sure."
|
||
msgstr ""
|
||
":func:`fromstring` analyse les données XML depuis une chaîne de caractères "
|
||
"et produit un :class:`Element`, qui est l'élément racine de l'arbre "
|
||
"analysé. D'autres fonctions d'analyse peuvent créer un :class:"
|
||
"`ElementTree`. Vérifiez la documentation pour en être sûr."
|
||
|
||
#: library/xml.etree.elementtree.rst:94
|
||
msgid ""
|
||
"As an :class:`Element`, ``root`` has a tag and a dictionary of attributes::"
|
||
msgstr ""
|
||
"En tant qu':class:`Element`, ``root`` a une balise (*tag*) et un "
|
||
"dictionnaire d'attributs ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:101
|
||
msgid "It also has children nodes over which we can iterate::"
|
||
msgstr ""
|
||
"Il contient aussi des nœuds enfants sur lesquels nous pouvons itérer ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:110
|
||
msgid "Children are nested, and we can access specific child nodes by index::"
|
||
msgstr ""
|
||
"Les enfants sont imbriqués et nous pouvons accéder aux nœuds enfants "
|
||
"spécifiques *via* un indice ::"
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:118
|
||
msgid ""
|
||
"Not all elements of the XML input will end up as elements of the parsed "
|
||
"tree. Currently, this module skips over any XML comments, processing "
|
||
"instructions, and document type declarations in the input. Nevertheless, "
|
||
"trees built using this module's API rather than parsing from XML text can "
|
||
"have comments and processing instructions in them; they will be included "
|
||
"when generating XML output. A document type declaration may be accessed by "
|
||
"passing a custom :class:`TreeBuilder` instance to the :class:`XMLParser` "
|
||
"constructor."
|
||
msgstr ""
|
||
"les éléments du XML d'entrée ne sont pas tous considérés comme des éléments "
|
||
"de l'arborescence. Actuellement, le module ignore les commentaires XML, les "
|
||
"instructions de traitements et la déclaration du type de document dans "
|
||
"l'entrée. Néanmoins, les arborescences construites en utilisant l'API du "
|
||
"module plutôt que par l'analyse du texte XML peuvent contenir des "
|
||
"commentaires et des instructions de traitement ; ils seront inclus lors de "
|
||
"la génération du XML de sortie. La DTD du document est accessible en passant "
|
||
"une instance de :class:`TreeBuilder` au constructeur de :class:`XMLParser`."
|
||
|
||
#: library/xml.etree.elementtree.rst:132
|
||
msgid "Pull API for non-blocking parsing"
|
||
msgstr "API à flux tiré"
|
||
|
||
#: library/xml.etree.elementtree.rst:134
|
||
msgid ""
|
||
"Most parsing functions provided by this module require the whole document to "
|
||
"be read at once before returning any result. It is possible to use an :"
|
||
"class:`XMLParser` and feed data into it incrementally, but it is a push API "
|
||
"that calls methods on a callback target, which is too low-level and "
|
||
"inconvenient for most needs. Sometimes what the user really wants is to be "
|
||
"able to parse XML incrementally, without blocking operations, while enjoying "
|
||
"the convenience of fully constructed :class:`Element` objects."
|
||
msgstr ""
|
||
"La plupart des fonctions d'analyse fournies par ce module nécessitent que le "
|
||
"document entier soit lu en même temps avant de renvoyer un résultat. Il est "
|
||
"possible d'utiliser un :class:`XMLParser` et d'y introduire des données de "
|
||
"manière incrémentielle, mais il s'agit d'une API à flux poussé qui appelle "
|
||
"des méthodes par rappel automatique, ce qui est de trop bas niveau et peu "
|
||
"pratique pour la plupart des besoins. Parfois, ce que l'utilisateur souhaite "
|
||
"réellement, c'est pouvoir analyser du XML de manière incrémentielle, sans "
|
||
"bloquer les opérations, tout en bénéficiant de la commodité des objets :"
|
||
"class:`Element` entièrement construits."
|
||
|
||
#: library/xml.etree.elementtree.rst:142
|
||
msgid ""
|
||
"The most powerful tool for doing this is :class:`XMLPullParser`. It does "
|
||
"not require a blocking read to obtain the XML data, and is instead fed with "
|
||
"data incrementally with :meth:`XMLPullParser.feed` calls. To get the parsed "
|
||
"XML elements, call :meth:`XMLPullParser.read_events`. Here is an example::"
|
||
msgstr ""
|
||
"L'outil le plus puissant pour ce faire est :class:`XMLPullParser`. Il ne "
|
||
"nécessite pas de lecture bloquante pour obtenir les données XML et est "
|
||
"plutôt alimenté en données de manière incrémentielle avec des appels à :meth:"
|
||
"`XMLPullParser.feed`. Pour obtenir les éléments XML analysés, appelez :meth:"
|
||
"`XMLPullParser.read_events`. Voici un exemple ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:158
|
||
msgid ""
|
||
"The obvious use case is applications that operate in a non-blocking fashion "
|
||
"where the XML data is being received from a socket or read incrementally "
|
||
"from some storage device. In such cases, blocking reads are unacceptable."
|
||
msgstr ""
|
||
"Le cas d'utilisation évident concerne les applications qui fonctionnent de "
|
||
"manière non bloquante dans lesquelles les données XML sont reçues à partir "
|
||
"d'un connecteur réseau ou lues de manière incrémentielle à partir d'un "
|
||
"périphérique de stockage. Dans de tels cas, le blocage des lectures est "
|
||
"inacceptable."
|
||
|
||
#: library/xml.etree.elementtree.rst:162
|
||
msgid ""
|
||
"Because it's so flexible, :class:`XMLPullParser` can be inconvenient to use "
|
||
"for simpler use-cases. If you don't mind your application blocking on "
|
||
"reading XML data but would still like to have incremental parsing "
|
||
"capabilities, take a look at :func:`iterparse`. It can be useful when "
|
||
"you're reading a large XML document and don't want to hold it wholly in "
|
||
"memory."
|
||
msgstr ""
|
||
"Parce qu'il est très flexible, :class:`XMLPullParser` peut être peu pratique "
|
||
"à utiliser pour des cas d'utilisation plus simples. Si cela ne vous dérange "
|
||
"pas que votre application se bloque pendant la lecture de données XML mais "
|
||
"que vous souhaitez tout de même disposer de capacités d'analyse "
|
||
"incrémentielle, jetez un œil à :func:`iterparse`. Cela peut être utile "
|
||
"lorsque vous lisez un document XML volumineux et que vous ne souhaitez pas "
|
||
"le conserver entièrement en mémoire."
|
||
|
||
#: library/xml.etree.elementtree.rst:169
|
||
msgid "Finding interesting elements"
|
||
msgstr "Atteinte d'éléments d'intérêt"
|
||
|
||
#: library/xml.etree.elementtree.rst:171
|
||
msgid ""
|
||
":class:`Element` has some useful methods that help iterate recursively over "
|
||
"all the sub-tree below it (its children, their children, and so on). For "
|
||
"example, :meth:`Element.iter`::"
|
||
msgstr ""
|
||
":class:`Element` a quelques méthodes très utiles qui aident à parcourir "
|
||
"récursivement tous les sous-arbres (ses enfants, leurs enfants et ainsi de "
|
||
"suite). Par exemple, :meth:`Element.iter` ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:184
|
||
msgid ""
|
||
":meth:`Element.findall` finds only elements with a tag which are direct "
|
||
"children of the current element. :meth:`Element.find` finds the *first* "
|
||
"child with a particular tag, and :attr:`Element.text` accesses the element's "
|
||
"text content. :meth:`Element.get` accesses the element's attributes::"
|
||
msgstr ""
|
||
":meth:`Element.findall` récupère seulement les éléments avec une balise qui "
|
||
"sont les descendants directs de l'élément courant. :meth:`Element.find` "
|
||
"récupère le *premier* élément avec une balise particulière et :attr:`Element."
|
||
"text` accède au contenu textuel de l'élément. :meth:`Element.get` accède "
|
||
"aux attributs de l'élément ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:198
|
||
msgid ""
|
||
"More sophisticated specification of which elements to look for is possible "
|
||
"by using :ref:`XPath <elementtree-xpath>`."
|
||
msgstr ""
|
||
"Une caractérisation plus sophistiquée des éléments à rechercher est possible "
|
||
"en utilisant :ref:`XPath <elementtree-xpath>`."
|
||
|
||
#: library/xml.etree.elementtree.rst:202
|
||
msgid "Modifying an XML File"
|
||
msgstr "Modification d'un fichier XML"
|
||
|
||
#: library/xml.etree.elementtree.rst:204
|
||
msgid ""
|
||
":class:`ElementTree` provides a simple way to build XML documents and write "
|
||
"them to files. The :meth:`ElementTree.write` method serves this purpose."
|
||
msgstr ""
|
||
":class:`ElementTree` fournit un moyen simple de créer des documents XML et "
|
||
"de les écrire dans des fichiers. La méthode :meth:`ElementTree.write` sert à "
|
||
"cet effet."
|
||
|
||
#: library/xml.etree.elementtree.rst:207
|
||
msgid ""
|
||
"Once created, an :class:`Element` object may be manipulated by directly "
|
||
"changing its fields (such as :attr:`Element.text`), adding and modifying "
|
||
"attributes (:meth:`Element.set` method), as well as adding new children (for "
|
||
"example with :meth:`Element.append`)."
|
||
msgstr ""
|
||
"Une fois créé, un objet :class:`Element` peut être manipulé en changeant "
|
||
"directement ses champs (tels que :attr:`Element.text`), en ajoutant et en "
|
||
"modifiant des attributs (méthode :meth:`Element.set`), ou en ajoutant de "
|
||
"nouveaux enfants (par exemple avec :meth:`Element.append`)."
|
||
|
||
#: library/xml.etree.elementtree.rst:212
|
||
msgid ""
|
||
"Let's say we want to add one to each country's rank, and add an ``updated`` "
|
||
"attribute to the rank element::"
|
||
msgstr ""
|
||
"Disons que nous voulons en ajouter un au classement de chaque pays, et "
|
||
"ajouter un attribut *updated* (« mis à jour ») à l'élément de classement ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:222 library/xml.etree.elementtree.rst:266
|
||
msgid "Our XML now looks like this:"
|
||
msgstr "Maintenant, notre XML ressemble à ceci :"
|
||
|
||
#: library/xml.etree.elementtree.rst:250
|
||
msgid ""
|
||
"We can remove elements using :meth:`Element.remove`. Let's say we want to "
|
||
"remove all countries with a rank higher than 50::"
|
||
msgstr ""
|
||
"Nous pouvons supprimer des éléments en utilisant :meth:`Element.remove`. "
|
||
"Supposons que nous souhaitions supprimer tous les pays dont le classement "
|
||
"est supérieur à 50 ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:261
|
||
msgid ""
|
||
"Note that concurrent modification while iterating can lead to problems, just "
|
||
"like when iterating and modifying Python lists or dicts. Therefore, the "
|
||
"example first collects all matching elements with ``root.findall()``, and "
|
||
"only then iterates over the list of matches."
|
||
msgstr ""
|
||
"Notez que les modifications simultanées lors de l'itération peuvent "
|
||
"entraîner des problèmes, tout comme lors de l'itération et de la "
|
||
"modification de listes ou de dictionnaires Python. Par conséquent, l'exemple "
|
||
"collecte d'abord tous les éléments correspondants avec ``root.findall()``, "
|
||
"et après seulement parcourt la liste des correspondances."
|
||
|
||
#: library/xml.etree.elementtree.rst:288
|
||
msgid "Building XML documents"
|
||
msgstr "Création de documents XML"
|
||
|
||
#: library/xml.etree.elementtree.rst:290
|
||
msgid ""
|
||
"The :func:`SubElement` function also provides a convenient way to create new "
|
||
"sub-elements for a given element::"
|
||
msgstr ""
|
||
"La fonction :func:`SubElement` fournit également un moyen pratique de créer "
|
||
"de nouveaux sous-éléments pour un élément donné ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:301
|
||
msgid "Parsing XML with Namespaces"
|
||
msgstr "Analyse d'un XML avec des espaces de noms"
|
||
|
||
#: library/xml.etree.elementtree.rst:303
|
||
msgid ""
|
||
"If the XML input has `namespaces <https://en.wikipedia.org/wiki/"
|
||
"XML_namespace>`__, tags and attributes with prefixes in the form ``prefix:"
|
||
"sometag`` get expanded to ``{uri}sometag`` where the *prefix* is replaced by "
|
||
"the full *URI*. Also, if there is a `default namespace <https://www.w3.org/"
|
||
"TR/xml-names/#defaulting>`__, that full URI gets prepended to all of the non-"
|
||
"prefixed tags."
|
||
msgstr ""
|
||
"Si l'entrée XML a des `espaces de noms <https://fr.wikipedia.org/wiki/"
|
||
"Espace_de_noms_XML>`__, les balises et les attributs avec des préfixes sous "
|
||
"la forme *préfixe:unebalise* sont étendus à ``{uri}unebalise`` où le "
|
||
"*préfixe* est remplacé par l'*URI* complet. De plus, s'il existe un `espace "
|
||
"de noms par défaut <https://www.w3.org/TR/xml-names/#defaulting>`__, cet URI "
|
||
"complet est ajouté au début de toutes les balises non préfixées."
|
||
|
||
#: library/xml.etree.elementtree.rst:311
|
||
msgid ""
|
||
"Here is an XML example that incorporates two namespaces, one with the prefix "
|
||
"\"fictional\" and the other serving as the default namespace:"
|
||
msgstr ""
|
||
"Voici un exemple XML qui intègre deux espaces de noms, l'un avec le préfixe "
|
||
"*fictional* et l'autre servant d'espace de noms par défaut :"
|
||
|
||
#: library/xml.etree.elementtree.rst:332
|
||
msgid ""
|
||
"One way to search and explore this XML example is to manually add the URI to "
|
||
"every tag or attribute in the xpath of a :meth:`~Element.find` or :meth:"
|
||
"`~Element.findall`::"
|
||
msgstr ""
|
||
"Une façon de rechercher et d'explorer cet exemple XML consiste à ajouter "
|
||
"manuellement l'URI à chaque balise ou attribut dans le *xpath* d'une "
|
||
"recherche :meth:`~Element.find` ou :meth:`~Element.findall` ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:343
|
||
msgid ""
|
||
"A better way to search the namespaced XML example is to create a dictionary "
|
||
"with your own prefixes and use those in the search functions::"
|
||
msgstr ""
|
||
"Une meilleure façon de rechercher dans l'exemple XML avec espace de noms "
|
||
"consiste à créer un dictionnaire avec vos propres préfixes et à les utiliser "
|
||
"dans les fonctions de recherche ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:355
|
||
msgid "These two approaches both output::"
|
||
msgstr "Ces deux approches donnent le même résultat ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:369
|
||
msgid "XPath support"
|
||
msgstr "Prise en charge de *XPath*"
|
||
|
||
#: library/xml.etree.elementtree.rst:371
|
||
msgid ""
|
||
"This module provides limited support for `XPath expressions <https://www.w3."
|
||
"org/TR/xpath>`_ for locating elements in a tree. The goal is to support a "
|
||
"small subset of the abbreviated syntax; a full XPath engine is outside the "
|
||
"scope of the module."
|
||
msgstr ""
|
||
"Ce module fournit une prise en charge limitée des `expressions XPath "
|
||
"<https://www.w3.org/TR/xpath>`_ pour localiser des éléments dans une "
|
||
"arborescence. L'objectif est de prendre en charge un petit sous-ensemble de "
|
||
"la syntaxe abrégée ; un moteur *XPath* complet sort du cadre du module."
|
||
|
||
#: library/xml.etree.elementtree.rst:377 library/xml.etree.elementtree.rst:769
|
||
msgid "Example"
|
||
msgstr "Exemple"
|
||
|
||
#: library/xml.etree.elementtree.rst:379
|
||
msgid ""
|
||
"Here's an example that demonstrates some of the XPath capabilities of the "
|
||
"module. We'll be using the ``countrydata`` XML document from the :ref:"
|
||
"`Parsing XML <elementtree-parsing-xml>` section::"
|
||
msgstr ""
|
||
"Voici un exemple qui démontre certaines des fonctionnalités *XPath* du "
|
||
"module. Nous utilisons le document XML ``countrydata`` de la section :ref:"
|
||
"`Parsing XML <elementtree-parsing-xml>` ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:403
|
||
msgid ""
|
||
"For XML with namespaces, use the usual qualified ``{namespace}tag`` "
|
||
"notation::"
|
||
msgstr ""
|
||
"Pour du XML avec des espaces de noms, utilisez la notation qualifiée "
|
||
"habituelle ``{namespace}tag`` ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:410
|
||
msgid "Supported XPath syntax"
|
||
msgstr "Prise en charge de la syntaxe *XPath*"
|
||
|
||
#: library/xml.etree.elementtree.rst:415
|
||
msgid "Syntax"
|
||
msgstr "Syntaxe"
|
||
|
||
#: library/xml.etree.elementtree.rst:415
|
||
msgid "Meaning"
|
||
msgstr "Signification"
|
||
|
||
#: library/xml.etree.elementtree.rst:417
|
||
msgid "``tag``"
|
||
msgstr "``tag``"
|
||
|
||
#: library/xml.etree.elementtree.rst:417
|
||
msgid ""
|
||
"Selects all child elements with the given tag. For example, ``spam`` selects "
|
||
"all child elements named ``spam``, and ``spam/egg`` selects all "
|
||
"grandchildren named ``egg`` in all children named ``spam``. ``{namespace}"
|
||
"*`` selects all tags in the given namespace, ``{*}spam`` selects tags named "
|
||
"``spam`` in any (or no) namespace, and ``{}*`` only selects tags that are "
|
||
"not in a namespace."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments enfants avec une balise donnée. Par exemple, "
|
||
"``spam`` sélectionne tous les éléments enfants nommés ``spam`` et ``spam/"
|
||
"egg`` sélectionne tous les petits-enfants nommés ``egg`` dans les enfants "
|
||
"nommés ``spam``. ``{namespace}*`` sélectionne toutes les balises dans "
|
||
"l'espace de noms donné, ``{*}spam`` sélectionne les balises nommées ``spam`` "
|
||
"dans n'importe quel (ou aucun) espace de noms et ``{}*`` sélectionne "
|
||
"seulement les balises qui ne sont pas dans un espace de noms."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:426
|
||
msgid "Support for star-wildcards was added."
|
||
msgstr "la prise en charge des caractères génériques étoiles a été ajoutée."
|
||
|
||
#: library/xml.etree.elementtree.rst:429
|
||
msgid "``*``"
|
||
msgstr "``*``"
|
||
|
||
#: library/xml.etree.elementtree.rst:429
|
||
msgid ""
|
||
"Selects all child elements, including comments and processing instructions. "
|
||
"For example, ``*/egg`` selects all grandchildren named ``egg``."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments enfants, y compris les commentaires et les "
|
||
"instructions de traitement. Par exemple, ``*/egg`` sélectionne tous les "
|
||
"petits-enfants nommés ``egg``."
|
||
|
||
#: library/xml.etree.elementtree.rst:433
|
||
msgid "``.``"
|
||
msgstr "``.``"
|
||
|
||
#: library/xml.etree.elementtree.rst:433
|
||
msgid ""
|
||
"Selects the current node. This is mostly useful at the beginning of the "
|
||
"path, to indicate that it's a relative path."
|
||
msgstr ""
|
||
"Sélectionne le nœud actuel. C'est surtout utile au début du chemin, pour "
|
||
"indiquer qu'il s'agit d'un chemin relatif."
|
||
|
||
#: library/xml.etree.elementtree.rst:437
|
||
msgid "``//``"
|
||
msgstr "``//``"
|
||
|
||
#: library/xml.etree.elementtree.rst:437
|
||
msgid ""
|
||
"Selects all subelements, on all levels beneath the current element. For "
|
||
"example, ``.//egg`` selects all ``egg`` elements in the entire tree."
|
||
msgstr ""
|
||
"Sélectionne tous les sous-éléments, à tous les niveaux situés sous l'élément "
|
||
"actuel. Par exemple, ``.//egg`` sélectionne tous les éléments ``egg`` dans "
|
||
"l'arborescence entière."
|
||
|
||
#: library/xml.etree.elementtree.rst:441
|
||
msgid "``..``"
|
||
msgstr "``..``"
|
||
|
||
#: library/xml.etree.elementtree.rst:441
|
||
msgid ""
|
||
"Selects the parent element. Returns ``None`` if the path attempts to reach "
|
||
"the ancestors of the start element (the element ``find`` was called on)."
|
||
msgstr ""
|
||
"Sélectionne l'élément parent. Renvoie ``None`` si le chemin tente "
|
||
"d'atteindre les ancêtres de l'élément de départ (l'élément sur lequel "
|
||
"``find`` a été appelé)."
|
||
|
||
#: library/xml.etree.elementtree.rst:445
|
||
msgid "``[@attrib]``"
|
||
msgstr "``[@attrib]``"
|
||
|
||
#: library/xml.etree.elementtree.rst:445
|
||
msgid "Selects all elements that have the given attribute."
|
||
msgstr "Sélectionne tous les éléments qui ont l'attribut donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:447
|
||
msgid "``[@attrib='value']``"
|
||
msgstr "``[@attrib='value']``"
|
||
|
||
#: library/xml.etree.elementtree.rst:447
|
||
msgid ""
|
||
"Selects all elements for which the given attribute has the given value. The "
|
||
"value cannot contain quotes."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments pour lesquels l'attribut donné a la valeur "
|
||
"donnée. La valeur ne peut pas contenir de guillemet simple (``'``)."
|
||
|
||
#: library/xml.etree.elementtree.rst:451
|
||
msgid "``[@attrib!='value']``"
|
||
msgstr "``[@attrib!='value']``"
|
||
|
||
#: library/xml.etree.elementtree.rst:451
|
||
msgid ""
|
||
"Selects all elements for which the given attribute does not have the given "
|
||
"value. The value cannot contain quotes."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments pour lesquels l'attribut donné n'a pas la "
|
||
"valeur donnée. La valeur ne peut pas contenir de guillemet simple (``'``)."
|
||
|
||
#: library/xml.etree.elementtree.rst:457
|
||
msgid "``[tag]``"
|
||
msgstr "``[tag]``"
|
||
|
||
#: library/xml.etree.elementtree.rst:457
|
||
msgid ""
|
||
"Selects all elements that have a child named ``tag``. Only immediate "
|
||
"children are supported."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments qui ont un enfant nommé ``tag``. Seuls les "
|
||
"enfants immédiats sont pris en charge."
|
||
|
||
#: library/xml.etree.elementtree.rst:460
|
||
msgid "``[.='text']``"
|
||
msgstr "``[.='text']``"
|
||
|
||
#: library/xml.etree.elementtree.rst:460
|
||
msgid ""
|
||
"Selects all elements whose complete text content, including descendants, "
|
||
"equals the given ``text``."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments dont le contenu textuel complet, y compris les "
|
||
"descendants, est égal au ``text`` donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:465
|
||
msgid "``[.!='text']``"
|
||
msgstr "``[.!='text']``"
|
||
|
||
#: library/xml.etree.elementtree.rst:465
|
||
msgid ""
|
||
"Selects all elements whose complete text content, including descendants, "
|
||
"does not equal the given ``text``."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments dont le contenu textuel complet, y compris les "
|
||
"descendants, n'est pas égal au ``text`` donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:471
|
||
msgid "``[tag='text']``"
|
||
msgstr "``[tag='text']``"
|
||
|
||
#: library/xml.etree.elementtree.rst:471
|
||
msgid ""
|
||
"Selects all elements that have a child named ``tag`` whose complete text "
|
||
"content, including descendants, equals the given ``text``."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments qui ont un enfant nommé ``tag`` dont le "
|
||
"contenu textuel complet, y compris les descendants, est égal au ``text`` "
|
||
"donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:475
|
||
msgid "``[tag!='text']``"
|
||
msgstr "``[tag!='text']``"
|
||
|
||
#: library/xml.etree.elementtree.rst:475
|
||
msgid ""
|
||
"Selects all elements that have a child named ``tag`` whose complete text "
|
||
"content, including descendants, does not equal the given ``text``."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments qui ont un enfant nommé ``tag`` dont le "
|
||
"contenu textuel complet, y compris les descendants, n'est pas égal au "
|
||
"``text`` donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:481
|
||
msgid "``[position]``"
|
||
msgstr "``[position]``"
|
||
|
||
#: library/xml.etree.elementtree.rst:481
|
||
msgid ""
|
||
"Selects all elements that are located at the given position. The position "
|
||
"can be either an integer (1 is the first position), the expression "
|
||
"``last()`` (for the last position), or a position relative to the last "
|
||
"position (e.g. ``last()-1``)."
|
||
msgstr ""
|
||
"Sélectionne tous les éléments situés à la position donnée. La position peut "
|
||
"être soit un entier (1 est la première position), l'expression ``last()`` "
|
||
"(pour la dernière position), ou une position relative à la dernière position "
|
||
"(par exemple ``last()-1``)."
|
||
|
||
#: library/xml.etree.elementtree.rst:488
|
||
msgid ""
|
||
"Predicates (expressions within square brackets) must be preceded by a tag "
|
||
"name, an asterisk, or another predicate. ``position`` predicates must be "
|
||
"preceded by a tag name."
|
||
msgstr ""
|
||
"Les prédicats (expressions entre crochets) doivent être précédés d'un nom de "
|
||
"balise, d'un astérisque ou d'un autre prédicat. Les prédicats ``position`` "
|
||
"doivent être précédés d'un nom de balise."
|
||
|
||
#: library/xml.etree.elementtree.rst:493 library/xml.etree.elementtree.rst:821
|
||
msgid "Reference"
|
||
msgstr "Référence"
|
||
|
||
#: library/xml.etree.elementtree.rst:498 library/xml.etree.elementtree.rst:826
|
||
msgid "Functions"
|
||
msgstr "Fonctions"
|
||
|
||
#: library/xml.etree.elementtree.rst:502
|
||
msgid "`C14N 2.0 <https://www.w3.org/TR/xml-c14n2/>`_ transformation function."
|
||
msgstr ""
|
||
"Fonction de transformation `C14N 2.0 <https://www.w3.org/TR/xml-c14n2/>`_."
|
||
|
||
#: library/xml.etree.elementtree.rst:504
|
||
msgid ""
|
||
"Canonicalization is a way to normalise XML output in a way that allows byte-"
|
||
"by-byte comparisons and digital signatures. It reduced the freedom that XML "
|
||
"serializers have and instead generates a more constrained XML "
|
||
"representation. The main restrictions regard the placement of namespace "
|
||
"declarations, the ordering of attributes, and ignorable whitespace."
|
||
msgstr ""
|
||
"La canonisation est un moyen de normaliser la sortie XML de manière à "
|
||
"permettre des comparaisons octet par octet et des signatures numériques. "
|
||
"Cela réduit la liberté dont disposent les outils de sérialisation XML et "
|
||
"génère à la place une représentation XML plus contrainte. Les principales "
|
||
"restrictions concernent le placement des déclarations d'espaces de noms, "
|
||
"l'ordre des attributs et les espaces à ignorer."
|
||
|
||
#: library/xml.etree.elementtree.rst:510
|
||
msgid ""
|
||
"This function takes an XML data string (*xml_data*) or a file path or file-"
|
||
"like object (*from_file*) as input, converts it to the canonical form, and "
|
||
"writes it out using the *out* file(-like) object, if provided, or returns it "
|
||
"as a text string if not. The output file receives text, not bytes. It "
|
||
"should therefore be opened in text mode with ``utf-8`` encoding."
|
||
msgstr ""
|
||
"Cette fonction prend une chaîne de données XML (*xml_data*) ou un chemin de "
|
||
"fichier ou un objet de type fichier (*from_file*) en entrée, la convertit "
|
||
"sous la forme canonique et l'écrit à l'aide de l'objet simili-fichier *out*, "
|
||
"s'il est fourni, ou le renvoie sous forme de chaîne de texte sinon. Le "
|
||
"fichier de sortie reçoit du texte, pas des octets. Il doit donc être ouvert "
|
||
"en mode texte avec l'encodage ``utf-8``."
|
||
|
||
#: library/xml.etree.elementtree.rst:517
|
||
msgid "Typical uses::"
|
||
msgstr "Utilisation typique ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:528
|
||
msgid "The configuration *options* are as follows:"
|
||
msgstr "Les *options* de configuration sont les suivantes :"
|
||
|
||
#: library/xml.etree.elementtree.rst:530
|
||
msgid "*with_comments*: set to true to include comments (default: false)"
|
||
msgstr ""
|
||
"*with_comments* : définissez cet attribut à vrai pour inclure les "
|
||
"commentaires (par défaut : faux)"
|
||
|
||
#: library/xml.etree.elementtree.rst:531
|
||
msgid ""
|
||
"*strip_text*: set to true to strip whitespace before and after text content"
|
||
msgstr ""
|
||
"*strip_text* : définissez à vrai pour supprimer les espaces avant et après "
|
||
"le contenu du texte"
|
||
|
||
#: library/xml.etree.elementtree.rst:532 library/xml.etree.elementtree.rst:534
|
||
msgid "(default: false)"
|
||
msgstr "(par défaut : faux)"
|
||
|
||
#: library/xml.etree.elementtree.rst:533
|
||
msgid ""
|
||
"*rewrite_prefixes*: set to true to replace namespace prefixes by "
|
||
"\"n{number}\""
|
||
msgstr ""
|
||
"*rewrite_prefixes* : définissez à vrai pour remplacer les préfixes d'espace "
|
||
"de noms par « n{nombre} »"
|
||
|
||
#: library/xml.etree.elementtree.rst:535
|
||
msgid "*qname_aware_tags*: a set of qname aware tag names in which prefixes"
|
||
msgstr ""
|
||
"*qname_aware_tags* : ensemble de noms de balises prenant en charge les noms "
|
||
"qualifiés dans lesquels les préfixes"
|
||
|
||
#: library/xml.etree.elementtree.rst:536 library/xml.etree.elementtree.rst:538
|
||
msgid "should be replaced in text content (default: empty)"
|
||
msgstr "doivent être remplacés dans le contenu du texte (par défaut : vide)"
|
||
|
||
#: library/xml.etree.elementtree.rst:537
|
||
msgid ""
|
||
"*qname_aware_attrs*: a set of qname aware attribute names in which prefixes"
|
||
msgstr ""
|
||
"*qname_aware_attrs* : ensemble de noms d'attributs prenant en charge les "
|
||
"noms qualifiés dans lesquels les préfixes"
|
||
|
||
#: library/xml.etree.elementtree.rst:539
|
||
msgid "*exclude_attrs*: a set of attribute names that should not be serialised"
|
||
msgstr ""
|
||
"*exclude_attrs* : ensemble de noms d'attributs qui ne doivent pas être "
|
||
"sérialisés"
|
||
|
||
#: library/xml.etree.elementtree.rst:540
|
||
msgid "*exclude_tags*: a set of tag names that should not be serialised"
|
||
msgstr ""
|
||
"*exclude_tags* : ensemble de noms de balises qui ne doivent pas être "
|
||
"sérialisés"
|
||
|
||
#: library/xml.etree.elementtree.rst:542
|
||
msgid ""
|
||
"In the option list above, \"a set\" refers to any collection or iterable of "
|
||
"strings, no ordering is expected."
|
||
msgstr ""
|
||
"Dans la liste d'options ci-dessus, un « ensemble » fait référence à toute "
|
||
"collection ou itérable de chaînes, aucun ordre n'est attendu."
|
||
|
||
#: library/xml.etree.elementtree.rst:550
|
||
msgid ""
|
||
"Comment element factory. This factory function creates a special element "
|
||
"that will be serialized as an XML comment by the standard serializer. The "
|
||
"comment string can be either a bytestring or a Unicode string. *text* is a "
|
||
"string containing the comment string. Returns an element instance "
|
||
"representing a comment."
|
||
msgstr ""
|
||
"Fabrique d’éléments de commentaire. Cette fonction crée un élément spécial "
|
||
"qui sera sérialisé sous forme de commentaire XML par le sérialiseur "
|
||
"standard. La chaîne de commentaire peut être une chaîne d'octets ou une "
|
||
"chaîne Unicode. *text* est une chaîne contenant la chaîne de commentaire. "
|
||
"Renvoie une instance d'élément représentant un commentaire."
|
||
|
||
#: library/xml.etree.elementtree.rst:556
|
||
msgid ""
|
||
"Note that :class:`XMLParser` skips over comments in the input instead of "
|
||
"creating comment objects for them. An :class:`ElementTree` will only contain "
|
||
"comment nodes if they have been inserted into to the tree using one of the :"
|
||
"class:`Element` methods."
|
||
msgstr ""
|
||
"Notez que :class:`XMLParser` ignore les commentaires dans l'entrée au lieu "
|
||
"de créer des objets de commentaire pour eux. Un :class:`ElementTree` ne "
|
||
"contiendra que des nœuds de commentaires qui ont été insérés dans "
|
||
"l'arborescence à l'aide de l'une des méthodes d':class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:563
|
||
msgid ""
|
||
"Writes an element tree or element structure to sys.stdout. This function "
|
||
"should be used for debugging only."
|
||
msgstr ""
|
||
"Écrit une arborescence d'éléments ou une structure d'éléments dans *sys."
|
||
"stdout*. Cette fonction doit être utilisée uniquement pour le débogage."
|
||
|
||
#: library/xml.etree.elementtree.rst:566
|
||
msgid ""
|
||
"The exact output format is implementation dependent. In this version, it's "
|
||
"written as an ordinary XML file."
|
||
msgstr ""
|
||
"Le format de sortie exact dépend de l’implémentation. Dans cette version, il "
|
||
"est écrit sous la forme d'un fichier XML ordinaire."
|
||
|
||
#: library/xml.etree.elementtree.rst:569
|
||
msgid "*elem* is an element tree or an individual element."
|
||
msgstr "*elem* est un élément de l'arborescence ou un élément individuel."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:571
|
||
msgid ""
|
||
"The :func:`dump` function now preserves the attribute order specified by the "
|
||
"user."
|
||
msgstr ""
|
||
"la fonction :func:`dump` préserve désormais l'ordre des attributs spécifié "
|
||
"par l'utilisateur."
|
||
|
||
#: library/xml.etree.elementtree.rst:578
|
||
msgid ""
|
||
"Parses an XML section from a string constant. Same as :func:`XML`. *text* "
|
||
"is a string containing XML data. *parser* is an optional parser instance. "
|
||
"If not given, the standard :class:`XMLParser` parser is used. Returns an :"
|
||
"class:`Element` instance."
|
||
msgstr ""
|
||
"Analyse une section XML à partir d'une constante de chaîne. Identique à :"
|
||
"func:`XML`. *text* est une chaîne contenant des données XML. *parser* est "
|
||
"une instance d'analyseur facultative. S'il n'est pas fourni, l'analyseur "
|
||
"standard :class:`XMLParser` est utilisé. Renvoie une instance d':class:"
|
||
"`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:586
|
||
msgid ""
|
||
"Parses an XML document from a sequence of string fragments. *sequence* is a "
|
||
"list or other sequence containing XML data fragments. *parser* is an "
|
||
"optional parser instance. If not given, the standard :class:`XMLParser` "
|
||
"parser is used. Returns an :class:`Element` instance."
|
||
msgstr ""
|
||
"Analyse un document XML à partir d'une séquence de fragments de chaîne. "
|
||
"*séquence* est une liste ou une autre séquence contenant des fragments de "
|
||
"données XML. *parser* est une instance d'analyseur facultative. S'il n'est "
|
||
"pas fourni, l'analyseur standard :class:`XMLParser` est utilisé. Renvoie une "
|
||
"instance d':class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:596
|
||
msgid ""
|
||
"Appends whitespace to the subtree to indent the tree visually. This can be "
|
||
"used to generate pretty-printed XML output. *tree* can be an Element or "
|
||
"ElementTree. *space* is the whitespace string that will be inserted for "
|
||
"each indentation level, two space characters by default. For indenting "
|
||
"partial subtrees inside of an already indented tree, pass the initial "
|
||
"indentation level as *level*."
|
||
msgstr ""
|
||
"Ajoute des espaces au sous-arbre pour indenter visuellement l'arborescence. "
|
||
"Cela peut être utilisé pour générer une sortie XML avec une mise en forme "
|
||
"agréable. *tree* peut être un élément ou un *ElementTree*. *espace* est la "
|
||
"chaîne d'espaces qui est insérée pour chaque niveau d'indentation, deux "
|
||
"caractères d'espace par défaut. Pour indenter des sous-arbres partiels à "
|
||
"l'intérieur d'un arbre déjà indenté, transmettez le niveau d'indentation "
|
||
"initial dans *level*."
|
||
|
||
#: library/xml.etree.elementtree.rst:608
|
||
msgid ""
|
||
"Check if an object appears to be a valid element object. *element* is an "
|
||
"element instance. Return ``True`` if this is an element object."
|
||
msgstr ""
|
||
"Vérifie si un objet semble être un objet élément valide. *element* est une "
|
||
"instance d'élément. Renvoie ``True`` s'il s'agit d'un objet élément."
|
||
|
||
#: library/xml.etree.elementtree.rst:614
|
||
msgid ""
|
||
"Parses an XML section into an element tree incrementally, and reports what's "
|
||
"going on to the user. *source* is a filename or :term:`file object` "
|
||
"containing XML data. *events* is a sequence of events to report back. The "
|
||
"supported events are the strings ``\"start\"``, ``\"end\"``, ``\"comment"
|
||
"\"``, ``\"pi\"``, ``\"start-ns\"`` and ``\"end-ns\"`` (the \"ns\" events are "
|
||
"used to get detailed namespace information). If *events* is omitted, only ``"
|
||
"\"end\"`` events are reported. *parser* is an optional parser instance. If "
|
||
"not given, the standard :class:`XMLParser` parser is used. *parser* must be "
|
||
"a subclass of :class:`XMLParser` and can only use the default :class:"
|
||
"`TreeBuilder` as a target. Returns an :term:`iterator` providing ``(event, "
|
||
"elem)`` pairs."
|
||
msgstr ""
|
||
"Analyse progressivement une section XML pour produire une arborescence "
|
||
"d'éléments et rapporte ce qui se passe à l'utilisateur. *source* est un nom "
|
||
"de fichier ou un :term:`objet fichier <file object>` contenant des données "
|
||
"XML. *events* est une séquence d'événements à signaler. Les événements pris "
|
||
"en charge sont les chaînes ``\"start\"``, ``\"end\"``, ``\"comment\"``, "
|
||
"``\"pi\"``, ``\"start-ns\"`` et ``\"end-ns\"`` (les événements ``\"ns\"`` "
|
||
"sont utilisés pour obtenir des informations détaillées sur les espaces de "
|
||
"noms). Si *events* est omis, seuls les événements ``\"end\"`` sont "
|
||
"rapportés. *parser* (facultatif) est une instance d'analyseur. S'il n'est "
|
||
"pas fourni, l'analyseur standard :class:`XMLParser` est utilisé. *parser* "
|
||
"doit être une sous-classe de :class:`XMLParser` et ne peut utiliser que le :"
|
||
"class:`TreeBuilder` par défaut comme cible. Renvoie un :term:`itérateur "
|
||
"<iterator>` fournissant des paires ``(event, elem)``."
|
||
|
||
#: library/xml.etree.elementtree.rst:626
|
||
msgid ""
|
||
"Note that while :func:`iterparse` builds the tree incrementally, it issues "
|
||
"blocking reads on *source* (or the file it names). As such, it's unsuitable "
|
||
"for applications where blocking reads can't be made. For fully non-blocking "
|
||
"parsing, see :class:`XMLPullParser`."
|
||
msgstr ""
|
||
"Notez que même si :func:`iterparse` construit l'arborescence de manière "
|
||
"incrémentielle, il bloque pendant les lectures sur *source*. En tant que "
|
||
"tel, il ne convient pas aux applications dans lesquelles le blocage pendant "
|
||
"les lectures ne peut pas être effectué. Pour une analyse entièrement non "
|
||
"bloquante, voir :class:`XMLPullParser`."
|
||
|
||
#: library/xml.etree.elementtree.rst:633
|
||
msgid ""
|
||
":func:`iterparse` only guarantees that it has seen the \">\" character of a "
|
||
"starting tag when it emits a \"start\" event, so the attributes are defined, "
|
||
"but the contents of the text and tail attributes are undefined at that "
|
||
"point. The same applies to the element children; they may or may not be "
|
||
"present."
|
||
msgstr ""
|
||
":func:`iterparse` garantit uniquement qu'il a vu le caractère ``\">\"`` "
|
||
"d'une balise de début lorsqu'il émet un événement ``\"start\"``, donc les "
|
||
"attributs sont définis mais le contenu des attributs *text* et *tail* n'est "
|
||
"pas défini à ce stade. La même chose s'applique aux nœuds enfants de "
|
||
"l'élément ; ils peuvent être présents ou non."
|
||
|
||
#: library/xml.etree.elementtree.rst:639 library/xml.etree.elementtree.rst:1469
|
||
msgid "If you need a fully populated element, look for \"end\" events instead."
|
||
msgstr ""
|
||
"Si vous avez besoin d'un élément entièrement rempli, recherchez plutôt les "
|
||
"événements ``\"end\"``."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:641
|
||
msgid "The *parser* argument."
|
||
msgstr "l'argument *parser*."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:644 library/xml.etree.elementtree.rst:1473
|
||
msgid "The ``comment`` and ``pi`` events were added."
|
||
msgstr "les évènements ``comment`` et ``pi`` ont été ajoutés."
|
||
|
||
#: library/xml.etree.elementtree.rst:650
|
||
msgid ""
|
||
"Parses an XML section into an element tree. *source* is a filename or file "
|
||
"object containing XML data. *parser* is an optional parser instance. If "
|
||
"not given, the standard :class:`XMLParser` parser is used. Returns an :"
|
||
"class:`ElementTree` instance."
|
||
msgstr ""
|
||
"Analyse une section XML dans une arborescence d'éléments. *source* est un "
|
||
"nom de fichier ou un objet fichier contenant des données XML. *parser* "
|
||
"(facultatif) est une instance d'analyseur. S'il n'est pas fourni, "
|
||
"l'analyseur standard :class:`XMLParser` est utilisé. Renvoie une instance d':"
|
||
"class:`ElementTree`."
|
||
|
||
#: library/xml.etree.elementtree.rst:658
|
||
msgid ""
|
||
"PI element factory. This factory function creates a special element that "
|
||
"will be serialized as an XML processing instruction. *target* is a string "
|
||
"containing the PI target. *text* is a string containing the PI contents, if "
|
||
"given. Returns an element instance, representing a processing instruction."
|
||
msgstr ""
|
||
"Fabrique d’éléments *Processing Instruction* (PI). Cette fonction crée un "
|
||
"élément spécial qui sera sérialisé en tant qu'instruction de traitement XML. "
|
||
"*target* est une chaîne contenant la cible PI. *text* est une chaîne "
|
||
"contenant le contenu de l'instruction de traitement (ou PI), s'il est "
|
||
"fourni. Renvoie une instance d'élément, représentant l'instruction de "
|
||
"traitement."
|
||
|
||
#: library/xml.etree.elementtree.rst:663
|
||
msgid ""
|
||
"Note that :class:`XMLParser` skips over processing instructions in the input "
|
||
"instead of creating comment objects for them. An :class:`ElementTree` will "
|
||
"only contain processing instruction nodes if they have been inserted into to "
|
||
"the tree using one of the :class:`Element` methods."
|
||
msgstr ""
|
||
"Notez que :class:`XMLParser` ignore les instructions de traitement dans "
|
||
"l'entrée au lieu de créer des objets de commentaire pour elles. Un :class:"
|
||
"`ElementTree` ne contiendra que des nœuds d'instructions de traitement qui "
|
||
"ont été insérés dans l'arborescence à l'aide de l'une des méthodes d':class:"
|
||
"`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:671
|
||
msgid ""
|
||
"Registers a namespace prefix. The registry is global, and any existing "
|
||
"mapping for either the given prefix or the namespace URI will be removed. "
|
||
"*prefix* is a namespace prefix. *uri* is a namespace uri. Tags and "
|
||
"attributes in this namespace will be serialized with the given prefix, if at "
|
||
"all possible."
|
||
msgstr ""
|
||
"Enregistre un préfixe d'espace de noms. Le registre est global et toute "
|
||
"correspondance existante pour le préfixe donné ainsi que l'URI de l'espace "
|
||
"de noms sera supprimé. *prefix* est un préfixe d'espace de noms. *uri* est "
|
||
"un URI d'espace de noms. Les balises et les attributs de cet espace de noms "
|
||
"seront sérialisés avec le préfixe donné, si possible."
|
||
|
||
#: library/xml.etree.elementtree.rst:682
|
||
msgid ""
|
||
"Subelement factory. This function creates an element instance, and appends "
|
||
"it to an existing element."
|
||
msgstr ""
|
||
"Fabrique de sous-élément. Cette fonction crée une instance d'élément et "
|
||
"l'ajoute à un élément existant."
|
||
|
||
#: library/xml.etree.elementtree.rst:685
|
||
msgid ""
|
||
"The element name, attribute names, and attribute values can be either "
|
||
"bytestrings or Unicode strings. *parent* is the parent element. *tag* is "
|
||
"the subelement name. *attrib* is an optional dictionary, containing element "
|
||
"attributes. *extra* contains additional attributes, given as keyword "
|
||
"arguments. Returns an element instance."
|
||
msgstr ""
|
||
"Le nom de l'élément, les noms d'attributs et les valeurs d'attributs peuvent "
|
||
"être des chaînes d'octets ou des chaînes Unicode. *parent* est l'élément "
|
||
"parent. *tag* est le nom du sous-élément. *attrib* est un dictionnaire "
|
||
"facultatif contenant les attributs de l'élément. *extra* contient des "
|
||
"attributs supplémentaires, donnés sous forme d'arguments nommés. Renvoie une "
|
||
"instance d'élément."
|
||
|
||
#: library/xml.etree.elementtree.rst:696
|
||
msgid ""
|
||
"Generates a string representation of an XML element, including all "
|
||
"subelements. *element* is an :class:`Element` instance. *encoding* [1]_ is "
|
||
"the output encoding (default is US-ASCII). Use ``encoding=\"unicode\"`` to "
|
||
"generate a Unicode string (otherwise, a bytestring is generated). *method* "
|
||
"is either ``\"xml\"``, ``\"html\"`` or ``\"text\"`` (default is ``\"xml"
|
||
"\"``). *xml_declaration*, *default_namespace* and *short_empty_elements* has "
|
||
"the same meaning as in :meth:`ElementTree.write`. Returns an (optionally) "
|
||
"encoded string containing the XML data."
|
||
msgstr ""
|
||
"Génère une représentation sous forme de chaîne d'un élément XML, y compris "
|
||
"tous les sous-éléments. *element* est une instance de :class:`Element`. "
|
||
"*encoding* [1]_ est l'encodage de sortie (la valeur par défaut est US-"
|
||
"ASCII). Utilisez ``encoding=\"unicode\"`` pour générer une chaîne Unicode "
|
||
"(sinon, une chaîne d'octets est générée). *method* vaut ``\"xml\"``, "
|
||
"``\"html\"`` ou ``\"text\"`` (la valeur par défaut est ``\"xml\"``). "
|
||
"*xml_declaration*, *default_namespace* et *short_empty_elements* ont la même "
|
||
"signification que dans :meth:`ElementTree.write`. Renvoie une chaîne codée "
|
||
"(éventuellement) contenant les données XML."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:705 library/xml.etree.elementtree.rst:732
|
||
#: library/xml.etree.elementtree.rst:1181
|
||
msgid "The *short_empty_elements* parameter."
|
||
msgstr "le paramètre *short_empty_elements*."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:708 library/xml.etree.elementtree.rst:735
|
||
msgid "The *xml_declaration* and *default_namespace* parameters."
|
||
msgstr "les paramètres *xml_declaration* et *default_namespace*."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:711
|
||
msgid ""
|
||
"The :func:`tostring` function now preserves the attribute order specified by "
|
||
"the user."
|
||
msgstr ""
|
||
"la fonction :func:`tostring` préserve désormais l'ordre des attributs "
|
||
"spécifié par l'utilisateur."
|
||
|
||
#: library/xml.etree.elementtree.rst:720
|
||
msgid ""
|
||
"Generates a string representation of an XML element, including all "
|
||
"subelements. *element* is an :class:`Element` instance. *encoding* [1]_ is "
|
||
"the output encoding (default is US-ASCII). Use ``encoding=\"unicode\"`` to "
|
||
"generate a Unicode string (otherwise, a bytestring is generated). *method* "
|
||
"is either ``\"xml\"``, ``\"html\"`` or ``\"text\"`` (default is ``\"xml"
|
||
"\"``). *xml_declaration*, *default_namespace* and *short_empty_elements* has "
|
||
"the same meaning as in :meth:`ElementTree.write`. Returns a list of "
|
||
"(optionally) encoded strings containing the XML data. It does not guarantee "
|
||
"any specific sequence, except that ``b\"\".join(tostringlist(element)) == "
|
||
"tostring(element)``."
|
||
msgstr ""
|
||
"Génère une représentation sous forme de chaîne d'un élément XML, y compris "
|
||
"tous les sous-éléments. *element* est une instance de :class:`Element`. "
|
||
"*encoding* [1]_ est l'encodage de sortie (la valeur par défaut est US-"
|
||
"ASCII). Utilisez ``encoding=\"unicode\"`` pour générer une chaîne Unicode "
|
||
"(sinon, une chaîne d'octets est générée). *method* vaut ``\"xml\"``, "
|
||
"``\"html\"`` ou ``\"text\"`` (la valeur par défaut est ``\"xml\"``). "
|
||
"*xml_declaration*, *default_namespace* et *short_empty_elements* ont la même "
|
||
"signification que dans :meth:`ElementTree.write`. Renvoie une liste de "
|
||
"chaînes codées (éventuellement) contenant les données XML. Elle ne garantit "
|
||
"aucune séquence spécifique, seulement ``b\"\".join(tostringlist(element)) == "
|
||
"tostring(element)``."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:738
|
||
msgid ""
|
||
"The :func:`tostringlist` function now preserves the attribute order "
|
||
"specified by the user."
|
||
msgstr ""
|
||
"la fonction :func:`tostringlist` préserve désormais l'ordre des attributs "
|
||
"spécifié par l'utilisateur."
|
||
|
||
#: library/xml.etree.elementtree.rst:745
|
||
msgid ""
|
||
"Parses an XML section from a string constant. This function can be used to "
|
||
"embed \"XML literals\" in Python code. *text* is a string containing XML "
|
||
"data. *parser* is an optional parser instance. If not given, the standard :"
|
||
"class:`XMLParser` parser is used. Returns an :class:`Element` instance."
|
||
msgstr ""
|
||
"Analyse une section XML à partir d'une constante de chaîne. Cette fonction "
|
||
"peut être utilisée pour intégrer des « littéraux XML » dans du code Python. "
|
||
"*text* est une chaîne contenant des données XML. *parser*, facultatif, est "
|
||
"une instance d'analyseur. S'il n'est pas fourni, l'analyseur standard :class:"
|
||
"`XMLParser` est utilisé. Renvoie une instance d':class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:753
|
||
msgid ""
|
||
"Parses an XML section from a string constant, and also returns a dictionary "
|
||
"which maps from element id:s to elements. *text* is a string containing XML "
|
||
"data. *parser* is an optional parser instance. If not given, the standard :"
|
||
"class:`XMLParser` parser is used. Returns a tuple containing an :class:"
|
||
"`Element` instance and a dictionary."
|
||
msgstr ""
|
||
"Analyse une section XML à partir d'une constante de chaîne et renvoie "
|
||
"également un dictionnaire qui fait correspondre les identifiants d'éléments "
|
||
"aux éléments. *text* est une chaîne contenant des données XML. *parser*, "
|
||
"facultatif, est une instance d'analyseur. S'il n'est pas fourni, l'analyseur "
|
||
"standard :class:`XMLParser` est utilisé. Renvoie un *n*-uplet contenant une "
|
||
"instance d':class:`Element` et un dictionnaire."
|
||
|
||
#: library/xml.etree.elementtree.rst:763
|
||
msgid "XInclude support"
|
||
msgstr "Prise en charge de *XInclude*"
|
||
|
||
#: library/xml.etree.elementtree.rst:765
|
||
msgid ""
|
||
"This module provides limited support for `XInclude directives <https://www."
|
||
"w3.org/TR/xinclude/>`_, via the :mod:`xml.etree.ElementInclude` helper "
|
||
"module. This module can be used to insert subtrees and text strings into "
|
||
"element trees, based on information in the tree."
|
||
msgstr ""
|
||
"Ce module fournit une prise en charge limitée des `directives XInclude "
|
||
"<https://www.w3.org/TR/xinclude/>`_, via le module d'assistance :mod:`xml."
|
||
"etree.ElementInclude`. Ce module peut être utilisé pour insérer des sous-"
|
||
"arbres et des chaînes de texte dans des arborescences d'éléments, en "
|
||
"fonction des informations contenues dans l'arborescence."
|
||
|
||
#: library/xml.etree.elementtree.rst:771
|
||
msgid ""
|
||
"Here's an example that demonstrates use of the XInclude module. To include "
|
||
"an XML document in the current document, use the ``{http://www.w3.org/2001/"
|
||
"XInclude}include`` element and set the **parse** attribute to ``\"xml\"``, "
|
||
"and use the **href** attribute to specify the document to include."
|
||
msgstr ""
|
||
"Voici un exemple qui montre l'utilisation du module *XInclude*. Pour inclure "
|
||
"un document XML dans le document actuel, utilisez l'élément ``{http://www.w3."
|
||
"org/2001/XInclude}include``, définissez l'attribut **parse** sur ``\"xml"
|
||
"\"`` et utilisez l'attribut **href** pour spécifier le document à inclure."
|
||
|
||
#: library/xml.etree.elementtree.rst:780
|
||
msgid ""
|
||
"By default, the **href** attribute is treated as a file name. You can use "
|
||
"custom loaders to override this behaviour. Also note that the standard "
|
||
"helper does not support XPointer syntax."
|
||
msgstr ""
|
||
"Par défaut, l'attribut **href** est traité comme un nom de fichier. Vous "
|
||
"pouvez utiliser des chargeurs personnalisés pour remplacer ce comportement. "
|
||
"Notez également que l'assistant standard ne prend pas en charge la syntaxe "
|
||
"*XPointer*."
|
||
|
||
#: library/xml.etree.elementtree.rst:782
|
||
msgid ""
|
||
"To process this file, load it as usual, and pass the root element to the :"
|
||
"mod:`xml.etree.ElementTree` module:"
|
||
msgstr ""
|
||
"Pour traiter ce fichier, chargez-le comme d'habitude et passez l'élément "
|
||
"racine au module :mod:`xml.etree.ElementTree` :"
|
||
|
||
#: library/xml.etree.elementtree.rst:793
|
||
msgid ""
|
||
"The ElementInclude module replaces the ``{http://www.w3.org/2001/XInclude}"
|
||
"include`` element with the root element from the **source.xml** document. "
|
||
"The result might look something like this:"
|
||
msgstr ""
|
||
"Le module *ElementInclude* remplace l'élément ``{http://www.w3.org/2001/"
|
||
"XInclude}include`` par l'élément racine du document **source.xml**. Le "
|
||
"résultat pourrait ressembler à ceci :"
|
||
|
||
#: library/xml.etree.elementtree.rst:801
|
||
msgid ""
|
||
"If the **parse** attribute is omitted, it defaults to \"xml\". The href "
|
||
"attribute is required."
|
||
msgstr ""
|
||
"Si l'attribut **parse** est omis, sa valeur par défaut est ``\"xml\"``. "
|
||
"L'attribut *href* est obligatoire."
|
||
|
||
#: library/xml.etree.elementtree.rst:803
|
||
msgid ""
|
||
"To include a text document, use the ``{http://www.w3.org/2001/XInclude}"
|
||
"include`` element, and set the **parse** attribute to \"text\":"
|
||
msgstr ""
|
||
"Pour inclure un document texte, utilisez l'élément ``{http://www.w3.org/2001/"
|
||
"XInclude}include`` et définissez l'attribut **parse** sur ``\"text\"`` :"
|
||
|
||
#: library/xml.etree.elementtree.rst:812
|
||
msgid "The result might look something like:"
|
||
msgstr "Le résultat pourrait ressembler à ceci :"
|
||
|
||
#: library/xml.etree.elementtree.rst:831
|
||
msgid ""
|
||
"Default loader. This default loader reads an included resource from disk. "
|
||
"*href* is a URL. *parse* is for parse mode either \"xml\" or \"text\". "
|
||
"*encoding* is an optional text encoding. If not given, encoding is "
|
||
"``utf-8``. Returns the expanded resource. If the parse mode is ``\"xml"
|
||
"\"``, this is an ElementTree instance. If the parse mode is \"text\", this "
|
||
"is a Unicode string. If the loader fails, it can return None or raise an "
|
||
"exception."
|
||
msgstr ""
|
||
"Chargeur par défaut. Ce chargeur par défaut lit une ressource incluse à "
|
||
"partir du disque. *href* est une URL. *parse* (le mode d'analyse) vaut soit "
|
||
"``\"xml\"``, soit ``\"text\"``. *encoding* est un encodage de texte "
|
||
"facultatif. S'il n'est pas indiqué, l'encodage est ``utf-8``. Renvoie la "
|
||
"ressource développée. Si le mode d'analyse est ``\"xml\"``, il s'agit d'une "
|
||
"instance d'``ElementTree``. Si le mode d'analyse est ``\"text\"``, il s'agit "
|
||
"d'une chaîne Unicode. Si le chargeur échoue, il peut renvoyer ``None`` ou "
|
||
"lever une exception."
|
||
|
||
#: library/xml.etree.elementtree.rst:843
|
||
msgid ""
|
||
"This function expands XInclude directives. *elem* is the root element. "
|
||
"*loader* is an optional resource loader. If omitted, it defaults to :func:"
|
||
"`default_loader`. If given, it should be a callable that implements the same "
|
||
"interface as :func:`default_loader`. *base_url* is base URL of the original "
|
||
"file, to resolve relative include file references. *max_depth* is the "
|
||
"maximum number of recursive inclusions. Limited to reduce the risk of "
|
||
"malicious content explosion. Pass a negative value to disable the limitation."
|
||
msgstr ""
|
||
"Cette fonction étend les directives *XInclude*. *elem* est l'élément racine. "
|
||
"*loader* est un chargeur de ressources facultatif. S'il est omis, la valeur "
|
||
"par défaut est :func:`default_loader`. S'il est donné, il doit s'agir d'un "
|
||
"appelable qui implémente la même interface que :func:`default_loader`. "
|
||
"*base_url* est l'URL de base du fichier d'origine, pour résoudre les "
|
||
"références relatives au fichier à inclure. *max_degree* est le nombre "
|
||
"maximum d'inclusions récursives. La limite existe pour réduire le risque "
|
||
"d’explosion de contenu malveillant. Passez une valeur négative pour "
|
||
"désactiver la limite."
|
||
|
||
#: library/xml.etree.elementtree.rst:851
|
||
msgid ""
|
||
"Returns the expanded resource. If the parse mode is ``\"xml\"``, this is an "
|
||
"ElementTree instance. If the parse mode is \"text\", this is a Unicode "
|
||
"string. If the loader fails, it can return None or raise an exception."
|
||
msgstr ""
|
||
"Renvoie la ressource développée. Si le mode d'analyse est ``\"xml\"``, il "
|
||
"s'agit d'une instance *ElementTree*. Si le mode d'analyse est ``\"text\"``, "
|
||
"il s'agit d'une chaîne Unicode. Si le chargeur échoue, il peut renvoyer "
|
||
"``None`` ou lever une exception."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:856
|
||
msgid "The *base_url* and *max_depth* parameters."
|
||
msgstr "les paramètres *base_url* et *max_depth*."
|
||
|
||
#: library/xml.etree.elementtree.rst:863
|
||
msgid "Element Objects"
|
||
msgstr "Objets *Element*"
|
||
|
||
#: library/xml.etree.elementtree.rst:867
|
||
msgid ""
|
||
"Element class. This class defines the Element interface, and provides a "
|
||
"reference implementation of this interface."
|
||
msgstr ""
|
||
"Classe Element. Cette classe définit l'interface Element et fournit une "
|
||
"implémentation de référence de cette interface."
|
||
|
||
#: library/xml.etree.elementtree.rst:870
|
||
msgid ""
|
||
"The element name, attribute names, and attribute values can be either "
|
||
"bytestrings or Unicode strings. *tag* is the element name. *attrib* is an "
|
||
"optional dictionary, containing element attributes. *extra* contains "
|
||
"additional attributes, given as keyword arguments."
|
||
msgstr ""
|
||
"Le nom de l'élément, les noms d'attributs et les valeurs d'attributs peuvent "
|
||
"être des chaînes d'octets ou des chaînes Unicode. *tag* est le nom de "
|
||
"l'élément. *attrib* est un dictionnaire facultatif contenant les attributs "
|
||
"des éléments. *extra* contient des attributs supplémentaires, donnés sous "
|
||
"forme d'arguments nommés."
|
||
|
||
#: library/xml.etree.elementtree.rst:878
|
||
msgid ""
|
||
"A string identifying what kind of data this element represents (the element "
|
||
"type, in other words)."
|
||
msgstr ""
|
||
"Chaîne identifiant le type de données que cet élément représente (en "
|
||
"d'autres termes, le type d'élément)."
|
||
|
||
#: library/xml.etree.elementtree.rst:885
|
||
msgid ""
|
||
"These attributes can be used to hold additional data associated with the "
|
||
"element. Their values are usually strings but may be any application-"
|
||
"specific object. If the element is created from an XML file, the *text* "
|
||
"attribute holds either the text between the element's start tag and its "
|
||
"first child or end tag, or ``None``, and the *tail* attribute holds either "
|
||
"the text between the element's end tag and the next tag, or ``None``. For "
|
||
"the XML data"
|
||
msgstr ""
|
||
"Ces attributs peuvent être utilisés pour contenir des données "
|
||
"supplémentaires associées à l'élément. Leurs valeurs sont généralement des "
|
||
"chaînes mais peuvent être n'importe quel objet spécifique à une application. "
|
||
"Si l'élément est créé à partir d'un fichier XML, l'attribut *text* contient "
|
||
"soit le texte entre la balise de début de l'élément et sa première balise "
|
||
"enfant ou de fin, soit ``None`` ; l'attribut *tail* contient soit le texte "
|
||
"entre la balise de fin de l'élément et la balise suivante, soit ``None``. "
|
||
"Pour les données XML"
|
||
|
||
#: library/xml.etree.elementtree.rst:897
|
||
msgid ""
|
||
"the *a* element has ``None`` for both *text* and *tail* attributes, the *b* "
|
||
"element has *text* ``\"1\"`` and *tail* ``\"4\"``, the *c* element has "
|
||
"*text* ``\"2\"`` and *tail* ``None``, and the *d* element has *text* "
|
||
"``None`` and *tail* ``\"3\"``."
|
||
msgstr ""
|
||
"les attributs *text* et *tail* de l'élément *a* valent ``None``, l'attribut "
|
||
"*text* de l'élément *b* vaut ``\"1\"`` et *tail* vaut ``\"4\"``, l'attribut "
|
||
"*text* de l'élément *c* vaut ``\"2\"`` et *tail* vaut ``None``, et "
|
||
"l'attribut *text* de l'élément *d* vaut ``None`` et *tail* vaut ``\"3\"``."
|
||
|
||
#: library/xml.etree.elementtree.rst:902
|
||
msgid ""
|
||
"To collect the inner text of an element, see :meth:`itertext`, for example ``"
|
||
"\"\".join(element.itertext())``."
|
||
msgstr ""
|
||
"Pour récupérer le texte interne d'un élément, voir :meth:`itertext`, par "
|
||
"exemple ``\"\".join(element.itertext())``."
|
||
|
||
#: library/xml.etree.elementtree.rst:905
|
||
msgid "Applications may store arbitrary objects in these attributes."
|
||
msgstr ""
|
||
"Les applications peuvent stocker des objets arbitraires dans ces attributs."
|
||
|
||
#: library/xml.etree.elementtree.rst:910
|
||
msgid ""
|
||
"A dictionary containing the element's attributes. Note that while the "
|
||
"*attrib* value is always a real mutable Python dictionary, an ElementTree "
|
||
"implementation may choose to use another internal representation, and create "
|
||
"the dictionary only if someone asks for it. To take advantage of such "
|
||
"implementations, use the dictionary methods below whenever possible."
|
||
msgstr ""
|
||
"Dictionnaire contenant les attributs de l'élément. Notez que même si la "
|
||
"valeur *attrib* est toujours un véritable dictionnaire Python mutable, une "
|
||
"implémentation d'*ElementTree* peut choisir d'utiliser une autre "
|
||
"représentation interne et de créer le dictionnaire uniquement si quelqu'un "
|
||
"le demande. Pour profiter de telles implémentations, utilisez les méthodes "
|
||
"de dictionnaire ci-dessous autant que possible."
|
||
|
||
#: library/xml.etree.elementtree.rst:916
|
||
msgid "The following dictionary-like methods work on the element attributes."
|
||
msgstr ""
|
||
"Les méthodes dictionnaire-compatibles suivantes traitent les attributs de "
|
||
"l'élément."
|
||
|
||
#: library/xml.etree.elementtree.rst:921
|
||
msgid ""
|
||
"Resets an element. This function removes all subelements, clears all "
|
||
"attributes, and sets the text and tail attributes to ``None``."
|
||
msgstr ""
|
||
"Réinitialise un élément. Cette fonction supprime tous les sous-éléments, "
|
||
"efface tous les attributs et définit les attributs *text* et *tail* sur "
|
||
"``None``."
|
||
|
||
#: library/xml.etree.elementtree.rst:927
|
||
msgid "Gets the element attribute named *key*."
|
||
msgstr "Accède à l'attribut de l'élément nommé *key*."
|
||
|
||
#: library/xml.etree.elementtree.rst:929
|
||
msgid ""
|
||
"Returns the attribute value, or *default* if the attribute was not found."
|
||
msgstr ""
|
||
"Renvoie la valeur de l'attribut ou *default* si l'attribut n'a pas été "
|
||
"trouvé."
|
||
|
||
#: library/xml.etree.elementtree.rst:934
|
||
msgid ""
|
||
"Returns the element attributes as a sequence of (name, value) pairs. The "
|
||
"attributes are returned in an arbitrary order."
|
||
msgstr ""
|
||
"Renvoie les attributs de l'élément comme une séquence de paire (nom, "
|
||
"valeur). Les attributs sont renvoyés dans un ordre arbitraire."
|
||
|
||
#: library/xml.etree.elementtree.rst:940
|
||
msgid ""
|
||
"Returns the elements attribute names as a list. The names are returned in "
|
||
"an arbitrary order."
|
||
msgstr ""
|
||
"Renvoie les noms d'attributs des éléments sous forme de liste. Les noms sont "
|
||
"renvoyés dans un ordre arbitraire."
|
||
|
||
#: library/xml.etree.elementtree.rst:946
|
||
msgid "Set the attribute *key* on the element to *value*."
|
||
msgstr "Change l'attribut *key* à l'élément *value*."
|
||
|
||
#: library/xml.etree.elementtree.rst:948
|
||
msgid "The following methods work on the element's children (subelements)."
|
||
msgstr "Les méthodes suivantes traitent les éléments enfants (sous-éléments)."
|
||
|
||
#: library/xml.etree.elementtree.rst:953
|
||
msgid ""
|
||
"Adds the element *subelement* to the end of this element's internal list of "
|
||
"subelements. Raises :exc:`TypeError` if *subelement* is not an :class:"
|
||
"`Element`."
|
||
msgstr ""
|
||
"Ajoute l'élément *subelement* à la fin de la liste interne des sous-éléments "
|
||
"de cet élément. Lève une :exc:`TypeError` si *subelement* n'est pas un :"
|
||
"class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:960
|
||
msgid ""
|
||
"Appends *subelements* from a sequence object with zero or more elements. "
|
||
"Raises :exc:`TypeError` if a subelement is not an :class:`Element`."
|
||
msgstr ""
|
||
"Ajoute *subelements* à partir d'un objet séquence avec zéro ou plusieurs "
|
||
"éléments. Lève une :exc:`TypeError` si un sous-élément n'est pas un :class:"
|
||
"`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:968
|
||
msgid ""
|
||
"Finds the first subelement matching *match*. *match* may be a tag name or "
|
||
"a :ref:`path <elementtree-xpath>`. Returns an element instance or "
|
||
"``None``. *namespaces* is an optional mapping from namespace prefix to full "
|
||
"name. Pass ``''`` as prefix to move all unprefixed tag names in the "
|
||
"expression into the given namespace."
|
||
msgstr ""
|
||
"Recherche le premier sous-élément correspondant à *match*. *match* peut être "
|
||
"un nom de balise ou un :ref:`path <elementtree-xpath>`. Renvoie une instance "
|
||
"d'élément ou ``None``. *namespaces* est un tableau de correspondances "
|
||
"facultatif de préfixes d'espaces de noms vers des noms complets. Passez "
|
||
"``''`` comme préfixe pour déplacer tous les noms de balises sans préfixe "
|
||
"dans l'expression dans l'espace de noms donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:977
|
||
msgid ""
|
||
"Finds all matching subelements, by tag name or :ref:`path <elementtree-"
|
||
"xpath>`. Returns a list containing all matching elements in document "
|
||
"order. *namespaces* is an optional mapping from namespace prefix to full "
|
||
"name. Pass ``''`` as prefix to move all unprefixed tag names in the "
|
||
"expression into the given namespace."
|
||
msgstr ""
|
||
"Recherche tous les sous-éléments correspondants, par nom de balise ou :ref:"
|
||
"`path <elementtree-xpath>`. Renvoie une liste contenant tous les éléments "
|
||
"correspondants dans l'ordre du document. *namespaces* est un tableau de "
|
||
"correspondances facultatif de préfixes d'espaces de noms vers des noms "
|
||
"complets. Passez ``''`` comme préfixe pour déplacer tous les noms de balises "
|
||
"sans préfixe dans l'expression dans l'espace de noms donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:986
|
||
msgid ""
|
||
"Finds text for the first subelement matching *match*. *match* may be a tag "
|
||
"name or a :ref:`path <elementtree-xpath>`. Returns the text content of the "
|
||
"first matching element, or *default* if no element was found. Note that if "
|
||
"the matching element has no text content an empty string is returned. "
|
||
"*namespaces* is an optional mapping from namespace prefix to full name. "
|
||
"Pass ``''`` as prefix to move all unprefixed tag names in the expression "
|
||
"into the given namespace."
|
||
msgstr ""
|
||
"Recherche le texte du premier sous-élément correspondant à *match*. *match* "
|
||
"peut être un nom de balise ou un :ref:`path <elementtree-xpath>`. Renvoie le "
|
||
"contenu textuel du premier élément correspondant, ou *default* si aucun "
|
||
"élément n'a été trouvé. Notez que si l'élément correspondant n'a pas de "
|
||
"contenu textuel, une chaîne vide est renvoyée. *namespaces* est un tableau "
|
||
"de correspondances facultatif de préfixes d'espaces de noms vers des noms "
|
||
"complets. Passez ``''`` comme préfixe pour déplacer tous les noms de balises "
|
||
"sans préfixe dans l'expression dans l'espace de noms donné."
|
||
|
||
#: library/xml.etree.elementtree.rst:997
|
||
msgid ""
|
||
"Inserts *subelement* at the given position in this element. Raises :exc:"
|
||
"`TypeError` if *subelement* is not an :class:`Element`."
|
||
msgstr ""
|
||
"Insère le *subelement* à la position donnée dans cet élément. Lève une :exc:"
|
||
"`TypeError` si *subelement* n'est pas un :class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1003
|
||
msgid ""
|
||
"Creates a tree :term:`iterator` with the current element as the root. The "
|
||
"iterator iterates over this element and all elements below it, in document "
|
||
"(depth first) order. If *tag* is not ``None`` or ``'*'``, only elements "
|
||
"whose tag equals *tag* are returned from the iterator. If the tree "
|
||
"structure is modified during iteration, the result is undefined."
|
||
msgstr ""
|
||
"Crée un :term:`itérateur <iterator>` sur l'arbre avec l'élément actuel "
|
||
"comme racine. L'itérateur parcourt cet élément et tous les éléments situés "
|
||
"en dessous, dans l'ordre du document (profondeur en premier). Si *tag* n'est "
|
||
"pas ``None`` ou ``'*'``, seuls les éléments dont la balise est égale à *tag* "
|
||
"sont renvoyés par l'itérateur. Si l'arborescence est modifiée au cours de "
|
||
"l'itération, le résultat est indéfini."
|
||
|
||
#: library/xml.etree.elementtree.rst:1014
|
||
msgid ""
|
||
"Finds all matching subelements, by tag name or :ref:`path <elementtree-"
|
||
"xpath>`. Returns an iterable yielding all matching elements in document "
|
||
"order. *namespaces* is an optional mapping from namespace prefix to full "
|
||
"name."
|
||
msgstr ""
|
||
"Recherche tous les sous-éléments correspondants, par nom de balise ou :ref:"
|
||
"`path <elementtree-xpath>`. Renvoie un itérable donnant tous les éléments "
|
||
"correspondants dans l'ordre du document. *namespaces* est un tableau de "
|
||
"correspondances facultatif de préfixes d'espaces de noms vers des noms "
|
||
"complets."
|
||
|
||
#: library/xml.etree.elementtree.rst:1025
|
||
msgid ""
|
||
"Creates a text iterator. The iterator loops over this element and all "
|
||
"subelements, in document order, and returns all inner text."
|
||
msgstr ""
|
||
"Crée un itérateur de texte. L'itérateur parcourt cet élément et tous les "
|
||
"sous-éléments, dans l'ordre du document, et renvoie tout le texte interne."
|
||
|
||
#: library/xml.etree.elementtree.rst:1033
|
||
msgid ""
|
||
"Creates a new element object of the same type as this element. Do not call "
|
||
"this method, use the :func:`SubElement` factory function instead."
|
||
msgstr ""
|
||
"Crée un nouvel objet élément du même type que cet élément. N'appelez pas "
|
||
"cette méthode, utilisez plutôt la fonction de fabrique :func:`SubElement`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1039
|
||
msgid ""
|
||
"Removes *subelement* from the element. Unlike the find\\* methods this "
|
||
"method compares elements based on the instance identity, not on tag value or "
|
||
"contents."
|
||
msgstr ""
|
||
"Supprime le *subelement* de l'élément. Contrairement aux méthodes *find\\**, "
|
||
"cette méthode compare les éléments en fonction de l'identité de l'instance, "
|
||
"et non de la valeur ou du contenu de la balise."
|
||
|
||
#: library/xml.etree.elementtree.rst:1043
|
||
msgid ""
|
||
":class:`Element` objects also support the following sequence type methods "
|
||
"for working with subelements: :meth:`~object.__delitem__`, :meth:`~object."
|
||
"__getitem__`, :meth:`~object.__setitem__`, :meth:`~object.__len__`."
|
||
msgstr ""
|
||
"Les objets :class:`Element` prennent également en charge les méthodes de "
|
||
"type séquence suivantes pour travailler avec des sous éléments : :meth:"
|
||
"`~object.__delitem__`, :meth:`~object.__getitem__`, :meth:`~object."
|
||
"__setitem__`, :meth:`~object.__len__`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1048
|
||
msgid ""
|
||
"Caution: Elements with no subelements will test as ``False``. This behavior "
|
||
"will change in future versions. Use specific ``len(elem)`` or ``elem is "
|
||
"None`` test instead. ::"
|
||
msgstr ""
|
||
"Attention : les éléments sans sous-élément sont évalués comme ``False``. Ce "
|
||
"comportement changera dans les versions futures. Utilisez plutôt un test "
|
||
"spécifique ``len(elem)`` ou ``elem is None``. ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:1060
|
||
msgid ""
|
||
"Prior to Python 3.8, the serialisation order of the XML attributes of "
|
||
"elements was artificially made predictable by sorting the attributes by "
|
||
"their name. Based on the now guaranteed ordering of dicts, this arbitrary "
|
||
"reordering was removed in Python 3.8 to preserve the order in which "
|
||
"attributes were originally parsed or created by user code."
|
||
msgstr ""
|
||
"Avant Python 3.8, l'ordre de sérialisation des attributs XML des éléments "
|
||
"était artificiellement rendu prévisible en classant les attributs par leur "
|
||
"nom. Sur la base de l'ordre désormais garanti des dictionnaires, cette "
|
||
"réorganisation arbitraire a été supprimée dans Python 3.8 pour préserver "
|
||
"l'ordre dans lequel les attributs ont été initialement analysés ou créés par "
|
||
"le code utilisateur."
|
||
|
||
#: library/xml.etree.elementtree.rst:1066
|
||
msgid ""
|
||
"In general, user code should try not to depend on a specific ordering of "
|
||
"attributes, given that the `XML Information Set <https://www.w3.org/TR/xml-"
|
||
"infoset/>`_ explicitly excludes the attribute order from conveying "
|
||
"information. Code should be prepared to deal with any ordering on input. In "
|
||
"cases where deterministic XML output is required, e.g. for cryptographic "
|
||
"signing or test data sets, canonical serialisation is available with the :"
|
||
"func:`canonicalize` function."
|
||
msgstr ""
|
||
"En général, le code utilisateur doit essayer de ne pas dépendre d'un ordre "
|
||
"spécifique des attributs, étant donné que la `documentation de référence XML "
|
||
"<https://www.w3.org/TR/xml-infoset/>`_ exclut explicitement que l'ordre des "
|
||
"attributs soit porteur d'information. Le code doit être prêt à gérer tout "
|
||
"ordre en entrée. Dans les cas où une sortie XML déterministe est requise, "
|
||
"par exemple pour la signature cryptographique ou les ensembles de données de "
|
||
"test, la sérialisation canonique est disponible avec la fonction :func:"
|
||
"`canonicalize`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1074
|
||
msgid ""
|
||
"In cases where canonical output is not applicable but a specific attribute "
|
||
"order is still desirable on output, code should aim for creating the "
|
||
"attributes directly in the desired order, to avoid perceptual mismatches for "
|
||
"readers of the code. In cases where this is difficult to achieve, a recipe "
|
||
"like the following can be applied prior to serialisation to enforce an order "
|
||
"independently from the Element creation::"
|
||
msgstr ""
|
||
"Dans les cas où la sortie canonique n'est pas applicable mais où un ordre "
|
||
"d'attributs spécifique est quand même souhaitable en sortie, le code doit "
|
||
"viser à créer les attributs directement dans l'ordre souhaité, afin d'éviter "
|
||
"des inadéquations de perception pour les lecteurs du code. Dans les cas où "
|
||
"cela est difficile à réaliser, une recette comme ci-dessous peut être "
|
||
"appliquée avant la sérialisation pour appliquer un ordre indépendant de la "
|
||
"création de l'élément ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:1094
|
||
msgid "ElementTree Objects"
|
||
msgstr "Objets *ElementTree*"
|
||
|
||
#: library/xml.etree.elementtree.rst:1099
|
||
msgid ""
|
||
"ElementTree wrapper class. This class represents an entire element "
|
||
"hierarchy, and adds some extra support for serialization to and from "
|
||
"standard XML."
|
||
msgstr ""
|
||
"Classe enveloppant *ElementTree*. Cette classe représente une hiérarchie "
|
||
"d'éléments entière et ajoute une prise en charge supplémentaire pour la "
|
||
"sérialisation vers et depuis le XML standard."
|
||
|
||
#: library/xml.etree.elementtree.rst:1103
|
||
msgid ""
|
||
"*element* is the root element. The tree is initialized with the contents of "
|
||
"the XML *file* if given."
|
||
msgstr ""
|
||
"*element* est l'élément racine. L'arborescence est initialisée avec le "
|
||
"contenu du fichier XML *file* s'il est fourni."
|
||
|
||
#: library/xml.etree.elementtree.rst:1109
|
||
msgid ""
|
||
"Replaces the root element for this tree. This discards the current contents "
|
||
"of the tree, and replaces it with the given element. Use with care. "
|
||
"*element* is an element instance."
|
||
msgstr ""
|
||
"Remplace l'élément racine de cette arborescence. Cela supprime le contenu "
|
||
"actuel de l'arborescence et le remplace par l'élément donné. À utiliser avec "
|
||
"précaution. *element* est une instance d'élément."
|
||
|
||
#: library/xml.etree.elementtree.rst:1116
|
||
msgid "Same as :meth:`Element.find`, starting at the root of the tree."
|
||
msgstr "Comme :meth:`Element.find`, commence à la racine de l'arbre."
|
||
|
||
#: library/xml.etree.elementtree.rst:1121
|
||
msgid "Same as :meth:`Element.findall`, starting at the root of the tree."
|
||
msgstr ""
|
||
"Identique à :meth:`Element.findall`, en commençant à la racine de "
|
||
"l'arborescence."
|
||
|
||
#: library/xml.etree.elementtree.rst:1126
|
||
msgid "Same as :meth:`Element.findtext`, starting at the root of the tree."
|
||
msgstr ""
|
||
"Identique à :meth:`Element.findtext`, en commençant à la racine de "
|
||
"l'arborescence."
|
||
|
||
#: library/xml.etree.elementtree.rst:1131
|
||
msgid "Returns the root element for this tree."
|
||
msgstr "Renvoie l'élément racine de l'arbre."
|
||
|
||
#: library/xml.etree.elementtree.rst:1136
|
||
msgid ""
|
||
"Creates and returns a tree iterator for the root element. The iterator "
|
||
"loops over all elements in this tree, in section order. *tag* is the tag to "
|
||
"look for (default is to return all elements)."
|
||
msgstr ""
|
||
"Crée et renvoie un itérateur d'arborescence pour l'élément racine. "
|
||
"L'itérateur parcourt tous les éléments de cette arborescence, dans l'ordre "
|
||
"des sections. *tag* est la balise à rechercher (la valeur par défaut est de "
|
||
"renvoyer tous les éléments)."
|
||
|
||
#: library/xml.etree.elementtree.rst:1143
|
||
msgid "Same as :meth:`Element.iterfind`, starting at the root of the tree."
|
||
msgstr ""
|
||
"Identique à :meth:`Element.iterfind`, en commençant à la racine de "
|
||
"l'arborescence."
|
||
|
||
#: library/xml.etree.elementtree.rst:1150
|
||
msgid ""
|
||
"Loads an external XML section into this element tree. *source* is a file "
|
||
"name or :term:`file object`. *parser* is an optional parser instance. If "
|
||
"not given, the standard :class:`XMLParser` parser is used. Returns the "
|
||
"section root element."
|
||
msgstr ""
|
||
"Charge une section XML externe dans cette arborescence d'éléments. *source* "
|
||
"est un nom de fichier ou un :term:`objet fichier <file object>`. *parser*, "
|
||
"facultatif, est une instance d'analyseur. S'il n'est pas fourni, l'analyseur "
|
||
"standard :class:`XMLParser` est utilisé. Renvoie l'élément racine de la "
|
||
"section."
|
||
|
||
#: library/xml.etree.elementtree.rst:1160
|
||
msgid ""
|
||
"Writes the element tree to a file, as XML. *file* is a file name, or a :"
|
||
"term:`file object` opened for writing. *encoding* [1]_ is the output "
|
||
"encoding (default is US-ASCII). *xml_declaration* controls if an XML "
|
||
"declaration should be added to the file. Use ``False`` for never, ``True`` "
|
||
"for always, ``None`` for only if not US-ASCII or UTF-8 or Unicode (default "
|
||
"is ``None``). *default_namespace* sets the default XML namespace (for \"xmlns"
|
||
"\"). *method* is either ``\"xml\"``, ``\"html\"`` or ``\"text\"`` (default "
|
||
"is ``\"xml\"``). The keyword-only *short_empty_elements* parameter controls "
|
||
"the formatting of elements that contain no content. If ``True`` (the "
|
||
"default), they are emitted as a single self-closed tag, otherwise they are "
|
||
"emitted as a pair of start/end tags."
|
||
msgstr ""
|
||
"Écrit l'arborescence des éléments dans un fichier, au format XML. *file* est "
|
||
"un nom de fichier ou un :term:`objet fichier <file object>` ouvert en "
|
||
"écriture. *encoding* [1]_ est l'encodage de sortie (la valeur par défaut est "
|
||
"US-ASCII). *xml_declaration* contrôle si une déclaration XML doit être "
|
||
"ajoutée au fichier. Utilisez ``False`` pour jamais, ``True`` pour toujours, "
|
||
"``None`` pour seulement si ce n'est pas de l'US-ASCII ou de l'UTF-8 ou de "
|
||
"l'Unicode (la valeur par défaut est ``None``). *default_namespace* définit "
|
||
"l'espace de noms XML par défaut (pour ``\"xmlns\"``). *method* vaut "
|
||
"``\"xml\"``, ``\"html\"`` ou ``\"text\"`` (la valeur par défaut est "
|
||
"``\"xml\"``). Le paramètre nommé (uniquement) *short_empty_elements* "
|
||
"contrôle le formatage des éléments qui ne contiennent aucun contenu. Si "
|
||
"c'est ``True`` (valeur par défaut), ils sont écrits sous la forme d'une "
|
||
"seule balise auto-fermée, sinon ils sont écrits sous la forme d'une paire de "
|
||
"balises de début-fin."
|
||
|
||
#: library/xml.etree.elementtree.rst:1174
|
||
msgid ""
|
||
"The output is either a string (:class:`str`) or binary (:class:`bytes`). "
|
||
"This is controlled by the *encoding* argument. If *encoding* is ``\"unicode"
|
||
"\"``, the output is a string; otherwise, it's binary. Note that this may "
|
||
"conflict with the type of *file* if it's an open :term:`file object`; make "
|
||
"sure you do not try to write a string to a binary stream and vice versa."
|
||
msgstr ""
|
||
"La sortie est une chaîne (:class:`str`) ou du binaire (:class:`bytes`). "
|
||
"C'est contrôlé par l'argument *encoding*. Si *encoding* est ``\"unicode\"``, "
|
||
"la sortie est une chaîne ; sinon, c'est binaire. Notez que cela peut entrer "
|
||
"en conflit avec le type de *fichier* s'il s'agit d'un :term:`objet fichier "
|
||
"<file object>` déjà ouvert ; assurez-vous de ne pas essayer d'écrire une "
|
||
"chaîne dans un flux binaire et vice versa."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:1184
|
||
msgid ""
|
||
"The :meth:`write` method now preserves the attribute order specified by the "
|
||
"user."
|
||
msgstr ""
|
||
"la méthode :meth:`write` préserve désormais l'ordre des attributs spécifié "
|
||
"par l'utilisateur."
|
||
|
||
#: library/xml.etree.elementtree.rst:1189
|
||
msgid "This is the XML file that is going to be manipulated::"
|
||
msgstr "Voici le fichier XML à manipuler ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:1201
|
||
msgid ""
|
||
"Example of changing the attribute \"target\" of every link in first "
|
||
"paragraph::"
|
||
msgstr ""
|
||
"Exemple de modification de l'attribut *target* de chaque lien dans le "
|
||
"premier paragraphe ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:1220
|
||
msgid "QName Objects"
|
||
msgstr "Objets *QName*"
|
||
|
||
#: library/xml.etree.elementtree.rst:1225
|
||
msgid ""
|
||
"QName wrapper. This can be used to wrap a QName attribute value, in order "
|
||
"to get proper namespace handling on output. *text_or_uri* is a string "
|
||
"containing the QName value, in the form {uri}local, or, if the tag argument "
|
||
"is given, the URI part of a QName. If *tag* is given, the first argument is "
|
||
"interpreted as a URI, and this argument is interpreted as a local name. :"
|
||
"class:`QName` instances are opaque."
|
||
msgstr ""
|
||
"Surcouche à *QName*. Cela peut être utilisé pour envelopper une valeur "
|
||
"d'attribut *QName*, afin d'obtenir une gestion appropriée de l'espace de "
|
||
"noms en sortie. *text_or_uri* est une chaîne contenant la valeur *QName*, "
|
||
"sous la forme *{uri}local* ou, si l'argument *tag* est donné, la partie URI "
|
||
"d'un *QName*. Si *tag* est donné, le premier argument est interprété comme "
|
||
"un URI et cet argument est interprété comme un nom local. Les instances :"
|
||
"class:`QName` sont opaques."
|
||
|
||
#: library/xml.etree.elementtree.rst:1237
|
||
msgid "TreeBuilder Objects"
|
||
msgstr "Objets *TreeBuilder*"
|
||
|
||
#: library/xml.etree.elementtree.rst:1243
|
||
msgid ""
|
||
"Generic element structure builder. This builder converts a sequence of "
|
||
"start, data, end, comment and pi method calls to a well-formed element "
|
||
"structure. You can use this class to build an element structure using a "
|
||
"custom XML parser, or a parser for some other XML-like format."
|
||
msgstr ""
|
||
"Générateur de structure d'éléments générique. Ce constructeur convertit une "
|
||
"séquence d'appels de méthode *start*, *data*, *end*, *comment* et *pi* en "
|
||
"une structure d'éléments bien formée. Vous pouvez utiliser cette classe pour "
|
||
"créer une structure d'éléments à l'aide d'un analyseur XML personnalisé ou "
|
||
"d'un analyseur pour un autre type de format XML."
|
||
|
||
#: library/xml.etree.elementtree.rst:1248
|
||
msgid ""
|
||
"*element_factory*, when given, must be a callable accepting two positional "
|
||
"arguments: a tag and a dict of attributes. It is expected to return a new "
|
||
"element instance."
|
||
msgstr ""
|
||
"*element_factory*, lorsqu'il est donné, doit être un appelable acceptant "
|
||
"deux arguments positionnels : une balise et un dictionnaire d'attributs. "
|
||
"Elle est censée renvoyer une nouvelle instance d'élément."
|
||
|
||
#: library/xml.etree.elementtree.rst:1252
|
||
msgid ""
|
||
"The *comment_factory* and *pi_factory* functions, when given, should behave "
|
||
"like the :func:`Comment` and :func:`ProcessingInstruction` functions to "
|
||
"create comments and processing instructions. When not given, the default "
|
||
"factories will be used. When *insert_comments* and/or *insert_pis* is true, "
|
||
"comments/pis will be inserted into the tree if they appear within the root "
|
||
"element (but not outside of it)."
|
||
msgstr ""
|
||
"Les fonctions *comment_factory* et *pi_factory*, lorsqu'elles sont données, "
|
||
"doivent se comporter comme les fonctions :func:`Comment` et :func:"
|
||
"`ProcessingInstruction` pour créer des commentaires et des instructions de "
|
||
"traitement. Lorsqu’elles ne sont pas fournies, les fabriques par défaut sont "
|
||
"utilisées. Lorsque *insert_comments* ou *insert_pis* sont vraies, les "
|
||
"commentaires et instructions de traitement sont insérés dans l'arborescence "
|
||
"s'ils apparaissent dans l'élément racine (mais pas à l'extérieur de celui-"
|
||
"ci)."
|
||
|
||
#: library/xml.etree.elementtree.rst:1261
|
||
msgid ""
|
||
"Flushes the builder buffers, and returns the toplevel document element. "
|
||
"Returns an :class:`Element` instance."
|
||
msgstr ""
|
||
"Vide les tampons du générateur et renvoie l'élément de document de niveau "
|
||
"supérieur. Renvoie une instance d':class:`Element`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1267
|
||
msgid ""
|
||
"Adds text to the current element. *data* is a string. This should be "
|
||
"either a bytestring, or a Unicode string."
|
||
msgstr ""
|
||
"Ajoute du texte à l'élément courant. *data* est une chaîne de caractères. "
|
||
"Cela peut être une chaîne d'octets ou une chaîne Unicode."
|
||
|
||
#: library/xml.etree.elementtree.rst:1273
|
||
msgid ""
|
||
"Closes the current element. *tag* is the element name. Returns the closed "
|
||
"element."
|
||
msgstr ""
|
||
"Ferme l'élément courant. *tag* est le nom de l'élément. Renvoie l'élément "
|
||
"fermé."
|
||
|
||
#: library/xml.etree.elementtree.rst:1279
|
||
msgid ""
|
||
"Opens a new element. *tag* is the element name. *attrs* is a dictionary "
|
||
"containing element attributes. Returns the opened element."
|
||
msgstr ""
|
||
"Ouvre un nouvel élément. *tag* est le nom de l'élément. *attrs* est un "
|
||
"dictionnaire contenant les attributs de l'élément. Renvoie l'élément ouvert."
|
||
|
||
#: library/xml.etree.elementtree.rst:1285
|
||
msgid ""
|
||
"Creates a comment with the given *text*. If ``insert_comments`` is true, "
|
||
"this will also add it to the tree."
|
||
msgstr ""
|
||
"Crée un commentaire avec le *text* donné. Si ``insert_comments`` est vrai, "
|
||
"cela l'ajoute également à l'arborescence."
|
||
|
||
#: library/xml.etree.elementtree.rst:1293
|
||
msgid ""
|
||
"Creates a comment with the given *target* name and *text*. If "
|
||
"``insert_pis`` is true, this will also add it to the tree."
|
||
msgstr ""
|
||
"Crée un commentaire avec le nom *target* et le *text* donnés. Si "
|
||
"``insert_pis`` est vrai, cela l'ajoute également à l'arborescence."
|
||
|
||
#: library/xml.etree.elementtree.rst:1299
|
||
msgid ""
|
||
"In addition, a custom :class:`TreeBuilder` object can provide the following "
|
||
"methods:"
|
||
msgstr ""
|
||
"De plus, un objet :class:`TreeBuilder` personnalisé peut fournir les "
|
||
"méthodes suivantes :"
|
||
|
||
#: library/xml.etree.elementtree.rst:1304
|
||
msgid ""
|
||
"Handles a doctype declaration. *name* is the doctype name. *pubid* is the "
|
||
"public identifier. *system* is the system identifier. This method does not "
|
||
"exist on the default :class:`TreeBuilder` class."
|
||
msgstr ""
|
||
"Gère une déclaration *doctype*. *name* est le nom du type de document. "
|
||
"*pubid* est l'identifiant public. *system* est l'identifiant du système. "
|
||
"Cette méthode n'existe pas sur la classe par défaut :class:`TreeBuilder`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1312
|
||
msgid ""
|
||
"Is called whenever the parser encounters a new namespace declaration, before "
|
||
"the ``start()`` callback for the opening element that defines it. *prefix* "
|
||
"is ``''`` for the default namespace and the declared namespace prefix name "
|
||
"otherwise. *uri* is the namespace URI."
|
||
msgstr ""
|
||
"Est appelée chaque fois que l'analyseur rencontre une nouvelle déclaration "
|
||
"d'espace de noms, avant le rappel ``start()`` pour l'élément d'ouverture qui "
|
||
"le définit. *prefix* est ``''`` pour l'espace de noms par défaut et le nom "
|
||
"du préfixe d'espace de noms déclaré dans le cas contraire. *uri* est l'URI "
|
||
"de l'espace de noms."
|
||
|
||
#: library/xml.etree.elementtree.rst:1321
|
||
msgid ""
|
||
"Is called after the ``end()`` callback of an element that declared a "
|
||
"namespace prefix mapping, with the name of the *prefix* that went out of "
|
||
"scope."
|
||
msgstr ""
|
||
"Est appelée après le rappel ``end()`` d'un élément qui a déclaré une "
|
||
"correspondance de préfixe d'espace de noms, avec le nom du *prefix* qui "
|
||
"passe hors de portée."
|
||
|
||
#: library/xml.etree.elementtree.rst:1333
|
||
msgid ""
|
||
"A `C14N 2.0 <https://www.w3.org/TR/xml-c14n2/>`_ writer. Arguments are the "
|
||
"same as for the :func:`canonicalize` function. This class does not build a "
|
||
"tree but translates the callback events directly into a serialised form "
|
||
"using the *write* function."
|
||
msgstr ""
|
||
"Écrivain `C14N 2.0 <https://www.w3.org/TR/xml-c14n2/>`_. Les arguments sont "
|
||
"les mêmes que pour la fonction :func:`canonicalize`. Cette classe ne "
|
||
"construit pas d'arborescence mais traduit les événements de rappel "
|
||
"directement sous une forme sérialisée à l'aide de la fonction *write*."
|
||
|
||
#: library/xml.etree.elementtree.rst:1344
|
||
msgid "XMLParser Objects"
|
||
msgstr "Objets *XMLParser*"
|
||
|
||
#: library/xml.etree.elementtree.rst:1349
|
||
msgid ""
|
||
"This class is the low-level building block of the module. It uses :mod:`xml."
|
||
"parsers.expat` for efficient, event-based parsing of XML. It can be fed XML "
|
||
"data incrementally with the :meth:`feed` method, and parsing events are "
|
||
"translated to a push API - by invoking callbacks on the *target* object. If "
|
||
"*target* is omitted, the standard :class:`TreeBuilder` is used. If "
|
||
"*encoding* [1]_ is given, the value overrides the encoding specified in the "
|
||
"XML file."
|
||
msgstr ""
|
||
"Cette classe est l’élément de base du module. Elle utilise :mod:`xml.parsers."
|
||
"expat` pour une analyse efficace du XML et fonctionne à base d'événements. "
|
||
"Elle peut être alimentée en données XML de manière incrémentielle avec la "
|
||
"méthode :meth:`feed`, et les événements d'analyse sont traduits en une API à "
|
||
"flux poussé – en appelant les méthodes de rappel de l'objet *target*. Si "
|
||
"*target* est omis, le :class:`TreeBuilder` standard est utilisé. Si "
|
||
"*encoding* [1]_ est donné, la valeur remplace l'encodage spécifié dans le "
|
||
"fichier XML."
|
||
|
||
# suit un :
|
||
#: library/xml.etree.elementtree.rst:1357
|
||
msgid ""
|
||
"Parameters are now :ref:`keyword-only <keyword-only_parameter>`. The *html* "
|
||
"argument no longer supported."
|
||
msgstr ""
|
||
"les paramètres sont désormais :ref:`nommés uniquement <keyword-"
|
||
"only_parameter>`. L'argument *html* n'est plus pris en charge."
|
||
|
||
#: library/xml.etree.elementtree.rst:1364
|
||
msgid ""
|
||
"Finishes feeding data to the parser. Returns the result of calling the "
|
||
"``close()`` method of the *target* passed during construction; by default, "
|
||
"this is the toplevel document element."
|
||
msgstr ""
|
||
"Termine l'envoi des données à l'analyseur. Renvoie le résultat de l'appel de "
|
||
"la méthode ``close()`` de la *target* passée lors de la construction ; par "
|
||
"défaut, il s'agit de l'élément de plus haut niveau du document."
|
||
|
||
#: library/xml.etree.elementtree.rst:1371
|
||
msgid "Feeds data to the parser. *data* is encoded data."
|
||
msgstr "Fournit des données à l’analyseur. *data* est une donnée encodée."
|
||
|
||
#: library/xml.etree.elementtree.rst:1373
|
||
msgid ""
|
||
":meth:`XMLParser.feed` calls *target*\\'s ``start(tag, attrs_dict)`` method "
|
||
"for each opening tag, its ``end(tag)`` method for each closing tag, and data "
|
||
"is processed by method ``data(data)``. For further supported callback "
|
||
"methods, see the :class:`TreeBuilder` class. :meth:`XMLParser.close` calls "
|
||
"*target*\\'s method ``close()``. :class:`XMLParser` can be used not only for "
|
||
"building a tree structure. This is an example of counting the maximum depth "
|
||
"of an XML file::"
|
||
msgstr ""
|
||
":meth:`XMLParser.feed` appelle la méthode ``start(tag, attrs_dict)`` de "
|
||
"*target* pour chaque balise d'ouverture, sa méthode ``end(tag)`` pour chaque "
|
||
"balise de fermeture, et les données sont traitées par la méthode "
|
||
"``data(data)``. Pour d'autres méthodes de rappel prises en charge, consultez "
|
||
"la classe :class:`TreeBuilder`. :meth:`XMLParser.close` appelle la méthode "
|
||
"``close()`` de *target*. :class:`XMLParser` peut être utilisée pour autre "
|
||
"chose que seulement construire une structure arborescente. Voici un exemple "
|
||
"de comptage de la profondeur maximale d'un fichier XML ::"
|
||
|
||
#: library/xml.etree.elementtree.rst:1417
|
||
msgid "XMLPullParser Objects"
|
||
msgstr "Objets *XMLPullParser*"
|
||
|
||
#: library/xml.etree.elementtree.rst:1421
|
||
msgid ""
|
||
"A pull parser suitable for non-blocking applications. Its input-side API is "
|
||
"similar to that of :class:`XMLParser`, but instead of pushing calls to a "
|
||
"callback target, :class:`XMLPullParser` collects an internal list of parsing "
|
||
"events and lets the user read from it. *events* is a sequence of events to "
|
||
"report back. The supported events are the strings ``\"start\"``, ``\"end"
|
||
"\"``, ``\"comment\"``, ``\"pi\"``, ``\"start-ns\"`` and ``\"end-ns\"`` (the "
|
||
"\"ns\" events are used to get detailed namespace information). If *events* "
|
||
"is omitted, only ``\"end\"`` events are reported."
|
||
msgstr ""
|
||
"Analyseur à flux tiré adapté aux applications non bloquantes. Son API côté "
|
||
"entrée est similaire à celle de :class:`XMLParser`, mais au lieu de pousser "
|
||
"les appels vers une cible de rappel, :class:`XMLPullParser` collecte une "
|
||
"liste interne d'événements d'analyse et permet à l'utilisateur de la lire. "
|
||
"*events* est une séquence d'événements à signaler. Les événements pris en "
|
||
"charge sont les chaînes ``\"start\"``, ``\"end\"``, ``\"comment\"``, ``\"pi"
|
||
"\"``, ``\"start-ns\"`` et ``\"end-ns\"`` (les événements ``\"ns\"`` sont "
|
||
"utilisés pour obtenir des informations détaillées sur les espaces de noms). "
|
||
"Si *events* est omis, seuls les événements ``\"end\"`` sont rapportés."
|
||
|
||
#: library/xml.etree.elementtree.rst:1432
|
||
msgid "Feed the given bytes data to the parser."
|
||
msgstr "Transmet les données d’octets à l’analyseur."
|
||
|
||
#: library/xml.etree.elementtree.rst:1436
|
||
msgid ""
|
||
"Signal the parser that the data stream is terminated. Unlike :meth:"
|
||
"`XMLParser.close`, this method always returns :const:`None`. Any events not "
|
||
"yet retrieved when the parser is closed can still be read with :meth:"
|
||
"`read_events`."
|
||
msgstr ""
|
||
"Signale à l'analyseur que le flux de données est terminé. Contrairement à :"
|
||
"meth:`XMLParser.close`, cette méthode renvoie toujours :const:`None`. Tous "
|
||
"les événements non encore récupérés lorsque l'analyseur est fermé peuvent "
|
||
"toujours être lus avec :meth:`read_events`."
|
||
|
||
#: library/xml.etree.elementtree.rst:1443
|
||
msgid ""
|
||
"Return an iterator over the events which have been encountered in the data "
|
||
"fed to the parser. The iterator yields ``(event, elem)`` pairs, where "
|
||
"*event* is a string representing the type of event (e.g. ``\"end\"``) and "
|
||
"*elem* is the encountered :class:`Element` object, or other context value as "
|
||
"follows."
|
||
msgstr ""
|
||
"Renvoie un itérateur sur les événements qui ont été rencontrés dans les "
|
||
"données fournies à l'analyseur. L'itérateur génère des paires ``(event, "
|
||
"elem)``, où *event* est une chaîne représentant le type d'événement (par "
|
||
"exemple ``\"end\"``) et *elem* est l'objet :class:`Element` rencontré, ou "
|
||
"une autre valeur de contexte comme suit."
|
||
|
||
#: library/xml.etree.elementtree.rst:1449
|
||
msgid "``start``, ``end``: the current Element."
|
||
msgstr "``start``, ``end`` : l'élément actuel."
|
||
|
||
#: library/xml.etree.elementtree.rst:1450
|
||
msgid "``comment``, ``pi``: the current comment / processing instruction"
|
||
msgstr ""
|
||
"``comment``, ``pi`` : le commentaire ou l'instruction de traitement actuel"
|
||
|
||
#: library/xml.etree.elementtree.rst:1451
|
||
msgid ""
|
||
"``start-ns``: a tuple ``(prefix, uri)`` naming the declared namespace "
|
||
"mapping."
|
||
msgstr ""
|
||
"``start-ns`` : couple ``(prefix, uri)`` nommant la correspondance d'espace "
|
||
"de noms déclarée."
|
||
|
||
#: library/xml.etree.elementtree.rst:1453
|
||
msgid "``end-ns``: :const:`None` (this may change in a future version)"
|
||
msgstr "``end-ns`` : :const:`None` (cela peut changer dans une version future)"
|
||
|
||
#: library/xml.etree.elementtree.rst:1455
|
||
msgid ""
|
||
"Events provided in a previous call to :meth:`read_events` will not be "
|
||
"yielded again. Events are consumed from the internal queue only when they "
|
||
"are retrieved from the iterator, so multiple readers iterating in parallel "
|
||
"over iterators obtained from :meth:`read_events` will have unpredictable "
|
||
"results."
|
||
msgstr ""
|
||
"Les événements fournis lors d'un appel précédent à :meth:`read_events` ne "
|
||
"seront plus renvoyés. Les événements sont consommés à partir de la file "
|
||
"d'attente interne uniquement lorsqu'ils sont récupérés de l'itérateur, donc "
|
||
"plusieurs lecteurs itérant en parallèle sur les itérateurs obtenus à partir "
|
||
"de :meth:`read_events` auront des résultats imprévisibles."
|
||
|
||
#: library/xml.etree.elementtree.rst:1463
|
||
msgid ""
|
||
":class:`XMLPullParser` only guarantees that it has seen the \">\" character "
|
||
"of a starting tag when it emits a \"start\" event, so the attributes are "
|
||
"defined, but the contents of the text and tail attributes are undefined at "
|
||
"that point. The same applies to the element children; they may or may not "
|
||
"be present."
|
||
msgstr ""
|
||
":class:`XMLPullParser` garantit uniquement qu'il a vu le caractère ``\">\"`` "
|
||
"d'une balise de début lorsqu'il émet un événement ``\"start\"``, donc les "
|
||
"attributs sont définis, mais le contenu des attributs *text* et *tail* n'est "
|
||
"pas défini à ce stade. La même chose s'applique aux nœuds enfants de "
|
||
"l'élément ; ils peuvent être présents ou non."
|
||
|
||
#: library/xml.etree.elementtree.rst:1478
|
||
msgid "Exceptions"
|
||
msgstr "Exceptions"
|
||
|
||
#: library/xml.etree.elementtree.rst:1482
|
||
msgid ""
|
||
"XML parse error, raised by the various parsing methods in this module when "
|
||
"parsing fails. The string representation of an instance of this exception "
|
||
"will contain a user-friendly error message. In addition, it will have the "
|
||
"following attributes available:"
|
||
msgstr ""
|
||
"Erreur d'analyse XML, générée par les différentes méthodes d'analyse de ce "
|
||
"module lorsque l'analyse échoue. La représentation sous forme de chaîne "
|
||
"d'une instance de cette exception contient un message d'erreur convivial. De "
|
||
"plus, elle possède les attributs suivants :"
|
||
|
||
#: library/xml.etree.elementtree.rst:1489
|
||
msgid ""
|
||
"A numeric error code from the expat parser. See the documentation of :mod:"
|
||
"`xml.parsers.expat` for the list of error codes and their meanings."
|
||
msgstr ""
|
||
"Code d'erreur numérique de l'analyseur *expat*. Voir la documentation de :"
|
||
"mod:`xml.parsers.expat` pour la liste des codes d'erreur et leur "
|
||
"signification."
|
||
|
||
#: library/xml.etree.elementtree.rst:1494
|
||
msgid ""
|
||
"A tuple of *line*, *column* numbers, specifying where the error occurred."
|
||
msgstr ""
|
||
"Un *n*-uplet de numéros de *ligne* et *colonne* indiquant le lieu "
|
||
"d'apparition de l'erreur."
|
||
|
||
#: library/xml.etree.elementtree.rst:1497
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: library/xml.etree.elementtree.rst:1498
|
||
msgid ""
|
||
"The encoding string included in XML output should conform to the appropriate "
|
||
"standards. For example, \"UTF-8\" is valid, but \"UTF8\" is not. See "
|
||
"https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl and https://"
|
||
"www.iana.org/assignments/character-sets/character-sets.xhtml."
|
||
msgstr ""
|
||
"La chaîne de caractères encodée inclue dans la sortie XML doit être conforme "
|
||
"aux standards. Par exemple, ``\"UTF-8\"`` est valide, mais pas ``"
|
||
"\"UTF8\"``. Voir https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-"
|
||
"EncodingDecl et https://www.iana.org/assignments/character-sets/character-"
|
||
"sets.xhtml."
|