Obtenir des <générateur de l'objet <genexpr>

J'ai 2 listes:

first_lst = [('-2.50', 0.49, 0.52), ('-2.00', 0.52, 0.50)]
second_lst = [('-2.50', '1.91', '2.03'), ('-2.00', '1.83', '2.08')]

Je veux faire le calcul suivant:

Multiplier 0.49 par 1.91 (les valeurs correspondantes de first_lst et second_lst), et de multiplier 0.52 par 2.03 (valeurs correspondantes aussi). Je veux faire qu'à la condition que les valeurs à la position 0 dans chaque tuple est idential donc -2.50 == -2.50 etc. De toute évidence, nous faisons le même calcul pour remaning tuples.

Mon code:

[((fir[0], float(fir[1])*float(sec[1]), float(fir[2])*float(sec[2])) for fir in first_lst) for sec in second_lst if fir[0] == sec[0]]

Génère cependant un certain objet:

[<generator object <genexpr> at 0x0223E2B0>]

Pouvez-vous m'aider à corriger le code?

Votre tuples ont désadaptation types de string et float. Est-ce intentionnel ou tout simplement une erreur? Votre LC serait un échec si vous avez comme votre tuples. Depuis float ne peut pas être multiplié à un string. Voir ma réponse à corriger cette erreur.
J'avais écrit ce code avant j'ai réalisé que j'avais besoin de convertir tout à flotteur. Va le modifier maintenant de ne pas confondre personne. Merci pour le tuyau.
Bien Ashwini la réponse de résoudre le problème. En général, lorsque vous utilisez des interprétations de la liste, vous devez transtypage/stocker le résultat final dans une liste ou un tuple.

OriginalL'auteur nutship | 2013-05-04

Vous devez utiliser tuple() ou list() convertir générateur d'expression pour un list ou tuple:

[tuple((fir[0], fir[1]*sec[1], fir[2]*sec[2]) for fir in first_lst)\
                               for sec in second_lst if fir[0] == sec[0]]

Version de travail de votre code:

>>> first_lst = [tuple(float(y) for y in x) for x in first_lst]
>>> second_lst = [tuple(float(y) for y in x) for x in second_lst]

>>> [((fir[0],) + tuple(x*y for x, y in zip(fir[1:], sec[1:]))) \
                  for fir in first_lst for sec in second_lst if fir[0]==sec[0]]
[(-2.5, 0.9359, 1.0555999999999999), (-2.0, 0.9516000000000001, 1.04)]

Ah si simple, merci. Je pensais que tout simplement () fera.
Étrangement bien, ce code donne un fir is not defined. erreur. Est-ce un problème de mon côté?
les noms utilisés dans ce LC sont différentes de ce que l'OP a posté.
Sa compréhension donne le même message d'erreur au lieu de créer un objet de générateur.
Vous devez être à l'aide de first_lst et second_lst que les variables des noms de n-uplets.

OriginalL'auteur Ashwini Chaudhary

1

Considérant que votre first_lst et second_lst sont définis comme suit.
```
>>> first_lst = [('-2.50', '0.49', '0.52'), ('-2.00', '0.52', '0.50')]
>>> second_lst = [('-2.50', '1.91', '2.03'), ('-2.00', '1.83', '2.08')]
```
La liste suivante de la compréhension, peut être utile.
```
>>> [tuple((float(elem[0][0]), float(elem[0][1])*float(elem[1][1]), float(elem[0][2])*float(elem[1][2]))) for elem in zip(first_lst, second_lst) if elem[0][0]==elem[1][0]]
[(-2.5, 0.9359, 1.0555999999999999), (-2.0, 0.9516000000000001, 1.04)]
```
btw. pourquoi si je voulais ajouter else déclaration à la fin permettrait de lever une erreur invalid syntax. comme ceci: if elem[0][0]==elem[1][0] else pass] Ce n'est pas en contradiction avec python docs que j'ai coché jusqu'à maintenant.
zip ne fonctionne que pour les éléments sur le même indice, et Si je ne me trompe pas alors l'OP est en essayant de multiplier les deux n-uplet d'entiers premiers éléments sont les mêmes.
Il dit que chaque tuple correspondant, alors j'ai pensé qu'il voulait travailler sur ceux avec le même indice.
Pour répondre à l'OP de la question, que vous pouvez faire qui vient de mettre la for déclaration à la fin. Comme si. [tuple((float(elem[0][0]), float(elem[0][1])*float(elem[1][1]), float(elem[0][2])*float(elem[1][2]))) if elem[0][0]==elem[1][0] else '' for elem in zip(first_lst, second_lst)] Pour quelque raison pass et continue ne fonctionnent pas, mais vous n'aurez pas besoin de toute façon, si vous essayez de sauter, la LC va le faire de toute façon.

OriginalL'auteur Sukrit Kalra

Il y a 2 questions à regarder.

Le code d'origine va générer l'erreur:

>>> first_lst = [('-2.50', 0.49, 0.52), ('-2.00', 0.52, 0.50)]
>>> second_lst = [('-2.50', '1.91', '2.03'), ('-2.00', '1.83', '2.08')]
>>> [((fir[0], float(fir[1])*float(sec[1]), float(fir[2])*float(sec[2])) for fir in first_lst) for sec in second_lst if fir[0] == sec[0]]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <listcomp>
NameError: name 'fir' is not defined
>>>

et <generator object <genexpr> message est mentionné.

1), nous allons fixer le code avec un montant minimum de modifications par la création de compréhension de liste:

>>> first_lst = [('-2.50', 0.49, 0.52), ('-2.00', 0.52, 0.50)]
>>> second_lst = [('-2.50', '1.91', '2.03'), ('-2.00', '1.83', '2.08')]
>>> [(fir[0],fir[1]*float(sec[1]),fir[2]*float(sec[2])) for fir in first_lst for sec in second_lst if fir[0] == sec[0]] # list comprehension
[('-2.50', 0.9359, 1.0555999999999999), ('-2.00', 0.9516000000000001, 1.04)]
>>>

2) Dans le code d'origine, le support après first_lst ) est mal placée.
Si l'on place cette tranche après la sec[0] au lieu de compréhension de liste nous obtenons générateur d'expression. Et qui sera la cause de la <generator object <genexpr> message:

>>> [((fir[0],fir[1]*float(sec[1]),fir[2]*float(sec[2])) for fir in first_lst for sec in second_lst if fir[0] == sec[0])]  # generator object
[<generator object <genexpr> at 0x00000184EEDE29E8>]

En termes de syntaxe, la seule différence est que l'on utilise des parenthèses au lieu des crochets.

Remarque: Si nécessaire, il y a deux façons de convertir un objet de générateur à la liste:

2a) Utiliser l'astérisque (*) opérateur pour décompresser objet à la liste

>>> [*((fir[0],fir[1]*float(sec[1]),fir[2]*float(sec[2])) for fir in first_lst for sec in second_lst if fir[0] == sec[0])]
[('-2.50', 0.9359, 1.0555999999999999), ('-2.00', 0.9516000000000001, 1.04)]
>>>

2b) de manière explicite list()

>>> list((fir[0],fir[1]*float(sec[1]),fir[2]*float(sec[2])) for fir in first_lst for sec in second_lst if fir[0] == sec[0])
[('-2.50', 0.9359, 1.0555999999999999), ('-2.00', 0.9516000000000001, 1.04)]
>>>

OriginalL'auteur sg7

Vous devez vous connecter pour publier un commentaire.