Just to make things clear. input("x: ") always returns a string. It can be "123" or "bananas". In the first case, it can be converted to an integer. In the second case, it cannot, and a ValueError is raised. But in either case the type is fine for the int function. So this is a value error, not a type error.

A Value error is

Raised when a built-in operation or function receives an argument that has the right type but an inappropriate value

the float function can take a string, ie float('5'), it's just that the value 'string' in float('string') is an inappropriate (non-convertible) string

On the other hand,

Passing arguments of the wrong type (e.g. passing a list when an int is expected) should result in a TypeError

so you would get a TypeError if you tried float(['5']) because a list can never be converted into a float.

Cite

@Liam Hayes (https://teamtreehouse.com/liamhayes) Hi! I have a note about @Steven Parker (https://teamtreehouse.com/stevenparker)'s example (especially the second one). When I was trying to wrap my head around this, I could not for the life of me understand why the built-in function for changing something to an int would give a ValueError with a string as opposed to a TypeError. Surely, it's expecting a number, right? Well, no. It isn't. The int() function takes either a number or a string. It can convert the string "21" to the integer 21, but it can't convert "dog" to a number. Thus, it's getting the right type, but it's still not a value that it can convert. This is when we get the ValueError. It's of the right type, but the value is such that it still can't be done. That being said, if we tried to send in something that was neither a string nor a number, it would have generated a TypeError as it is of the wrong type. Hope this helps! :sparkles: edited for additional note In your own custom made functions, you can pass in whatever you want, although ideally, you know what you're passing in. This is not true of built-in functions in Python. When in doubt, check the documentation for the function in question.

As in most programming languages, Python has multiple kinds of errors. ValueError usually refers to an invalid value passed into a function, e.g. if you try to execute the statement int('a'), Python will throw a ValueError ('a' is not appropriate for converting into an integer). TypeError refers to a mismatch in types. (Types are the "kinds" of values, e.g. numbers [integers], decimals [floats], pieces of text [strings], etc.) For example, if you try to add an integer to a string, you get a TypeError. Python throws a NameError if you try to access a non-existent variable. A list of built-in errors can be found in the official Python documentation (https://docs.python.org/3/library/exceptions.html)

In python it is valid to pass a string type to the int function. However, if it cannot be parsed to an integer you will get the ValueError you have described.

You may want to wrap your attempt to parse a string to an integer in a try catch construct, such as seen here: How do I parse a string to a float or int?

ValueError inherits from Exception. You can decide to trap either only ValueError, or Exception, that's what exception inheritance is for.

In this example:

try:
    a=12+"xxx"
except Exception:
    # exception is trapped (TypeError)

exception is trapped, all exceptions (except BaseException exceptions) are trapped by the except statement.

In this other example:

try:
    a=12+"xxx"
except ValueError:
    # not trapped

Here, exception is NOT trapped (TypeError is not ValueError and does not inherit)

You generally use specific exceptions to trap only the ones that are likely to occur (best example is IOError when handling files), and leave the rest untrapped. The danger of catching all exceptions is to get a piece of code that does not crash, but does nothing.

(editing the answer in response to your edit:) when you raise an exception: you're creating an instance of Exception which will be filtered out by future except ValueError: statements. the message is different because the representation of the exception (when printed) includes the exception class name.