bonjour,
comment faire pour recupere le nom de mon instance ?
class Vide():
pass
a=Vide()
a.__class__.__name__
'Vide'
le nom de la classe
class Toto(object): pass
Titi = Toto
del Toto
Titi.__name__
Toto
Titi.__name__ = 'Tata'
Titi
Tata
a.__instance__.__name__
==> Attribute Error ...
x = list()
x.append(Vide())
a = Vide()
locals()['a'] = Vide()
bonjour,
comment faire pour recupere le nom de mon instance ?
class Vide():
pass
a=Vide()
a.__class__.__name__
'Vide'
le nom de la classe
class Toto(object): pass
Titi = Toto
del Toto
Titi.__name__
Toto
Titi.__name__ = 'Tata'
Titi
Tata
a.__instance__.__name__
==> Attribute Error ...
x = list()
x.append(Vide())
a = Vide()
locals()['a'] = Vide()
bonjour,
comment faire pour recupere le nom de mon instance ?
class Vide():
pass
a=Vide()
a.__class__.__name__
'Vide'
le nom de la classe
class Toto(object): pass
Titi = Toto
del Toto
Titi.__name__
Toto
Titi.__name__ = 'Tata'
Titi
Tata
a.__instance__.__name__
==> Attribute Error ...
x = list()
x.append(Vide())
a = Vide()
locals()['a'] = Vide()
chris a écrit :bonjour,
comment faire pour recupere le nom de mon instance ?
Tiens, une FAQ !-)class Vide():
pass
a=Vide()
a.__class__.__name__
'Vide'
le nom de la classe
*Un* des noms de la classe - celui qui a été passé au constructeur de la
métaclasse en l'occurence. Pas forcément le 'nom' par lequel tu y
accèdes, d'ailleurs. Exemple:class Toto(object): pass
...Titi = Toto
del Toto
Titi.__name__
'Toto'Toto
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Toto' is not definedTiti.__name__ = 'Tata'
Titi
<class '__main__.Tata'>Tata
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Tata' is not defineda.__instance__.__name__
==> Attribute Error ...x = list()
x.append(Vide())
Quel est le "nom" de l'instance de Vide qui vient d'être créée ?-)
Dans ton exemple, 'x' n'est rien d'autre qu'un nom - une clé dans un
dictionnaire (l'espace de nommage courant) en fait. L'instruction:a = Vide()
est fonctionnellement équivalente à :locals()['a'] = Vide()
Tu comprends bien d'une part qu'un même objet peut être associé à
plusieurs clés différentes, et d'autre part que l'objet ne sais rien des
clés auxquelles il est associé. Sans parler des cas où l'object n'est
pas associé à une clé (dictionnaire) mais à un index (example avec la
liste ci-dessus...)...
Dans le cas des classes (et des fonctions et modules), l'attribut
'__name__' est positionné par le constructeur de l'objet (oui, les
classes, fonctions et modules Python sont des objets), à partir d'une
valeur qui lui est fournie - par défaut, le 'nom' utilisé dans
(respectivement) les instructions 'class' et 'def' ou, pour les modules,
le nom du fichier .py correspondant. Mais ce nom n'est qu'un attribut
tout à fait ordinaire (tu peux d'ailleurs le modifier à volontée, cf
ci-avant) dont la vocation est essentiellement informative.
HTH
chris a écrit :
bonjour,
comment faire pour recupere le nom de mon instance ?
Tiens, une FAQ !-)
class Vide():
pass
a=Vide()
a.__class__.__name__
'Vide'
le nom de la classe
*Un* des noms de la classe - celui qui a été passé au constructeur de la
métaclasse en l'occurence. Pas forcément le 'nom' par lequel tu y
accèdes, d'ailleurs. Exemple:
class Toto(object): pass
...
Titi = Toto
del Toto
Titi.__name__
'Toto'
Toto
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Toto' is not defined
Titi.__name__ = 'Tata'
Titi
<class '__main__.Tata'>
Tata
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Tata' is not defined
a.__instance__.__name__
==> Attribute Error ...
x = list()
x.append(Vide())
Quel est le "nom" de l'instance de Vide qui vient d'être créée ?-)
Dans ton exemple, 'x' n'est rien d'autre qu'un nom - une clé dans un
dictionnaire (l'espace de nommage courant) en fait. L'instruction:
a = Vide()
est fonctionnellement équivalente à :
locals()['a'] = Vide()
Tu comprends bien d'une part qu'un même objet peut être associé à
plusieurs clés différentes, et d'autre part que l'objet ne sais rien des
clés auxquelles il est associé. Sans parler des cas où l'object n'est
pas associé à une clé (dictionnaire) mais à un index (example avec la
liste ci-dessus...)...
Dans le cas des classes (et des fonctions et modules), l'attribut
'__name__' est positionné par le constructeur de l'objet (oui, les
classes, fonctions et modules Python sont des objets), à partir d'une
valeur qui lui est fournie - par défaut, le 'nom' utilisé dans
(respectivement) les instructions 'class' et 'def' ou, pour les modules,
le nom du fichier .py correspondant. Mais ce nom n'est qu'un attribut
tout à fait ordinaire (tu peux d'ailleurs le modifier à volontée, cf
ci-avant) dont la vocation est essentiellement informative.
HTH
chris a écrit :bonjour,
comment faire pour recupere le nom de mon instance ?
Tiens, une FAQ !-)class Vide():
pass
a=Vide()
a.__class__.__name__
'Vide'
le nom de la classe
*Un* des noms de la classe - celui qui a été passé au constructeur de la
métaclasse en l'occurence. Pas forcément le 'nom' par lequel tu y
accèdes, d'ailleurs. Exemple:class Toto(object): pass
...Titi = Toto
del Toto
Titi.__name__
'Toto'Toto
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Toto' is not definedTiti.__name__ = 'Tata'
Titi
<class '__main__.Tata'>Tata
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Tata' is not defineda.__instance__.__name__
==> Attribute Error ...x = list()
x.append(Vide())
Quel est le "nom" de l'instance de Vide qui vient d'être créée ?-)
Dans ton exemple, 'x' n'est rien d'autre qu'un nom - une clé dans un
dictionnaire (l'espace de nommage courant) en fait. L'instruction:a = Vide()
est fonctionnellement équivalente à :locals()['a'] = Vide()
Tu comprends bien d'une part qu'un même objet peut être associé à
plusieurs clés différentes, et d'autre part que l'objet ne sais rien des
clés auxquelles il est associé. Sans parler des cas où l'object n'est
pas associé à une clé (dictionnaire) mais à un index (example avec la
liste ci-dessus...)...
Dans le cas des classes (et des fonctions et modules), l'attribut
'__name__' est positionné par le constructeur de l'objet (oui, les
classes, fonctions et modules Python sont des objets), à partir d'une
valeur qui lui est fournie - par défaut, le 'nom' utilisé dans
(respectivement) les instructions 'class' et 'def' ou, pour les modules,
le nom du fichier .py correspondant. Mais ce nom n'est qu'un attribut
tout à fait ordinaire (tu peux d'ailleurs le modifier à volontée, cf
ci-avant) dont la vocation est essentiellement informative.
HTH
Merci pour ces éclaircissements,
en fait je n'avais pas du tout réfléchi au cas comme X.append(Vide())
en fait il s'agit d'instance "anonyme" par opposition a
v = Vide()
X.append(v)
En fait je cherchais a stocker et fiabiliser des astuces
comme
===== Exemple long ========================== > class Vide():
pass
RAPPORT = Vide()
RAPPORT.entete = "Rapport du mois de juillet"
RAPPORT.auteur = "Moi"
RAPPORT.date = "14 Juin 2009"
INTRO = Vide()
INTRO.titre = "Introduction"
INTRO.texte = "..."
INTRO.Graphic = ...
RAPPORT.INTRODUCTION = INTRO
CHAPITRE_1 = Vide()
CHAPITRE_1.titre = "Titre chap 1"
CHAPITRE_1.texte = "..."
CHAPITRE_1.tableau = do_tablo()
RAPPORT.chapitre["1"] = CHAPITRE_1
============================================= >
Bref de stocker tout et n'importe quoi dans une structure minimale
la classe Vide()
Mais des que l'on depasse le stade du brouillon ...
Comment stocker , serialiser voire meme afficher ce style de classe
pickle (que je n'ai pas tester) est difficile a lire pour un etre humain
normal
Je pensais a du XML (mais je suis pas fan !) ou du yaml
bref je cherche un moyen simple de faire un load et un dump de ma classe
Vide mais dont le resultat soit lisible facilement
Merci pour ces éclaircissements,
en fait je n'avais pas du tout réfléchi au cas comme X.append(Vide())
en fait il s'agit d'instance "anonyme" par opposition a
v = Vide()
X.append(v)
En fait je cherchais a stocker et fiabiliser des astuces
comme
===== Exemple long ========================== > class Vide():
pass
RAPPORT = Vide()
RAPPORT.entete = "Rapport du mois de juillet"
RAPPORT.auteur = "Moi"
RAPPORT.date = "14 Juin 2009"
INTRO = Vide()
INTRO.titre = "Introduction"
INTRO.texte = "..."
INTRO.Graphic = ...
RAPPORT.INTRODUCTION = INTRO
CHAPITRE_1 = Vide()
CHAPITRE_1.titre = "Titre chap 1"
CHAPITRE_1.texte = "..."
CHAPITRE_1.tableau = do_tablo()
RAPPORT.chapitre["1"] = CHAPITRE_1
============================================= >
Bref de stocker tout et n'importe quoi dans une structure minimale
la classe Vide()
Mais des que l'on depasse le stade du brouillon ...
Comment stocker , serialiser voire meme afficher ce style de classe
pickle (que je n'ai pas tester) est difficile a lire pour un etre humain
normal
Je pensais a du XML (mais je suis pas fan !) ou du yaml
bref je cherche un moyen simple de faire un load et un dump de ma classe
Vide mais dont le resultat soit lisible facilement
Merci pour ces éclaircissements,
en fait je n'avais pas du tout réfléchi au cas comme X.append(Vide())
en fait il s'agit d'instance "anonyme" par opposition a
v = Vide()
X.append(v)
En fait je cherchais a stocker et fiabiliser des astuces
comme
===== Exemple long ========================== > class Vide():
pass
RAPPORT = Vide()
RAPPORT.entete = "Rapport du mois de juillet"
RAPPORT.auteur = "Moi"
RAPPORT.date = "14 Juin 2009"
INTRO = Vide()
INTRO.titre = "Introduction"
INTRO.texte = "..."
INTRO.Graphic = ...
RAPPORT.INTRODUCTION = INTRO
CHAPITRE_1 = Vide()
CHAPITRE_1.titre = "Titre chap 1"
CHAPITRE_1.texte = "..."
CHAPITRE_1.tableau = do_tablo()
RAPPORT.chapitre["1"] = CHAPITRE_1
============================================= >
Bref de stocker tout et n'importe quoi dans une structure minimale
la classe Vide()
Mais des que l'on depasse le stade du brouillon ...
Comment stocker , serialiser voire meme afficher ce style de classe
pickle (que je n'ai pas tester) est difficile a lire pour un etre humain
normal
Je pensais a du XML (mais je suis pas fan !) ou du yaml
bref je cherche un moyen simple de faire un load et un dump de ma classe
Vide mais dont le resultat soit lisible facilement
<hs>
Attention, par convention, les nom en ALL_CAPS sont considéré comme des
constantes.
</hs>
Pas vraiment une bonne idée en général - il est préférable de créer les
classes kivonbien(tm). Mais bon, au cas où, il existe un idiome connu:
class Struct(object):
def __init__(self, **kw):
self.__dict__.update(kw)
Ca te permet au moins de coder ça un peu plus proprement:
RAPPORT = Struct(
entete="Rapport du mois de juillet",
auteur="Moi",
date="14 Juin 2009"
introduction = Struct(
....
)
chapitres = dict(
"1" : Struct(....)
)
)
Mais des que l'on depasse le stade du brouillon ...
Comment stocker , serialiser voire meme afficher ce style de classe
s/classe/objet/. Ce n'est pas la classe que tu stocker, mais les
instances...
pickle (que je n'ai pas tester) est difficile a lire pour un etre
humain normal
Ce n'est pas fait pour (être lisible par un être humain normal, j'entend).Je pensais a du XML (mais je suis pas fan !) ou du yaml
ou du json. Mais si le but est que ce soit éditable par un
non-informaticien, XML reste probablement la meilleure solution.
bref je cherche un moyen simple de faire un load et un dump de ma
classe Vide mais dont le resultat soit lisible facilement
Juste une question comme ça : quel va être le contexte d'utilisation ?
(appli web ? GUI monoposte mono-utilisateur ? autre ?). Parce que
générer une représentation lisible (XML ou autre) n'est pas en soi un
problème majeur, et n'a pas nécessairement à être lié à la gestion de la
persistence des données.
<hs>
Attention, par convention, les nom en ALL_CAPS sont considéré comme des
constantes.
</hs>
Pas vraiment une bonne idée en général - il est préférable de créer les
classes kivonbien(tm). Mais bon, au cas où, il existe un idiome connu:
class Struct(object):
def __init__(self, **kw):
self.__dict__.update(kw)
Ca te permet au moins de coder ça un peu plus proprement:
RAPPORT = Struct(
entete="Rapport du mois de juillet",
auteur="Moi",
date="14 Juin 2009"
introduction = Struct(
....
)
chapitres = dict(
"1" : Struct(....)
)
)
Mais des que l'on depasse le stade du brouillon ...
Comment stocker , serialiser voire meme afficher ce style de classe
s/classe/objet/. Ce n'est pas la classe que tu stocker, mais les
instances...
pickle (que je n'ai pas tester) est difficile a lire pour un etre
humain normal
Ce n'est pas fait pour (être lisible par un être humain normal, j'entend).
Je pensais a du XML (mais je suis pas fan !) ou du yaml
ou du json. Mais si le but est que ce soit éditable par un
non-informaticien, XML reste probablement la meilleure solution.
bref je cherche un moyen simple de faire un load et un dump de ma
classe Vide mais dont le resultat soit lisible facilement
Juste une question comme ça : quel va être le contexte d'utilisation ?
(appli web ? GUI monoposte mono-utilisateur ? autre ?). Parce que
générer une représentation lisible (XML ou autre) n'est pas en soi un
problème majeur, et n'a pas nécessairement à être lié à la gestion de la
persistence des données.
<hs>
Attention, par convention, les nom en ALL_CAPS sont considéré comme des
constantes.
</hs>
Pas vraiment une bonne idée en général - il est préférable de créer les
classes kivonbien(tm). Mais bon, au cas où, il existe un idiome connu:
class Struct(object):
def __init__(self, **kw):
self.__dict__.update(kw)
Ca te permet au moins de coder ça un peu plus proprement:
RAPPORT = Struct(
entete="Rapport du mois de juillet",
auteur="Moi",
date="14 Juin 2009"
introduction = Struct(
....
)
chapitres = dict(
"1" : Struct(....)
)
)
Mais des que l'on depasse le stade du brouillon ...
Comment stocker , serialiser voire meme afficher ce style de classe
s/classe/objet/. Ce n'est pas la classe que tu stocker, mais les
instances...
pickle (que je n'ai pas tester) est difficile a lire pour un etre
humain normal
Ce n'est pas fait pour (être lisible par un être humain normal, j'entend).Je pensais a du XML (mais je suis pas fan !) ou du yaml
ou du json. Mais si le but est que ce soit éditable par un
non-informaticien, XML reste probablement la meilleure solution.
bref je cherche un moyen simple de faire un load et un dump de ma
classe Vide mais dont le resultat soit lisible facilement
Juste une question comme ça : quel va être le contexte d'utilisation ?
(appli web ? GUI monoposte mono-utilisateur ? autre ?). Parce que
générer une représentation lisible (XML ou autre) n'est pas en soi un
problème majeur, et n'a pas nécessairement à être lié à la gestion de la
persistence des données.
Merci pour ton aide,
Comment stocker , serialiser voire meme afficher ce style de classe
Je pensais a du XML (mais je suis pas fan !) ou du yaml
ou du json. Mais si le but est que ce soit éditable par un
non-informaticien, XML reste probablement la meilleure solution.
a moitié d'accord mais après tout pkoi pas
bref je cherche un moyen simple de faire un load et un dump de ma
classe Vide mais dont le resultat soit lisible facilement
Juste une question comme ça : quel va être le contexte d'utilisation ?
(appli web ? GUI monoposte mono-utilisateur ? autre ?). Parce que
générer une représentation lisible (XML ou autre) n'est pas en soi un
problème majeur, et n'a pas nécessairement à être lié à la gestion de
la persistence des données.
le besoin est simple :
en entrée des données issues d'un scripts shell contenant des infos
de base de données / de systèmes d'exploitation et autres
(états des disques / statistiques de la machine / évolution diverses de
paramètres comme la mémoire etc .. )
en sortie un rapport structuré fait avec reportlab avec table des
matières, annotation diverses sur les graphique généré etc ..
pdf transmis a l'utilisateur final par mail.
chaque rapport est quasiment spécifique en fonction des besoins finaux
mais la structure de base doit rester la même
en gros je me connecte sur un système
je lance le shell script
je récupère les données brutes
je génère un "paquet de données" intermédiaire que je peu modifier ( au
début avec vi ou autre editeur mais après pkoi pas dvper un mini editeur )
je lance la génération du rapport qui me génère mon pdf
je relis
je modifie éventuellement
je régénère
quand je suis content j'envoie par mail
le shell script est presque fini
le rapport avec reportlab aussi (c'est la que j'ai utilise Vide() )
et je reflechissais au "paquet de données"
et c'est vrai que le xml me parait coherent dans ce cas
surtout que je
viens de voir des modules comme ElementTree
bref encore merci de tes conseils avisés.
Merci pour ton aide,
Comment stocker , serialiser voire meme afficher ce style de classe
Je pensais a du XML (mais je suis pas fan !) ou du yaml
ou du json. Mais si le but est que ce soit éditable par un
non-informaticien, XML reste probablement la meilleure solution.
a moitié d'accord mais après tout pkoi pas
bref je cherche un moyen simple de faire un load et un dump de ma
classe Vide mais dont le resultat soit lisible facilement
Juste une question comme ça : quel va être le contexte d'utilisation ?
(appli web ? GUI monoposte mono-utilisateur ? autre ?). Parce que
générer une représentation lisible (XML ou autre) n'est pas en soi un
problème majeur, et n'a pas nécessairement à être lié à la gestion de
la persistence des données.
le besoin est simple :
en entrée des données issues d'un scripts shell contenant des infos
de base de données / de systèmes d'exploitation et autres
(états des disques / statistiques de la machine / évolution diverses de
paramètres comme la mémoire etc .. )
en sortie un rapport structuré fait avec reportlab avec table des
matières, annotation diverses sur les graphique généré etc ..
pdf transmis a l'utilisateur final par mail.
chaque rapport est quasiment spécifique en fonction des besoins finaux
mais la structure de base doit rester la même
en gros je me connecte sur un système
je lance le shell script
je récupère les données brutes
je génère un "paquet de données" intermédiaire que je peu modifier ( au
début avec vi ou autre editeur mais après pkoi pas dvper un mini editeur )
je lance la génération du rapport qui me génère mon pdf
je relis
je modifie éventuellement
je régénère
quand je suis content j'envoie par mail
le shell script est presque fini
le rapport avec reportlab aussi (c'est la que j'ai utilise Vide() )
et je reflechissais au "paquet de données"
et c'est vrai que le xml me parait coherent dans ce cas
surtout que je
viens de voir des modules comme ElementTree
bref encore merci de tes conseils avisés.
Merci pour ton aide,
Comment stocker , serialiser voire meme afficher ce style de classe
Je pensais a du XML (mais je suis pas fan !) ou du yaml
ou du json. Mais si le but est que ce soit éditable par un
non-informaticien, XML reste probablement la meilleure solution.
a moitié d'accord mais après tout pkoi pas
bref je cherche un moyen simple de faire un load et un dump de ma
classe Vide mais dont le resultat soit lisible facilement
Juste une question comme ça : quel va être le contexte d'utilisation ?
(appli web ? GUI monoposte mono-utilisateur ? autre ?). Parce que
générer une représentation lisible (XML ou autre) n'est pas en soi un
problème majeur, et n'a pas nécessairement à être lié à la gestion de
la persistence des données.
le besoin est simple :
en entrée des données issues d'un scripts shell contenant des infos
de base de données / de systèmes d'exploitation et autres
(états des disques / statistiques de la machine / évolution diverses de
paramètres comme la mémoire etc .. )
en sortie un rapport structuré fait avec reportlab avec table des
matières, annotation diverses sur les graphique généré etc ..
pdf transmis a l'utilisateur final par mail.
chaque rapport est quasiment spécifique en fonction des besoins finaux
mais la structure de base doit rester la même
en gros je me connecte sur un système
je lance le shell script
je récupère les données brutes
je génère un "paquet de données" intermédiaire que je peu modifier ( au
début avec vi ou autre editeur mais après pkoi pas dvper un mini editeur )
je lance la génération du rapport qui me génère mon pdf
je relis
je modifie éventuellement
je régénère
quand je suis content j'envoie par mail
le shell script est presque fini
le rapport avec reportlab aussi (c'est la que j'ai utilise Vide() )
et je reflechissais au "paquet de données"
et c'est vrai que le xml me parait coherent dans ce cas
surtout que je
viens de voir des modules comme ElementTree
bref encore merci de tes conseils avisés.
Oui moi aussi je crains le XML et j'ai même un exemple parfait
imagine un echange client serveur basé sur des messages xml
a l'époque c'etait sexy et tout et tout
mais bon si t'avais pas du 100M full duplex pas la peine
puis les concepteurs ont réfléchi ...
En diminuant le texte des balises
<FENETRE_DE_SELECTION>
FENA
</FENETRE_DE_SELECTION>
par
<FS>
FENA
</FS>
gain 30% de volume sur le flux et même plus
Oui moi aussi je crains le XML et j'ai même un exemple parfait
imagine un echange client serveur basé sur des messages xml
a l'époque c'etait sexy et tout et tout
mais bon si t'avais pas du 100M full duplex pas la peine
puis les concepteurs ont réfléchi ...
En diminuant le texte des balises
<FENETRE_DE_SELECTION>
FENA
</FENETRE_DE_SELECTION>
par
<FS>
FENA
</FS>
gain 30% de volume sur le flux et même plus
Oui moi aussi je crains le XML et j'ai même un exemple parfait
imagine un echange client serveur basé sur des messages xml
a l'époque c'etait sexy et tout et tout
mais bon si t'avais pas du 100M full duplex pas la peine
puis les concepteurs ont réfléchi ...
En diminuant le texte des balises
<FENETRE_DE_SELECTION>
FENA
</FENETRE_DE_SELECTION>
par
<FS>
FENA
</FS>
gain 30% de volume sur le flux et même plus