Générer une liste de nombres en Python

Fondamentalement, j'ai besoin d'aide dans la production de nombres à partir d'une liste que j'ai créée en Python:

[1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, ...]

J'ai essayé un couple de différentes méthodes, mais à chaque fois j'ai l'impression, il y a un nombre impair mélangé avec des evens!

Je sais comment générer de pair/impair nombre si je devais faire une échelle de 0 à 100, cependant, que le même nombre d'précédentes, la liste m'a déconcerté les!

P. S. j'ai seulement été à l'aide de python pour un couple de jours, si cela s'avère être extrêmement simple, merci d'avance!

EDIT: Merci pour toutes les réponses, avec votre aide, j'ai obtenu par le biais de ce petit problème.
Voici ce que j'ai à remplir un peu d'excercice demandant de faire la somme des nombres de fibonacci:

F = [1, 2]
while F[-1] < 4000000
    F.append(F[-1] + F[-2])

sum(F[1::3])
4613732

Seulement inclure le numéro dans votre liste cible si elle est divisible par 2.
Quelles ont été les différentes méthodes que vous avez essayé?
Un peu étrange que vous avez réussi à générer une séquence de Fibonacci avant vous pouvez filtrer une liste... 😉

OriginalL'auteur user1486654 | 2012-06-27

17

Utiliser une liste de compréhension (voir: La recherche d'une liste d'objets en Python)
```
myList = [<your list>]
evensList = [x for x in myList if x % 2 == 0]
```
C'est bien parce que ça laisse de la liste intacte, et vous pouvez travailler avec evensList comme un objet de la liste.

Espérons que cette aide!

C'est le plus propre. Vous me battre pour elle, avoir un upvote.
Je pense que la compréhension de liste pourrait être un peu avancé pour les premiers jours avec python... mais c'est juste mon avis!
interprétations de la liste sont l'une des meilleures parties sur python... pourquoi ne pas introduire dès le début?
Oh je suis d'accord, mais c'est la meilleure pratique - et il lui laisse un objet de la liste.
Je pense juste qu'il serait plus sain pour apprendre les boucles for tenants et les aboutissants avant d'entrer dans la compréhension de liste. Mais encore une fois, à mon humble avis.

OriginalL'auteur Erty Seidohl
4

L'exemple suivant devrait résoudre votre problème.
```
Newlist = []
for x in numList:
   if x % 2 == 0:
      print x          
      Newlist.append(x)
```
C'est, si vous voulez imprimer tous les nombres pairs - si vous voulez obtenir une liste que vous pouvez travailler avec, de voir les réponses ci-dessous. Edit: je vois la nouvelle version ajoute une nouvelle liste 🙂

OriginalL'auteur 8bitwide
3

Dans votre cas particulier my_list[1::3] fonctionne. Il y a toujours deux entiers impairs entre même entiers dans de fibonacci: pair, impair, pair, impair, bizarre, bizarre.....
```
>>> my_list = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368]
>>>         
... 
>>> my_list[1::3]
[2, 8, 34, 144, 610, 2584, 10946, 46368]
```
Ce cas fonctionne, mais parce que vous êtes en s'appuyant sur le découpage et l'intensification par l'indice ce n'est pas une solution portable.
Je vois que vous êtes découpage de la liste, mais il y a deux virgules? Qu'est-ce que cette méthode est appelée?
Le troisième numéro est le "stride". Vous commencez à le premier élément, puis prendre chaque 3ème élément de la suite.
Ohhh très cool. +1
ce sera toujours le cas pour de fibonacci.

OriginalL'auteur Akavall
3

Vous pouvez faire cela avec une compréhension de liste:
```
evens = [n for n in numbers if n % 2 == 0]
```
Vous pouvez également utiliser le filtre function.
```
evens = filter(lambda x: x % 2 == 0,numbers)
```
Si la liste est très longue, il peut être souhaitable de créer quelque chose d'itérer sur la liste plutôt que de créer une copie de la moitié de l'aide ifilter par itertools:
```
from itertools import ifilter
evens = ifilter(lambda x: x % 2 == 0,numbers)
```
Ou à l'aide d'un générateur d'expression:
```
evens = (n for n in numbers if n % 2 == 0)
```
OP, c'est une excellente réponse, mais considèrent que lambda est un peu trop avancé pour les premiers jours de python 🙂
Pouah, ifilter? Juste (x for x in numbers if not x % 2) œuvres.
Ont ajouté un générateur d'expression, même si je suis allé pour n % 2 == 0

