Bonsoir,
après avoir recopié de nombreuse ligne d'algorithme, j'ai remarqué que mon tableau d'alias semble effectuer une copie des variables au lieu de pointer dessus, pour le tableau, j'utilise une variable dict, voici le tableau :
Comme vous pouvez le voir, j'ai créer le tableau d'alias de crainte que mon code devienne incompréhensible à cause des tableaux à trois dimensions, les variables ressembles à ceci : [['Cu', [1, 0, 1]], ['O', [2, 1, 1]]]
Concernant le code que j'utilise et pour le quel j'ai remarquer le problème, le voici :
# Début du calcule
if alias['reactif'] % 2 != 0 and alias['produit'] % 2 == 0 :
if alias['produit'] % alias['reactif'] == 0 :
alias['reactifSolution'] = alias['produit'] / alias['reactif']
alias['reactifNombre'] *= (alias['produit'] / alias['reactif'])
else :
alias['reactifSolution'] = alias['produit']
alias['reactifNombre'] = alias['reactif'] * alias['produit']
En clair, le tableau d'alias ne modifie pas les variables, elle réalise une copie au lieu de pointer sur la valeur. Ceci fait que si je modifie une variable, cette modification disparaît après.
En clair, le tableau d'alias ne modifie pas les variables, elle réalise une copie au lieu de pointer sur la valeur. Ceci fait que si je modifie une variable, cette modification disparaît après.
Tu n'as pas l'air de comprendre les concepts d'affectations, de valeurs et de variables en Python qui n'ont rien à voir avec le C.
En Python, une variable est un identificateur lié à une valeur (qui est un objet). Affecter une valeur à cette variable, ce n'est pas modifier la valeur précédente de la variable mais faire en sorte que l'identificateur en question désigne cette nouvelle valeur.
Je pense que je vais faire comme a dit Maxibolt, un classe, mais j'ignore pour le moment totalement comment je pourrais le réaliser.
Lexileduval : Rien s'affiche, j'ai juste une boucle infinie
#!/usr/bin/python
# -*- coding: utf-8 -*-
class Reaction():
"""
Noter dans un objet les éléments d'une réaction chimique
Exemple : 2*H + 1*O => 1*H2O
"""
def __init__(self, init_nom, init_reacts, init_nbreacts, init_prods, init_nbprods):
"""Créée l'objet et met à jour les éléments : nom, réactifs et produits"""
self.modif(init_nom, init_reacts, init_nbreacts, init_prods, init_nbprods)
def modif(self, mod_nom, mod_reacts, mod_nbreacts, mod_prods, mod_nbprods):
"""Met à jour les éléments : nom, réactifs et produits"""
self.nom = mod_nom # Nom de l'objet
self.reacts = mod_reacts # liste des réactifs ex : ['H', 'O']
self.nbreacts = mod_nbreacts # Liste des quantités de réactifs ex : [2, 1]
self.prods = mod_prods # liste des produits ex : ['H2O']
self.nbprods = mod_nbprods # Liste des quantités de produits
def nice_print(self):
""" Affiche dans le bon format les éléments de l'objet"""
print("Affichage de la réaction suivante :") # Titre d'affichage
print(self.nom) # Affichage du nom
prettyreacts = ['%s*%s' % (self.nbreacts[ind], react) for ind, react in enumerate(self.reacts)] # Liste des réactifs combinés
# avec leurs quantités
prettyprods = ['%s*%s' % (self.nbprods[ind], prod) for ind, prod in enumerate(self.prods)] # Idem pour les produits
# On combine ces listes et on les affiche :
print('%s => %s' % (' + '.join(prettyreacts), ' + '.join(prettyprods)))
## Le test :
# On créée un objet réaction
syntheseH2O = Reaction(init_nom = "Synthèse de l'eau", init_reacts = ['H', 'O'], init_nbreacts = [2, 1],\
init_prods = ['H2O'], init_nbprods = [1])
syntheseH2O.nice_print() # Et on l'affiche
# Ensuite on modifie les paramétres de l'objet (2*H sont remplacés par 3*H)
syntheseH2O.modif("Synthèse de l'eau : attention cette réaction est incorrecte", ['H', 'O'], [3, 1], ['H2O'], [1])
syntheseH2O.nice_print() # Et on l'affiche
Bon après c'est à adapter en fonction de ce que tu veux faire, il y a juste le squelette basique.
Et si au lieu de rajouter une méthode nice_print, on surchargeait __str__() ? C'est quand même plus pythonic de faire printobjet que de faire printobjet.nice_print()...
Une solution facile, mais moche : l'utilisation d'une liste ou d'un dico de lambdas, qu'on appelle quand on en a besoin, genre lias={'reactif':lambda:atomeReactif[1][0],'reactifNombre':lambda:reactif[i][1][0]}, que tu appelles en faisant lias['reactif'](). C'est moche, mais ça peut donner des pistes pour créer une classe qui fait ça de façon bien plus propre, ce que j'ai la flemme de faire.
Et si au lieu de rajouter une méthode nice_print, on surchargeait __str__() ? C'est quand même plus pythonic de faire print objet que de faire print objet.nice_print() ...
Encore mieux mais bon c'était juste un exemple à l'arrache (la flemme de faire mieux).
Maintenant j'attends de voir comment jb1993 va nous adapter ça...
Tableaux d'alias qui ne modifie pas réellement la variable
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Python c'est bon, mangez-en.