Haypo le 12 août 2006 à 01:44

Haypo — Sat, 12 Aug 2006 01:44:11 GMT

Nouvelle page

[[CatÃ©gorie:Langage de programmation]]
{{Retour|Langage de programmation|Retour aux langages de programmation}}

Ce document se veut Ãªtre un document concis expliquant pourquoi [[Python]] est un langage surpuissant :-) (rien que Ã§a !)

== Structures de donnÃ©es ==

Les tableaux (Ã©galement appelÃ©s vecteurs ou listes), les dictionnaires (tableaux associatifs) et chaÃ®nes de caractÃ¨res existent de base. Ce n'est pas une bibliothÃ¨que externe comme en [[Cpp|C++]] par exemple. De plus, ce sont des objets, on peut donc leur appliquer des mÃ©thodes :
# '''ChaÃ®ne de caractÃ¨re''' : Affiche "Bonjour Victor"
print " Hello Victor ".replace("Hello", "Bonjour").strip()

# '''Tableau''' : Affiche [1, 3]
nombres = [1]
nombres.extend([2, 3])
nombres.remove(2)
print nombres

# '''Dictionnaire''' : Affiche "one"
anglais = {1: "one", 2: "two"}
print anglais[1]
D'ailleurs, on peut utiliser l'[[Unicode et UTF-8|unicode]] sans difficultÃ© : voir la notation Â« u"accentuÃ©" Â», la mÃ©thode Â« "accentuÃ©".decode("utf-8") Â» et la fonction Ã©quivalente Â« unicode("accentuÃ©", "utf-8") Â». Il existe Ã©galement les tuples qui sont des tableaux de taille fixe (exemple : (1, 2, 3)) qui utilisent moins d'espace mÃ©moire.

Les tableaux et tuples sont trÃ¨s bien intÃ©grÃ©s dans le langage. On peut assigner plusieurs valeurs Ã la fois et une fonction peu renvoyer plusieurs valeurs trÃ¨s naturellement.
>>> x, y, z = 10, 5, 2
>>> def div_mod(x, y):
... return x/y, x%y
...
>>> div_mod(14, 5)
(2, 4)
>>> texte = "Tout est bon dans le Python"
>>> tout_est_bon, python = texte[:12], texte[21:]

== GÃ©nÃ©rateur et boucle Â« pour chaque Â» ==

Â« GÃ©nÃ©rateur Â» avec la mÃ©thode ''yield'' et boucle Â« pour chaque Â» (Â« for each Â» en anglais) avec ''for x in â€¦'' :
def fibonacci():
a = 0
b = 1
while True:
'''yield''' a
a, b = b, a+b

