variables appelées par leur nom

val <vlepage@aoll.com> writes:

Je voudrais créer un tableau dont le nom de chaque ligne serait les
deux lettres d'identification d'un pays et les autres colonnes des
nombres associé au pays. Comment faire pour créer un tel tablea u à
partir des noms et, surtout, comment lire un tel tableau.
Je ne sais pas si j'explique bien mais il s'agit d'une sorte
d'adressage indirect par nom.

tableau = dict()
tableau['fr'] = (1,2,3)
tableau['de'] = (2,3,4)
...
for k in tableau:
print k,tableau[k][0]

C'est cela que tu voulais ?

Après bien sûr, il y a beaucoup de variations possibles. Par exem ple:

class Tableau: pass

tableau = Tableau()
tableau.fr = (0,1,2)
tableau.de = (1,2,3)
...
for k in tableau.__dict__:
print k,tableau.__dict__[k][0]

Bref, c'est la même chose.

-- Alain.

Le Tue, 08 Mar 2011 17:32:29 +0100, val a écrit:

Bonjour,

Je voudrais créer un tableau dont le nom de chaque ligne serait les deux
lettres d'identification d'un pays et les autres colonnes des nombres
associé au pays. Comment faire pour créer un tel tableau à partir des
noms et, surtout, comment lire un tel tableau. Je ne sais pas si
j'explique bien mais il s'agit d'une sorte d'adressage indirect par nom.

Peut-être devrais-je essayer plutôt avec une liste ?

1) lire ce fil:
http://tinyurl.com/6l7kyef

2) si le conseil est à côté de la plaque, reformuler le problème en
donnant un exemple concret (genre un tableau de deux lignes et deux
colonnes).

Cordialement,
--
Yves

Après mûre réflexion, val a écrit :

Bonjour,

Je voudrais créer un tableau dont le nom de chaque ligne serait les deux
lettres d'identification d'un pays et les autres colonnes des nombres associé
au pays. Comment faire pour créer un tel tableau à partir des noms et,
surtout, comment lire un tel tableau.
Je ne sais pas si j'explique bien mais il s'agit d'une sorte d'adressage
indirect par nom.

Peut-être devrais-je essayer plutôt avec une liste ?

Merci pour les réponses. J'ai mal expliqué. En fait ce que je souhaite
c'est un truc comme ça :

Je pars d'une liste contenant les noms des pays
listePays = ("fr", "uk", "de", "es", "us", "ng",...)

et après affectation magique j'obtiens un tableau que je peux manipuler
directement avec les sigles de pays, genre:

sigle="fr"
data="population"
tableau(sigle,population) = '62.6 millions'

sur le même principe qu'une base de données. Je pourrais d'ailleurs
utiliser SQLite pour ça, mais ça me semble un peu extrème.

Le 08/03/2011 21:16, val a écrit :

Après mûre réflexion, val a écrit :

Bonjour,

Je voudrais créer un tableau dont le nom de chaque ligne serait les
deux lettres d'identification d'un pays et les autres colonnes des
nombres associé au pays. Comment faire pour créer un tel tableau à
partir des noms et, surtout, comment lire un tel tableau.
Je ne sais pas si j'explique bien mais il s'agit d'une sorte
d'adressage indirect par nom.

Peut-être devrais-je essayer plutôt avec une liste ?

Merci pour les réponses. J'ai mal expliqué. En fait ce que je souhaite
c'est un truc comme ça :

Je pars d'une liste contenant les noms des pays
listePays = ("fr", "uk", "de", "es", "us", "ng",...)

et après affectation magique j'obtiens un tableau que je peux
manipuler directement avec les sigles de pays, genre:

sigle="fr"
data="population"
tableau(sigle,population) = '62.6 millions'

sur le même principe qu'une base de données. Je pourrais d'ailleurs
utiliser SQLite pour ça, mais ça me semble un peu extrème.

Il faut encore rajouter les tests d'intégrité si c'est nécessaire mais
le principe d'un dictionnaire de dictionnaires peut suffire.

class tableau:

colonnes = None
data = {}

def __init__(self, colonnes={}):
self.colonnes = colonnes

def __call__(self, key, colonnes):
result = []
for colonne in colonnes:
result.append(self.data[key][colonne])
return result

def addKey(key):
self.data[key] = colonnes

def delKey(key):
del self.data[key]

def addValue(key, colonne, value):
self.data[key][colonne] = value

def delValue(key, colonne):
self.data[key][colonne] = self.colonnes[colonne]

--
Encolpe DEGOUTE
http://encolpe.degoute.free.fr/
Logiciels libres, hockey sur glace et autres activités cérébrales

val, le 3/8/2011 a écrit :

[...]

Merci pour les réponses. J'ai mal expliqué. En fait ce que je souhaite c'est
un truc comme ça :

Je pars d'une liste contenant les noms des pays
listePays = ("fr", "uk", "de", "es", "us", "ng",...)

