impression python

Bonjour,
Merci pour tes remarques, je vais de ce pas les prendre en compte. Par
contre, pour ce qui d'intégrer le module d'impression dans le prog
appelant, cela suppose que je réécrive celui-ci en wxpython. Or de ce
coté je n'y connais rien et je n'ai trouvé que peu de doc en français
dessus. Il faut dire que python j'ai commencé mi octobre à l'étudier.
Alors tkinter, c'est facile à utiliser et il y a plein de docs et
d'exemples même en français, alors que wx c'est uniquement en anglais
et les exemples sont toujours en objet. Et j'ai un peu de mal à me
faire à l'objet : ce doit être mes neurones qui ne sont pas adaptés.
Je ne suis plus tout jeune (je suis à la retraite) et la programmation
c'est pour me faire plaisir en me disant que je n'ai pas encore perdu
toutes mes connexions synaptiques... :)
Merci pour ton aide et tes conseils.
A+ YLC

Bonjour,
Merci pour tes remarques, je vais de ce pas les prendre en compte. Par
contre, pour ce qui d'intégrer le module d'impression dans le prog
appelant, cela suppose que je réécrive celui-ci en wxpython. Or de ce
coté je n'y connais rien et je n'ai trouvé que peu de doc en français
dessus. Il faut dire que python j'ai commencé mi octobre à l'étudier.
Alors tkinter, c'est facile à utiliser et il y a plein de docs et
d'exemples même en français, alors que wx c'est uniquement en anglais
et les exemples sont toujours en objet. Et j'ai un peu de mal à me
faire à l'objet : ce doit être mes neurones qui ne sont pas adaptés.
Je ne suis plus tout jeune (je suis à la retraite) et la programmation
c'est pour me faire plaisir en me disant que je n'ai pas encore perdu
toutes mes connexions synaptiques... :)
Merci pour ton aide et tes conseils.
A+ YLC
Bonjour,

Si tu as peur d'utiliser des objets, tu ne vas rien pouvoir faire avec Python car en Python tout est objet ;)

Il est vrai qu'il y a beaucoup de docs en anglais mais on en trouve aussi en français.
Entre autres :
- Wiki : http://wikipython.flibuste.net/moin.py/FrontPage
- Tutoriel : http://www.tuxfinder.com/french/Python/python_tut_html-1.5.2_fr_2.0/tut/tut.html
- Livre : http://www.cifen.ulg.ac.be/inforef/swi/python.htm
- Site de Laurent Pointal : http://www.limsi.fr/Individu/pointal/python.html#liens

Et évidemment, tu peux poser toutes tes questions sur ce newsgroup.

J'ai débuté l'utilisation de wxPython il y a quelques mois. Mon erreur a été de vouloir faire une appli directement sans chercher à compendre les principes de base de wxPython. Je me suis planté. J'ai trouvé des tutoriels qui partent de zéro et qui expliquent les principes de base de wxPython.
Il est important de passer du temps à apprendre avant de te lancer dans ton propre code.


Nicolas

Bonjour,
Merci pour tes remarques, je vais de ce pas les prendre en compte. Par
contre, pour ce qui d'intégrer le module d'impression dans le prog
appelant, cela suppose que je réécrive celui-ci en wxpython.

Dans la mesure où tu utilisais wxPython pour l'impression, j'ai supposé
que tu l'avais aussi utilisé pour l'application - ce qui semblerait
cohérent, n'est-ce pas ?-)

Or de ce
coté je n'y connais rien et je n'ai trouvé que peu de doc en français
dessus.

Je crains que la grande majorité des ressources en matière de
programmation ne soient en anglais. Avec des raisons éventuellement
discutables mais réelles : l'anglais étant de fait la lingua franca
informatique, en rédigeant un document en anglais, on est sûr de toucher
une bien plus grande population. Bref, difficile de faire l'impasse sur
l'anglais technique dans ce domaine.

Il faut dire que python j'ai commencé mi octobre à l'étudier.

