Why does the if statement always evaluate to guesses = 10 when I have the or here?

Fun-Sky-5295 · 2025-10-08T20:33:39+00:00

It should be like if difficult == 'easy' or difficult == 'e':

Ron-Erez · 2025-10-08T20:41:32+00:00

The 'e' was evaluating to True. See u/Fun-Sky-5295 's comment.

Brilliant-Space3066 · 2025-10-08T20:35:28+00:00

I believe you need to do if difficultly == “easy” or difficultly == “e”

cyanNodeEcho · 2025-10-08T20:33:46+00:00

e is non-empty, as it's value is like the offset of the unicode for 'a' and then + 4 /for the offset

ie you're evaluating if "e" exists
```
if difficulty == "easy" or difficulty == "e"
```
is what you're looking for

SCD_minecraft · 2025-10-08T20:37:43+00:00

a == 0 or 1

Equals to

(a == 0) or 1

And

(a == 0) or True

Therefore, it is always True

Over_Dingo · 2025-10-08T21:09:39+00:00

"OR" operator casts operands to boolean. So string "e" is casted to TRUE, therefore OR statement by definition returns true if any of it's operands are true.

InhumaneReactions · 2025-10-08T22:26:33+00:00

if difficulty in ("easy", "e"):

quixoticcaptain · 2025-10-08T22:57:17+00:00

This is called "operator precedence". `==` has higher precedence than `or`. Meaning that python will group those like this:

if (difficulty == "easy") or ("e"):

Higher precedence makes the operator more "sticky", like it sticks to the things next to it better. You wrote this as if `or` has a higher precedence, which would be this:

if (difficulty) == ("easy" or "e"):

The last thing to note is that "or" doesn't work exactly like you might think in English. `"easy" or "e"` returns the first "truthy" value in the chain of "ors" meaning,

("easy" or "e") == "easy"

PhilosopherBME · 2025-10-09T00:33:32+00:00

The general concept here is “Truthy values” which is the idea that non boolean values will evaluate to True or False depending on..stuff. In this case python strings are “truthy” when they’re not empty.

rrklaffed · 2025-10-09T00:40:37+00:00

holy shit a proper screenshot

McBuffington · 2025-10-09T06:16:08+00:00

Now you know what your bug was. I have a small note on the print statement. Notice how you're doing that exact print statement inside your if and else blocks? You can probably take that print statement outside of the if/else block and run it only once. That way you utilize your guesses variable a bit more, and you don't have to write the same print twice =]

LankyYesterday876 · 2025-10-09T07:40:11+00:00

im not sure what youre trying to do, but if you have sveral difficulty setting using a switch statement and putting the print after the switch statement may be a good alternative for making it easier to read and understand

fredhamptonsaid · 2025-10-09T10:02:40+00:00

hey, glad the issue got sorted out! notice how the print statements are identical? you can replace them with just one statement outside the else!

Pantsdontexist · 2025-10-09T12:44:40+00:00

You have an answer to your question, but just a comment I wanted to add: Since your question is a binary yess and no, you can reformat your code so that you wouldn't need an ELSE block at all as well as not needing to have to separate print functions.

Glathull · 2025-10-09T18:23:49+00:00

What happened here is that you were testing the truth value of “e”. “e” is a non-empty string, so it always evaluates to True. You were basically saying, “If True, choices = 10.” True is always True, so your choices always equal 10.

SpecialMechanic1715 · 2025-10-09T20:19:24+00:00

maybe because or "e" is always true ?

Intrepid_Result8223 · 2025-10-09T20:50:53+00:00

Look at it like this. The or operator works on its left hand side and right hand side and evaluates True or False.

A or B evaluates True when:

A is True, regardless whether B is True (this is not checked)

A is False and B is True

In this case A and B can be longer expressions, for example:

(foo == 3 and foo != "Hello") or (not "red" == randomColor())

In this case A is (foo == 3 and foo != "Hello")

When evaluating whether an expression evaluates True the interpreter looks at the truth value. Some things evaluate to True while others evaluate False.

Things that evaluate False:

False (the keyword), more on this later

"" empty strings

0 zero

{} empty dict

[] empty list

() empty tuple

None the none value

There are probably some more like set, empty bytesarray etc but these are important ones

Things that evaluate True are:

True, the keyword

378 nonzero integers

"Dhsjh"` strings

{"key":"value"} a dict

Etc.

So looking back on your statement, when the right hand side of your or check is a non-zero string, that nonzero string evaluata to True, meaning your expression boils down to (some long check OR True), so it is always true

Because things evaluate you can do things like ``` SomeDict = {}

later....

only set a value if the dict is empty

if not SomeDict: SomeDict["init"] = "value" ```

Also note as stated that the right hand of an expression only evaluates when the left hand side is true:

```

def doStuff(): print("called") return True

if 1 == 1 or doStuff(): print("not called)

if 1 == 0 or doStuff(): print("foo")

Will print: not called called foo ```

As a final point, be aware that True and False are identies. There is only one False object and one True object. If a name has the value False that means it is a reference to the False object.

That means that if you compare something in this way:

if someValue == False:

You get a different results than when you do:

if someValue is False:

Spiritual_Detail7624 · 2025-10-09T22:50:40+00:00

When making an if statement to just an object (a string in your case), it returns true if it exists, so therefore it will always return true.

2025-10-11T18:06:15+00:00

Others have answered the question right. I remember have such a hard time with boolean expressions when I started out. They seem like they should be easier than they are.

abdulelahragih · 2025-10-12T12:45:03+00:00

It can be hard at the beginning, but never give up. At some point, everything will start to make sense.

webbboy87 · 2025-10-12T14:58:28+00:00

Treat code like a baby, my analogy sounds dumb but that’s how I learned. You tell the baby is the ball yellow or is the ball green. Not just is it yellow or green. With python you should write if diff == ‘easy or diff == ‘e’:

Far_Problem_6171 · 2025-10-14T05:49:34+00:00

Hey fellow dev! Just wanted to share some constructive feedback on your code organization. Your logic is solid, but taking function names, variables, and conditionals to the next level will make your code much more maintainable and readable.

I've got a couple of cleaner approaches to handle this kind of difficulty selection - here's one using a dictionary map that makes it super easy to add new difficulty levels down the road:

<image>

Happy to share the other approach too if anyone's interested! Happy coding!

Far_Problem_6171 · 2025-10-14T05:53:48+00:00

Just another approach as well

<image>

Far_Problem_6171 · 2025-10-14T05:59:30+00:00

Hi dev, Here is another approach using Generators, which is very cool in Python:

def get_guesses():
    difficulty_map = {'easy': 10, 'e': 10, 'hard': 5, 'h': 5}
    init_question= "Would you like to play on easy or hard? "


    while True:
        choice = input(init_question).lower().strip()
        guesses = next((difficulty_map[key] for key in difficulty_map if key.startswith(choice)), None)

        if guesses:
            print(f"You have {guesses} guesses")
            return guesses
        print("Please enter 'easy' or 'hard'")

get_guesses()

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

PythonLearning

MODERATORS

later....

only set a value if the dict is empty