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.

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.

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)

A string is a sequence too; you can unpack a string into separate characters:

>>> a, b = 'cd'
>>> a
'c'
>>> b
'd'

The ValueError is raised because a string of length 1 cannot be unpacked into two targets.

When looping over a sequence of integers, however, you are trying to unpack each integer value into two targets, and integers are not iterable at all. That's a TypeError, because this is directly connected to the type of object you are trying to unpack:

>>> a, b = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Compare this to strings, lists, tuples, iterators, generators, etc. which are all types that are iterable.

If you wanted to unpack the set directly, don't use a for loop:

>>> a, b = set([1, 2])
>>> a
1
>>> b
2

but do know that sets have no fixed order (just like dictionaries), and in what order the values are assigned depends on the exact history of insertions into and deletions from the set.

Python exceptions can be caught in this way:

try:
<your code>
except <Exception>:
    <CODE 2>

OR LIKE THIS

try:
    <your code>
except(<exception1>,<exception2>):
    <Code to handle exception>

You are simply handling multiple exceptions together. You can always split them. They are not 2 different ways. In your case the as is for logging it .

Here are a few examples:

try:
    <code>
except TypeError:
    <Code for handling exception>
except ValueError:
    <Code for handling exception>
except ValidationError:
    <Code for handling exception>
except:
    <Code for handling exception>

In the last case it catches exception of any type since no type is specified.
In Python programs can raise any exception for anything.
In fact exception is just a special class, even you can create one for your library.

So the best way to find about the exception is to read the docs of the library not the exception class.

If your program catches the exception and wants more detail about it for creating a log file the code can be written like this.

except TypeError as e:
    i=str(e)

In this case you are catching the exception and converting its detail to a string.
This is from the Django docs about the error which you are talking about.

Form validation happens when the data is cleaned. If you want to customize this process, there are various places to make changes, each one serving a different purpose. Three types of cleaning methods are run during form processing. These are normally executed when you call the is_valid() method on a form. There are other things that can also trigger cleaning and validation (accessing the errors attribute or calling full_clean() directly), but normally they won’t be needed.

In general, any cleaning method can raise ValidationError if there is a problem with the data it is processing, passing the relevant information to the ValidationError constructor. See below for the best practice in raising ValidationError. If no ValidationError is raised, the method should return the cleaned (normalized) data as a Python object.

Some further references:

The link to docs
This link has info about other common builtin exception classes.