Effectivement, c'est tout jeune.

Alors tkinter, c'est facile à utiliser

Tiens, c'est curieux, je n'ai jamais vraiment réussi à m'y faire...

et il y a plein de docs et
d'exemples même en français, alors que wx c'est uniquement en anglais
et les exemples sont toujours en objet.

Je ne voudrais pas t'alarmer, mais au cas où ça t'aurais échappé, Python
est *100%* objet !-)

Et j'ai un peu de mal à me
faire à l'objet : ce doit être mes neurones qui ne sont pas adaptés.

Ca arrive... Ceci étant, ce n'est pas non plus si monstrueux - au moins
les bases. Est-ce qu'il t'es déjà arrivé d'utiliser un dictionnaire
(dict) pour structurer tes données , et d'écrire un jeu de fonctions
pour travailler dessus ? Si oui, tu a déjà fait la moitié du chemin...

Je ne suis plus tout jeune (je suis à la retraite) et la programmation
c'est pour me faire plaisir en me disant que je n'ai pas encore perdu
toutes mes connexions synaptiques... :)

Si ça peut te rassurer, bien que je sois plus jeune que toi, j'ai depuis
longtemps passé l'âge où l'apprentissage est une formalité !-)

En tous cas, bonne chance dans ton apprentissage, et surtout n'hésite
pas à poser tes questions ici, même les plus basiques. Comme disais feu
mon grand-père, il vaut mieux passer pour une andouille en posant une
question bête que de rester une andouille en ne la posant pas !-)

Bonjour !

Dans la mesure où tu utilisais wxPython pour l'impression, j'ai
supposé que tu l'avais aussi utilisé pour l'application - ce qui
semblerait cohérent, n'est-ce pas ?-)

J'avais fait une supposition similaire.

Alors, si wxpython n'est plus un préalable, et si ylc travaille sous
Windows, je rappelle que j'ai fait un petit module d'impression, qui
utilise une DLL externe, est assez simple d'emploi (mais plus limité)
(présenté dans ce newsgroup, le 13 août).

difficile de faire l'impasse sur l'anglais technique

Hélas, oui. Mais cela freine énormément la pénétration de Python (entre
autres), dans beaucoup de pays.

je ne voudrais pas t'alarmer, mais au cas où ça t'aurais échappé,
Python est *100%* objet !-)

Et c'est très bien.
Mais, je pense que ylc a fait une confusion entre "Objet" et
"Programmation Orientée Objet". Si j'ai vu juste, je peux le rassurer :
on peut déjà faire beaucoup de choses, en Python, sans utiliser la POO
(la structure objet de Python est très bien faite, et
quasi-transparente).



@-salutations

Michel Claveau

Bonjour,
Effectivement, j'ai utilisé wxpython pour l'impression alors que mon
programme est en tkinter et il n'est apparamment pas possible de
fusionner les deux.
Quand le parle de programmation objet c'est effectivement quand il
s'agit de créer des classes et des méthodes (partout où il y a des
self...quelque chose)
Je ne trouve pas que le code soit limpide dans ce cas. J'utilise par
contre effectivement les objets (widgets) mais n'en crée pas.
Quand à l'anglais, je le lis mais la doc wx est absconse !
D'ailleurs j'ai une nouvelle question (aie je vais me faire
jeter.....) Voila :
toujours avec wx, comment faire pour que 2 boutons appellent deux
fonctions différentes puis que chacune de ces 2 fonctions appellent
une même 3 eme fonction ?
Je m'explique : j'ai un bouton "visualiser" et un bouton "imprimer"
pour l'instant j'ai duplique toutes la fonction appelée par les 2
boutons en changeant seulement l'instruction de Print ou de Préview.

