Some lines of code - mostly function and method calls - are "risky", in the sense that under certain circumstances they aren't guaranteed to succeed. The most risky functions are those that rely on another system succeeding at a task. For instance, if you ask a remote server for a response, you're relying on the remote server to successfully respond. What if it doesn't? What if I've reached over and turned the power off just as you've sent the request? What if the internet stops working at that time? A function relates input to output - the input are the function's parameters, and the output is the return value. But that makes the assumption that a function always yields the return value demanded by its arguments. How does a function indicate when it won't be possible to return that value? That's what exceptions are for - they're a way for the function to terminate in an "exceptional" way, that is, a way that is an exception to the normal operation of the function. Since the exception isn't a return value of the function, but a different and special way for the function to terminate, we use a different term to describe yielding an exception - we say that a function throws an exception. This should bring to mind the idea of "throwing your back out" or "my car threw a piston rod", in the sense of how it indicates something has gone wrong. In other languages, functions that can throw exceptions have to declare that they do, which puts the risks of calling the function up-front but it also requires that when you call those functions, you make some decisions about what to do with exceptions. This is a little bit of an unreasonable expectation on new programmers so Python doesn't require either of these things, and so you should assume that a function might throw an exception if it would be reasonable for it to do so under certain circumstances. Adding two numbers isn't going to throw an exception. Making a remote procedure call on another system is going to throw different kinds of exceptions based on the myriad ways that can go wrong (the system doesn't exist, the system refuses to comply, the system doesn't know how, etc.) When you call a function and it throws an exception, if you don't immediately handle the exception, your function will terminate as well. It'll throw the exception "up" the calling chain, up to the very top level of your program where, if the exception isn't handled, it'll crash your program. This is an important safety tool because it prevents your program from continuing in an undeterminable state. If you want to try to handle the exception - it's predictable and there's some reasonable action your code can take in response, like try again in a couple of seconds or something - then you can use a "try/except" block to enclose the logic that may throw an exception, and handle it if it does. You can choose which exceptions you want to handle via declaration and you can handle different exceptions differently. Or you can handle some and not others. More on reddit.com

I come from Java where Exceptions and Errors are quite different things and they both derive from something called Throwable. In Java normally you should never try to catch an Error. In Python thou... More on stackoverflow.com

About the equality check returning True instead of False in if-clauses: I think python protects against using = instead of == and raises a SyntaxError. More on reddit.com

Really, this list is endless. The number of ways a new programmer can screw up is limited only by your imagination. Some things off the top of my head though: A misunderstanding of how = and references work. They think it makes copies, and reassigning references in functions will effect the passed argument. Uses mutable default arguments without understanding why that's almost always a bad thing. Doesn't close resources when they're done with them/doesn't use with to manage resources when with is appropriate. Uses list comprehensions to carry out side effects instead of to produce a list. Doesn't follow PEP8 or any style guidelines consistently. Uses except: without understanding why that's so dangerous. And, catches exceptions but doesn't actually handle the error properly. Uses for i in range(len(coll)): instead of for elem in coll: when the latter is appropriate. Those are just the ones I could think of in a couple minutes. There's likely many more. More on reddit.com