web-dev-qa-db-fra.com

Python Beginner's Loop (Recherche de prix)

Je suis vraiment un débutant chez Python, alors je m'excuse pour le manque de connaissances, mais la raison pour laquelle je vous pose cette question est que vous lisez le manuel et le tutoriel Python ( http://docs.python.org/2.7/tutorial ) Je ne suis pas incapable de comprendre totalement le fonctionnement des boucles. J'ai écrit quelques programmes simples, je pense donc comprendre les bases mais, pour une raison quelconque, ce programme censé répertorier tous les nombres premiers inférieurs ou égaux à n ne fonctionne pas:

n = int(raw_input("What number should I go up to? "))
p = 2
while p <= n:
        for i in range(2, p):
                if p%i == 0:
                        p=p+1 
        print "%s" % p,
        p=p+1
print "Done"

La sortie lorsque j'entre 100 par exemple est:

2 3 5 7 11 13 17 19 23 27 29 31 35 37 41 43 47 53 59 61 67 71 73 79 83 87 89 95 97 101 Done

Ce qui semble presque correct mais pour une raison quelconque contient 27, 35, 95, qui sont composites bien sûr. J'ai essayé de distinguer le fonctionnement de ma boucle, mais je ne vois tout simplement pas où la vérification de la divisibilité n'est pas faite subitement. Je pensais que si quelqu'un jetait un coup d'œil, il pourrait m'expliquer ce que la syntaxe provoque. Merci beaucoup!

pythonprimes
4
user2034140

En fait, je restructurerais le programme pour ressembler à ceci:

for p in range(2, n+1):
    for i in range(2, p):
        if p % i == 0:
            break
    else:
        print p,
print 'Done'

C'est peut-être une solution plus idiomatique (en utilisant une boucle for au lieu d'une boucle while), et fonctionne parfaitement.

La boucle for extérieure parcourt tous les nombres de 2 à n.

Le numéro intérieur itère tous les nombres de 2 à p. Si elle atteint un nombre qui se divise également en p, elle sort de la boucle interne.

Le bloc else s'exécute chaque fois que la boucle for n'est pas interrompue (impression des nombres premiers).

Ensuite, le programme imprime 'Done' à la fin.

En remarque, il vous suffit de parcourir 2 à la racine carrée de p, car chaque facteur a une paire. Si vous n'obtenez pas de correspondance, il n'y aura pas d'autres facteurs après la racine carrée, et le nombre sera premier.

17
Volatility

Votre code a deux boucles, l'une dans l'autre. Cela devrait vous aider à comprendre le code si vous remplacez la boucle interne par une fonction. Ensuite, assurez-vous que la fonction est correcte et peut être autonome (séparée de la boucle extérieure).

Voici ma réécriture de votre code original. Cette réécriture fonctionne parfaitement.

def is_prime(n):
    i = 2
    while i < n:
        if n%i == 0:
            return False
        i += 1
    return True


n = int(raw_input("What number should I go up to? "))

p = 2
while p <= n:
    if is_prime(p):
        print p,
    p=p+1

print "Done"

Notez que is_prime() ne touche pas l'indice de boucle de la boucle externe. C'est une fonction pure autonome. Incrémenter p à l'intérieur de la boucle interne était le problème, et cette version décomposée n'a pas le problème.

Maintenant, nous pouvons facilement réécrire en utilisant des boucles for et je pense que le code est amélioré:

def is_prime(n):
    for i in range(2, n):
        if n%i == 0:
            return False
    return True


n = int(raw_input("What number should I go up to? "))

for p in range(2, n+1):
    if is_prime(p):
        print p,

print "Done"

Notez qu'en Python, range() n'inclut jamais la limite supérieure que vous indiquez. Ainsi, la boucle interne, qui vérifie < n, nous pouvons simplement appeler range(2, n), mais pour la boucle externe, où nous voulons <= n, nous devons en ajouter un à n afin que n sera inclus: range(2, n+1)

Python a des fonctionnalités intégrées qui sont amusantes. Vous n'avez pas besoin d'apprendre toutes ces astuces immédiatement, mais voici une autre façon d'écrire is_prime():

def is_prime(n):
    return not any(n%i == 0 for i in range(2, n))

Cela fonctionne comme la version de la boucle for de is_prime(). Il définit i sur les valeurs de range(2, n) et les vérifie. Si un test échoue, il arrête la vérification et renvoie. Si elle vérifie n par rapport à chaque nombre compris dans la plage et et non aucun divise n de manière égale, alors le nombre est premier.

Encore une fois, vous n'avez pas besoin d'apprendre tous ces trucs tout de suite, mais je pense qu'ils sont plutôt amusants quand vous les apprenez.

6
steveha

Cela devrait fonctionner et est un peu plus optimisé

import math
for i in range(2, 99):
  is_prime = True
  for j in range(2, int(math.sqrt(i)+1)):
    if i % j == 0:
      is_prime = False
  if is_prime:
    print(i)
