Python for Data Science For Dummies Cheat Sheet

Every developer on the planet makes mistakes. However, knowing about common mistakes will save you time and effort later. The following list tells you about the most common errors that developers experience when working with Python:

• Using the incorrect indentation: Many Python features rely on indentation. For example, when you create a new class, everything in that class is indented under the class declaration. The same is true for decision, loop, and other structural statements. If you find that your code is executing a task when it really shouldn’t be, start reviewing the indentation you’re using.

• Relying on the assignment operator instead of the equality operator: When performing a comparison between two objects or value, you just use the equality operator (==), not the assignment operator (=). The assignment operator places an object or value within a variable and doesn’t compare anything.

• Placing function calls in the wrong order when creating complex statements: Python always executes functions from left to right. So the statement MyString.strip().center(21, "*") produces a different result than MyString.center(21, "*").strip(). When you encounter a situation in which the output of a series of concatenated functions is different from what you expected, you need to check function order to ensure that each function is in the correct place.

• Misplacing punctuation: You can put punctuation in the wrong place and create an entirely different result. Remember that you must include a colon at the end of each structural statement. In addition, the placement of parentheses is critical. For example, (1 + 2) * (3 + 4), 1 + ((2 * 3) + 4), and 1 + (2 * (3 + 4)) all produce different results.

• Using the incorrect logical operator: Most of the operators don’t present developers with problems, but the logical operators do. Remember to use and to determine when both operands must be True and or when either of the operands can be True.

• Creating count-by-one errors on loops: Remember that a loop doesn’t count the last number you specify in a range. So, if you specify the range [1:11], you actually get output for values between 1 and 10.

• Using the wrong capitalization: Python is case sensitive, so MyVar is different from myvar and MYVAR. Always check capitalization when you find that you can’t access a value you expected to access.

• Making a spelling mistake: Even seasoned developers suffer from spelling errors at times. Ensuring that you use a common approach to naming variables, classes, and functions does help. However, even a consistent naming scheme won’t always prevent you from typing MyVer when you meant to type MyVar.

• Misunderstanding how function defaults work: A function’s default value is set at the time it’s first evaluated, rather than each time you call it. Consequently, a function declaration like this:def myFunc(list=[]):list.append(“value”)

  return list

  will only provide an empty list the first time you call it, rather than every time you call it without providing a value for list. Subsequent calls will simply add “value” to an ever growing list. So if you call myFunc() three times, list will actually equal [“value”, “value”, “value”]. The workaround for this issue is to check the input value every time in the code and act accordingly, such as:

  def myFunc(list=None):

  if list is None:

  list = []

  list.append(“value”)

  return list

• Modifying a list while iterating over it: If a developer is lucky, this particular mistake results in an index out-of-range error. At least there is some indication of where to look. However, when working with some data science problems that don’t use the entire list, but simply iterate over parts of it, the mistake can introduce all sorts of data skewing and analysis problems that can be extremely difficult to locate (assuming that you know there is a problem at all). Using list comprehensions is a common method of avoiding this problem.
• Creating a module name that clashes with a Python standard library module: If you create a module that has the same name as an existing Python module, Python may import your module instead of the one you wanted, leading to some difficult-to-find errors. The best way to avoid this issue is to ensure that you use module names that are guaranteed to be unique, such as prepending your organization name to the module name.

Whenever you create a plot, you need to identify the sources of information using more than just the lines. Creating a plot that uses differing line types and data point symbols makes the plot much easier for other people to use. The following table lists the line plot styles.

Remember that you can also use these styles with other kinds of plots. For example, a scatter plot can use these styles to define each of the data points. When in doubt, try the styles to see whether they’ll work with your particular plot.

It’s kind of amazing to think that IPython provides you with magic, but that’s precisely what you get with the magic functions. Most magic functions begin with either a % or %% sign. Those with a % sign work within the environment, and those with a %% sign work at the cell level.

There are a few specialized functions, such as the system command escape (!), that require a special symbol or technique. Of these, the system command escape is the most essential to know. Another useful alternative is variable expansion ($), which is used like $(myVar), to provide a value without retyping it.

Note that the magic functions work best with Jupyter Notebook. People using alternatives, such as Google Colab, may find that some magic functions fail to provide the desired result.

The following list gives you a few of the most common magic functions and their purposes. To obtain a full list, type %quickref and press Enter in Jupyter Notebook or Google Colab, or check out the full list.