trouver la valeur de forloop à quel événement est survenu Python

Question

hey les gars, ce qui est très déroutant ...

je suis en train de trouver le minimum d'un tableau par:

for xpre in range(100): #used pre because I am using vapor pressures with some x molarity 
     xvalue=xarray[xpre] 
     for ppre in range(100): #same as xpre but vapor pressures for pure water, p 
      pvalue=parray[p] 
      d=math.fabs(xvalue-pvalue) #d represents the difference(due to vapor pressure lowering, a phenomenon in chemistry) 
      darray.append(d) #darray stores the differences 
     mini=min(darray) #mini is the minimum value in darray 
     darr=[] #this is to make way for a new set of floats 

tous les tableaux (xarr , parr, darr) sont déjà définis et non. Donc, ma question est de savoir comment trouver le pvap et le xvap @ qui min (darr) est trouvé?

modifier ont changé quelques noms de variables et a ajouté des descriptions variables, désolé les gars

Answer 1

A de deux choses:

1. Essayez enumerate
2. Au lieu de darr être un list, utilisez un dict et stocker les valeurs dvp en tant que clés, avec les variables xindex et pindex comme valeurs

Voici le code

for xindex, xvalue in enumerate(xarr): 
    darr = {} 
    for pindex, pvalue in enumerate(parr): 
    dvp = math.fabs(xvalue - pvalue) 
    darr[dvp] = {'xindex': xindex, 'pindex': pindex} 
    mini = min(darr.keys()) 
    minix = darr[mini]['xindex'] 
    minip = darr[mini]['pindex'] 
    minindex = darr.keys().index(mini) 


    print "minimum_index> {0}, is the difference of xarr[{1}] and parr[{2}]".format(minindex, minix, minip) 
    darr.clear() 

Explication

La fonction enumerate vous permet de parcourir sur une liste et de recevoir également l'index de l'élément. C'est une alternative à votre range(100). Notez que je n'ai pas la ligne où je reçois la valeur à l'index xpre, ppre, c'est parce que la fonction enumerate me donne à la fois l'index et la valeur sous la forme d'un tuple.

cependant, est que, au lieu de votre darr étant une telle liste Le changement le plus important:

[130, 18, 42, 37 ...] 

Il est maintenant un dictionnaire comme celui-ci:

{ 
    130: {'xindex': 1, 'pindex': 4}, 
    18: {'xindex': 1, 'pindex': 6}, 
    43: {'xindex': 1, 'pindex': 9}, 
    ... 
} 

Alors maintenant, au lieu de Je stocke simplement les valeurs dvp seul, je stocke également les indices dans x et p qui a généré ces valeurs dvp. Maintenant, si je veux savoir quelque chose, disons, quelles valeurs x et p produisent la valeur dvp de 43? Je fais ceci:

xindex = darr[43]['xindex'] 
pindex = darr[43]['pindex'] 
x = xarr[xindex] 
p = parr[pindex] 

Maintenant x et p sont les valeurs en question.

Note Je stockerais personnellement les valeurs qui ont produit un dvp particulier, et non les indices de ces valeurs. Mais vous avez demandé les indices, alors je vous ai donné cette réponse. Je vais supposer que vous avez une raison de vouloir gérer des indices comme celui-ci, mais en général, vous ne trouvez pas vous-même manipuler des index de cette manière quand vous programmez de manière Pythonienne. C'est une façon très C de faire les choses.

Answer 2

Edit: Cela ne répond pas à la question de l'OP:

min_diff, min_idx = min((math.fabs(a - b), i) for i, (a, b) in enumerate(zip(xpre, ppre) 

droite à gauche:

zip prend xpre et PPRE et fait un tuple du 1er, 2ème, ... éléments respectivement, comme suit:

[ (xpre[0],ppre[0]) , (xpre[1],ppre[1]) , ... ] 

énumérer énumère ajoute l'index en comptant seulement vers le haut à partir de 0:

[ (0 , (xpre[0],ppre[0])) , (1 , (xpre[1],ppre[1])) , ... ] 

Cette décompresse chaque tuple nestet:

for i, (a, b) in ... 

i est l'index généré par énumérer, a et b sont les éléments de xarr et parr.

On construit ainsi un tuple constitué d'une différence et de l'indice:

(math.fabs(a - b), i) 

L'ensemble de l'entre min (...) est une expression de la génératrice. min trouve ensuite la valeur minimale dans ces valeurs et l'affectation les décompresse:

min_diff, min_idx = min(...)