2
Adeel

vous ne redémarrez pas la boucle i après avoir trouvé un non-prime

p = i = 2
while p <= n:
    i = 2
    while i < p:
        if p%i == 0:
            p += 1 
            i = 1
        i += 1

    print p,
    p += 1

print "Done"

Une boucle while exécute le corps, puis vérifie si la condition en haut est True; si elle est vraie, elle refait le corps. Une boucle for exécute le corps une fois pour chaque élément de l'itérateur.

1
tacaswell

Veuillez comparer votre extrait avec celui collé ci-dessous et vous remarquerez où vous vous êtes trompé.

n = int(raw_input("What number should I go up to? "))
p = 2
while p <= n:
    is_prime=True
    for i in range(2, p):
        if p%i == 0:
            is_prime=False
            break;
    if is_prime==True:
        print "%d is a Prime Number\n" % p
    p=p+1
1
Guddu
print('Enter a Number: ')
number=abs(int(input()))
my_List=[0,1]
def is_prime(n):
    if n in my_List:
        return True
    Elif n>=2:
        for i in range(2, n):
            if n%i == 0:
                return False
        return True
    else:
        return False

if is_prime(number):
    print("%d is Prime!"%number)
else:
    print(number,'is not prime')
0
Ahsanul kabir

Voici un exemple plus complet d'optimisation pour Python 3.

import sys

inner_loop_iterations: int = 0

def is_prime(n):
    a: int = 2
    global inner_loop_iterations

    if n == 1:
        return("Not prime")
    Elif n == 2:
        return("Prime")

    while a * a <= n + 1:
        inner_loop_iterations += 1
        # This if statement reduces the number of inner loop iterations by roughy 50%
        # just weeding out the even numbers.
        if a % 2 == 0:
            a += 1
        else:
            a += 2

        if n % 2 == 0 or n % a == 0:
            return ("Not prime")
    else:
        return ("Prime")

while True:
    sys.stdout.write("Enter number to see if it's prime ('q' to quit): ")
    n = input()
    if not n:
        continue
    if n == 'q':
        break

    try:
        n = int(n)
    except ValueError:
        print("Please enter a valid number")

    if n < 1:
        print("Please enter a valid number")
        continue

    sys.stdout.write("{}\n".format(is_prime(n)))
    sys.stderr.write("Inner loops: {}\n\n".format(inner_loop_iterations))
    inner_loop_iterations=0

Ce programme a deux optimisations principales, d’abord il ne fait qu’itérer de 2 à la racine carrée de n et il ne fait que itérer des nombres impairs. En utilisant ces optimisations, j'ai pu découvrir que le nombre 1000000007 n'était primordial que dans 15811 itérations de boucle.

0
Sonny Parlin

Faisons encore quelques améliorations.

  1. Vous savez que 2 est le seul nombre premier pair, vous ajoutez donc 2 à votre liste et commencez à 3 en incrémentant votre nombre pour qu'il soit vérifié par 2.
  2. Une fois que vous avez dépassé le point milieu (voir les exemples ci-dessus sqrt et *), vous n'avez plus besoin de tester un nombre premier.
  3. Si vous utilisez une liste pour garder la trace des nombres premiers, il vous suffit de diviser par ces nombres premiers.

J'ai écrit mon code et chacun des éléments ci-dessus améliorerait mon temps d'exécution du code d'environ 500%.

prime_list=[2]
def is_prime(a_num):
    for i in prime_list:
        div, rem = divmod(a_num, i)
        if rem == 0:
            return False    
        Elif div < i:
            break;

    prime_list.append(a_num)        
    return True
0
Omid
for i in range(2, p):
    if p%i == 0:
        p=p+1 
     print "%s" % p,
     p=p+1

Je vais raconter votre erreur seulement, à la ligne 3, vous augmentez p, mais en fait, ce qui vous manque, c’est votre i si votre i dans l’affaire précédente est disons 13, il vérifiera votre boucle après 13 mais laissera 2,3. , 5,7,11, c’est donc une erreur. C’est ce qui se passe dans le cas d'un 27, votre 13 avant 27 est maintenant 13 et il va maintenant vérifier à partir de 14.et je ne pense pas que vous ayez besoin d'une solution.

0
mayank
def is_prime(n):
    if n>=2:
        for i in range(2, n):
            if n%i == 0:
                return False
        return True
    else:
        return False

Pour trouver le numéro de prime

0
John Haggin
def findprime(num):
  count = 0
  for i in range(1,num+1):
    list1 = []
    for ch in range(1,i+1):
      if i%1==0 and i%ch==0:
        list1.append(ch)
    if len(list1)==2:
      count += 1
      print(i,end=", ")
  print()
  return count  
num2 = int(input("enter a number: "))
result=findprime(num2)
print("prime numbers between 1 and",num2,"are",result)
0
brilliant