trouver la valeur de boucle à 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, tacons, Darr) sont déjà définis et que non. ils ont 100 flotteurs chaque

ma question est donc comment pourrais-je trouver le PVAP et le xvap @ qui min (Darr) se trouve?

modifier ont changé quelques noms de variables et les descriptions supplémentaires variables, désolé les gars

Answer 1

Un couple de choses:

1. enumerate
2. Au lieu de darr être un list, utilisez un dict et stocker les valeurs dvp que les 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 d'itérer sur une liste et de recevoir également l'index de l'élément. Il est une alternative à votre range(100). Notez que je n'ai pas la ligne où je reçois la valeur c'est à l'index xpre, ppre, parce que la fonction enumerate me donne à la fois l'indice et la valeur en tant que tuple.

Mais le changement le plus important, est que, au lieu de votre darr étant une liste comme ceci:

[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 simplement stocker les valeurs de dvp seul, je stocke aussi les indices dans x et p qui a généré ces valeurs dvp. Maintenant, si je veux savoir quelque chose, dire, Quelles sont les valeurs de x et p produisent la valeur dvp de 43? Je ferais ceci:

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

x et p sont les valeurs en question.

Remarque Personnellement, je stocker les valeurs qui ont produit un dvp particulier, et non les indices de ces valeurs. Mais vous avez demandé les indices si je vous ai donné cette réponse. Je vais supposer que vous avez une raison de vouloir les indices de manche comme celui-ci, mais en Python généralement vous ne trouvez pas vous-même des indices de manipulation de cette façon lors de la programmation de manière Pythonic. Ceci est un moyen 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)

de 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]) , ... ]

Enumerate ajoute l'indice énumère en comptant seulement vers le haut 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 des é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)

Le tout inbetween le min (...) est une expression de la génératrice. min trouve alors la valeur minimale dans ces valeurs, et l'attribution les décompresse:

min_diff, min_idx = min(...)