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

Even if syntax errors were included, I don't think most of us see those often because our IDEs/editors tend to practically scream about them before we even run the code. Beyond beginners, in my experience they're a rarity. Since I make heavy use of type hints, type errors are also very rare to me nowadays. Truthfully I don't know for sure what errors I run into the most often, but a good guess would be value errors. If I'm using a library or framework I've not really used before, if the documentation is lacking it's not uncommon for me to proceed with trial and error sometimes. I try something that sounds reasonable to me, sometimes that works and other times it yells at me when I provide a value it's not happy with. More on reddit.com

Most errors are not syntax errors. A syntax error means your code cannot be executed at all, because it cannot be parsed. But most errors are runtime errors, in that they happen during the course of running your program. A good example is an IndexError; if you try to access the second element of a list that only has one element, you will get an error. But if you expect that might happen, you can catch that error and handle it, say by using a default value. More on reddit.com

Not quite an error message, but this one boils my blood every time: $ python >>> exit Use exit() or Ctrl-D (i.e. EOF) to exit I mean come on python, you knew exactly what I meant, why not just do the god-damned thing? Every other REPL in the world implements an exit keyword, why you gotta be the special snowflake? More on reddit.com