"curses.ascii" — Utilitaires pour les caractères ASCII
******************************************************

**Code source :** Lib/curses/ascii.py

======================================================================

The "curses.ascii" module supplies name constants for ASCII characters
and functions to test membership in various ASCII character classes.
The constants supplied are names for control characters as follows:

+-----------------+------------------------------------------------+
| Nom             | Signification                                  |
|=================|================================================|
| curses.ascii.N  |                                                |
| UL              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.S  | Début d'en-tête, interruption de console       |
| OH              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.S  | Début du texte                                 |
| TX              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.E  | Fin du texte                                   |
| TX              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.E  | Fin de transmission                            |
| OT              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.E  | Enquête, va avec le contrôle de flux "ACK"     |
| NQ              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.A  | Accusé de réception                            |
| CK              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.B  | Caractère d'appel                              |
| EL              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.BS | Retour arrière                                 |
+-----------------+------------------------------------------------+
| curses.ascii.T  | Tabulation                                     |
| AB              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.HT | Alias pour "TAB": « Tabulation horizontale »   |
+-----------------+------------------------------------------------+
| curses.ascii.LF | Saut de ligne                                  |
+-----------------+------------------------------------------------+
| curses.ascii.NL | Alias pour "LF": « Nouvelle ligne »            |
+-----------------+------------------------------------------------+
| curses.ascii.VT | Tabulation verticale                           |
+-----------------+------------------------------------------------+
| curses.ascii.FF | Saut de page                                   |
+-----------------+------------------------------------------------+
| curses.ascii.CR | Retour chariot                                 |
+-----------------+------------------------------------------------+
| curses.ascii.SO | Bascule vers l’ensemble de caractères          |
|                 | alternatif                                     |
+-----------------+------------------------------------------------+
| curses.ascii.SI | Reprise de l'ensemble de caractères par défaut |
+-----------------+------------------------------------------------+
| curses.ascii.D  | Échappement de liaison de données              |
| LE              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.D  | XON, pour le contrôle de flux                  |
| C1              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.D  | Contrôle de périphérique 2, contrôle de flux   |
| C2              | en mode bloc                                   |
+-----------------+------------------------------------------------+
| curses.ascii.D  | XOFF, pour le contrôle de flux                 |
| C3              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.D  | Contrôle de périphérique 4                     |
| C4              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.N  | Accusé de réception négatif                    |
| AK              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.S  | Inactif synchrone                              |
| YN              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.E  | Fin du bloc de transmission                    |
| TB              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.C  | Annuler                                        |
| AN              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.EM | Fin du médium                                  |
+-----------------+------------------------------------------------+
| curses.ascii.S  | Substitut                                      |
| UB              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.E  | Échappement                                    |
| SC              |                                                |
+-----------------+------------------------------------------------+
| curses.ascii.FS | Séparateur de fichiers                         |
+-----------------+------------------------------------------------+
| curses.ascii.GS | Séparateur de groupe                           |
+-----------------+------------------------------------------------+
| curses.ascii.RS | Séparateur d'enregistrement, terminateur en    |
|                 | mode bloc                                      |
+-----------------+------------------------------------------------+
| curses.ascii.US | Séparateur d'unités                            |
+-----------------+------------------------------------------------+
| curses.ascii.SP | Espace                                         |
+-----------------+------------------------------------------------+
| curses.ascii.D  | Caractère d'effacement                         |
| EL              |                                                |
+-----------------+------------------------------------------------+

Notez que beaucoup d'entre elles ont peu de signification pratique
dans l'utilisation moderne. Les mnémoniques proviennent de conventions
de téléscripteur qui préexistent aux ordinateurs numériques.

Le module fournit les fonctions suivantes, basées sur celles de la
bibliothèque C standard :

curses.ascii.isalnum(c)

   Vérifie si un caractère ASCII est alphanumérique ; il est
   équivalent à "isalpha(c) or isdigit(c)".

curses.ascii.isalpha(c)

   Vérifie si un caractère ASCII est alphanumérique ; il est
   équivalent à "isupper(c) or islower(c)".

curses.ascii.isascii(c)

   Vérifie si une valeur de caractère appartient à l'ensemble ASCII 7
   bits.