......................................
bprin = wx.Button(panel, -1, u"Impression")
bsizer1.Add(bprin, 10,wx.RIGHT|wx.ALL, 10)
bprev = wx.Button(panel, -1, u"Prévisualisation")
bsizer1.Add(bprev, 10,wx.RIGHT|wx.ALL, 10)
self.Bind(wx.EVT_BUTTON, self.Printer, bprin)
self.Bind(wx.EVT_BUTTON, self.Visual, bprev)


def Visual(self,evt) :
self.lignes=[]
cx = sqlite3.connect(u"repert.db3")
cur = cx.cursor()
cur.execute(u"select
nom,pren,adress,copost,nocom,nutel1,nutel2,mail from coord order by
nom,pren")
for row in cur:
self.lignes = cur.fetchall()
prt = printout.PrintTable(self)
prt.SetLandscape()
prt.SetHeader("LISTE DU REPERTOIRE")
prt.label =
[u"Nom",u"Prénom",u"Adresse",u"C.postal",u"Commune",u"Tél.1",u"Tél.
2",u"Mail"]
prt.text_font_size = 7
prt.set_column =[1.4,1,2,0.6,1.7,0.7,0.7,2]
prt.cell_left_margin = 1/32.5
prt.data = self.lignes
prt.SetFooter(u"Page ", type =u"Num")
prt.Preview()
cur.close()
cx.close()

def Printer(self, iprint):
self.lignes=[]
cx = sqlite3.connect(u"repert.db3")
cur = cx.cursor()
cur.execute(u"select
nom,pren,adress,copost,nocom,nutel1,nutel2,mail from coord order by
nom,pren")
for row in cur:
self.lignes = cur.fetchall()
prt = printout.PrintTable(self)
prt.SetLandscape()
prt.SetHeader("LISTE DU REPERTOIRE")
prt.label =
[u"Nom",u"Prénom",u"Adresse",u"C.postal",u"Commune",u"Tél.1",u"Tél.
2",u"Mail"]
prt.text_font_size = 7
prt.set_column =[1.4,1,2,0.6,1.7,0.7,0.7,2]
prt.cell_left_margin = 1/32.5
prt.data = self.lignes
prt.SetFooter(u"Page ", type =u"Num")
prt.Print()
cur.close()
cx.close()
self.Destroy()
...........................

C'est un peu lourd. J'aurais voulu positionner un indicateur pour
chacun des chois et le tester pour exécuter l'instruction qui va bien
du style :
if ind == True :

suite de mon message qui est parti un peu vite......désolé :(
Donc j'aurais aimé avoir qu'une seule fonction avec :

if ind==True:
prt.Print()
else:
prt.Preview()

A+
YLC

Bonjour,
Effectivement, j'ai utilisé wxpython pour l'impression alors que mon
programme est en tkinter et il n'est apparamment pas possible de
fusionner les deux.

Bin non, ce sont deux toolkit bien différents. En général, on s'en tient
à un seul pour une appli !-)

Quand le parle de programmation objet c'est effectivement quand il
s'agit de créer des classes et des méthodes (partout où il y a des
self...quelque chose)

NB : n'hésite pas à sauter ce qui vient si ça te gaves - la réponse à te
question est plus bas !-)

<mode="didactique">
Allez, petit exemple vite fait: une personne. On va d'abord la
représenter avec un dict, et écrire un jeu de fonction pour travailler
dessus:

def Personne():
return dict()

def init(personne, nom, prenom, sexe, date_naissance):
personne['nom]=nom
personne['prenom']=prenom
personne['sexe']=sexe
personne['date_naissance']Úte_naissance

def dire_bonjour(personne):
print "bonjour, je m'appelle %s %s"
% (personne['prenom'], personne['nom'])

def age(personne):
# approximatif
return (personne['date_naissance'] - datetime.now()) / 365


def renommer(personne, nom):
personne['nom'] = nom


def test():
p = Personne()
init(p, "Desthuilliers", "Bruno", "M", datetime(1967, 5, 1))
dire_bonjour(p)
print p['nom'], " à ", age(p), " ans"
renommer(p, "Latuile")
dire_bonjour(p)


Je suppose que jusque là, ça ne te pose pas trop de problème de
compréhension ?

Ok, alors maintenant, dis toi qu'un objet est avant tout un genre de
dict un peu spécial. Il est spécial en quelques points. Le premier,
c'est que au lieu de dic['cle'], la syntaxe est dic.cle

Pour définir un "type" de dict de cet acabit, on utilise l'instruction
"class". On verra plus loin à quoi ça sert.

class Personne:
pass

Maintenant, on va adapter un peu nos fonctions pour la syntaxe "pointée":

def init(personne, nom, prenom, sexe, date_naissance):
personne.nom = nom
personne.prenom = prenom
personne.sexe = sexe
personne.date_naissance = date_naissance

def dire_bonjour(personne):
print "bonjour, je m'appelle %s %s"
% (personne.prenom, personne.nom)

def age(personne):
# approximatif
return (personne.date_naissance - datetime.now()) / 365


def renommer(personne, nom):
personne.nom = nom

Et notre fonction test:

def test():
p = Personne()
init(p, "Desthuilliers", "Bruno", "M", datetime(1967, 5, 1))
dire_bonjour(p)
print p.nom, " à ", age(p), " ans"
renommer(p, "Latuile")
dire_bonjour(p)


Comme tu peux le voir, pour le moment, pas de grande différence - si ce
n'est l'appel à la classe Personne, qui pour le moment nous retourne un
objet 'personne' vide - enfin, presque... Presque, parce que cet objet
contient une référence sur la classe Personne - qui est elle même un
objet (et oui, en Python tout est objet), dans lequel on peut *aussi*
stocker des données:

Personne.truc = "bidule"
print Personne.truc
=> "bidule"

Une autre particularité d'un objet par rapport à un dict, c'est que si
on essaie de lire une clé qui n'est pas dans l'objet, l'objet ira
chercher cette clé dans sa classe. Enfin, il y a deux autres choses à
savoir: la première est qu'en Python, les fonctions sont des objets
aussi (et oui...), la seconde est que si on stocke une fonction dans un
objet classe et qu'on essaie de la récupérer depuis un objet (une
instance) de cette classe, l'objet est automatiquement passé en premier
paramètre de la fonction.

Maintenant, on va se servir de ces possibilités pour "ajouter" les
fonctions à notre objet classe:

Personne.dire_bonjour = dire_bonjour
Personne.age = age
Personne.renommer = renommer
Personne.init = init

Et notre fonction test:

def test():
p = Personne()
p.init("Desthuilliers", "Bruno", #etc...)
p.dire_bonjour()
print p.age()
p.renommer("Latuile")
p.dire_bonjour()


Dernier point: si au lieu de stocker la fonction init sous ce nom, on la
stocke sous le nom de '__init__', elle sera automatiquement appelée
quand on crée une nouvelle personne:

del Personne.init
Personne.__init__ = init

def test():
p = Personne("Desthuilliers", "Bruno", #etc...)
p.dire_bonjour()
print p.age()
p.renommer("Latuile")
p.dire_bonjour()


Et voili voila... Comme tu peux le voir, on n'a pas utilisé "self" une
seule fois là dedans !-)
</mode>

Je ne trouve pas que le code soit limpide dans ce cas.

Pour des choses simples, pas nécessairement. A partir d'un certain
niveau de complexité - qui arrive très vite en fait -, c'est au
contraire d'une grande aide. Mais effectivement, ça demande un
apprentissage qui n'est pas toujours évident, au moins au début. A vrai
dire, certains ne s'y font jamais - ça ne correspond pas à la façon dont
leurs neurones sont cablés.

J'utilise par
contre effectivement les objets (widgets) mais n'en crée pas.

Bin si pourtant - dans ton exemple, tu définis une classe !-)

Quand à l'anglais, je le lis mais la doc wx est absconse !

C'est en effet le moins qu'on puisse dire. Mais au moins, elle existe,
et elle est à peu près à jour.

D'ailleurs j'ai une nouvelle question (aie je vais me faire
jeter.....)

Mais non, mais non...

Voila :
toujours avec wx, comment faire pour que 2 boutons appellent deux
fonctions différentes puis que chacune de ces 2 fonctions appellent
une même 3 eme fonction ?

Dans le principe, ça n'a rien de spécifique à wxPython. Il suffit que
les fonctions A et B appellent effectivement la fonction C :

def C():
print "dans C"

def A()
print "Dans A"
C()

def B():
print "Dans B"
C()

Mais ton cas (je triche: j'ai déjà lu la suite) est un peu différent.

Je m'explique : j'ai un bouton "visualiser" et un bouton "imprimer"
pour l'instant j'ai duplique toutes la fonction appelée par les 2
boutons en changeant seulement l'instruction de Print ou de Préview.

C'est pas bien. C'est même très vilain.

......................................
bprin = wx.Button(panel, -1, u"Impression")
bsizer1.Add(bprin, 10,wx.RIGHT|wx.ALL, 10)
bprev = wx.Button(panel, -1, u"Prévisualisation")
bsizer1.Add(bprev, 10,wx.RIGHT|wx.ALL, 10)
self.Bind(wx.EVT_BUTTON, self.Printer, bprin)
self.Bind(wx.EVT_BUTTON, self.Visual, bprev)


def Visual(self,evt) :
self.lignes=[]

Cette affectation est inutile, puisque tu écrases self.ligne plus bas.

cx = sqlite3.connect(u"repert.db3")
cur = cx.cursor()
cur.execute(u"select
nom,pren,adress,copost,nocom,nutel1,nutel2,mail from coord order by
nom,pren")
for row in cur:
self.lignes = cur.fetchall()

Heu... Tu n'a pas besoin d'appeller ça en boucle. Il vaudrait mieux
éviter, même...

prt = printout.PrintTable(self)
prt.SetLandscape()
prt.SetHeader("LISTE DU REPERTOIRE")
prt.label > [u"Nom",u"Prénom",u"Adresse",u"C.postal",u"Commune",u"Tél.1",u"Tél.
2",u"Mail"]
prt.text_font_size = 7
prt.set_column =[1.4,1,2,0.6,1.7,0.7,0.7,2]
prt.cell_left_margin = 1/32.5
prt.data = self.lignes
prt.SetFooter(u"Page ", type =u"Num")
prt.Preview()
cur.close()
cx.close()

def Printer(self, iprint):
self.lignes=[]
cx = sqlite3.connect(u"repert.db3")
cur = cx.cursor()
cur.execute(u"select
nom,pren,adress,copost,nocom,nutel1,nutel2,mail from coord order by
nom,pren")
for row in cur:
self.lignes = cur.fetchall()
prt = printout.PrintTable(self)
prt.SetLandscape()
prt.SetHeader("LISTE DU REPERTOIRE")
prt.label > [u"Nom",u"Prénom",u"Adresse",u"C.postal",u"Commune",u"Tél.1",u"Tél.
2",u"Mail"]
prt.text_font_size = 7
prt.set_column =[1.4,1,2,0.6,1.7,0.7,0.7,2]
prt.cell_left_margin = 1/32.5
prt.data = self.lignes
prt.SetFooter(u"Page ", type =u"Num")
prt.Print()
cur.close()
cx.close()
self.Destroy()
...........................

C'est un peu lourd.

N'est-ce pas ? Et puis si facile à maintenir !-)

J'aurais voulu positionner un indicateur pour
chacun des chois et le tester pour exécuter l'instruction qui va bien
du style :
if ind == True :

Tu peux effectivement faire ça avec un "indicateur" (en franglish: un flag):


def _DoTheJob(which):
cx = sqlite3.connect(u"repert.db3")
cur = cx.cursor()
cur.execute(u"select
nom,pren,adress,copost,nocom,nutel1,nutel2,mail from coord order by
nom,pren")
# cursor.fetchall récupère tous les rows
self.lignes = cur.fetchall()
prt = printout.PrintTable(self)
prt.SetLandscape()
prt.SetHeader("LISTE DU REPERTOIRE")
prt.label [u"Nom",u"Prénom",u"Adresse",u"C.postal",u"Commune",u"Tél.1",u"Tél.
2",u"Mail"]
prt.text_font_size = 7
prt.set_column =[1.4,1,2,0.6,1.7,0.7,0.7,2]
prt.cell_left_margin = 1/32.5
prt.data = self.lignes
prt.SetFooter(u"Page ", type =u"Num")
if which == "Print":
prt.Print()
elif which == "Preview":
prt.Preview()
cur.close()
cx.close()
self.Destroy()


# en général, on prefère que les fonctions soient des verbes:
def Print(self, whatever):
self._DoTheJob('Print')

def Preview(self, whatever):
self._DoTheJob('Preview')


Maintenant, c'est loin d'être ce qu'on peut faire de mieux comme
découpage. Personnellement, je ferais plutôt un truc du genre:

def _getLines(self, sql):
cx = sqlite3.connect("repert.db3")
cur = cx.cursor()
try:
cur.execute(sql)
# cursor.fetchall récupère tous les rows
lines = cur.fetchall()
return lines
finally:
cur.close()
cx.close()

def _preparePrint(self, lines):
sql = """
select nom, pren, adress, copost,
nocom, nutel1, nutel2, mail
from coord
order by nom, pren
"""
lines = self._getLines(sql)
prt = printout.PrintTable(self)
prt.SetLandscape()
prt.SetHeader("LISTE DU REPERTOIRE")
prt.label = [u"Nom",
u"Prénom",
u"Adresse",
u"C.postal",
u"Commune",
u"Tél.1",
u"Tél.2",
u"Mail"
]
prt.text_font_size = 7
prt.set_column =[1.4,1,2,0.6,1.7,0.7,0.7,2]
prt.cell_left_margin = 1/32.5
prt.data = lines
prt.SetFooter(u"Page ", type =u"Num")
return prt

def Previev(self, whatever):
prt = self._preparePrint()
prt.Preview()
self.Destroy()

def Print(self, whatever):
prt = self._preparePrint()
prt.Print()
self.Destroy()

HTH

Bonjour,
Alors là, grand merci ! Je ne pensais pas avoir droit à un cours
particulier sur la Poo.
Pour le moment j'ai imprimé le message afin de prendre le temps de
l'étudier, crayon en main et à tête reposée. C'est vraiment sympa.
J'espère que je vais "capter" tout ça et me coucher un peu moins bête
ce soir.
J'ai pris le temps de découper ce que tu aurais écrit pour mon
impression/visualisation ligne par ligne pour bien comprendre ce qui
se passe. J'ai trouvé à cette occasion un petite erreur dans <<def
_preparePrint(self, lines):>> qu'il faut écrire à mon avis plutôt:
<<def _preparePrint(self):>> le paramètre lines est inutile, étant
en retour de <<def _getLines(self, sql):>>
Ca y est (j'ai qd même essayé pour voir si ça marchait) et c'est ok.
Pour la Poo j'ai trouvé çà : http://www.linux62.org/wiki/index.php/L' OO_selon_St_Python
mais je n'ai toujours pas bien compris exactement l'utilité du self.
C'est apparamment un pointeur sur la classe de l'objet, mais dans ton
topo tu n'en n'utilise pas......:( je vais devoir encore relire tout
ça.
Merci encore.
YLC

Bonjour,
Alors là, grand merci ! Je ne pensais pas avoir droit à un cours
particulier sur la Poo.

C'est un newsgroup public, ça peut donc servir à d'autres... Si du moins
c'est compréhensible !-)

Pour le moment j'ai imprimé le message afin de prendre le temps de
l'étudier, crayon en main et à tête reposée. C'est vraiment sympa.
J'espère que je vais "capter" tout ça et me coucher un peu moins bête
ce soir.

Si ça te cause, tant mieux, et n'hésites pas à poser des questions.
Sinon, ne te sens pas non plus obligé...

J'ai pris le temps de découper ce que tu aurais écrit pour mon
impression/visualisation ligne par ligne pour bien comprendre ce qui
se passe. J'ai trouvé à cette occasion un petite erreur dans <<def
_preparePrint(self, lines):>> qu'il faut écrire à mon avis plutôt:
<<def _preparePrint(self):>> le paramètre lines est inutile, étant
en retour de <<def _getLines(self, sql):>>

Effectivement - c'est un résidu d'une version antérieure.

Ca y est (j'ai qd même essayé pour voir si ça marchait) et c'est ok.
Pour la Poo j'ai trouvé çà : http://www.linux62.org/wiki/index.php/L'OO_selon_St_Python

Hmm... Pas une bonne explication de l'OO AMHA. Par exemple:

mais je n'ai toujours pas bien compris exactement l'utilité du self.

cqfd.

C'est apparamment un pointeur

<mode="pedant">
en Python, il n'y a pas de pointeur (au sens des pointeurs C), mais des
références.
</mode>

sur la classe de l'objet,

Non, sur l'objet lui-même. Note que dans la majorité des langages
objets, cette référence est directement injectée dans les méthodes, sans
qu'il soit nécessaire de la déclarer dans les arguments. Le fait qu'en
Python on doive la déclarer, mais qu'on ne la passe pas explicitement
lors de l'appel est de fait assez déroutant au premier abord. Après,
quand on connait mieux le modèle objet de Python, on comprend pourquoi
ça fonctionne ainsi, et pourquoi c'est une bonne chose.

mais dans ton
topo tu n'en n'utilise pas......:(

Le fait de nommer cet argument 'self' est uniquement une convention. Si
tu veux, reprend le code du topo et dans les prototypes des fonctions,
remplace systématiquement le premier argument 'personne' par 'self' - ca
revient exactement au même. Accessoirement, j'avais fait exprès de ne
*pas* utiliser le nom 'self' - pour bien expliciter qu'il n'y a en fait
rien de magique là-dedans.

Dans la première version - celle avec les dicts - l'utilité de cet
argument est évident : il faut bien passer le dict à la fonction pour
qu'elle travaille dessus. Dans la version OO, c'est la même chose : il
faut bien que la fonction ait accès à l'objet sur lequel elle est
appelée. Simplement, au lieu d'utiliser une syntaxe:

nom_fonction(obj, ...)

on utilise:

obj.nom_fonction(...)

que de fait Python traduit en :

type(obj).nom_fonction(obj, ...)

(sachant que type(obj) retourne la classe de obj)

Je te passe les explications techniques sur la façon dont cette
substitution est faite - l'essentiel (au moins dans un premier temps)
est de comprende le principe.


HTH

Bonjour,
ok, je crois que j'ai compris. De là à ce que je me sente à l'aise
pour écrire un prog ainsi, il y a de la marge.... Cela me facilitera
par contre la lecture des exemples trouvés sur le Web. Et puis j'ai
encore du temps devant moi, il n'y a que moins de 2 mois que je me
suis mis au python.
J'ai essayé de mettre les 3 programmes que j'ai écrit à ce jour sur un
site pour en faire peut-être profiter d'autres débutants et aussi
avoir éventuellement un feed back sur mes programmes qui ne sont
surement pas bien codés comme il faut (par contre ils fonctionnent
impec sans que j'aie réussi à les planter), mais sur wiki je n'ai pas
compris comment faire et sur PythonFrance.com le transfert (pourtant
zippé) s'interrompt au bout d'un moment et rien ne passe. Il faut peut-
être un débit supérieur au mien (ADSL non dégroupé).
Bon ce n'est pas grave, j'en fait profiter mon entourage que ça
intéresse.
A+ YLC