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 :

alias = {'reactif': atomeReactif[1][0], 'reactifNombre': reactif[i][1][0], 'reactifSolution': reactif[i][1][2], 'reactifJointure': atomeReactif[1][1],
        'produit': atomeProduit[1][0], 'produitNombre': produit[j][1][0], 'produitSolution': produit[i][1][2], 'produitJointure': atomeProduit[1][1]}

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']

Voilà ! Merci beaucoup pour votre aide

et le problème se situe .... ?

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.

Si tu veux faire un truc de ce genre, je pense que la solution de la plus simple est de passer par des objets.

Citation : jb1993

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.

Et les int ne sont pas modifiables.

Citation : Maxibolt

Si tu veux faire un truc de ce genre, je pense que la solution de la plus simple est de passer par des objets.

+1

Salut jb1993, tu peux montrer avec un exemple simple ce que tu obtiens ?

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

Un exemple d'objet pour stocker des variables :

#!/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 print objet que de faire print objet.nice_print() ...

Et le premier qui dit que c'est moins OO d'écrire print(objet), il a perdu.

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.

Maxibolt : enfoiré.

Citation : quelqun_dautre

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...