Appliquer la formule avec deux listes différentes

Question

j'ai deux listes comme celle-ci:

listA = [51, 988, 1336, 2067, 1857, 3160] 
listB = [1, 2, 3, 4, 5, 6] 

Je dois appliquer cette formule dans les listes:

n/pi * ((x*0.1)+1)**2 - pi * (x*0.1)**2 

Le « n » est les éléments de listeA, 'x' est les éléments qui correspondent au même index de 'n' dans listB.

Je dois appliquer cette formule à tous les éléments des deux listes. De sorte que lorsque la boucle exécute la première fois qu'il doit faire ceci:

51/pi*((1*0.1)+1)**2 - pi *(1*0.1)**2 

Pour la deuxième cela, il a besoin de le faire:

988/pi*((2*0.1)+1)**2 - pi*(2*0.1)**2 

Et il répète jusqu'à la fin des deux listes. Je sais que je dois utiliser une boucle 'for', mais mon problème est que je ne sais pas comment obtenir les éléments de la deuxième liste. Je suis en train de le faire:

for n in listA: 
    n/pi*((......)) 

intérieur supports de Thhe il devrait être les éléments de listeB mais je ne sais pas comment les obtenir, et ils ont besoin d'avoir le même indice que l'élément de listeA. La sortie devrait être une troisième liste avec le résultat de chaque formule appliquée.

J'ai essayé de m'expliquer de la meilleure façon possible, mais si vous ne comprenez pas ma question, n'hésitez pas à poser n'importe quelle question.

Merci d'avance.

Answer 1

Je suppose que les deux listes ont la même taille tout le temps, la plus pythonique est d'utiliser lambda et liste compréhensions:

listA = [51, 988, 1336, 2067, 1857, 3160] 
listB = [1, 2, 3, 4, 5, 6] 

from math import pi 

formula = lambda n,x: n/pi * ((x*0.1)+1)**2 - pi * (x*0.1)**2 

res = [ formula(a,b) for a,b in zip(listA,listB) ] 

>> [19.621466242038217, 
452.96994140127384, 
718.7747248407644, 
1289.7268993630569, 
1329.8678662420382, 
2575.175332484077] 

Answer 2

Ce code pour la première formule:

from math import pi 

def func(l1, l2): 
    l = list() 
    for x,n in zip(l1, l2): 
     l.append(n/pi * ((x*0.1)+1)**2 - pi * (x*0.1)**2) 
    return l 

listA = [51, 988, 1336, 2067, 1857, 3160] 
listB = [1, 2, 3, 4, 5, 6] 
print func(listA, listB) 

Sortie:

[-69.86851405497168, -24325.709794885548, -38773.5481974975, 
-79297.55058963387, -52859.75700368613, -121787.02310052476] 

Answer 3

Vous pouvez les zip():

for a, b in zip([1,2,3], [4,5,6]): 
    print a, b 

donnera

1 4 
2 5 
3 6 

Answer 4

numpy vectorisé approche sera beaucoup plus rapide par rapport à régulier/liste compréhension/etc.en particulier sur les grandes listes:

import numpy as np 

listA = np.array([51, 988, 1336, 2067, 1857, 3160]) 
listB = np.array([1, 2, 3, 4, 5, 6]) 
result = listA/np.pi * ((listB*0.1)+1)**2 - np.pi * (listB*0.1)**2 

Sortie:

In [175]: result 
Out[175]: array([ 19.61148715, 452.74017757, 718.41005008, 1289.07255327, 1329.19288378, 2573.86868192]) 

Calendrier et comparaison sur deux listes 1M:

In [183]: A = np.random.randint(1,100, 10**6) 

In [184]: B = np.random.randint(1,100, 10**6) 

In [185]: formula = lambda n,x: n/pi * ((x*0.1)+1)**2 - pi * (x*0.1)**2 

approche de Vectorized:

In [186]: %timeit formula(A, B) 
10 loops, best of 3: 65.4 ms per loop 

Liste compréhension:

In [191]: %timeit [ formula(a,b) for a,b in zip(A.tolist(),B.tolist()) ] 
1 loop, best of 3: 3.6 s per loop 

Conclusion: approche vectorisé est 55 fois plus rapide