Commande de l'évaluation à l'aide booléenne ou

Question

J'ai ce bout de code. Et cela fonctionne (Il dit 1 est non-prime).

n = 1
s = 'prime'
for i in range(2, n / 2 + 1):
    if n == 1 or n % i == 0:
        s= 'non-' +s
        break

print s

Mon problème est que si je change la quatrième ligne à: (. Il dit 1 est premier) if n % i == 0 or n == 1:, il ne fonctionne pas

Pourquoi? Depuis que je suis en utilisant or devrait-il que l'un d'eux est vrai si l'ordre ne compte pas?

(je suis encore à apprendre au sujet booléen donc je formulerai une erreur de base.)

Merci à l'avance!

EDIT: Merci pour les réponses; Je ne ai jamais réalisé mon problème avec la fonction range(). Et à propos du code de travail et ne fonctionne pas: Je ne sais pas ce qui est arrivé. J'ai fait une erreur quelque part de le long du chemin (peut-être oublié d'enregistrer avant d'exécuter le script Bien que j'aurais juré que cela a fonctionné différemment. P). Peut-être que je suis juste fatigué ...

Merci pour les réponses toute façon!

Answer 1

La priorité est bien. % est évalué d'abord, puis ==, puis or, il se décompose en:

     ___or___
    /        \
  ==          ==
 /  \        /  \
n    1      %    0
           / \
          n   i

Votre problème est que votre boucle de for n'est pas exécuté du tout, de sorte que s est toujours réglé sur "prime".

Le 2,n/2+1 de plage lorsque n est de 1 correspond à 2,1 qui se traduira par l'organisme non en cours d'exécution.

En fait, il ne sera pas exécutée où n est 2 soit depuis 2/2+1 est 2 et la 2,2 gamme n'exécute pas. Les valeurs sont le début et mettre fin à la valeur, ne démarre pas et à la fin (dernière) valeur - il est juste que fortuite il 2 est considéré comme un premier en vertu de l'initialisation du s: -)

Essayez ceci:

#!usr/bin/python

n = 9
s = 'prime'
if n == 1:
    s = 'non-prime'
else:
    i = 2
    while i * i <= n:
        if n % i == 0:
            s= 'non-prime'
            break
        i = i + 1
print s

Il est inutile d'aller tout le chemin jusqu'à n/2, la racine carrée de n est tout ce qui est nécessaire.

Answer 2

Dans les deux cas, le corps de la boucle ne fonctionne pas, parce que, quand n 'est 1, il ne tombe pas dans la gamme de (n, n / 2 + 1)

Le code affiché indique que 1 est premier (encore une fois, parce que le corps de la boucle n'exécute pas du tout)

Answer 3

i pense que le problème est lorsque n est égal à 1, la boucle est sautée.

Answer 4

D'autres réponses déjà correctement répondu à votre problème spécifique (qui, autrement dit, est que les exécute en boucle que si la n/2 + 1 > 2, qui est, n/2 > 1 qui moyens n > 2 avec division new-style [[python 3 ou les importations appropriées de l'avenir ou drapeaux ...]], avec n > 3 division tronquer style classique).

Wrt la question spécifique que vous avez posée:

  

Depuis que je suis en utilisant ou faut-il que   l'un d'eux est vrai si la   pour ne compte pas?

L'ordre fait count parce que or (comme and) est un opérateur court-circuit: en particulier, or est garantie pour aller à gauche à droite, et l'arrêt si la gauche opérande est vrai (car il n'a pas besoin de savoir sur le bon). Cela n'a pas d'importance pour votre code spécifique, mais il est crucial dans des cas tels que, par exemple:.

if i == 0 or n / i > 3: ...

Si or n'a pas été en cours à droite à gauche (et l'arrêt le plus tôt possible), l'opérande de droite peut s'exécuter même lorsque i est égal à 0 - mais la division soulèverait une exception! Avec les règles de Python, cet extrait de code ne générant des exceptions (si i est un entier, au moins; -)

.

Encore une fois: cela n'a rien à voir avec le problème spécifique que vous rencontrez (voir d'autres réponses et le début de celui-ci), mais il est important pour vous de savoir pour l'avenir, donc, puisque vous avez demandé, je pris la possibilité d'expliquer -)

Answer 5

for n in range(101):
    s = 'prime'
    if n < 2 or not (n & 1): ## not(n & 1) == is even number (last bit 0) == not (n % 2) 
        s = 'non-'+s
    else:
        for i in range(3, int(n**0.5) + 1,2):
             if not(n % i):
                 s= 'non-' +s
                 break
    print "%i is %s" % (n,s)

Vous ne vérifie pas tous les nombres pairs et vous pouvez arrêter la procédure à la racine carrée de n.