OriginalL'auteur Dave Webb

Il suffit de cocher cette

A = [i for i in range(101)]
B = [x for x in A if x%2 == 0]
print B

OriginalL'auteur Ankit Vyas

1

parcourir la liste et l'utilisation de l'opérateur modulo de vérifier, même
```
for number in list:
    if (number % 2) == 0: 
        ##EVEN
```
nan, les interprétations de la liste sont bien mieux pour ce genre de chose
d'accord...je n'ai jamais vu avant. Ils regardent rapide et efficace!

OriginalL'auteur javajavajava
0

Juste pour le fun, vérifier si les number%2 != 1 fonctionne aussi 😉
```
evens=[x for x in evens_and_odds if number%2 != 1 ]
```
Note que vous pouvez faire des choses intelligentes afin de séparer les evens et les cotes dans une boucle:
```
evens=[]
odds=[]
numbers=[ evens, odds ]
for x in evens_and_odds:
    numbers[x%2 == 1].append(x)

print evens
print odds   
```
Ci-dessus astuce fonctionne parce que les expressions logiques (==, >, etc.) d'exploitation sur les numéros de True (1) et/ou False (0).

OriginalL'auteur mgilson
0

Vous pouvez utiliser compréhension de liste pour générer une nouvelle liste contient uniquement les membres de votre liste d'origine.
```
data = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
```
alors:
```
new_data = [i for i in data if not i%2]
```
rendements
```
[2, 8, 34, 144]
```
Ou vous pouvez également utiliser un générateur d'expression si vous n'avez pas besoin de tous ces numéros
à la fois:
```
new_data = (i for i in data if not i%2)
```
Les valeurs serait alors disponible en tant que de besoin, par exemple, si vous avez utilisé une boucle for:

par exemple,
```
for val in new_data:
   print val
```
L'avantage du générateur d'expression, c'est que l'ensemble de la liste n'est pas générée et stockée dans la mémoire à la fois, mais les valeurs sont générées lorsque vous en avez besoin qui fait moins appel à la mémoire. Il y a d'autres différences importantes, vous pourriez vouloir lire jusqu'à un certain point, si vous êtes intéressé.

OriginalL'auteur Levon

Au lieu de générer tous les nombres de Fibonacci, puis de filtrage pour les evens, pourquoi ne pas générer simplement les même valeurs?

def even_fibs():
    a,b = 1,2
    while True:
        yield b
        a,b = a+2*b, 2*a+3*b

génère [2, 8, 34, 144, 610, 2584, 10946 ...]

alors votre somme code devient:

total = 0
for f in even_fibs():
    if f >= 4000000:
        break
    else:
        total += f

from itertools import takewhile
total = sum(takewhile(lambda n: n<4000000, even_fibs()))

OriginalL'auteur Hugh Bothwell

Vous pouvez le faire en utilisant la fonction de filtre comme suit:

F = [1, 2]
while F[-1] < 4000000:
    F.append(F[-1] + F[-2])
print(F)
print('\n')
#create the variable that could store the sorted values from the list you have created.
sorted_number=list(filter(lambda x:x%2==0,F))
print(sorted_number)

OriginalL'auteur Eng.Boniphace Udoya

0

Vous pouvez utiliser un pour et si la boucle à l'aide de la longueur de la fonction, comme ceci:
```
for x in range(len(numList)):
    if x%2 == 0:
        print(x)
        NewList.append(x)
```
OriginalL'auteur Adeesh Jain
0

Fondamentalement, vous devez créer une variable et de mettre votre liste et ensuite trier vos même liste de numéros en l'ajoutant uniquement les numéros de

numbers = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, ...] even = [e for e in numbers if e%2==0]

OriginalL'auteur gxet4n
-1
```
a = range(0,1000)
b = []
for c in a:
    if c%2==0:
        b.append(c)
print b
```
Il serait bien si vous avez inclus des informations sur ce qu'il fait. Aussi, vous pouvez épargner beaucoup de code à l'aide de la troisième step argument range.

OriginalL'auteur user3894953

Vous devez vous connecter pour publier un commentaire.