n = 0
'''for x in fibonacci()''':
print "u(%s)=%s" % (n, x)
n = n + 1
if n == 10:
break
La fonction ''fibonacci'' renvoie un Â« gÃ©nÃ©rateur Â» qui peut Ãªtre lu comme on lirait un fichier et est infini. Nul besoin de stocker les (deux) termes de la [http://fr.wikipedia.org/wiki/Suite_de_Fibonacci suite de l'italien surnommÃ© ''Fibonacci''], Python le fait pour nous.

Autre exemple avec la boucle Â« pour chaque Â», numÃ©rotation d'un fichier texte :
n = 1
'''for ligne in''' ''open("fichier.txt", "r").readlines()'':
print "%u: %s" % (n, ligne.rstrip("\r\n"))
n += 1

== Langage dynamique ==

=== Introspection ===

Exemple d'introspection :
class Personne:
def __init__(self, prenom, nom):
self.prenom = prenom
self.nom = nom

def __str__(self):
return "%s %s" % (self.prenom, self.nom)

# Ajoute un attribut non prÃ©vu dans la classe
victor = Personne("Victor", "Stinner")
victor.age = 22

# Modification et lecture d'un attribut en donnant son nom
# sous forme d'une chaÃ®ne de caractÃ¨re
'''setattr'''(victor, "age", victor.age+1)
print "%s a %s ans" % (victor, '''getattr'''(victor, "age"))

# On peut avoir la liste des attributs d'une classe avec :
print victor'''.__dict__'''

RÃ©sultat :
Victor Stinner a 23 ans
{'nom': 'Stinner', 'age': 23, 'prenom': 'Victor'}

'''Voir aussi le module ''inspect''.'''

=== Typage dynamique ===

Changement de type automatique :
>>> n=10
>>> type(n)
<type 'int'>
>>> n = n*100000000000000000000
>>> type(n)
<type 'long'>

MÃ©thode qui s'en fiche du type, appellÃ©e Â« ''template'' Â» en C++ ou encore mÃ©thode ''gÃ©nÃ©rique'' :
>>> liste=[]
>>> def ajoute(x):
... liste.append(x)
...
>>> ajoute(10) # Ajoute un nombre
>>> ajoute("abc") # Ajoute une chaÃ®ne de caractÃ¨res
>>> ajoute({"blanc": "noir"}) # Ajoute un dictionnaire
>>> print liste
[10, 'abc', {'blanc': 'noir'}

== Surchage d'opÃ©rateur ==

Python donne la possibilitÃ© de faire de la programmation orientÃ©e objet. Beaucoup d'opÃ©rateurs et fonctions sont surchargeables :
class ObjetEnPython:
# Constructeur
def '''__init__'''(self):
self.items = [1, 2, 3]

# Destructeur
def '''__del__'''(self):
print "BOUM"

# UtilisÃ© pour : "cmp(p1, p2)", exemple : tri d'une liste de p avec sort()
def '''__cmp__'''(a, b):
return cmp(a.items, b.items)

# UtilisÃ© pour : "str(p)", exemple : "print p"
def '''__str__'''(self):
return "liste = %s" % self.items

# UtilisÃ© pour : "len(p)"
def '''__len__'''(self):
return len(self.items)

# UtilisÃ© pour : "p[x]"
def '''__getitem__'''(self, key):
return self.items[key]

# UtilisÃ© pour : "x in p"
def '''__contains__'''(self, value):
return (value in self.items)

# UtilisÃ© pour : "for x in p"
def '''__iter__'''(self):
for x in self.items:
yield x
On peut Ã©galement surcharger les opÃ©rateurs arithmÃ©tiques (a+b, a*b, ...). Quelques jolis exemples (dans l'interprÃ©teur Python) :
>>> print "zZ" * 3 # Surchage de l'opÃ©rateur a*b
zZzZzZ
>>> from path import path # BibliothÃ¨que [https://sixthdev.versionhost.com/viewcvs.cgi/handy/path.py path d'Orendorf]
>>> usr = path("/usr")
>>> print usr/"bin" # Surcharge de l'opÃ©rateur a/b
/usr/bin

== Comparatif avec d'autres langages ==

=== Comparatif avec le C++ ===

* Le C++ possÃ¨de Ã©galement les vecteurs, listes, tables de hachage, itÃ©rateurs, l'opÃ©rateur Â« pour chaque Â» (bien que lourd Ã utiliser), etc.
* La gestion des exceptions existe, mais il manque finally (que Borland a ajoutÃ© sans son compilateur) et on ne peut pas rÃ©cupÃ©rer la pile d'appel.
* Il manque les ''properties'' (Borland les a ajoutÃ© Ã son compilateur)
* La gestion des paquetages est trÃ¨s lourde : il faut dupliquer les commentaires et prototypes dans les fichiers d'entÃªtes, extension ".h". Par contre, il existe les espaces de nom (''namespace'').

{| style="font-size: 80%" border="1"
! C++ !! Python
|- valign="top"
|
#include <string>
#include <vector>
#include <iostream>

class Personne {
std::string prenom, nom;
public:
Personne(const std::string &prenom, const std::string &nom) {
this->prenom = prenom;
this->nom = nom;
}
friend std::ostream& operator<< (std::ostream&, const Personne&);
}

std::ostream& operator<< (std::ostream &os, const Personne &p) {
os << p.prenom << ' ' << p.nom;
return os;
}

void test() {
std::vector<Personne> liste;
liste.push_back(Personne("Victor", "Stinner"));
liste.push_back(Personne("Damien", "Boucard"));
for (std::vector<Personne>::iterator it=liste.begin(); it != liste.end(); ++it) {
std::cout << *it << std::endl;
}
}
||
class Personne:
def __init__(self, prenom, nom):
self.prenom = prenom
self.nom = nom

def __str__(self):
return "%s %s" % (self.prenom, sel.nom)

def test():
liste = [Personne("Victor", "Stinner"), Personne("Damien", "Boucard")]
for personne in liste:
print personne
|}

=== Comparatif avec le Java ===

* Java possÃ¨de Ã©galement les vecteurs, listes, tables de hachage et itÃ©rateurs. Par contre avant Java 1.5, l'opÃ©rateur Â« pour chaque Â» manquait et les ''cast'' alourdissaient le code.
* La gestion des exceptions est trÃ¨s bonne, finally existe Ã©galement et on peut rÃ©cupÃ©rer la pile d'appel. Par contre, il faut explicitement attraper les exceptions pouvant Ãªtre levÃ©es et les renvoyer si on ne peut pas les traiter tout de suite. C'est un choix de Sun.
* La gestion des paquetages est trÃ¨s propre en Java, mais par contre une seule classe par fichier est autorisÃ©e (correctif: une seule classe '''publique''' par fichier)
* Java supporte Ã©galement les ''decorators'' (Python 2.4 s'en est largement inspirÃ©)
* Il manque les ''properties'', mais ceci est un choix de Sun

{| style="font-size: 80%" border="1"
! Java !! Python
|- valign="top"
|
import java.util.Vector;
import java.util.Iterator;

class Personne {
String prenom, nom;

public Personne(String nom, String prenom) {
this.nom = nom;
this.prenom = prenom;
}

public String toString() {
return this.prenom+" "+this.nom;
}
}

void test() {
Vector liste = new Vector();
liste.addElement( new Personne("Victor", "Stinner") );
liste.addElement( new Personne("Damien", "Boucard") );
for (Iterator it = liste.iterator(); it.hasNext(); ) {
System.out.println( it.next() );
}
}
||
class Personne:
def __init__(self, prenom, nom):
self.prenom = prenom
self.nom = nom

def __str__(self):
return "%s %s" % (self.prenom, sel.nom)

def test():
liste = [Personne("Victor", "Stinner"), Personne("Damien", "Boucard")]
for personne in liste:
print personne
|-
|}

== Programmation orientÃ©e objet ==

Python supporte l'hÃ©ritage multiple, la visibilitÃ© (public, privÃ©, protÃ©gÃ©) et les propriÃ©tÃ©s (''property''). Ces derniÃ¨res sont vraiment trÃ¨s pratiques, et je ne comprend pas pourquoi cela n'a pas Ã©tÃ© ajoutÃ© au C++. Pour Java, Sun a choisi l'explicite en interdisant par exemple la surcharge des opÃ©rateurs. C'est un choix, mais je trouve Ã§a bien dommage.

Les propriÃ©tÃ©s sont une invention gÃ©niale permettant d'ajouter des traitements lors de l'accÃ¨s en lecture sur un Â« attribut Â» d'un objet et sur la modification d'un Â« attribut Â» d'un objet. Je met attribut entre guillemets car on peut avoir des attributs fictifs ou calculÃ©s. De plus, on peut interdire la modification ou la lecture.

Exemple sans propriÃ©tÃ© avec attributs publics :
class Animal:
def __init__(self, nom, age):
self.nom = nom
self.age = age

def __str__(self):
return "%s (%s ans)" % (self.nom, self.age)

maurice = Animal("Poisson", 2)
print maurice
maurice.age = "ooops"
print maurice
RÃ©sultat :
Poisson (2 ans)
Poisson (ooops ans)
Le problÃ¨me est qu'on peut entrer n'importe quelle valeur pour l'Ã¢ge, pas forcÃ©ment un nombre entier positif. On va donc ajouter des tests :
class Animal('''object'''):
def __init__(self, nom, age):
self.nom = nom
self.'''_age''' = age

def _getAge(self):
return self._age
def _setAge(self, age):
assert isinstance(age, int)
assert 1 <= age <= 200
self._age = age
age = '''property'''(_getAge, _setAge)

def __str__(self):
return "%s (%s ans)" % (self.nom, self.age)

maurice = Animal("Poisson", 1)
maurice.age = "ooops" <nowiki>~~~></nowiki> BOUM, une exception est levÃ©e
maurice.age = -7 <nowiki>~~~></nowiki> BOUM, une exception est levÃ©e
L'attribut age est passÃ© en protÃ©gÃ© (accessible aux fils mais pas en dehors de l'objet) simplement en ajoutant "_". Si l'on avait voulu le passer en privÃ©, il aurait fallu ajouter utiliser le nom "__age".

Le gros avantage de propriÃ©tÃ©s et qu'on garde la mÃªme API publique, par contre le dÃ©savantage est qu'on est obligÃ© d'Ã©crire un ''getter'' '''et''' un ''setter''.

== Ã€ complÃ©ter ==

* Gestion des erreurs
* Documentation
* Paquetage
* HÃ©ritage d'une ou plusieurs classes
* Property, private & protected

== Voir aussi ==

* [[Python]] â€” [[pypy]]

Python ou rien - Historique des versions

Haypo le 12 août 2006 à 01:44