Largest odd number

The key point here: each step in the process does just one simple thing. You build programs that way -- one incremental, tightly defined step at a time. Don't mix everything in a jumble -- e.g. a loop where we interact with a user while also making conversions and calculations needed later.

def as_int(s):
    try:
        return int(s)
    except Exception:
        return 0

N = 3
MSG = 'Enter number: '

replies = [input(MSG) for _ in range(N)]  # Interact.
nums = [as_int(r) for r in replies]       # Convert.
odds = [n for n in nums if n % 2]         # Compute.

if odds:                                  # Report.
    print(max(odds))

I'll try to build on the last suggestion of the accepted answer.

while True:
    try:
        x = int(input("Enter a number: "))
        break
    except ValueError:
        continue

I definitely endorse this suggestion, it allows your program to handle invalid input gracefully instead of just crashing.

However, it creates an usability problem. The user who just typoed a letter into a number probably did not notice it. They'll think they got the intended number in, proceed with the next, and then get confused at the end, when they think they got all numbers in, but the computer is still asking for the next one.

Better to give them feedback:

while True:
    try:
        x = int(input("Enter a number: "))
        break
    except ValueError:
        print("Invalid number will be ignored.")
        continue

... or even better, print their typoed number back at them:

while True:
    try:
        inputString = input("Enter a number: ")
        x = int(inputString)
        break
    except ValueError:
        print("Invalid number will be ignored: {}".format(inputString))
        continue

I would also consider keeping the full list of valid numbers entered, not just odd ones, and printing them all back at the user before the result, to give them a last chance to spot typos. They can, after all, have mistyped a valid but unintended number. Note that this would increase memory usage, and some would consider it over-communication.

print("Numbers provided are: {}".format(all_valid_numbers_inputted))
if not odds:
    print("No odd number was entered")
else:
    print("The largest odd number is:", max(odds))

If you do this, the next step would be to get rid of the "odds" variable, and figure out the largest odd directly from the full list.

May I ask what programming language did you practice before python?
I want to mention a one-liner for this:

max(l,key=lambda x:(x%2,x))

assuming you already have l somehow inputed, like

s='Enter a number: '
l=[int(input(s)) for i in range(10)]

How does the code work? It looks for maximum of key(x) for x in l and returns such x. Key here is the lambda function that returns tuple (1,x) for odd x and (0,x) for even x. Tuples are compared left to right, e.g. (1,x)>(0,y) for every x and y. So we are just saying "give me the maximum of l, assuming that an odd number is always larger than an even number".

So all program will look like

s='Enter a number: '
l=[int(input(s)) for i in range(10)]
m=max(l,key=lambda x:(x%2,x))
if m%2:
    print('The largest odd number is: %d'%m)
else: #the greatest is even, therefore no odd numbers
    print('No odd number was entered')

Short, nice and easy, as python.

But I agree that a try-except block around int(input()) form the accepted answer is useful, along with no pre-storing the entire list of odd values.

I only wanted to demonstrate the paradigm of functional programming in python, when you just tell python 'I want that done (e.g. a maximum value)' and it does it for you, you don't need to explain how should it do it.

Thanks for reading.

Adding to the previous review:

• When x is an integer, abs(x) % 2 is equivalent to x % 2 in Python. The output of the modulo operator % has the same sign as the second operand.
• When running code outside a method / class, it is a good practice to put the code inside a main guard. See here for more explanation.

In Python 3.8, the code can be shortened using the assignment operator := together with max function.

if __name__ == "__main__":
    # Number generator
    num_gen = (o for _ in range(10) if (o := int(input("Enter a number: "))) % 2 != 0)
    max_odd = max(num_gen, default=None)
    if max_odd is None:
        print("No odd number was entered")
    else:
        print(f"The largest odd number is: {max_odd}")

Wrapping int(input("Enter a number: ")) into a function provides better readability:

def read_input() -> int:
    return int(input("Enter a number: "))

if __name__ == "__main__":
    num_gen = (o for _ in range(10) if (o := read_input()) % 2 != 0)
    max_odd = max(num_gen, default=None)
    if max_odd is None:
        print("No odd number was entered")
    else:
        print(f"The largest odd number is: {max_odd}")

Another variant that handles invalid user inputs is as follows:

def read_input() -> int:
    while True:
        try:
            return int(input("Enter a number: "))
        except ValueError:
            continue

if __name__ == "__main__":
    try:
        max_odd = max(o for _ in range(10) if (o := read_input()) % 2 != 0)
        print(f"The largest odd number is: {max_odd}")
    except ValueError:
        # Since read_input() no longer raises ValueError, the except
        # statement here only handles the cases where max() gets no inputs
        print("No odd number was entered")