Discussion :

[alexis_c]

Bonjour,

je test différent moyen de bien gérer et utiliser certaines données.
Ces données sont représenté par un ensemble de variables définie par un nombre limité de clé fixe. A l'image de ce que j'ai montré dans mon poste précèdant

Il existent donc les classes avec slots
Je suis tombé sur un tuto parlant de "MutableTuple": Voici un exemple test: (j'ai juste ajouté kwargs par moi même)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
from collections import Sequence
 
class MutableTuple(Sequence):
    """Abstract Base Class for objects that work like mutable
    namedtuples. Subclass and define your named fields with
    __slots__ and away you go.
    """
    __slots__ = ()
    def __init__(self, *args, **kwargs):
        for slot, arg in zip(self.__slots__, args):
            setattr(self, slot, arg)
        for slot, arg in kwargs.items():
            setattr(self, slot, arg)
    def __repr__(self):
        return type(self).__name__ + repr(tuple(self))
    # more direct __iter__ than Sequence's
    def __iter__(self):
        for name in self.__slots__:
            yield getattr(self, name)
    # Sequence requires __getitem__ & __len__:
    def __getitem__(self, index):
        return getattr(self, self.__slots__[index])
    def __len__(self):
        return len(self.__slots__)
 
class Student(MutableTuple):
    __slots__ = 'first', 'last', 'grade' # customize
 
#usage
student = Student('Lisa', 'Simpson', 'A')
print(student)
first, last, grade = student
print(first,last,grade)
student[0]
student[2]
'Lisa' in student
'Bart' in student
student.first = 'Bart'
for i in student: print(i)
 
p1 = Student(first='type', last='etq', grade = 0)
print(p1)
p2 = Student(firt='truc', last='mach', grade = 0)
print(p2)

Quel est votre opinion sur cette methode?
J'ai vue sur internet que les tuples nommé était moins efficace que les dictionnaires quand on recherché les valeurs a l'aide de leur nom?

Je me demande s'il existe l’équivalent pour les dictionnaires: définir un dictionnaire avec des clés fixe a l'image de mutable tuple ?
Si quelqu'un peu m'orienter vers un exemple?

Quels sont les avantages et inconvénient entre ces différentes méthodes?

J'ai également l'intention d’effectué des contrôles sur ces données, et j'avais en premières intention envie d'effectué ces contrôlés avec une fonction interne à la classe représentant les données. Mais je pourrai tout aussi bien mettre ces contrôles dans la classe utilisatrice . Quel est la bonne pratique?

[papajoker]

bonjour

Quel est votre opinion sur cette methode?

Aucune Et ici tu n'as pas de tuple ! simplement un objet classique qui imite parfois un tuple donc, rien d'extraordinaire.

existe l’équivalent pour les dictionnaires: définir un dictionnaire avec des clés fixe

rein de difficile, dommage que tu ne puisses pas l'écrire toi même... ajouter un "self._fixed=True" n'a rien de compliqué !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class SlotDict(UserDict):
    """ clés fixées uniquement après init """
    def __init__(self, dico=None, /, **kwargs):
        self._fixed = False
        """
        self.__keys__ = set()  # NON utilisé ici, mais peut-être pour tes cas particuliers...
        if isinstance(dico, dict):
            self.__keys__ = set(dico.keys())
        if kwargs:
            self.__keys__ = self.__keys__  | set(kwargs.keys())
        # fin du non utile
        """
        super().__init__(dico, **kwargs)
        self._fixed = True
 
    def __setitem__(self, key, value):
        if self._fixed and key not in self.keys():
            raise KeyError(f"Clés sont fixées, `{key}` est invalide")
        super().__setitem__(key, value)
 
 
dico = SlotDict({'nom': 'Legrand', 'prenom':'alice'})
print(dico)
dico['nom'] = 'lefranc'
try:
    dico['age'] = 28
except KeyError as err:
    print(err)
print(dico)
print()
 
dico = SlotDict({'prenom':'Arlette'}, nom='Legrand')
print(dico)
dico['nom'] = 'Lefranc'
dico['prenom'] = 'Anette'
try:
    dico['age'] = 28
except KeyError as err:
    print(err)
print(dico)

Quels sont les avantages et inconvénient entre ces différentes méthodes?

Aucun en particulier, c'est que simplement, on utilise uniquement si on en a un réel besoin. une petite surcharge de l'init, ni setitem() ne va pas rendre lent l'app

[tyrtamos]

Bonjour

Le principal avantage des dictionnaires est la rapidité avec laquelle on accède à la valeur d'une clé. En effet, avec un tuple ou une list, il faut tester une grande quantité de données (en moyenne la moitié de la totalité des données) avant de trouver la bonne. Avec un dictionnaire, l'emplacement des données se retrouve grâce un calcul avec la clé (hachage). Ce qui impose, bien sûr, que les clés soient "hachables" (https://docs.python.org/fr/3/glossar...#term-hashable).

Tout dépend donc de l'utilisation qu'on prévoit pour choisir la bonne structure de données.

[papajoker]

l'intention d’effectué des contrôles sur ces données, et j'avais en premières intention envie d'effectué ces contrôlés avec une fonction interne à la classe représentant les données. Mais je pourrai tout aussi bien mettre ces contrôles dans la classe utilisatrice . Quel est la bonne pratique?

Il faut voir en premier lieu si ces contrôles sont uniques à ton objet ... mais séparer est généralement une bonne pratique.
Et rien ne t'empêche dans ta classe de datas d'utiliser une autre classe de contrôle (classe de contrôle utilisable par différentes datas). Mais ici, attention aux dépendances.

------
De plus ici on a aucune idée du pourquoi tu désires cela (et quoi faire si data bas bonne), il y a donc 36000 bonnes façons
Tu as utilisé "mamachine" dans le sujet précédent, donc on peut imaginer des capteurs pour un moteur sur un banc d'essai, ici chaque "capteur" a sa propre règle et retourne (? exception ou autre)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
machine = Machine()
capteur1.regle = machine.temperature_max_supportee()
while true:
    with capteur1.open() as temperature, capteur2.open() as vitesse:
        try:
            machine.temperature = temperature.valider(exception=True)
            machine.vitesse = vitesse.valider(default=0, exception=None)
            log(machine)
       except (CapteurWarning, CapteurError) as err:
           log.error(err)
       except CapteurErrorCritique as err:
           log.error(err)
           machine.stop()
           break
       moteur.accelerer(10)
       time.sleep(150)
 
print("A ", machine.vitesse, "le moteur chauffe trop")

[alexis_c]

Tu as utilisé "mamachine" dans le sujet précédent, donc on peut imaginer des capteurs pour un moteur sur un banc d'essai,

Mon objectif est de créé une class permettant de représenté des paramètres accessible a un utilisateur permettant de géré le fonctionnement d'une sous partie de machine. Ces paramètres doivent être typé, possédé ou non des limites devants être contrôlé suivant les cas a l'init en en permanence...

dommage que tu ne puisses pas l'écrire toi même...

Ce doit être parce que mon niveau dépasse à peine le tuto de Swinnen et que je commence à m'intéresser à l'usage des fonctions magiques.

Le principal avantage des dictionnaires est la rapidité avec laquelle on accède à la valeur d'une clé.

Suivant vos conseil, je vais m'intéresser à l'usage de UserDict et voire si j'arrive a faire une version avec cet méthode pour mon apprentissage.

Je vous remercie pour vos conseils.

[tyrtamos]

Bonjour,

je vais m'intéresser à l'usage de UserDict et voire si j'arrive a faire une version avec cet méthode pour mon apprentissage

Au lieu d'utiliser UserDict, on peut aussi sous-classer directement dict:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Dict2(dict):
    """Dictionnaire sous-classé
    """
 
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs) # initialisation du parent
 
        self.toto = "Bonjour!" # variable ajoutée
 
dico = Dict2()
 
print(dico.toto)
Bonjour!

[papajoker]

userdict est plus lent (ce n'était pas le sujet ici)
Nous n'avons pas de code python (mais C) avec dict par contre userdict est en python et tu peux donc directement regarder/comprendre le code depuis ton éditeur et réutiliser des choses pour tes essais et créations à la Frankenstein(ou non).

Rien que la déclaration de __init__() de dict me donne mal à la tête

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
    # __init__ should be kept roughly in line with `collections.UserDict.__init__`, which has similar semantics
    # Also multiprocessing.managers.SyncManager.dict()
    @overload
    def __init__(self) -> None: ...
    @overload
    def __init__(self: dict[str, _VT], **kwargs: _VT) -> None: ...
    @overload
    def __init__(self, __map: SupportsKeysAndGetItem[_KT, _VT]) -> None: ...
    @overload
    def __init__(self: dict[str, _VT], __map: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> None: ...
    @overload
    def __init__(self, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ...
    @overload
    def __init__(self: dict[str, _VT], __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ...
    # Next overload is for dict(string.split(sep) for string in iterable)
    # Cannot be Iterable[Sequence[_T]] or otherwise dict(["foo", "bar", "baz"]) is not an error
    @overload
    def __init__(self: dict[str, str], __iterable: Iterable[list[str]]) -> None: ...

[wiztricks]

Salut,

J'ai vue sur internet que les tuples nommé était moins efficace que les dictionnaires quand on recherché les valeurs a l'aide de leur nom?

Un tuple est une séquence (un tableau à une dimension) qui ne permet l'accès à ses éléments que via un indice (0, 1, 2,...).
Un dictionnaire a 2 dimensions: le hash de la clef donne la "ligne" dans laquelle on fera une recherche séquentielle.

Un tuple nommé est un tuple auquel on a ajouté un dictionnaire pour pouvoir récupérer l'indice associé au nom puis récupérer la données dans le tuple. Plus d'opérations ==> un peu plus lent/long mais quand je dispose de l'indice, l'accès au tuple sera plus rapide.

Quel est la bonne pratique

Avec le Python de base la structure de données la plus élaborée est le Dataclass du module dataclasses. Il rend quelque peu "obsolète" les namedtuple et tout ce qu'on tend à écrire soi-même. La bonne pratique est de partir de là (et de ne s'en départir que si on a de bonnes raisons techniques de le faire).

Ces paramètres doivent être typé, possédé ou non des limites devants être contrôlé suivant les cas a l'init en en permanence...

Cet aspect est sans rapport avec ce qui précède puisqu'on parle des objets éléments du tuple/valeurs du dictionnaire/...
Je vous ai déjà indiqué les descripteurs car c'est la construction utilisée par toutes les bibliothèques qui font ce genre de chose. Après, je conçois que ce soit un peu compliqué à comprendre comment les mettre en place... mais prendre le temps d'apprendre et voir comment réaliser ce que vous voulez faire avec vous appartient.

- W

[alexis_c]

dataclasses

Entendu je vais m'intéresser au sujet.

Je vous ai déjà indiqué les descripteurs

Oui en effet, je me suis fait une version de cette classe avec les descripteurs. Mais j'essayai de voire quel pouvais être les autres solutions.

Cet aspect est sans rapport avec ce qui précède

Il s'agissait juste d'une mise en contexte que papajocker semblait demander.

[papajoker]

Mais j'essayai de voire quel pouvais être les autres solutions.

Donc c'est moi qui n'ai rien compris, je pensais que tu avais 2 questions distinctes dans ce sujet

Ton code objet avec slots est une sécurité (sans doute inutile) pour ne pas ajouter accidentellement une valeur dans une classe (et éventuellement, tu désires ne plus utiliser de tuples dans ton code car tu as lu que... ).
Ta classe "machine" n'est pas un tuple, alors pourquoi nous parler des tuples ???
L'autre sujet était de valider les attributs d'une classe

Soit tu t'égares complètement (puisque les 2 non rien à voir), soit tu désires sur-blinder ton objet alors que le premier blindage n'existe pas encore.

Et vu ta question sur les dicos (" s'il existe l’équivalent pour les dictionnaires"), j'ai l'impression que tu n'as même pas commencé ta classe "machine" car tu ne sais pas encore si tu vas stoker les datas comme attributs ou dans un dictionnaire

[alexis_c]

Donc c'est moi qui n'ai rien compris, je pensais que tu avais 2 questions distinctes dans ce sujet

Je vais essayer de clarifier:

Ton code objet avec slots est une sécurité (sans doute inutile)

Il me semble que cela améliore également les performances et facilite le débuguage puisque les clés de la class paramètre sont figé

(et éventuellement, tu désires ne plus utiliser de tuples dans ton code car tu as lu que... )

ma question: " les tuples nommé était moins efficace que les dictionnaires " ne concerne que les "tuples nommé"
J'avoue pour l'instant ne pas les utilisés du tout. Et ma question porte plus sur leurs condition d'usage et sur leurs intérêt par rapport a un dictionnaire. Si, comme lu sur internet il sont moins rapide qu'un dictionnaire si on utilise le nom.

Ta classe "machine" n'est pas un tuple, alors pourquoi nous parler des tuples ???

Cet question est la plus mystérieuse a mes yeux?
Je ne pense pas avoir parler de classe "machine" ni dans ce sujet n'y dans le sujet précédant. (Ou alors j'ai parcouru les sujets un peu trop en diagonal)
Et pourtant il existe bien une classe "machine" qui sera la classe mère d'un ensemble de classe définissant des "machine" spécifiques.
Je me demande si tu ne confond pas avec un autre poste.

Je parle des tuples car dans le cas des paramètres défini uniquement a l'initialisation, ils pourrais être stocké dans des tuples et utilisé et contrôlé dans la classe machine. Même si je préférerai standardisé l'usage de ces "paramètres" partout dans le programme.

Soit tu t'égares complètement (puisque les 2 non rien à voir), soit tu désires sur-blinder ton objet alors que le premier blindage n'existe pas encore.

Je pense que cette phrase est due a notre incompréhension mutuel.
Non je ne croit pas que la classe "machine" soit un tuple?
Surblindage? Je ne compte pas effectué les contrôles et dans la classe paramètre et dans la classe machine mais dans l'un , l'autre, ou une classe spécifique. C'est en cours dévaluation.

j'ai l'impression que tu n'as même pas commencé ta classe "machine" car tu ne sais pas encore si tu vas stoker les datas comme attributs ou dans un dictionnaire

Oui effectivement, ma classe "machine" est dans le même état que ma classe paramètre: En cour dévaluation des possibilités et de la meilleurs façons d'organisé l'ensemble.

[wiztricks]

ma question: " les tuples nommé était moins efficace que les dictionnaires " ne concerne que les "tuples nommé"
J'avoue pour l'instant ne pas les utilisés du tout. Et ma question porte plus sur leurs condition d'usage et sur leurs intérêt par rapport a un dictionnaire. Si, comme lu sur internet il sont moins rapide qu'un dictionnaire si on utilise le nom.

Avec les dataclass, on peut écrire:

Code :

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

1
2
3
4
5
6
from dataclasses import dataclass
 
@dataclass(frozen=True, slots=True)
class Point:
    x: int = 0
    y: int = 0

Et on a un truc "homogène" qu'il suffit de tester pour voir côté performances.

Pour le reste, des données attributs d'un même objet, ça fait des lignes dans une table avec des noms sur chaque colonne.... et d'autres outils à utiliser dès que la taille de la collection (le nombre de lignes) devient important. Et comme il s'agit de données, la persistance (les sauvegarder/récupérer entre deux exécution du programme) devient un vrai sujet qui va forcer la solution à adopter.

- W

[papajoker]

ne concerne que les "tuples nommé" ...
ma question porte plus sur leurs condition d'usage et sur leurs intérêt par rapport a un dictionnaire

tuple nommé ou dico Mauvaise question car ce sont 2 usages bien différents

En fait, j'ai l'impression que tu pollues ta conception à cause de l'optimisation ! par exemple __slots__ n'apporte pratiquement rien en vitesse mais plutot en mémoire, donc on va utiliser si on a des milliers d'objets de cette classe.
Pense avant tout à tes api. Après, ce qu'il y a à l'intérieur des classes est une autre étape (plus facile)

une classe "machine" qui sera la classe mère d'un ensemble de classe définissant des "machine" spécifiques.

Donc, j'avais bien compris. Bien que "machine" est flou et moins tu en dit et moins on peu t'aider (dans cette phase de conception)

Je ne compte pas effectué les contrôles et dans la classe paramètre et dans la classe machine mais dans l'un , l'autre, ou une classe spécifique

Et on t'a (re)parlé des descripteurs ! ce n'est qu'une interface, donc avec peu d'ajout si nécessaire, tu peux très bien les utiliser dans ou hors de ta classe de datas. On te donne une solution qui répond à tes besoin, mais tu cherches sur le web des astuces de sioux

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class ValidatorLimit(Validator):    # voir exemple donné en lien
    pass
class Machine(Machinebase):
    temperature = ValidatorLimit(-20, 500)
    modele = validatorIn(("XL", "L", "M"))
 
# Ou utilisation hors classe
v = ValidatorLimit(4,50)
v.validate(70)   # beep

[alexis_c]

En fait, j'ai l'impression que tu pollues ta conception à cause de l'optimisation !
On te donne une solution qui répond à tes besoin, mais tu cherches sur le web des astuces de sioux

C'est bien vrai, en se moment je suis un peu perdu avec la profusion de possibilité pour réalisé une chose et je tente d'évalué les différentes méthodes, en testant et en demandant conseil, pour voire ce que cela donne.
Et j'avoue vouloir choisir plutôt une méthode mieux optimisé, ou plus pratique, si j'ai le choix entre deux.
Je ne doute pas que cette première conception ne sera pas la meilleur. Mais c'est en forgeant ...

En tout cas je remercie les différents intervenant pour leurs conseils et leurs aides.