Develop Reference

Why, using "and" in a for loop and "or" in a while loop gives the same result?

I am trying to practice writing these loops, and I had an exercise which asked me to print numbers from 0 to 20 that aren't divisible by 3 or 5.
For the while loop, I wrote this code:
#solution with while
i = 0
while i < 21:
i += 1
if i % 3 == 0 or i % 5 == 0:
continue
print(i)
Whereas, for the for...in loop, I struggled because I found out that I needed to use and instead of or here.
The code is as follows:
#solution with for
for k in range(21):
if k % 3 != 0 and k % 5 != 0:
print(k)
Why did I have to change the logical operator?
In my head, the first rows of the two codes do the same thing, iterate a number from 0 to 20. So the condition, after these, should be equal for both the iterations used.
Can anyone explain to me what am I missing here?

This isn't a loop type problem, the issue is in using different equality operators in your conditions - != instead of ==.
After changing or to and, the result stays the same because you've accidentally used De Morgan's second law (negation of disjunction):
Now, let's look at the code.
In the while loop:
the program doesn't print i:
if it's divisible by 3 (but not necessarily by 5)
or
if it's divisible by 5 (but not necessarily by 3).
In other words:
the program prints i:
if it's not divisible by 3
and
if it's not divisible by 5.
Noe, let's check, what says the condition in the for...in loop:
the program prints k:
if it's not divisible by 3
and
if it's not divisible by 5.
Looks like the same condition, doesn't it?
As you noticed, in the In other words: paragraph, we've naturally used the negation of disjunction.
To sum up, both programs for i / k lower than 21 print:
0
1
2
4
7
8
11
13
14
16
17
19
If you still aren't sure, try to replace the conditions between loops:
i = 0
while i < 21:
i += 1
if i % 3 != 0 and i % 5 != 0:
print(i)
for k in range(21):
if k % 3 == 0 or k % 5 == 0:
continue
print(k)

In while loop.
if i % 3 == 0 or i % 5 == 0: # this means when i is evenly divided by 3 or 5 then don't do anything.
continue
print(i) # means only print i when i is not evenly divided by 3 and 5
And in the for loop
if k % 3 != 0 and k % 5 != 0: # here this means print i when k is not evenly divided by 3 and 5. Which same as while loop
print(k)
You just reverse order and nothing. You can use the same method in both way and you will get the same result.
While loop
i = 0
while i < 21:
i += 1
if i % 3 != 0 and i % 5 != 0:
print(i)
For Loop
for a in range(21):
if a % 3 != 0 and a % 5 != 0:
print(a)

Because you have also changed the conditions for the results in the while loop you have used ==, but in for loop you have used != if you modify the code you will get the same output by or operator in both
for k in range(21):
if k % 3 == 0 or k % 5 == 0:
continue
print(k)

The two loop types are totally equivalent. You had to use and instead of or, and != instead of ==, because you reversed the logic.
In the first case, you are saying "if the number is divisible then skip it, else print it" while in the second one_ "if the number is not divisible then print (else do nothing)"_.

how to use while loop?

number = 50
while number >= 0:
if number % 5 == 0:
print(number)
number = number - 1
elif number % 5 == 1:
continue
number = number = number - 1
the answer it's giving me is 50 then the loop stops executing
Here is the program I am trying to make:
While Loops Practice #2
Create a While Loop that subtracts one by one the numbers from 50 to 0 (both numbers included) with the following additional conditions:
If the number is divisible by 5, show that number on the screen (remember that here you can use the modulus operation dividing by 5 and checking the remainder!)
If the number is not divisible by 5, continue executing the loop without showing the value on the screen (don't forget to continue subtracting so that the program doesn't run infinitely).

Here is your code, improved:
number = 50
while number >= 0:
if number % 5 == 0:
print(number)
number = number - 1
I'm confused about that too, but here are my thoughts: you only subtracted when number % 5 == 1, but it can also be 2, 3, 4 or 5.

num = 50
while num != 0:
if num % 5 == 0:
print(num)
num -= 1
would work for this as it will only print the number if it is divisible by 5, and always subtract.