et après affectation magique j'obtiens un tableau que je peux manipuler
directement avec les sigles de pays, genre:

sigle="fr"
data="population"
tableau(sigle,population) = '62.6 millions'

Sans doute plutôt tableau(sigle, data), non ?
Ou alors tableau("fr", "population"), tableau(fr, population) étant
plus compliqué à atteindre.

sur le même principe qu'une base de données. Je pourrais d'ailleurs utiliser
SQLite pour ça, mais ça me semble un peu extrème.

Ce que j'aime bien faire avec Python quand j'ai des structures de
données un peu velues, c'est de les saisir en texte, genre CSV, et de
les analyser ensuite par programme. Les données peuvent indifféremment
être dans le script lui-même ou dans un fichier à part. Notez
d'ailleurs que l'analyse du code source comme du texte est la seule
solution à ma connaissance pour détecter un doublon de clés dans un
gros dictionnaire.

Un exemple bâclé, avec des données piquées sur internet, via un
tableur. La partie extraction n'est ni élégante (100% regex l'eut été
beaucoup plus) ni pythonesque, ni commentée. C'est fait comme je fais
mes scripts à usage personnel (je vérifie juste que les erreurs se
manifestent avant le premier dégat). Juste l'assert, puisqu'une clé en
double est une erreur silencieuse.


#! /usr/bin/env python
# -*- coding: utf-8 -*-

r"""zorglub
Chine, 1 341 403 687 (2010), 9 574 479, 140.10
Inde, 1 189 172 906 (2011), 3 287 263, 361.75
Etats-Unis, 308 745 538 (2010), 9 629 047, 32.06
Indonésie, 237 512 355 (2008), 1 904 443, 124.71
Brésil, 192 298 177 (2010), 8 547 877, 22.50
Pakistan, 172 800 051 (2008), 796 096, 217.06
Bangladesh, 150 448 339 (2007), 142 615, 1 054.93
Nigéria, 146 255 306 (2008), 923 768, 158.32
Russie, 141 927 199 (2010), 17 075 400, 8.31
Japon, 127 470 060 (2010), 377 944, 337.27
zorglub"""

import sys, re


class dataPays(object):
def __init__(self, filename=sys.argv[0], balise=''):
def cl(s):
return s.strip().replace(' ', '')
rx = re.compile('"""' + balise + r"""s*(?P<line>.*?)""" +
balise + '"""', re.DOTALL | re.MULTILINE)
lignes = rx.search(open(filename,
'r').read()).group('line').split('n')[:-1]
self._dico = {}
for ligne in lignes:
e = ligne.split(',')
p, y = e[1].split(')')[0].split('(')
self._dico[unicode(e[0])] = {u'population':int(cl(p)),
u'année': int(cl(y)),
u'superficie':
int(cl(e[2])),
u'densité': float(cl(e[3]))}
assert len(self._dico) == len(lignes)
self.defaultKey = None

def __call__(self, key, data=None):
return self.getData(key, data)

def getData(self, key, data=None):
if data is None:
data = key
key = self.defaultKey
return self._dico[key][data]

def setDefaultKey(self, key):
self.defaultKey = key


tab = dataPays(balise='zorglub')

print tab.getData(u'Inde', u'densité')
print tab.getData(u'Japon', u'population')
print tab.getData(u'Nigéria', u'année')
print tab.getData(u'Brésil', u'superficie'), 'n'

print tab(u'Inde', u'densité')
print tab(u'Japon', u'population')
print tab(u'Nigéria', u'année')
print tab(u'Brésil', u'superficie'), 'n'

tab.setDefaultKey(u'Bangladesh')

print tab(u'densité')
print tab(u'population')
print tab(u'année')
print tab(u'superficie'), 'n'

tab.setDefaultKey(u'Etats-Unis')

print tab.getData(u'densité')
print tab.getData(u'population')
print tab.getData(u'année')
print tab.getData(u'superficie'), 'n'

print tab(u'Inde', u'densité')
print tab(u'Japon', u'population')
print tab(u'Nigéria', u'année')
print tab(u'Brésil', u'superficie'), 'n'


--
Pierre Maurette

Le Tue, 08 Mar 2011 21:16:26 +0100, val a écrit:

et après affectation magique

Une autre façon de faire:
On crée une classe Pays:

***début du code***

class Pays(object):
def __init__(self, sigle, nom, capitale, population):
self.sigle = sigle
self.nom = nom
self.capitale = capitale
self.population = population # en millions

fr = Pays("fr","France","Paris",66)
fi = Pays("fi","Finlande","Helsinki",5)

print fi.capitale
print fr.population
****fin du code ***

Le problème ensuite, c'est la façon de gérer tous ces objets. On peut
créer une collection de ces objets sous forme d'un dictionnaire:

****complément de code ****

monde = {}
monde["fr"] = Pays("fr","France","Paris",66)
monde["fi"] = Pays("fi","Finlande","Helsinki",5)

print monde

print monde["fr"].capitale

*****fin ****

--
Yves