curses.ascii.isblank(c)

   Vérifie si un caractère ASCII est caractère d'espacement,
   spécifiquement : espace ou tabulation horizontale.

curses.ascii.iscntrl(c)

   Vérifie si un caractère ASCII est un caractère de contrôle (dans la
   plage de 0x00 à 0x1f ou 0x7f).

curses.ascii.isdigit(c)

   Vérifie si un caractère ASCII est un chiffre décimal, de "'0'" à
   "'9'". C'est équivalent à "c in string.digits".

curses.ascii.isgraph(c)

   Vérifie si un caractère ASCII est n'importe quel caractère
   imprimable à l'exception de l'espace.

curses.ascii.islower(c)

   Vérifie si un caractère ASCII est une lettre minuscule.

curses.ascii.isprint(c)

   Vérifie si un caractère ASCII est n'importe quel caractère
   imprimable, y compris l'espace.

curses.ascii.ispunct(c)

   Vérifie si un caractère ASCII imprimable n'est ni une espace ni un
   caractère alphanumérique.

curses.ascii.isspace(c)

   Vérifie si un caractère ASCII est un caractère d'espacement,
   spécifiquement : espace, saut de ligne, retour chariot, saut de
   page, tabulation horizontale, ou tabulation verticale.

curses.ascii.isupper(c)

   Vérifie si un caractère ASCII est une lettre majuscule.

curses.ascii.isxdigit(c)

   Vérifie si un caractère ASCII est un chiffre hexadécimal. C'est
   équivalent à "c in string.hexdigits".

curses.ascii.isctrl(c)

   Vérifie si un caractère ASCII est un caractère de contrôle (valeurs
   ordinales de 0 à 31).

curses.ascii.ismeta(c)

   Vérifie si un caractère n'est pas ASCII (valeurs ordinales de 0x80
   et plus).

Ces fonctions acceptent soit des entiers soit des chaînes de
caractères d'un seul caractère ; lorsque l'argument est une chaîne, il
est d'abord converti en utilisant la fonction intégrée "ord()".

Notez que toutes ces fonctions vérifient les valeurs de bits ordinales
dérivées du caractère de la chaîne que vous fournissez ; elles ne
connaissent rien de l'encodage de caractères de la machine hôte.

Les deux fonctions suivantes acceptent soit une chaîne de caractères
d'un seul caractère soit une valeur d'octet sous forme d'entier ;
elles renvoient une valeur du même type.

curses.ascii.ascii(c)

   Renvoie la valeur ASCII correspondant aux 7 bits les moins
   significatifs de *c*.

curses.ascii.ctrl(c)

   Renvoie le caractère de contrôle correspondant au caractère donné
   (une opération ET bit-à-bit avec 0x1F est appliqué à la valeur du
   caractère).

curses.ascii.alt(c)

   Renvoie le caractère de contrôle correspondant au caractère donné
   (une opération OU bit-à-bit avec 0x80 est appliqué à la valeur du
   caractère).

La fonction suivante accepte soit une chaîne de caractères d'un seul
caractère soit une valeur entière ; elle renvoie une chaîne de
caractères.

curses.ascii.unctrl(c)

   Renvoie une représentation du caractère ASCII *c* sous forme d’une
   chaîne. Si *c* est imprimable, cette chaîne est le caractère lui-
   même. Si le caractère est un caractère de contrôle (0x00 – 0x1f),
   la chaîne se compose d'un accent circonflexe ("'^'") suivi de la
   lettre majuscule correspondante. Si le caractère est un caractère
   de suppression ASCII (0x7f), la chaîne est "'^?'". Si le bit *meta*
   du caractère est défini (0x80), le bit *meta* est supprimé, les
   règles précédentes appliquées, et "'!'" est ajouté au début du
   résultat.

curses.ascii.controlnames

   Tableau de chaînes de 33 éléments qui contient les mnémoniques
   ASCII pour les trente-deux caractères de contrôle ASCII de 0 (NUL)
   à 0x1f (US), dans l'ordre, ainsi que le mnémonique "SP" pour le
   caractère d'espace.