Make sure you always subtract 1 from number before continuing the loop. As the prompt reminds you, this is especially important when you use the continue statement, since that brings you straight back to the top of the loop -- if you haven't subtracted before then, the loop will repeat infinitely!
One way to make sure that something always happens even if execution is interrupted (not just a continue but maybe a return, a break, a raise, etc) is try/finally:
number = 50
while number >= 0:
try:
if number % 5 == 0:
print(number)
elif number % 5 == 1:
continue
finally:
number -= 1
prints:
50
45
40
35
30
25
20
15
10
5
0
In this case, though, there's no need to immediately continue the loop, since there's nothing in the loop that you explicitly need to skip in the number % 5 == 1 case (note that this isn't the same as "not divisible by 5" -- what you're testing for here is "has a reminder of 1 after dividing by 5", i.e. 1, 6, 11, and so on, which isn't part of the problem statement).
You can therefore just do:
number = 50
while number >= 0:
if number % 5 == 0:
print(number)
number -= 1

The main structure is corret, but in the last line you wrote two times the code "number =" and "else" is useless in this case, because you need to substract 1 in every loop.
here's the code solved:
number = 50
while number != 0:
if (number%5) == 0:
print(number)
number = number - 1

I'm stuck with a prime number calculator

I'm reading a book about python programming for begginers.
One of it's tasks is to write a prime number calcutator that calculates 'n' prime numbers.
So far I've studied strings, logic gates, while and conditions.
The idea is to make it using only those operators.
I need help because I'm stuck with this code.
Here's what I've done:
odd = 3
number = 2
limit = int(input('How many primes do you need: '))
remnant = number % odd
even_remnant = number % 2
counter = 0
while counter <= limit:
if number == 2:
print('2')
number += 2
elif (number % 2) != 0:
remnant = number % odd
while odd < number:
print('while2')
remnant = number % odd
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
odd = 3
number += 1
counter += 1
break
elif (number % odd) == 0:
break
odd += 2
elif (number % 2) == 0:
number += 1
odd = 3
What do you think?
Thanks everyone.

Put your debugging pants on, we're going in.
First, the code doesn't run as it's written. The variables counter and impar are undefined. First step is to remove syntax errors like that. Looks like we want to start counter at 0 and the line that uses impar isn't necessary so we can delete it.
odd = 3
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
if number == 2:
print('2')
number += 2
elif (number % 2) != 0:
while odd < number:
print('while2')
remnant = number % odd
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
odd = 3
number += 1
break
elif (number % odd) == 0:
break
odd += 2
elif (number % 2) == 0:
number += 1
odd = 3
Now the code runs without error, but all it does is print
2
while2
And then fails to terminate.
So we know we enter the while odd < number loop only once and we don't print anything during that loop. If we also print the value of odd and number while we are in there we see odd = 3 and number = 5. Neither of the if conditions are met and the odd += 2 line is hit. Now odd = 5 and the while loop exits without printing 5 even though 5 is prime. If we want to hit our print statement by meeting the condition odd == (number - 1) we better go in steps of 1 when incrementing odd. Let's change to odd += 1 and re-run the code.
Now when I say I need 2 primes it prints
2
5
7
And then prints while2 forever. At least it prints prime numbers! But it skipped 3 and printed too many, and I had to use Ctrl-C to quit the program. Too many primes were printed because the outer loop while counter <= limit: condition was never reached. Inside the loop, we never increase the value of counter. Whenever we print a prime, we need to increase counter.
Also, to make sure we print 3, take a look at the first if condition in the loop.
if number == 2:
print('2')
number += 2 # Oops, we skipped over 3
Let's update this:
if number == 2:
print('2')
print('3')
counter += 2 # Let's count both of these!
number += 2
Also adding counter += 1 after the other print, re-running the code we get
How many primes do you need: 2
2
3
5.
How many primes do you need: 3
2
3
5.
7.
Oops, we are getting one more than we need. This is because when counter == limit we run the while loop one more time. Let's change our while loop condition to while counter < limit:. That change gets us just the right number of primes.
How many primes do you need: 4
2
3
5.
7.
But if we ask for 5
How many primes do you need: 5
2
3
5.
7.
And the program never exits. If we check the values of odd and number, we see that the loops is running with odd=3 and number=9 over and over again.
Reason through the code when odd=3 and number=9. We break out of the while odd < number while loop when we hit this code
elif (number % odd) == 0
break
But we never increase the value of number, so it is still equal to 9 the next time through the loop. Let's update this to
elif (number % odd) == 0
number += 1
break
Now when we re-run the code we get
How many primes do you need: 5
2
3
5.
7.
11.
Huzzah! And it works when asking for more primes as well. Here is the code as it is currently:
odd = 3
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
if number == 2:
print('2')
print('3')
counter += 2
number += 2
elif (number % 2) != 0:
while odd < number:
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
odd = 3
number += 1
break
elif (number % odd) == 0:
number += 1
break
odd += 1
elif (number % 2) == 0:
number += 1
odd = 3
Now that we have working code, let's improve it! One of our bugs was that we forgot to increase number by 1 in one case. Notice that no matter how we exit the outer while loop while counter <= limit: we want to increment number. So, instead of doing it in many places, let's move all of those to the end of the while block.
We also set odd=3 whenever exiting the while block. What we want to ensure is that odd=3 at the start of the while loop, so let's move that there. Now there is no more code in the elif (number % 2) == 0: block, so we can remove that line.
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 3
if number == 2:
print('2')
print('3')
counter += 2
elif (number % 2) != 0:
while odd < number:
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
counter += 1
break
elif (number % odd) == 0:
break
odd += 1
number += 1
I think the code is more clear if the while loop ends when the condition is met, rather than on break statements. We want the while loop to end if we find the number is divisible by something, or we run out of numbers to check.
`while number % odd != 0 and odd < number:`
And the only thing we need to do in the while loop is increment odd. Then after the loop, we can check the value of odd to see which condition was met.
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 3
if number == 2:
print('2')
print('3')
counter += 2
elif (number % 2) != 0:
while number % odd != 0 and odd < number:
odd += 1
if odd == number: # No divisor was found!
print(f'{number}.')
counter += 1
number += 1
Notice that we are "hard coding" the divisibility by 2 (number % 2) != 0 and then using the variable odd to check divisibility by everything else. If we start odd at 2 instead of 3, we don't have to do the hard coding.
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 2
if number == 2:
print('2')
print('3')
counter += 2
while number % odd != 0 and odd < number:
odd += 1
if odd == number: # No divisor was found!
print(f'{number}.')
counter += 1
number += 1
When we make this change, we also notice that we find the primes 2 and 3 twice, so we can remove the hard coded version of those:
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 2
while number % odd != 0 and odd < number:
odd += 1
if odd == number: # No divisor was found!
print(f'{number}.')
counter += 1
number += 1

When I try to run this code it tells me that Counter is not set, so right before entering the loop set Counter to 0.
Another problem is that you start by finding 2 in the first case of your loop, this is nice. Here after the loop runs again, now with number set to 4. Because of your += 2 instruction.
It then runs the last elif case. where (number % 2) == 0. here it set number = 5, and odd = 3. But it doesn't print 3. I think you mean to do this.
Now it runs the loop again, and enter the second elif case (number % 2) != 0.
The first line in the elif clause the variable impar is not defined so it will fail.

I can't understand your program but it's good
def is_prime(n):
st = "prime" # being prime status
for i in range(2,n):
if n % i == 0: # if number is prime
st = "not prime"
break;
return st
n = int(input("enter n: "))
pc = 0 # prime conter
c = 1 # counter
while n != pc:
if is_prime(c) == "prime":
print (c)
pc += 1
c += 1

To calculate 'n' number for prime numbers you needn't use so many statements, if you make use of the the arithmetic and logical or bit-wise operators, which you will be learning in the future chapters of the python book you're referring.
I shall help you by editing the code for you.
number = int(input("Enter range: "))
print("Prime numbers:", end=' ')
for n in range(2, number):
for i in range(2, n):
if n % i == 0:
break
else:
print(n, end=' ')

programing function in python

I'm trying to create a function that take two parameters: D = digit (0-9) and n = positive number.
If the D is parity number, the function should give me 0 but ,if the D is odd number, the function should count numbers of odd number I have in n.
There is a problem with this code but I don't know what:
def testD(D,n):
if D % 2 == 0:
return 0
count = 0
while n > 0:
if(n%10) %2==1:
count +=1
n=n/10
return count

I changed 2 things :
while n > 1: instead of while n > 0: otherwise your loop never stops
n=n//10 instead of n=n/10, where // is the euclidian division, which is what you need here
You should try this :
def testD(D,n):
if D % 2 == 0:
return 0
count = 0
while n > 1:
if(n%10) %2==1:
count +=1
n=n//10
return count
print(testD(7, 555))
# output : 3 (because 7 is odd, and there is 3 odd digits in 555)

While Statement(no result in shell)

My program should print the sum from even numbers from 2 to 10, but when I pass even_while() in the shell I don't see any result. Which is the problem?
def even_while():
number = 2
s = 0
while number < 10:
if number % 2 == 0:
old_number = number
number = number + 1
s = s + old_number
print(s)
Thanks!

"Infinite loop". number starts as 2. That's even, so add 1 to it. That leaves number as 3. Now the while loop goes around "forever". number % 2 == 0 is never true (number is 3!), and number never changes again.

You don't increment number unless number % 2 == 0, so the while loop doesn't make any progress.
Additionally, you might enjoy the range builtin:
def even_while():
s = 0
for number in range(2, 10):
if number % 2 == 0:
old_number = number
s = s + old_number
print(s)

def even_while():
number = 0
s = 0
while number < 11:
number = number + 1
if number % 2 == 0:
old_number = number
s = s + old_number
print(s)
I think this is ok.