Cet article est le quatrième d'une série destinée à vous faire découvrir le langage Python. Le mois dernier nous avons exploré les fonctionnalités objets et les exceptions. Nous allons ce mois-ci examiner les différentes fonctionnalités fournies par les modules Python les plus classiques ainsi que quelques astuces courantes de programmation permises par le langage.
Ce mois-ci, les exemples seront un peu moins nombreux, mais nous nous
attacherons à décrire les principaux modules, car non seulement
de ceux-ci dépend en grande partie la convivialité du langage,
mais vous les retrouverez dans la majorité des programmes "sérieux",
et nous devons donc les présenter avant d'aborder la programmation
d'applications plus sérieuses que les exemples de quelques lignes
des articles précédents.
Cependant, avant d'entrer dans le vif du sujet, voyons comment s'utilisent
les chaînes '__doc__' qui sont d'une très grande
utilité pour documenter votre code ainsi que pour obtenir des informations
sur l'utilisation des modules avec lesquels vous n'êtes pas encore
totalement familiers.
Les chaînes __doc__
Il est possible de commencer la déclaration d'un module, d'une
classe, d'une méthode ou d'une fonction par une chaîne de
caractères qui peut être utilisée pour documenter le
code.
Cette chaîne doit être une constante et être placée
avant la première instruction. Considérons le code du module
suivant :
#-- fichier module1.py --
"""Ceci est un module d'exemple."""
def fonct(param):
"documentation de la fonction 'fonct'."
print param
class Exemple:
"""Documentation de la Classe 'Exemple'"""
def __init__(self,x):
"methode constructrice
de la classe Exemple"
self.data=x
#-- module1.py --
On peut ensuite "interroger" le module de la manière suivante :
>>> import module1
>>> print module1.__doc__
Ceci est un module d'exemple.
>>> print module1.fonct.__doc__
documentation de la fonction 'fonct'.
>>> print module1.Exemple.__doc__
Documentation de la Classe 'Exemple'.
>>> print module1.Exemple.__init__.__doc__
methode constructrice de la classe Exemple
Il est également possible d'utiliser l'attribut '__dict__' du
module pour avoir la liste des variables, fonctions et classes qu'il définit
:
>>> print module1.__dict__.keys()
['fonct', '__doc__', 'Exemple', '__file__', '__name__', '__builtins__']
Les symboles __file__, __name__ et __builtins__ sont définis automatiquement par tous les modules et ils correspondent respectivement aux nom du fichier depuis lequel le module a été chargé, au nom du module et à une référence au module __builtins__ qui est importé automatiquement et donc toujours disponible.
La plupart des modules Python (en particulier ceux que nous allons examiner dans la suite de cet article) utilisent ces chaînes de descriptions qui peuvent être utilisées comme aide en ligne. Par exemple, si l'on veut savoir ce que fait la fonction hypot du module math, il suffit de faire afficher la chaîne de documentation de cette fonction :
>>> import math
>>> print math.hypot.__doc__
hypot(x,y)
Returns the Euclidean distance, sqrt(x*x + y*y).
Les chaînes __doc__ constituent la méthode standard de documentation du code Python et tend dans la plupart des cas à remplacer les commentaires. Nous vous conseillons très fortement d'utiliser cette technique lorsque vous écrirez du code qui aura vocation d'être réutilisable ou d'être examiné par quelqu'un d'autre que vous.
Examinons maintenant les principaux modules fournis avec l'interpréteur Python. Nous ne les passerons pas tous en revue, cependant il nous semble important de décrire les plus importants pour éviter aux programmeurs Python débutants d'avoir à réinventer la roue ainsi que de vous permettre de comprendre plus facilement les programmes que vous aurez à examiner.
Module __builtins__
Ce module 'virtuel' rassemble les fonctions, exceptions et objets définis directement par l'interpréteur Python.
Du fait du grand nombre de fonctions définies par l'interpréteur
Python, la table suivante n'est pas exhaustive, mais elle contient cependant
toutes les fonctions dont les programmeurs ont besoin. Notez également
que certaines de ces fonctions peuvent être appelées avec
des paramètres rarement utilisés qui ne sont pas détaillés
ici.
Si vous désirez obtenir plus d'informations qu'il n'en est donné
ici, n'oubliez pas que vous pouvez pour cela utiliser la fonctionnalité
d'instrospection (voir l'article dans le numéro 19), ainsi que le
système de documentation en ligne présenté dans le
paragraphe précédant. Par exemple, la description complète
de la fonction open, est contenue dans la variable __builtins__.open.__doc__
.
Exemple pratique :
>>> F=open("fichier", w)
Traceback (innermost last):
File "<stdin>", line 1, in ?
NameError: w
(Zut !)
>>> print __builtins__.open.__doc__
open(filename[, mode[, buffering]]) -> file object
Open a file. The mode can be 'r', 'w' or 'a' for reading (default),
writing or appending. The file will be created if it doesn't
exist
[etc]
(Ah oui, c'est vrai !)
>>> F=open("fichier", 'w')
>>>
(Et voila ! ;-)
Cela vous prendra sûrement quelques temps pour vous habituer à utiliser cette méthode, mais en pratique, elle vous économisera des heures de lecture et de recherche dans la documentation.
Comme nous l'avons dit précédemment, le module __builtins__ est importé automatiquement et contient les fonctions de base du langage. La table suivante donne un aperçu de chacune d'entre elles.
Note: les paramètres suivis du signe '?' sont optionnels.
|
|
|
| abs(x) | Retourne la valeur absolue d'un nombre. |
| apply(fonct, params) | Appelle la fonction avec le tuple de paramètres spécifié. |
| callable(x) | Retourne 1 si x est une méthode ou une fonction, retourne 0 sinon. |
| chr(x) | Retourne la chaîne contenant le caractère dont le code ASCII est x. |
| cmp(x, y) | Retourne -1, 0 ou 1, selon que x est inférieur, égal ou supérieur à x. |
| coerce(x, y) | Retourne un tuple contenant x et y convertis dans le même type. |
| delattr(objet, nom) | Efface l'attribut correspondant de l'objet (équivalent à del objet.nom). |
| dir(objet) | Retourne la liste des attributs de l'objet. |
| divmod(x,y) | Retourne le tuple (x/y, x%y). |
| eval(code,global?,local?) | Exécute l'expression (chaîne ou code retourné par la fonction compile()) passée en paramètre dans l'environnement local, ou ceux passés en paramètres. |
| execfile(fichier,global?,local?) | Exécute le code contenu dans le fichier passé en paramètre. |
| filter(fonct, liste) | Retourne une liste constituée des éléments de 'liste' pour lesquels la fonction 'fonct' retourne une valeur vraie. |
| float(x) | converti le paramètre en nombre flottant. |
| getattr(objet, nom) | Retourne la valeur de l'attribut 'nom' de l'objet 'objet'. |
| globals() | Retourne un dictionnaire contenant tous les symboles définis globalement. |
| hasattr(objet, nom) | Retourne vrai si l'objet a un attribut nommé 'nom'. |
| hex(x) | Retourne une chaîne donnant la représentation hexadécimale de x. |
| id(objet) | Retourne un entier unique correspondant à 'objet' (dans l'implementation actuelle de Python c'est l'adresse mémoire à laquelle l'objet est stocké). |
| input(prompt?) | Lit une chaîne entrée au clavier. Si 'prompt' est spécifié, cette chaîne est d'abord affichée. |
| int(x) | Converti x en un nombre entier. |
| isinstance(objet, classe-ou-type?) | Retourne la valeur booléene vraie ou fausse selon que l'objet est une instance de classe. Si le deuxième paramètre est utilisé, la valeur retournée est vrai si l'objet est du type ou hérite de la classe spécifié. |
| issubclass(a,b) | Retourne la valeur booléene vraie si 'b' hérite de la classe 'a'. |
| len(x) | Retourne le nombre d'éléments contenus dans l'objet x. En particulier, cette fonction retourne le nombre de caractères si x est une chaîne. |
| locals() | Retourne un dictionnaire contenant tous les symboles définis localement. |
| long(x) | Converti x en un entier long. |
| map(fonct, liste, ...) | Retourne la liste des résultats de l'appel de la fonction 'fonct' avec comme paramètre chacun des éléments de la liste. |
| max(seq) | Retourne l'élément de la séquence ayant la plus grande valeur. |
| min(seq) | Retourne l'élément de la séquence ayant la plus petite valeur. |
| oct(x) | Retourne une chaîne donnant la représentation octale (en base 8) de x. |
| open(fich, mode?,
taillebuf?) |
Ouvre le fichier 'fich' avec le mode éventuellement spécifié : 'r' pour lecture (mode par défaut si aucun n'est spécifié), 'w' pour écriture. En outre, les signes 'b' (pour un fichier binaire) et '+' (pour dire que l'on désire ouvrir le fichier à la fois en mode lecture et écriture) sont disponibles. Le paramètre 'taillebuf' indique si l'écriture dans le fichier doit utiliser un tampon ou être immédiate. 0 indique que les écritures doivent être immédiates, 1 indique qu'un tampon doit être utilisé, une valeur plus grande indiquant la taille du tampon à utiliser. |
| ord(x) | Retourne le code ASCII du caractère passé en paramètre (c'est-à-dire la fonction inverse de chr() ). |
| pow(x, y, z?) | Retourne x à la puissance y. Si le troisième paramètre est utilisé, cette fonction retourne (x^y) % z. |
| range(début?, fin, pas?) | Retourne la liste des entiers de 'début' à 'fin' en incrémentant à chaque fois de 'pas'. Les valeurs par défaut de 'début' et 'pas' sont (respectivement) zéro et +1. |
| raw_input() | Lit une ligne de caractères sur l'entrée standard en supprimant le retour à la ligne final. |
| reduce(fonct, liste, init?) | Applique successivement 'fonct' par paire d'arguments, en utilisant éventuellement 'init' comme valeur initiale. |
| reload(module) | Réimporte un module déjà importé. |
| repr(x) | Donne une chaîne représentant l'objet x. Idem que `x`. |
| round(x, n?) | Arrondi le nombre en virgule flottante x à n décimales après la virgule (zéro par défaut). |
| setattr(obj, nom, valeur) | Assigne une valeur à une donnée membre d'un objet (Idem que obj.nom=valeur). |
| tuple(seq) | Converti une séquence en tuple. |
| type(obj) | Retourne le type de l'objet spécifié. |
| xrange(début?, fin, pas?) | Idem que range mais retourne les entiers un par un au lieu de construire une liste. |
Module string
Bien qu'elles ne fassent pas parti des fonctions de base du langage,
les fonctions du module 'string' sont indispensable au développement
de la plupart des applications. Les programmeurs habitués à
Perl, notamment, devraient y trouver leur bonheur.
|
|
|
| atof(s) | Converti une chaîne de caractères en nombre à virgule flottante. |
| atoi(s,base?), atol(s,base?) | Converti une chaîne de caractères en (respectivement) un entier ou entier long. Le deuxième paramètre est optionnel et précise la base à utiliser (10 par défaut). |
| find(s,sub,start?) | Recherche la position de la première occurrence de la chaîne 'sub' dans la chaîne 's' en commençant la recherche au start-ième caractère (0 par défaut). |
| count(s,sub,start?) | Compte le nombre d'occurrences de 'sub' dans 's' en commençant au start-ième caractère. |
| split(s) | Retourne une liste d'éléments constituée en coupant la chaîne 's' entre chaque caractère espace. |
| splitfields(s,sep) | Idem que split, mais utilise la séquence 'sep' comme séparateur. |
| join(x) | Concatène une liste ou un tuple de chaînes de caractères en ajoutant un espace entre chaque élément (inverse de la fonction split). |
| joinfields(x,sep) | Idem que join, mais la chaîne 'sep' et utilisée à la place du caractère espace (Inverse de la fonction splitfields). |
| strip(x) | Enlève les caractères espace situés au début et la fin de la chaîne. |
| upper(x) | Converti tous les caractères en majuscule. |
| lower(x) | Converti tous les caractères en minuscule. |
Modules regex et regsub
Les aficionados de Perl auront sans aucun doute déjà remarqué le manque d'expressions régulières jusqu'à présent. Qu'ils soient rassurés, les expressions régulières non seulement existent en Python, mais sont presque totalement compatibles avec celles de Perl (Que demander de plus? ;-).
Le module regex implémente la recherche (matching) de
sous-chaînes classiques, tandis que le module regsub fournis
le moyen d'effectuer des remplacements.
|
|
|
| match(motif, chaîne) | Retourne la longueur de la sous-chaîne de 'chaîne' qui "matche" le motif de recherche. |
| search(motif, chaîne) | Retourne la position du premier caractère de la sous-chaîne qui correspond au motif, ou -1 si le motif recherché n'apparait pas dans la chaîne. |
| compile(motif) | Compile le motif en un objet pour utilisation ultérieure (principalement utilisé pour améliorer les performances). |
| set_syntax(mode) | Permet de définir la variante de la syntaxe utilisée par les expressions regulières. 'mode' peut être une des chaînes suivantes : RE_SYNTAX_AWK, RE_SYNTAX_EGREP, RE_SYNTAX_GREP, RE_SYNTAX_EMACS. |
Sur les objets retournés par la fonction compile() peuvent
d'autre part s'appliquer les méthodes suivantes :
obj.match(chaine, from?)
Idem que la fonction regex.match en utilisant
le motif défini par 'obj'. S'il est mentionné, 'from' est
le premier caractère à considérer pour la recherche.
obj.search(chaine, from?)
Idem que la fonction regex.seach.
obj.group(index, index, ...)
Retourne les sous-chaînes correspondant aux
sous-expressions groupées dans le motif.
Examinons quelques exemples pour fixer les choses :
>>> import regex
>>> print regex.search("de", "abcdefgh")
3
>>> r=regex.compile("XX")
>>> print r.match("XX")
2
>>> print r.match("XY")
-1
>>> r=regex.compile("A\(.\)B\(.\)")
>>> r.match("AXBZ")
4
>>> print r.group(1)
X
>>> print r.group(2)
Z
regsub
Le module 'regsub' est basé sur 'regex' et permet d'effectuer
des remplacements de sous-chaînes. Ce module contient les 3 fonctions
suivantes :
| sub(motif, remplacement, chaîne) | Remplace la première occurrence du motif dans 'chaîne' par 'remplacement'. |
| gsub(motif, remplacement, chaîne) | Remplace toutes les occurrences du motif dans 'chaîne' par 'remplacement'. |
| split(chaîne, motif) | Sépare la chaine en sous-chaîne, en utilisant le motif comme délimiteur. |
Module math
Le module 'math' défini les fonctions nécessaires pour
faire la plupart des calculs mathématiques et scientifiques courants.
Outre les variables e et pi (dont je vous laisse deviner
les valeurs ;-), ce module défini également les fonctions
suivantes :
|
|
|
| fmod(x,y) | Retourne le reste de la division de x par y (modulo). |
| log10(x) | Logarithme en base 10 de x. |
| sqrt(x) | Racine carré. |
| modf(x) | Retourne un tuple contenant les parties fractionnaire et entière
de x.
>>> math.modf(3.14159) (0.14159, 3.0) |
| sin(x)
cos(x) tan(x) |
Respectivement : sinus, cosinus et tangente de x. |
| frexp(x) | Retourne un tuple contenant la mantise et l'exposant de x lorsqu'il est exprimé en notation scientifique binaire. |
| exp(x) | Retourne la constante e à la puissance x. |
| acos(x)
asin(x) atan(x) |
Respectivement : arc-cosinus, arc-sinus et arc-tangente de x. |
| atan2(x,y) | Équivalent à atan(x/y) |
| floor(x) | Retourne la valeur entière de x sous forme de nombre réel
:
>>> math.floor(3.14159) 3.0 |
| fabs(x) | Retourne la valeur absolue du nombre x :
>>> math.fabs(-3.14) 3.14 |
| log(x) | Retourne le logarithme Népérien de x. |
| pow(x,y) | Retourne x^y. |
| hypot(x,y) | Calcul de la distance euclidienne : sqrt(x*x+y*y). |
| ldexp(x,i) | Retourne x*2^i (Inverse de la fonction 'frexp'). |
| cosh(x)
sinh(x) tanh(x) |
Respectivement : cosinus hyperbolique, sinus hyperbolique et tangente hyperbolique. |
| ceil(x) | Retourne l'entier immédiatement supérieur à x
sous forme de nombre réel :
>>> math.ceil(3.14) 4.0 |
Persistance
Les bibliothèques standards Python offrent également une fonctionnalité intéressante connue sous le nom de persistance (et que les programmeurs C++/Java connaissent sous le nom de "sérialisation d'objets"). Cette fonctionnalité est fournie par 2 modules distincts : pickle et shelve. Examinons-les de plus près :
pickle
Ce module comporte 4 fonctions :
dump(objet, fichier)
Enregistre l'objet dans un fichier.
chaîne <- dumps(objet)
Donne une représentation de l'objet sous
forme d'une chaîne de caractères que le programme peut archiver
ou transmettre comme il l'entend.
objet <- load(fichier)
Récupération de l'objet enregistré
dans le fichier.
objet <- loads(chaîne)
Récupération de l'objet encodé
sous forme de chaîne de caractères.
Voici un petit exemple :
>>> import pickle
>>> obj=[1,2,"hello",3+4j]
>>> fichier=open('/tmp/objet', 'w')
>>> pickle.dump(obj,fichier)
[plus tard dans le même script, ou à partir d'un autre programme]
>>> import pickle
>>> fichier=open('/tmp/objet')
>>> obj2=pickle.load(fichier)
>>> print obj2
[1, 2, 'hello', (3+4j)]
shelve
Le fonctionnement du module 'shelve' est similaire à celui de 'pickle', avec pour différence notable qu'un fichier peut contenir plusieurs objets qui peuvent être référencés comme les éléments d'un dictionnaire.
>>> import shelve
>>> sh=shelve.open('/tmp/objets')
>>> sh['nbcplx']=3+4j
>>> sh['liste']=[1,2,4,8]
>>> sh.close()
Les deux objets sont maintenant archivés dans le fichier /tmp/objets (qui utilise le format dbm qui est standard sur tous les UNIX). Ils peuvent maintenant être récupérés à partir d'un autre script grâce au code suivant :
>>> import shelve
>>> sh=shelve.open('/tmp/objets')
>>> print sh['liste']
[1, 2, 4, 8]
>>> print sh['nbcplx']
(3+4j)
>>> print sh.keys()
['nbcplx', 'liste']
>>> del sh['nbcplx']
>>> print sh.keys()
['liste']
Vous voyez au passage que toutes les opérations courantes sur les dictionnaires peuvent également être appliquées aux objets de type 'shelve'.
Module os
Le module 'os' est en quelque sorte un alias qui va conduire au chargement
d'un module différent en fonction de la plate-forme utilisée.
Sous linux, la directive 'import os' importera en fait le module 'posix',
sur d'autres plate-formes ce pourra être 'nt', 'dos', 'mac', 'os2',
ou 'ce'. Ce module est un peu 'fourre-tout' dans la mesure où il
regroupe un grand nombre de fonctions dont la seule caractèristique
commune est que leur implémentation est différente d'une
plate-forme à une autre. La plupart d'entre elles concernent les
entrées/sorties et plus généralement l'interaction
avec le système d'exploitation. Ce module comportant un grand nombre
de fonctions, seules les plus utiles sont listées dans le tableau
suivant.
|
|
|
| getcwd() | Retourne une chaîne référençant le répertoire courant. |
| listdir(répertoire) | Retourne la liste de toutes les entrées contenues dans le répertoire passé en paramètre. |
| chown(path,uid,gid) | Change le propriétaire et le groupe du fichier ou répertoire donné. |
| rename(src, dest) | Renomme le fichier 'src' en 'dest'. |
| remove(path), unlink(path) | Efface le fichier donné. |
| mkdir(path, mode?) | Crée un répertoire. |
| rmdir(path) | Effacement d'un répertoire. |
| system(commande) | Exécution d'une commande shell. La valeur retournée par la fonction est celle qui a été retourné par la commande. |
| symlink(src,dest) | Création d'un lien symbolique de 'src' vers 'dest'. |
| link(src,dest) | Création d'un lien "hard" de 'src' vers 'dest'. |
| environ | Dictionnaire contenant toutes les variables d'environnement du processus
:
>>> print os.environ['HOME'] /home/vincent |
| popen(commande, mode?, bufsize?) | Ouvre un pipe vers la commande shell mentionnée. Le mode peut être 'r' (lecture; mode par défaut) ou 'w'. Le paramètre 'mode' a le même rôle que pour la fonction open. Le code de retour de la commande est celui retourné par la fonction close() sur l'objet fichier retourné par popen(). |
| fork() | Forke un nouveau processus. La valeur retournée est zéro dans le processus fils et le PID du processus fils dans le père. |
| kill(pid,signal) | Envoie un signal à un processus. |
| curdir | Chaîne utilisée par le système d'exploitation pour désigner le répertoire courant (c.à.d. '.' sous UNIX/Windows et ':' sous Mac). Cette variable ainsi que celle qui suivent doivent impérativement être utilisées lorsque vous manipulez des noms de fichiers pour garantir la portabilité de vos applications. |
| pardir | Chaîne utilisée par le système d'exploitation pour désigner le répertoire parent (c.à.d. '..' sous UNIX/Windows et '::' sous Mac). |
| sep | Chaîne utilisée par le système d'exploitation pour séparer les répertoires dans un chemin d'accès (c.à.d. '/' sous UNIX, '\' sous Windows et ':' sous Mac). |
| linesep | Chaîne correspondant à la fin de ligne sur l'OS utilisé, c.à.d. : '\n' sous UNIX, '\r' sous Macintosh et '\r\n' sous Windows). |
Module sys
Ce module contient les variables propres au fonctionnement de l'interpréteur ainsi que quelques unes permettant d'identifier la plate-forme en cours d'utilisation.
(Note : Le tableau suivant n'est pas exhaustif. Seul les attributs et fonctions les plus utiles y sont mentionnés)
|
|
|
| argv | Liste constituée du nom de la commande et de ses paramètres ayant été utilisés pour démarrer le script Python. |
| builtin_module_names | Retourne la liste des modules qui ont été compilés dans l'interpréteur Python. |
| exit(valeur) | Termine l'interpréteur Python en levant l'exception SystemExit et en retournant valeur au processus appelant. |
| version | Affiche une chaîne indiquant la version de l'interpréteur. (Celle qui est affichée par défaut au lancement de l'interpréteur) |
| platform | Retourne une chaîne identifiant le système d'exploitation sur lequel l'interpréteur Python tourne ('linux2' pour la version Linux). |
| modules | Renvoie un dictionnaire dont les clés sont les noms des modules qui ont été chargés. |
| path | Contient la liste des répertoires dans lequel l'interpréteur tentera de trouver les modules à importer. |
| ps1, ps2 | Donne les chaînes utilisées comme prompts primaires et secondaires. Leur valeur par défaut sont respectivement '>>>' et '...'. |
| stdin, stdout, stderr | Renvoie les objets, de type fichier, utilisés comme (respectivement) entrée de l'interpréteur, sortie par défaut et affichage des erreurs et des prompts. |
| getrefcount(obj) | Retourne le nombre de variables qui référencent l'objet 'obj'. |
| executable | Retourne le path complet de l'interpréteur Python en cours d'utilisation. |
Module socket
Ce module fourni les primitives de base pour opérer sur les sockets.
Sur les plates-formes UNIX, il gère IP et les sockets 'Unix domain'.
Sur les autres systèmes d'exploitation, il gère seulement
IP.
En plus des fonctions mentionnées dans le tableau qui suit (qui
reprennent noms et fonctionnalités de leur équivalent dans
la bibliothèque C standard), le module socket défini également
le type 'SocketType' auquel appartiennent les sockets.
|
|
|
| socket(famille,type,proto?) | Ouvre une socket du type donné. La 'famille' peut être soit AF_INET (IP), soit AF_UNIX (UNIX Domain). Le paramètre 'type' indique si la socket est de type flux (SOCK_STREAM) ou datagramme (SOCK_DGRAM). Le paramètre 'proto' (dont la valeur par défaut est zéro) spécifie optionnellement le protocole à utiliser. |
| fromfd(df,famille,type,proto?) | Crée un objet de type socket à partir d'un descripteur de fichier donné. Les autres paramètres sont identiques à ceux de la fonction socket(). |
| gethostname() | Retourne le nom de la machine hôte. |
| gethostbyname(nom-d-hôte) | Retourne sous forme de chaîne de caractères l'adresse
IP d'un hôte à partir de son nom :
>>> print socket.gethostbyname('localhost') 127.0.0.1 |
| gethostbyaddr(hôte) | Retourne un tuple contenant le nom d'hote, une liste d'alias et une
liste d'adresses IP pour la machine donnée. Le paramètre
doit être une chaîne représentant le nom de la machine
ou son adresse IP :
>>> print socket.gethostbyaddr('vince') ('vince', ['localhost'], ['127.0.0.1']) |
| getservbyname(service,protocole) | Retourne le numéro de port en fonction du nom d'un service et
de son type (TCP ou UDP) :
>>> print socket.getservbyname('www', 'tcp') 80 >>> print socket.getservbyname('domain', 'udp') 53 Web et DNS utilisent donc 80 et 53 comme ports respectifs. |
| getprotobyname(nom) | Retourne le numéro correspondant au protocole mentionné
:
>>> print socket.getprotobyname('tcp') 6 >>> print socket.getprotobyname('icmp') 1 |
| ntohs(), ntohl() | Converti des entiers (respectivement) 16 ou 32 bits de l'ordre réseau vers l'ordre de la plate-forme hôte. |
| htons(), htonl() | Converti des entiers (respectivement) 16 ou 32 bits de l'ordre de la plate-forme hôte vers l'ordre réseau. |
Voila, grâce à ce quatrième article, vous en savez maintenant assez pour voler de vos propres ailes et réaliser de véritables applications en Python.
Dans les articles qui suivent nous verrons notamment comment programmer
des applications GNOME en Python grâce au module gnome-python et
comment analyser et produire facilement des fichiers XML, etc.
Rendez-vous le mois prochain. D'ici la, bons scripts !
|
|
| * Polémique sur les fonctionnalités de Py3K
Guido van Rossum a annoncé les principales nouvelles fonctionnalités qui devraient être inclues dans Python3000, le successeur de la version actuelle et qui sera une réécriture complète de l'interpréteur. Si la plupart des fonctionnalités prévues ont reçu un bon accueil, la possibilité que le langage devienne insensible à la casse a levé un vent de protestation. Heureusement, le développement de Python3000 ne commencera pas avant le début de l'année prochaine et Guido a indiqué qu'il était près à se laisser convaincre si on lui présente des arguments valables ;-) * Déménagement chez BeOpen.com Les principaux développeurs de Python travaillaient jusqu'à
présent au CNRI. Le 30 mai, ils ont annoncé leur départ
pour BeOpen.com (société spécialisée dans le
développement de logiciels Open Source) où ils forment le
"Python Labs". Cette entité fonctionnera sur le même principe
que le "Red Hat Labs", à savoir que les employés sont payés
uniquement pour assurer le développement de Python à temps
plein.
|
|
|
| Site web :
http://www.python.org/ Listes de diffusion Python : - En Français : http://www.aful.org/mailman/listinfo/python - En Anglais : http://www.python.org/psa/MailingLists.html - Listes des développeurs (pour ceux d'entre vous qui sont intéressés par des discussions d'assez haut niveau technique; attention, ce n'est pas une liste de diffusion destinée au support) http://www.python.org/sigs/ Groupes de discussion : comp.lang.python comp.lang.python.announce Documentation en Français (traduite par Olivier Berger) :
|
| Utilisateur de GNU/Linux depuis 1993, Vincent
Renardias a commencé a s'impliquer activement dans le développement
à partir de 1996 : Développeur de la distribution Debian,
auteur de la traduction Française de The GIMP et de l'environnement
GNOME, créateur du groupe d'utilisateurs Linux de Marseille (PLUG),
... Actuellement employé par la société Echo, il continue
à contribuer activement au système GNU/Linux.
Vincent Renardias <vincent@echo.fr> |