Python pro tips
Tags: python, webdev
Published: 2020-07-04 13:40:21


Learn useful tricks and concepts to write smarter scripts and prevent bad errors in Python.

## Use `get()` with dictionaries

In Python, dictionaries are collections of data with key-value pairs.

A direct call of any value through its key is one of the most common mistakes in Python. It leads to bad behaviours.

If the key does not exist, the script exits. Endgame! Instead, use the `get()` method, it already checks if the key exists: 

```python
team = {
   "productor": "Lionsgate",
   "actor": "Keanu Reeves",
   "director": "Chad Stahelski" 
}

actress = team.get("bullets", 2000000)
```

In the above example, I don't have to check if the key "bullets" exists, and the script does not stop. I can even specify a default value.

Sometimes, in tutorials, we write quick and dirty examples with direct calls, but beginners cannot know it's a bad practice.

## `==`  is not `is`

`==` does the same as in any other language. It checks if variables have equal values.

`is` checks if two operands refer to the same object. Every time you add a variable in your script, it gets a new "slot" in memory. You can check it with the `id()` method:

```python
x = "unknown"
y = "elsewhere"
print(id(x))
print(id(y))
```
You get:
```
140476677427376
140476698294128
```
so :
```python
if (x is y):
    print("wtf")
else:
    print("x is not y")
```
displays: 
```
 x is not y
```
However, Python has internal optimisations:

```python
x = 111
y = 111
print(id(x))
print(id(y))

if (x is y):
    print("wtf")
else:
    print("x is not y")
```
will display something like that:
```
4457849408
4457849408
wtf
```
That's normal. Python uses the same memory slot for integers less than 256. 

Therefore, be extra careful with the `is` keyword.

## Do not switch between tabs and spaces

This one is especially not allowed in Python3. If you have only one command line in your code block, using spaces instead of tabs won't produce any error.

Choose whatever style you want, but keep consistency. Otherwise, you will get errors sooner or later.

If it's not your code, please consider reformatting it. Most of the time, the IDE (integrated development environment) has options such as "convert tabs into spaces" for that.

## Reserved keywords

All languages have reserved keywords. To get the full list just run the following in the Python interpreter:

```python
help("keywords") 
```

Your IDE is useful here too. Most of the time, if it supports Python (which is likely), reserved keywords have a specific colour.

## Use try/except/else and finally

It's always a better idea to try code and catch errors instead of assuming everything will work as expected.

In Python, you can use exceptions like that:

```python
answer = input()

try:
    answer = 111/int(answer)
except:
    print("Error, please check your input and use a positive number")
else:
    print("The answer is", answer)
finally:
    print("That's all folks!")
```
The keyword "finally" always displays, even if you get exceptions.

## Use shorter if statements

Instead of writing:

```python
if myvar == 9 or myvar ==1 or myvar == 7
```
you can do the following:

```python
if myvar in [9,1,7]
```
It's faster, and the code is more readable.

## Follow guidelines and standards

Of course, you can write your stuff, but guidelines and code standards are the easiest ways, especially if you are a beginner.

In Python, you can use [PEP 8 Style Guide](http://pep8.org/). It's a set of rules with Dos and Don'ts.

For example, with PEP8 styles, you cannot use tabs to indent your code. Instead, you use four spaces per each indent.

Besides, it's excellent if you want to contribute.

## Write Object Oriented code (OOP)

OOP is a paradigm. It goes beyond any programming/scripting language.

Writing class in Python might look like this:
```python
class Calculation:
    """An example of Python class"""

    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2

    def add(self):
        print(self.num1 + self.num2)


calc = Calculation(36, 37)
calc.add()
```

## Import libraries

Any module can access other modules with the `import` keyword.

Libraries are handy; for example, if you want to use Python for machine learning, you will probably use [Numpy](https://numpy.org/).

But, don't use import like the following:
```python
from os import *

mkdir("existenz")
```
Instead, do this:
```python
# Standard library imports
import os

try:
    os.mkdir("existenz")
except:
    print("existenz exists")
else:
    print("existenz created")
finally:
    print("\\o/")
```

The first will import all objects from the os package, which can lead to unexpected errors such as naming conflicts.

Besides, you can import third-party and local packages. For them, I recommend using aliases:

```python
import foo as bar

print(bar)
```

Note that it's possible to use relative paths to import libraries, but, IMHO, it's not a good practice. Pep8 discourages the use of relative paths in imports, and Python3 removed support for implicit relative imports.

## Wrap up

I hope those tips and concepts will help you write better Python code. Indeed, it's not an exhausting list, do not hesitate to share your tricks in the comment section below ;)