Pierre Maurette a écrit le 09/03/2011 :

Sans doute plutôt tableau(sigle, data), non ?
Ou alors tableau("fr", "population"), tableau(fr, population) étant plus
compliqué à atteindre.

Oui, bien sûr : tableau(sigle, data)

sur le même principe qu'une base de données. Je pourrais d'ailleurs
utiliser SQLite pour ça, mais ça me semble un peu extrème.

Ce que j'aime bien faire avec Python quand j'ai des structures de données un
peu velues, c'est de les saisir en texte, genre CSV, et de les analyser
ensuite par programme. Les données peuvent indifféremment être dans le script
lui-même ou dans un fichier à part. Notez d'ailleurs que l'analyse du code
source comme du texte est la seule solution à ma connaissance pour détecter
un doublon de clés dans un gros dictionnaire.

En fait c'est exactement ce que je cherche à faire. Mon projet est de
couler la base World Fact Book dans une bdd SQLite. En ce moment
j'extrais les données par pays pour chacun des 164 paramètres
statistiques représentés dans la base WFB. Je fais ça simplement avec
avec des regexp. En regardant les fichiers html qui composent la base
(un fichier par paramètre statistique contenant les valeurs pour chaque
pays) je distingue 5 types de codage des données dans les fichiers html
(valeurs, liste, texte brut...). Pour vérifier que mon script détecte
bien le type de donnée je construis un tableau (pays, variables_stat,
type_de_donnée). Ça me permet de tracer facilement les problèmes de
mauvaises détection de type.

Une fois que le type sera bien détecté pour chaque couple (pays,
var_stat) je pourrais faire l'extraction finale des données en
construisant un filtre spécifique pour chaque type. Ça sera plus facile
je pense.

Un exemple bâclé, avec des données piquées sur internet, via un tableur. La
partie extraction n'est ni élégante (100% regex l'eut été beaucoup plus) ni
pythonesque, ni commentée. C'est fait comme je fais mes scripts à usage
personnel (je vérifie juste que les erreurs se manifestent avant le premier
dégat). Juste l'assert, puisqu'une clé en double est une erreur silencieuse.

Merci pour ce code qui va m'apprendre pas mal de choses.

Encolpe Degoute a écrit le 09/03/2011 :

Le 08/03/2011 21:16, val a écrit :

Après mûre réflexion, val a écrit :

Bonjour,

Je voudrais créer un tableau dont le nom de chaque ligne serait les
deux lettres d'identification d'un pays et les autres colonnes des
nombres associé au pays. Comment faire pour créer un tel tableau à
partir des noms et, surtout, comment lire un tel tableau.
Je ne sais pas si j'explique bien mais il s'agit d'une sorte
d'adressage indirect par nom.

Peut-être devrais-je essayer plutôt avec une liste ?

Merci pour les réponses. J'ai mal expliqué. En fait ce que je souhaite
c'est un truc comme ça :

Je pars d'une liste contenant les noms des pays
listePays = ("fr", "uk", "de", "es", "us", "ng",...)

et après affectation magique j'obtiens un tableau que je peux
manipuler directement avec les sigles de pays, genre:

sigle="fr"
data="population"
tableau(sigle,population) = '62.6 millions'

sur le même principe qu'une base de données. Je pourrais d'ailleurs
utiliser SQLite pour ça, mais ça me semble un peu extrème.

Il faut encore rajouter les tests d'intégrité si c'est nécessaire mais
le principe d'un dictionnaire de dictionnaires peut suffire.

class tableau:

colonnes = None
data = {}

def __init__(self, colonnes={}):
self.colonnes = colonnes

def __call__(self, key, colonnes):
result = []
for colonne in colonnes:
result.append(self.data[key][colonne])
return result

def addKey(key):
self.data[key] = colonnes

def delKey(key):
del self.data[key]

def addValue(key, colonne, value):
self.data[key][colonne] = value

def delValue(key, colonne):
self.data[key][colonne] = self.colonnes[colonne]

Pourriez-vous me dire comment utiliser le code ? Ça m'aidera à
comprendre le principe (je débute en python et en programmation objet).

Je pensais faire :
var=tableau()
var.addKey('fr')

mais python me dit que la deuxième ligne contient un paramètre de trop.

val, le 3/9/2011 a écrit :

[...]

Merci pour ce code qui va m'apprendre pas mal de choses.

Ça fait toujours plaisir à lire ;-) Mais méfiez-vous quand même,
sincèrement mon code habituel est loin d'être une référence en termes
de bonnes pratiques. Et celui-ci est encore en-dessous.
Déjà il est certainement calamiteux dans le cas d'un gros fichier avec
éventuellement peu de données utiles. Il faudra regarder du coté de
itertools.islice() et re.finditer().

--
Pierre Maurette

Encolpe Degoute a écrit le 09/03/2011 :

le principe d'un dictionnaire de dictionnaires peut suffire.

Je ne connaissais pas les dictionnaires, c'est exactement ce que je
cherchais, merci.