Discussion :

[diam's]

Bonjour,

Je suis un newbie en Python (j'utilise plutot les langages de type pascal) et je suis en train d'avaler l'excellent livre Apprendre à programmer avec Python 3 par Gérard Swinnen, ainsi que les tutoriels Python du site. Je ne vais pas me battre entre les versions 2.x et 3.x : je vais me faire la main direct sur la 3.

Dans ce qui suit, je vais certainement dire des bétises, donc n'hésitez pas à me corriger (pas le fouet svp )

Voilà ma question :
- en pascal, il m'arrive fréquemment d'utiliser des structures "record"
- en python, je vois qu'il existe les "tuple"
- le problème est qu'un tuple n'est pas modifiable à l'éxécution
- existe-t-il donc un moyen pour créer une structure "record" en python ?

PS : je sais que Guido a dit qu'il fallait utiliser une classe, mais j'aime bien mes records...

PS2 : le 1er projet que je veux attaquer en Python concerne le calcul de de réseaux de canalisations, qu'on doit pouvoir modifier (avec le coef de simultanéité et tout le toutim, ce qui revient en gros à calculer le diamètre d'un tronc en observant uniquement les feuilles de l'arbre...)

Pour mémoire, le record c'est ça (je ne vous apprend rien, c'est juste pour être sûr qu'on parle de la même chose [source : wiki lazarus.freepascal])

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Type
   ExampleRecord = Record
                     Values: array [1..200] of real;
                     NumValues: Integer; 
                     Average: Real 
                   End;
 
   Member = Record
              Firstname, Surname : string;
              Address: array [1..3] of string;
              Phone : Integer;
              Birthdate: TDateTime;
              PaidCurrentSubscription: Boolean
            End;

[fred1599]

Tu as 2 solutions, soit utiliser les dictionnaires, soit utiliser les classes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
exemple = {'values': [i for i in range(201)], 'numvalues': 150, 'average': 20.5}
 
print exemple['values'] # [0,...,200]

Mais ça se compliquera vite...

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class exemple:
    def __init__(self, values, numvalues, average):
        self.values = values
        self.numvalues = numvalues
        self.average = average
 
# Execution
 
my_exemple = exemple([i for i in range(201)], 150, 20.5)
print my_exemple.values # [0,...,200]
# etc...

[diam's]

Merci de cette confirmation.
Bon, bah, y'a plus qu'à panacher... (bien pratique ces "dictionnaires")

[plxpy]

Bonjour,

Pour gérer les "records" (des "struct" C), j'utilise aussi l'une ou l'autre des approches (dictionnaire ou classe), selon le contexte.

Même si, au final, la classe n'a pas de méthode (j'exclus le constructeur), elle me parait quand même, plus adaptée notamment si on souhaite vérifier et tester, dans une méthode ou une fonction, les types des paramètres qui sont fournis par l'appelant.

Noyé dans le type très général dict, il faudra vérifier la liste des clés pour être (moyennement) sur qu'on a bien affaire à un record donné. Un simple isinstance(record,dict) ne sera pas très sélectif. Même si ça ne fait pas tout, isinstance(record,MaClasseRecord) laissera passer moins de choses.

Ce que j'ai aussi l'habitude de faire, en passant par les classes, c'est de mettre assez systématiquement aux paramètres une valeur par défaut (None le plus souvent) dans le constructeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class exemple:
    def __init__(self, values=None, numvalues=None, average=None):
        self.values = values
        self.numvalues = numvalues
        self.average = average

(pour reprende brutalement le même exemple)

Ca permet de ne pas être tenu d'avoir toutes les valeurs des champs au moment de l'instanciation mais de pouvoir remplir le "record" au fur et à mesure (certaines valeurs de champs peuvent parfois être le résultat d'un calcul non trivial. Il faut alors passer par un tas de variables auxiliaires/intermédiaires, le temps de tout calculer avant de faire l'instanciation).

Par contre, je réserve les dictionnaires pour les cas où j'écris des modules bas niveau qui "s'attaquent" (en lecture) à des records dont on ne connait pas à priori les champs (pour fixer les idées, un export texte d'un tableur où les lignes sont les records et la première ligne donne la signification/le nom de chaque colonne/champ)

[wiztricks]

Salut,
voir aussi namedtuple de la bibliothèque collections. Construit à partir de tuple ces records ne sont pas mutables.
La version "mutable" est dans ce recipe
nota, comme vous venez à priori de langage pre-OO avoir des records mutables ou pas est sans doute trop subtil.
- W

[diam's]

voir aussi namedtuple de la bibliothèque collections. Construit à partir de tuple ces records ne sont pas mutables.
La version "mutable" est dans ce recipe

Oui, j'avais vu les namedtuple. Mais il me semble que, comme les tuples, ils ne peuvent pas être modifié à l'exécution (j'ai peut-être mal compris)

nota, comme vous venez à priori de langage pre-OO avoir des records mutables ou pas est sans doute trop subtil.
- W

Pré-OO = un pré Orienté Objet ?
Si oui, mauvais à priori - L'exemple que j'ai donné est tiré du wiki Lazarus... J'ai dis que je venais des langages "de type Pascal". J'aurais du préciser "utilisateur des RAD Delphi et Lazarus"...

Pour ce qui est du mutable, à moins que je me trompe sur la définition du terme, j'y fait référence dès mon premier post :

un tuple n'est pas modifiable à l'éxécution