So I guess it’s something wrong with my understanding of Input command Kind of, but also no. The reason the code asks for input three times is because Each if/elif calls the function separately, and None of the conditions are true. The reason why the conditions fail is not because of input, but because you've misunderstood what the or-operator does here. The code isn't comparing the input to each of the listed cases, instead, if input ("What's your name?") == (("Bill") or ("Andrew") or ("Son") or ("Bella")): print ("You passed") is actually read by Python as if input("What's your name?") == "Bill": print ("You passed") due to short-circuiting. or is roughly equivalent to def my_or(left, right): if left: return left return right and because all non-empty strings are truthy, Python simply takes the first one and ignores the rest. So, how should you write this? My suggestion; use a tuple or a set and check inclusion with in: name = input("What's your name?") if name in {"Bill", "Andrew", "Son", "Bella"}: print("You passed") The rest of the conditions should use the already asked input, stored in name in my example. More on reddit.com

The short answer is "because input takes input from the keyboard, and what the keyboard outputs are characters." But, of course, we could just try to coerce every input string into a float, and if that doesn't work, then coerce it to an integer, and if that doesn't work, it must be a string. Right? You're assuming that an interpretable sequence of digits and periods should always be numeric. What if it's part of an IP address? What if it's an [accession number]( https://en.wikipedia.org/wiki/Accession_number_(cultural_property) )? "1992.10" isn't the same accession number as "1992.1", but as floats they're ambiguous. Not everyone uses periods as a decimal separator; commas are commonplace outside of the US. Why stop with numerics? There are lots of literal types - lists, dictionaries, sets, etc. There's even math - should we interpret "19 - 6" as a string, or as the number 13, and why should we do so? You're not wrong to think "well, actually we should try to evaluate any inputted string as a Python literal, what a convenience that would be" and indeed they agreed with you in Python 2. That's the behavior of input in Python 2, it attempts to evaluate the input to arrive at a value. The result was a ton of errors that beginners didn't really understand, because input doesn't say that it attempts to evaluate all input, except in the documentation and beginners don't read that. But beginners are the only ones who write code using input. That's Python training wheels - real programs don't need it, they either expose a GUI for input or they take their input as command-line arguments, not via prompts. In any case, what people mostly did was use raw_input instead of input in Python 2 to disable the implicit evaluation, since it's almost never what anyone actually needed. So the evaluating version of input was bad - it was more likely to break, and when it broke, it broke for the programmers least likely to understand why. In Python 3, the evaluating version of input was replaced by raw_input's non-evaluating version, raw_input went away altogether, and now there's no ambiguity about what input does or doesn't do. So, we ran the natural experiment - the reason input doesn't coerce to anything besides a string is that nobody actually wants it to. More on reddit.com

That is correct. As a general rule of thumb, your functions shouldn't care where the data is coming from. As soon as you use input within a function, that function can only ever be used to take data from input; even if it doesn't actually care where the data is coming from. This means this function can't be used if the data is coming from, say, the disk, or from over the network. In other words, you make the function less useful by enforcing where it gives/takes data to/from. Functions should take data, and give back data. Ideally, avoid taking input via side effects (like input), and avoid giving data back via side effects (like mutating globals). At some point in your program, you obviously need to call input (or wherever else you're getting data from), but the point where IO happens should be somewhat isolated. The IO code takes/gives data from/to the outside world, and passes that data to the pure functions that process it (and those pure functions ideally make up the majority of your code). And I'm not sure where you'd best learn about guidelines like this. I know of it from experience, and because I know Haskell. Haskell enforces this "rule" at the type-system level. The type-system actually prevents you from calling Haskell's equivalent of input in any old function unless you're willing to contaminate your entire program with IO, or use the unsafe backdoor that allows it. More on reddit.com

Think of it as the literal same thing as math. f(x) -> some something with x and give it back. def(x) -> do something with x and return it. More on reddit.com