# 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: 2019-09-04 11:33+0200\n" "PO-Revision-Date: 2019-04-12 15:04+0200\n" "Last-Translator: \n" "Language-Team: FRENCH \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 2.0.6\n" #: ../Doc/library/textwrap.rst:2 msgid ":mod:`textwrap` --- Text wrapping and filling" msgstr ":mod:`textwrap` --- Encapsulation et remplissage de texte" #: ../Doc/library/textwrap.rst:10 msgid "**Source code:** :source:`Lib/textwrap.py`" msgstr "**Source code:** :source:`Lib/textwrap.py`" #: ../Doc/library/textwrap.rst:14 msgid "" "The :mod:`textwrap` module provides some convenience functions, as well as :" "class:`TextWrapper`, the class that does all the work. If you're just " "wrapping or filling one or two text strings, the convenience functions " "should be good enough; otherwise, you should use an instance of :class:" "`TextWrapper` for efficiency." msgstr "" "Le module :mod:`textwrap` fournit quelques fonctions pratiques, comme :class:" "`TextWrapper`, la classe qui fait tout le travail. Si vous ne faites que " "formater ou ajuster une ou deux chaînes de texte, les fonctions de commodité " "devraient être assez bonnes ; sinon, nous vous conseillons d'utiliser une " "instance de :class:`TextWrapper` pour une meilleure efficacité." #: ../Doc/library/textwrap.rst:22 msgid "" "Wraps the single paragraph in *text* (a string) so every line is at most " "*width* characters long. Returns a list of output lines, without final " "newlines." msgstr "" "Reformate le paragraphe simple dans *text* (une chaîne de caractères) de " "sorte que chaque ligne ait au maximum *largeur* caractères. Renvoie une " "liste de lignes de sortie, sans ligne vide ou caractère de fin de ligne à la " "fin." #: ../Doc/library/textwrap.rst:26 msgid "" "Optional keyword arguments correspond to the instance attributes of :class:" "`TextWrapper`, documented below. *width* defaults to ``70``." msgstr "" "Les arguments par mot-clé optionnels correspondent aux attributs d'instance " "de :class:`TextWrapper`, documentés ci-dessous. *width* vaut ``70`` par " "défaut." #: ../Doc/library/textwrap.rst:29 msgid "" "See the :meth:`TextWrapper.wrap` method for additional details on how :func:" "`wrap` behaves." msgstr "" "Consultez la méthode :meth:`TextWrapper.wrap` pour plus de détails sur le " "comportement de :func:`wrap`." #: ../Doc/library/textwrap.rst:35 msgid "" "Wraps the single paragraph in *text*, and returns a single string containing " "the wrapped paragraph. :func:`fill` is shorthand for ::" msgstr "" "Formate le paragraphe unique dans *text* et renvoie une seule chaîne dont le " "contenu est le paragraphe formaté. :func:`fill` est un raccourci pour : :" #: ../Doc/library/textwrap.rst:40 msgid "" "In particular, :func:`fill` accepts exactly the same keyword arguments as :" "func:`wrap`." msgstr "" "En particulier, :func:`fill` accepte exactement les mêmes arguments par mot-" "clé que :func:`wrap`." #: ../Doc/library/textwrap.rst:46 msgid "Collapse and truncate the given *text* to fit in the given *width*." msgstr "" "Réduit et tronque le *text* donné pour l'adapter à la *largeur* donnée." #: ../Doc/library/textwrap.rst:48 msgid "" "First the whitespace in *text* is collapsed (all whitespace is replaced by " "single spaces). If the result fits in the *width*, it is returned. " "Otherwise, enough words are dropped from the end so that the remaining words " "plus the :attr:`placeholder` fit within :attr:`width`::" msgstr "" "Tout d'abord, les espaces dans *text* sont réduites (toutes les espaces " "blancs sont remplacées par des espaces simples). Si le résultat tient dans " "la *width*, il est renvoyé. Sinon, suffisamment de mots sont supprimés en " "fin de chaîne de manière à ce que les mots restants plus le :attr:" "`placeholder` tiennent dans :attr:`width`: :" #: ../Doc/library/textwrap.rst:60 msgid "" "Optional keyword arguments correspond to the instance attributes of :class:" "`TextWrapper`, documented below. Note that the whitespace is collapsed " "before the text is passed to the :class:`TextWrapper` :meth:`fill` function, " "so changing the value of :attr:`.tabsize`, :attr:`.expand_tabs`, :attr:`." "drop_whitespace`, and :attr:`.replace_whitespace` will have no effect." msgstr "" "Les arguments par mot-clé optionnels correspondent aux attributs d'instance " "de :class:`TextWrapper`, documentés ci-dessous. Notez que l'espace blanc " "est réduit avant que le texte ne soit passé à la fonction :meth:`fill` de :" "class:`TextWrapper`, donc changer la valeur de :attr:`.tabsize`, :attr:`." "expand_tabs`, :attr:`.drop_whitespace`, et :attr:`.replace_whitespace` est " "sans effet." #: ../Doc/library/textwrap.rst:71 msgid "Remove any common leading whitespace from every line in *text*." msgstr "Supprime toutes les espaces en de tête de chaque ligne dans *text*." #: ../Doc/library/textwrap.rst:73 msgid "" "This can be used to make triple-quoted strings line up with the left edge of " "the display, while still presenting them in the source code in indented form." msgstr "" "Ceci peut être utilisé pour aligner les chaînes à trois guillemets avec le " "bord gauche de l'affichage, tout en les présentant sous forme indentée dans " "le code source." #: ../Doc/library/textwrap.rst:76 msgid "" "Note that tabs and spaces are both treated as whitespace, but they are not " "equal: the lines ``\" hello\"`` and ``\"\\thello\"`` are considered to have " "no common leading whitespace." msgstr "" "Notez que les tabulations et les espaces sont traitées comme des espaces, " "mais qu'elles ne sont pas égales : les lignes ``\" hello\"`` et ``\"\\thello" "\"`` sont considérées comme n'ayant pas d'espaces de tête communes." #: ../Doc/library/textwrap.rst:80 msgid "" "Lines containing only whitespace are ignored in the input and normalized to " "a single newline character in the output." msgstr "" #: ../Doc/library/textwrap.rst:83 ../Doc/library/textwrap.rst:104 msgid "For example::" msgstr "Par exemple ::" #: ../Doc/library/textwrap.rst:97 msgid "Add *prefix* to the beginning of selected lines in *text*." msgstr "Ajoute *prefix* au début des lignes sélectionnées dans *text*." #: ../Doc/library/textwrap.rst:99 msgid "Lines are separated by calling ``text.splitlines(True)``." msgstr "Les lignes sont séparées en appelant ``text.splitlines(True)``." #: ../Doc/library/textwrap.rst:101 msgid "" "By default, *prefix* is added to all lines that do not consist solely of " "whitespace (including any line endings)." msgstr "" "Par défaut, *prefix* est ajouté à toutes les lignes qui ne sont pas " "constituées uniquement d'espaces (y compris les fins de ligne)." #: ../Doc/library/textwrap.rst:110 msgid "" "The optional *predicate* argument can be used to control which lines are " "indented. For example, it is easy to add *prefix* to even empty and " "whitespace-only lines::" msgstr "" "L'argument optionnel *predicate* peut être utilisé pour contrôler quelles " "lignes sont en retrait. Par exemple, il est facile d'ajouter *prefix* aux " "lignes vides et aux lignes blanches seulement : :" #: ../Doc/library/textwrap.rst:123 msgid "" ":func:`wrap`, :func:`fill` and :func:`shorten` work by creating a :class:" "`TextWrapper` instance and calling a single method on it. That instance is " "not reused, so for applications that process many text strings using :func:" "`wrap` and/or :func:`fill`, it may be more efficient to create your own :" "class:`TextWrapper` object." msgstr "" ":func:`wrap`, :func:`fill` et :func:`shorten` travaillent en créant une " "instance :class:`TextWrapper` et en appelant une méthode unique sur celle-" "ci. Cette instance n'est pas réutilisée, donc pour les applications qui " "traitent plusieurs chaînes de texte en utilisant :func:`wrap` et/ou :func:" "`fill`, il peut être plus efficace de créer votre propre objet :class:" "`TextWrapper`." #: ../Doc/library/textwrap.rst:129 msgid "" "Text is preferably wrapped on whitespaces and right after the hyphens in " "hyphenated words; only then will long words be broken if necessary, unless :" "attr:`TextWrapper.break_long_words` is set to false." msgstr "" "Le formatage du texte s'effectue en priorité sur les espaces puis juste " "après les traits d'union dans des mots séparés par des traits d'union ; ce " "n'est qu'alors que les mots longs seront cassés si nécessaire, à moins que :" "attr:`TextWrapper.break_long_words` soit défini sur *False*." #: ../Doc/library/textwrap.rst:135 msgid "" "The :class:`TextWrapper` constructor accepts a number of optional keyword " "arguments. Each keyword argument corresponds to an instance attribute, so " "for example ::" msgstr "" "Le constructeur :class:`TextWrapper` accepte un certain nombre d'arguments " "par mots-clés optionnels. Chaque argument par mot-clé correspond à un " "attribut d'instance, donc par exemple : :" #: ../Doc/library/textwrap.rst:141 msgid "is the same as ::" msgstr "est identique à ::" #: ../Doc/library/textwrap.rst:146 msgid "" "You can re-use the same :class:`TextWrapper` object many times, and you can " "change any of its options through direct assignment to instance attributes " "between uses." msgstr "" "Vous pouvez réutiliser le même objet :class:`TextWrapper` plusieurs fois et " "vous pouvez changer n'importe laquelle de ses options par assignation " "directe aux attributs d'instance entre les utilisations." #: ../Doc/library/textwrap.rst:150 msgid "" "The :class:`TextWrapper` instance attributes (and keyword arguments to the " "constructor) are as follows:" msgstr "" "Les attributs d'instance de la classe :class:`TextWrapper` (et les arguments " "par mot-clé au constructeur) sont les suivants :" #: ../Doc/library/textwrap.rst:156 msgid "" "(default: ``70``) The maximum length of wrapped lines. As long as there are " "no individual words in the input text longer than :attr:`width`, :class:" "`TextWrapper` guarantees that no output line will be longer than :attr:" "`width` characters." msgstr "" "(par défaut : ``70```) Longueur maximale des lignes reformatées. Tant qu'il " "n'y a pas de mots individuels dans le texte d'entrée plus longs que :attr:" "`width`, :class:`TextWrapper` garantit qu'aucune ligne de sortie n'est plus " "longue que :attr:`width` caractères." #: ../Doc/library/textwrap.rst:164 msgid "" "(default: ``True``) If true, then all tab characters in *text* will be " "expanded to spaces using the :meth:`expandtabs` method of *text*." msgstr "" "(par défaut : ``True``) Si `true`, alors tous les caractères de tabulation " "dans *text* sont transformés en espaces en utilisant la méthode :meth:" "`expandtabs` de *text*." #: ../Doc/library/textwrap.rst:170 msgid "" "(default: ``8``) If :attr:`expand_tabs` is true, then all tab characters in " "*text* will be expanded to zero or more spaces, depending on the current " "column and the given tab size." msgstr "" "(par défaut : ``8``) Si :attr:`expand_tabs` est `true`, alors tous les " "caractères de tabulation dans *text* sont transformés en zéro ou plus " "d'espaces, selon la colonne courante et la taille de tabulation donnée." #: ../Doc/library/textwrap.rst:179 msgid "" "(default: ``True``) If true, after tab expansion but before wrapping, the :" "meth:`wrap` method will replace each whitespace character with a single " "space. The whitespace characters replaced are as follows: tab, newline, " "vertical tab, formfeed, and carriage return (``'\\t\\n\\v\\f\\r'``)." msgstr "" "(par défaut : ``True``) Si `true`, après l'expansion des tabulations mais " "avant le formatage, la méthode :meth:`wrap` remplace chaque *blanc* par une " "espace unique. Les *blancs* remplacés sont les suivants : tabulation, " "nouvelle ligne, tabulation verticale, saut de page et retour chariot (``'\\t" "\\n\\v\\f\\r'``)." #: ../Doc/library/textwrap.rst:187 msgid "" "If :attr:`expand_tabs` is false and :attr:`replace_whitespace` is true, each " "tab character will be replaced by a single space, which is *not* the same as " "tab expansion." msgstr "" "Si :attr:`expand_tabs` est *False* et :attr:`replace_whitespace` est vrai, " "chaque caractère de tabulation est remplacé par une espace unique, ce qui " "*n'est pas* la même chose que l'extension des tabulations." #: ../Doc/library/textwrap.rst:193 msgid "" "If :attr:`replace_whitespace` is false, newlines may appear in the middle of " "a line and cause strange output. For this reason, text should be split into " "paragraphs (using :meth:`str.splitlines` or similar) which are wrapped " "separately." msgstr "" "Si :attr:`replace_whitespace` est faux, de nouvelles lignes peuvent " "apparaître au milieu d'une ligne et provoquer une sortie étrange. Pour cette " "raison, le texte doit être divisé en paragraphes (en utilisant :meth:`str." "splitlines` ou similaire) qui sont formatés séparément." #: ../Doc/library/textwrap.rst:201 msgid "" "(default: ``True``) If true, whitespace at the beginning and ending of every " "line (after wrapping but before indenting) is dropped. Whitespace at the " "beginning of the paragraph, however, is not dropped if non-whitespace " "follows it. If whitespace being dropped takes up an entire line, the whole " "line is dropped." msgstr "" "(par défaut : ``True``) Si *True*, l'espace au début et à la fin de chaque " "ligne (après le formatage mais avant l'indentation) est supprimée. L'espace " "au début du paragraphe n'est cependant pas supprimée si elle n'est pas " "suivie par une espace. Si les espaces en cours de suppression occupent une " "ligne entière, la ligne entière est supprimée." #: ../Doc/library/textwrap.rst:210 msgid "" "(default: ``''``) String that will be prepended to the first line of wrapped " "output. Counts towards the length of the first line. The empty string is " "not indented." msgstr "" "(par défaut : ```''```) Chaîne qui est ajoutée à la première ligne de la " "sortie formatée. Elle compte pour le calcul de la longueur de la première " "ligne. La chaîne vide n'est pas indentée." #: ../Doc/library/textwrap.rst:217 msgid "" "(default: ``''``) String that will be prepended to all lines of wrapped " "output except the first. Counts towards the length of each line except the " "first." msgstr "" "(par défaut : ```''```) Chaîne qui préfixe toutes les lignes de la sortie " "formatée sauf la première. Elle compte pour le calcul de la longueur de " "chaque ligne à l'exception de la première." #: ../Doc/library/textwrap.rst:224 msgid "" "(default: ``False``) If true, :class:`TextWrapper` attempts to detect " "sentence endings and ensure that sentences are always separated by exactly " "two spaces. This is generally desired for text in a monospaced font. " "However, the sentence detection algorithm is imperfect: it assumes that a " "sentence ending consists of a lowercase letter followed by one of ``'.'``, " "``'!'``, or ``'?'``, possibly followed by one of ``'\"'`` or ``\"'\"``, " "followed by a space. One problem with this is algorithm is that it is " "unable to detect the difference between \"Dr.\" in ::" msgstr "" "(par défaut : ``Faux``) Si `true`, :class:`TextWrapper` tente de détecter " "les fins de phrases et de s'assurer que les phrases sont toujours séparées " "par exactement deux espaces. Ceci est généralement souhaité pour un texte " "en police à chasse fixe. Cependant, l'algorithme de détection de phrase est " "imparfait : il suppose qu'une fin de phrase consiste en une lettre minuscule " "suivie de l'une des lettres suivantes : ``'.'``, ``'!'``, ou ``'?'``, " "éventuellement suivie d'une des lettres ``'\"'`` ou ``\"'\"``, suivie par " "une espace. Un problème avec cet algorithme est qu'il est incapable de " "détecter la différence entre \"Dr\" dans : :" #: ../Doc/library/textwrap.rst:235 msgid "and \"Spot.\" in ::" msgstr "et \"Spot.\" dans ::" #: ../Doc/library/textwrap.rst:239 msgid ":attr:`fix_sentence_endings` is false by default." msgstr ":attr:`fix_sentence_endings` est *False* par défaut." #: ../Doc/library/textwrap.rst:241 msgid "" "Since the sentence detection algorithm relies on ``string.lowercase`` for " "the definition of \"lowercase letter,\" and a convention of using two spaces " "after a period to separate sentences on the same line, it is specific to " "English-language texts." msgstr "" "Étant donné que l'algorithme de détection de phrases repose sur ``string." "lowercase`` pour la définition de \"lettres minuscules\" et sur une " "convention consistant à utiliser deux espaces après un point pour séparer " "les phrases sur la même ligne, ceci est spécifique aux textes de langue " "anglaise." #: ../Doc/library/textwrap.rst:249 msgid "" "(default: ``True``) If true, then words longer than :attr:`width` will be " "broken in order to ensure that no lines are longer than :attr:`width`. If " "it is false, long words will not be broken, and some lines may be longer " "than :attr:`width`. (Long words will be put on a line by themselves, in " "order to minimize the amount by which :attr:`width` is exceeded.)" msgstr "" "(par défaut : ``True``) Si *True*, alors les mots plus longs que :attr:" "`width` sont cassés afin de s'assurer qu'aucune ligne ne soit plus longue " "que :attr:`width`. Si c'est *False*, les mots longs ne sont pas cassés et " "certaines lignes peuvent être plus longues que :attr:`width` (les mots longs " "seront mis sur une ligne qui leur est propre, afin de minimiser le " "dépassement de :attr:`width`)." #: ../Doc/library/textwrap.rst:258 msgid "" "(default: ``True``) If true, wrapping will occur preferably on whitespaces " "and right after hyphens in compound words, as it is customary in English. If " "false, only whitespaces will be considered as potentially good places for " "line breaks, but you need to set :attr:`break_long_words` to false if you " "want truly insecable words. Default behaviour in previous versions was to " "always allow breaking hyphenated words." msgstr "" "(par défaut : ``True``) Si c'est vrai, le formatage se fait de préférence " "sur les espaces et juste après sur les traits d'union des mots composés, " "comme il est d'usage en anglais. Si *False*, seuls les espaces sont " "considérées comme de bons endroits pour les sauts de ligne, mais vous devez " "définir :attr:`break_long_words` à *False* si vous voulez des mots vraiment " "insécables. Le comportement par défaut dans les versions précédentes était " "de toujours permettre de couper les mots avec trait d'union." #: ../Doc/library/textwrap.rst:268 msgid "" "(default: ``None``) If not ``None``, then the output will contain at most " "*max_lines* lines, with *placeholder* appearing at the end of the output." msgstr "" "(par défaut : ``None```) Si ce n'est pas ``None```, alors la sortie contient " "au maximum *max_lines* lignes, avec *placeholder* à la fin de la sortie." #: ../Doc/library/textwrap.rst:278 msgid "" "(default: ``' [...]'``) String that will appear at the end of the output " "text if it has been truncated." msgstr "" "(par défaut : ``'' [...]'``) Chaîne qui apparaît à la fin du texte de sortie " "s'il a été tronqué." #: ../Doc/library/textwrap.rst:284 msgid "" ":class:`TextWrapper` also provides some public methods, analogous to the " "module-level convenience functions:" msgstr "" ":class:`TextWrapper` fournit également quelques méthodes publiques, " "analogues aux fonctions de commodité au niveau du module :" #: ../Doc/library/textwrap.rst:289 msgid "" "Wraps the single paragraph in *text* (a string) so every line is at most :" "attr:`width` characters long. All wrapping options are taken from instance " "attributes of the :class:`TextWrapper` instance. Returns a list of output " "lines, without final newlines. If the wrapped output has no content, the " "returned list is empty." msgstr "" "Formate le paragraphe unique dans *text* (une chaîne de caractères) de sorte " "que chaque ligne ait au maximum :attr:`width` caractères. Toutes les " "options de formatage sont tirées des attributs d'instance de l'instance de " "classe :class:`TextWrapper`. Renvoie une liste de lignes de sortie, sans " "nouvelles lignes finales. Si la sortie formatée n'a pas de contenu, la liste " "vide est renvoyée." #: ../Doc/library/textwrap.rst:298 msgid "" "Wraps the single paragraph in *text*, and returns a single string containing " "the wrapped paragraph." msgstr "" "Formate le paragraphe unique de *text* et renvoie une seule chaîne contenant " "le paragraphe formaté."