Install it with pip:

pip install python-dateutil

The relativedelta object from the dateutil.relativedelta module allows you to subtract any number of years from a date object.

In this example I always take the current date using the date.today() method.

Then I set a relativedelta of 2 years and subtract it from current_date.

from datetime import date
from dateutil.relativedelta import relativedelta

current_date = date.today()

print(current_date)

future_date = current_date - relativedelta(years=2)

print(future_date)

2022-02-15
2020-02-15

You can also check:

• How to subtract days from a date in Python
• Adding days to a date in Python

Watch this on Youtube

The content Subtracting years from a date in Python is from Renan Moura - Software Engineering.

Install it with pip:

pip install python-dateutil

The relativedelta object from the dateutil.relativedelta module allows you to add any number of years to a date object.

In this example I always take the current date using the date.today() method.

Then I set a relativedelta of 2 years and add it to the current_date.

from datetime import date
from dateutil.relativedelta import relativedelta

current_date = date.today()

print(current_date)

future_date = current_date + relativedelta(years=2)

print(future_date)

2022-02-15
2024-02-15

You can also check:

• How to subtract days from a date in Python
• Adding days to a date in Python

The content Adding years to a date in Python is from Renan Moura - Software Engineering.

Install it with pip:

pip install python-dateutil

The relativedelta object from the dateutil.relativedelta module allows you to subtract any number of months from a date object.

In this example I always take the current date using the date.today() method.

Then I set a relativedelta of 2 months and subtract it from current_date.

from datetime import date
from dateutil.relativedelta import relativedelta

current_date = date.today()

print(current_date)

future_date = current_date - relativedelta(months=2)

print(future_date)

2022-02-15
2021-12-15

You can also check:

• How to subtract days from a date in Python
• Adding days to a date in Python

The content How to subtract months from a date in Python is from Renan Moura - Software Engineering.

Install it with pip:

pip install python-dateutil

The relativedelta object from the dateutil.relativedelta module allows you to add any number of months to a date object.

In this example I always take the current date using the date.today() method.

Then I set a relativedelta of 2 months and add it to the current_date.

from datetime import date
from dateutil.relativedelta import relativedelta

current_date = date.today()

print(current_date)

future_date = current_date + relativedelta(months=2)

print(future_date)

2022-02-15
2022-04-15

You can also check:

• How to subtract days from a date in Python
• Adding days to a date in Python

The content Adding months to a date in Python is from Renan Moura - Software Engineering.

Maybe you are importing a bunch of rows from a CSV file and want to make sure you only have unique values.

Or you are making sure to avoid repeated values for the sake of keeping your data sanitized.

Fortunately, you can drop duplicates from a list in Python with a single line.

This is one of those simple, but powerful features that Python gives us for free and can save you a lot of trouble by applying the Pythonic way of doing things.

Removing duplicates with set

In the code snippet below we are creating a list named car_brands.

Notice how 'bmw' and 'toyota' are repeated.

'bmw' is included twice, while 'toyota' appears three times.

To drop these duplicates we just need to convert the list to a set and then convert the result back to a list.

car_brands = ['bmw', 'mercedes', 'toyota', 'mclaren', 'toyota', 'bmw', 'toyota']

print(car_brands)

car_brands = list(set(car_brands))

print(car_brands)

The output of the code above is:

['bmw', 'mercedes', 'toyota', 'mclaren', 'toyota', 'bmw', 'toyota']

['toyota', 'mercedes', 'bmw', 'mclaren']

This works because sets, by default, don’t allow duplicates, so converting the list to set will automatically remove the duplicates.

But there is a catch, sets don’t keep the order of your items, while lists do keep the order of the items

Notice how 'toyota' appears as the first item in the final result, even though it was the third in the original list.

So, what to do if I want to remove the duplicates but keep the order of the items?

Droping duplicates and keeping the order with dict

The simple and "straightforward" (but not recommended) way would be to loop of the original list and add only new items to a new list.

The code below implements such logic.

car_brands = ['bmw', 'mercedes', 'toyota', 'mclaren', 'toyota', 'bmw', 'toyota']
new_brands = []

for item in car_brands: 
    if item not in new_brands: 
        new_brands.append(item)

print(car_brands)
print(new_brands)

The output is:

['bmw', 'mercedes', 'toyota', 'mclaren', 'toyota', 'bmw', 'toyota']

['bmw', 'mercedes', 'toyota', 'mclaren']

But, as always, there is a better way in Python!

As of Python 3.6, you can use the method fromkeys from dict.

It is slower than using sets to remove duplicates, but it is the best solution to drop duplicates and keep order.

It also takes only one line.

car_brands = ['bmw', 'mercedes', 'toyota', 'mclaren', 'toyota', 'bmw', 'toyota']

car_brands = list(dict.fromkeys(car_brands))

print(car_brands)

The output of the above is:

['bmw', 'mercedes', 'toyota', 'mclaren']

Since the solution with dict is slower, only use it if order is something you really need.

I recommend you to read How to choose a Data Structure in Python to have a broad view of each one and when to use them.

The content Python list drop duplicates is from Renan Moura - Software Engineering.

But there are situations where you want to increment the iteration counter by 2.

For some reason you might want to work with only even values.

Let’s see a few solutions for this.

range function

The solution to increment a for loop by 2 in Python is to use the range() function.

This function allows you to specify three parameters: start, stop, and step.

start is the counter’s initial value, step is by how much you want to increment until you reach the value of stop - 1, because the value of stop is included.

The example bellow shows how to use range() with a step of 2 starting from 0.

for i in range(0,20,2):
    print(i)

The output:

0
2
4
6
8
10
12
14
16
18

Of course, you can use range() to specify any step you would like, so if you want a step of 5, just do:

for i in range(0,20,5):
    print(i)

The output is:

0
5
10
15

Slicing

If you never heard of slicing before, I recommend you to read Understanding Slicing in Python first, there is also a video linked in the article if you prefer.

Slicing is useful when you want to apply a different step when working with a pre-defined list.

In this case I have a list numbers with the number from 1 to 16.

The logic is very similar to range(), since you also have a start, a stop, and a step.

In this case I’m starting on index 1, which is the number 2 in the list, remember lists are 0-indexed in Python.

I won’t put any stop value since I want to go until the last index.

Finally, I put a step of 2.

numbers = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

for i in numbers[1::2]:
    print(i)

The output will be:

2
4
6
8
10
12
14
16

Another way to implement the slicing from the code above is to combine range() with len():

numbers = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

for i in range(1, len(numbers), 2):
   print(numbers[i])

The output is the same:

2
4
6
8
10
12
14
16

Again, the same way we could use any step in range(), we can change the step in slicing to anything we would like.

What about about float values?

An extra trick is how to achieve the same thing with float values.

In this case you have to use the library numpy and its function arange.

This way you can use floats as start, stop, and step.

import numpy as np

for i in np.arange(1.5, 2.5, 0.1):
    print (i)

The output is:

1.5
1.6
1.7000000000000002
1.8000000000000003
1.9000000000000004
2.0000000000000004
2.1000000000000005
2.2000000000000006
2.3000000000000007
2.400000000000001

Watch this on Youtube:

The content Python for loop increment by 2 is from Renan Moura - Software Engineering.

Basic syntax of a 1 line for loop

To use a one line for loop to replace a regular for loop, we can make:

[statement for i in list]

Which is the same as doing:

for i in list:
    expression

If we want some conditional to apply the expression, we have:

[statement for i in list if condition ]

Which translates to:

for i in list:
    if condition:
        statement

Example 1: calculating the cube of a number

Regular way

numbers = [10, 20, 30, 40, 50]
new_list = []

for n in numbers:
    new_list.append(n**3)

print(new_list)

[1000, 8000, 27000, 64000, 125000]

Using 1 line for loop

numbers = [10, 20, 30, 40, 50]
new_list = []

new_list = [n**3 for n in numbers]

print(new_list)

[1000, 8000, 27000, 64000, 125000]

Example 2: calculating the cube of a number only if it is greater than 30

Using the conditional, we can filter only the values we want the expression to be applied to.

Regular way

numbers = [10, 20, 30, 40, 50]
new_list = []

for n in numbers:
    if(n > 30):
        new_list.append(n**3)

print(new_list)

[64000, 125000]

Using 1 line for loop

numbers = [10, 20, 30, 40, 50]
new_list = []

new_list = [n**3 for n in numbers if n > 30]

print(new_list)

[64000, 125000]

Example 3: calling functions with a 1 line for loop

We can also call functions using the list comprehension syntax:

numbers = [10, 20, 30, 40, 50]
new_list = []

def cube(number):
    return number**3

new_list = [cube(n) for n in numbers if n > 30]

print(new_list)

[64000, 125000]

To know more about loops, check these posts on for Loops in Python and While Loops in Python.

The content Python 1 line for loop is from Renan Moura - Software Engineering.

The data in a JWT can be validated at any given time since the token is digitally signed.

The JWT has three parts separated by dots .: Header, Payload, and Signature.

Header

The Header defines the information about the JSON object.

In this case, we are saying this is a JWT token and its signature algorithm, HS256.

{
  "alg": "HS256",
  "typ": "JWT"
}

Payload

The Payload is a JSON object with information about the entity, usually used for the authenticated user info.

We can have three types of Claims: Registered, Public, and Private.

The most common Registered Claims are iss (issuer), exp (expiration time), and sub (subject).

The Public Claims are the ones we use in our applications and you can define them as you need.

Finallt, Private claims are for sharing info between applications.

DO NOT store sensitive information in your tokens.

Here is an example of a valid token:

{
  "sub": "000000",
  "name": "Admin",
  "admin": true
}

Signature

The signature is simply the concatenation of both the Header and Payload, hashed using base64UrlEncode.

It’s important to notice the secret key to make it more secure.

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

Final Result

The final result is a token with three sections separated by a dot .

The first section is the hashed header, then the payload, and finally the signature.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Implementing JWT in Python

To implement JWT in Python we are going to use the lib PyJWT.

Install it using pip as follows:

pip install PyJWT==2.1.0

Then we are going to import it as jwt.

As explained before, we are going to need a secret key, the more random the better as you can see defined in the variable JWT_SECRET_KEY.

Define the algorithm, as you can see in the JWT_ALGORITHM variable.

And finally, define for how long the token will be valid, in the example below it will last 2 days (60 minutes 24 hours 2 days).

The function create_jwt_token receives a username and role that will be assigned to sub and role in our token.

The exp value will be calculated by using the datetime and timedelta.

We can then call jwt.encode passing the jwt_payload, the secret key, and the algorithm of our choice.

The result will be a token that will expire in two days.

Then we create another function check_jwt_token that expects a token as a string.

We call jwt.decode from PyJWT, pass the token, the secret key, and the algorithm to have the info back in plain values (not hashed).

This way we can recover the values of username, role, and expiration.

Then we check if time.time() < expiration:, this will return true if the token is not expired.

Then we make a second check to match the username with one we might have in our database.

The function check_jwt_username(username) is a generic function that simply takes the username and looks for it in a user table in a database, you could implement it in any way you need.

If the token is not valid, an Exception will be thrown and the code will return False.

If the token has expired or if the username is not found in the database, the function will also return False.

import jwt
from datetime import datetime, timedelta
import time

JWT_SECRET_KEY = "MY_SUPER_SECRET_KEY"
JWT_ALGORITHM = "HS256"
JWT_EXPIRATION_TIME_MINUTES = 60 * 24 * 2

# Create access JWT token
def create_jwt_token(username, role):
    expiration = datetime.utcnow() + timedelta(minutes=JWT_EXPIRATION_TIME_MINUTES)
    jwt_payload = {"sub": username, "role": role, "exp": expiration}
    jwt_token = jwt.encode(jwt_payload, JWT_SECRET_KEY, algorithm=JWT_ALGORITHM)

    return jwt_token

# Check whether JWT token is correct
def check_jwt_token(token):
    try:
        jwt_payload = jwt.decode(token, JWT_SECRET_KEY, algorithms=JWT_ALGORITHM)
        username = jwt_payload.get("sub")
        role = jwt_payload.get("role")
        expiration = jwt_payload.get("exp")
        if time.time() < expiration:
            is_valid = check_jwt_username(username)
            if is_valid:
                return True
            else:
                return False
        else:
            return False
    except Exception as e:
        return False

This is the most generic and simple way to work with JWT tokens in Python.

One could use this to implement JWT in any framework, like Flask or FastAPI.

The content JWT in Python is from Renan Moura - Software Engineering.

• Classes and Objects in Python
• Object-Oriented Programming: Encapsulation in Python
• Inheritance in Python
• Object-Oriented Programming: Polymorphism in Python

The Single Responsibility Principle (SRP) is about making a class focus on its primary responsibility.

Other responsibilities must be avoided.

Letting your objects take too many responsibilities is the formula for future headaches and a bunch of code smells.

This can be better explained with code, so let’s see an example of this principle.

Python Code Example

Consider a class called Vehicle like the one below.

We can initialize a vehicle with some attributes like model and year.

We also have some methods like move and accelerate, which are actions a vehicle does.

We also have a __str__(self) to make it easy to print the object in a human-readable format.

class Vehicle:
    def __init__(self, year, model, plate_number, current_speed = 0):
        self.year = year
        self.model = model
        self.plate_number = plate_number
        self.current_speed = current_speed

    def move(self):
        self.current_speed += 1

    def accelerate(self, value):
        self.current_speed += value

    def stop(self):
        self.current_speed = 0

    def __str__(self):
        return f'{self.model}-{self.year}-{self.plate_number}'

my_car = Vehicle(2009, 'F8', 'ABC1234', 100)

my_car.move()

print(my_car.current_speed)

my_car.accelerate(10)

print(my_car.current_speed)

my_car.stop()

print(my_car)

The output of the test above will be:

101
111
F8-2009-ABC1234

The class above follows the Single Responsibility Principle.

It only handles attributes and methods that concern itself, a Vehicle.

Breaking the Single Responsibility Principle

Let’s break the SRP.

Say you want to save the object in a file, to store the information in a persistent way.

Naively, a programmer can just add a save(self, filename) method.

This method will take the object it belongs to and save it in a file.

class Vehicle:
    def __init__(self, year, model, plate_number, current_speed = 0):
        self.year = year
        self.model = model
        self.plate_number = plate_number
        self.current_speed = current_speed

    def move(self):
        self.current_speed += 1

    def accelerate(self, value):
        self.current_speed += value

    def stop(self):
        self.current_speed = 0

    def __str__(self):
        return f'{self.model}-{self.year}-{self.plate_number}'

    def save(self, filename):
        file = open(filename, "w")
        file.write(str(self))
        file.close()

my_car = Vehicle(2009, 'F8', 'ABC1234', 100)

print(my_car)

my_car.save("my_car.txt")

with open("my_car.txt") as f:
    print(f.read())

The output for the code above is:

F8-2009-ABC1234
F8-2009-ABC1234

You can test the code and check it works.

But should a Vehicle class be able to write data to a file?

What does storing info have to do with a Vehicle?

Think about it in terms of a massive system with hundreds or thousands of classes.

Are you going to write a "save file" method for each class?

What happens when you need to make a change to the way your files are stored?

Maybe you want to check whether the path of the file exists to avoid errors and print a message for the user.

In this case, you would need to change every single file containing the "save file" method, which is prone to errors and it is bad practice.

How do we solve this then?

Fixing the class

The fixing, in this case, is as in the code below.

I created a new class called DataService and moved the save method from Vehicle to DataService.

Since DataService is a utility class meant to only save objects to a file, it doesn’t make sense to save itself.

So I annotated the save method with @staticmethod.

If you execute the code below you will notice the behavior is the same and the code still runs.

The difference is that now I can use DataService and save(my_object, filename) to store any kind of object.

And if I want to change the way I save my objects from files to a database, for instance, I just need to make a change in a single place.

Later I cans also implement methods to retrieve the data, update the data, or delete it, among other actions related to data management that are very common in any real-world system.

class Vehicle:
    def __init__(self, year, model, plate_number, current_speed = 0):
        self.year = year
        self.model = model
        self.plate_number = plate_number
        self.current_speed = current_speed

    def move(self):
        self.current_speed += 1

    def accelerate(self, value):
        self.current_speed += value

    def stop(self):
        self.current_speed = 0

    def __str__(self):
        return f'{self.model}-{self.year}-{self.plate_number}'

class DataService:
    @staticmethod
    def save(my_object, filename):
        file = open(filename, "w")
        file.write(str(my_object))
        file.close()

my_car = Vehicle(2009, 'F8', 'ABC1234', 100)

print(my_car)

data_service = DataService()
data_service.save(my_car, "my_car.txt")

with open("my_car.txt") as f:
    print(f.read())

The output will be:

F8-2009-ABC1234
F8-2009-ABC1234

Anti-Pattern: God Classes (God Object)

For every pattern, there is an anti-pattern.

Classes with loads of responsibility are called God Classes.

God is omnipotent, omnipresent, and omniscient, and so it is a God Object.

It is everywhere, it can do everything and it knows everything.

This creates massive classes with thousands of lines of code that no one wants to touch in fear of breaking something.

Keep your classes cohesive, focus on their primary responsibility and avoid this bad practice.

Your future self (and your workmates) will thank you.

The content Single Responsibility Principle (SRP) in Python is from Renan Moura - Software Engineering.

Languages like Java, JavaScript, C#, and Python are amongst the most famous for the purpose of developing web apps.

In this article, I will discuss some of the benefits of using Python, specifically, for the development of web apps.

Easy to learn

Python is one of the easiest languages to learn.

If you are an experienced developer, you can learn enough Python in a week to be dangerous and do a lot.

If you are a complete newbie, Python is a great first language, with a clear syntax, and allows you to get started as quickly as one can be.

In any case, if you want a hand in starting out with Python, try my free Python Guide For Beginners to get you up to speed as fast as possible.

This image from xkcd exemplifies this better than I ever could:

Ecosystem

Libraries for everything.

Python has a library for every use case.

From web scraping and simple scripting tasks to machine learning.

The plethora of tools you can find in the Python ecosystem is so big that you can jump many levels of the heavy lifting in your app idea by just importing some super useful libraries.

There is no advantage in reinventing the wheel, the same way there is no benefit in rewriting code that has already been coded.

Especially considering how the most used libraries are battle-tested in levels a single developer could never do.

Frameworks

Python has lots of frameworks for web development.

By far, the most famous are Django and Flask, and as a recent new contender we have FastAPI.

Django

Django is an interesting choice when you don’t want to think too much about all the pieces you are going to use.

Django has “Batteries Included”, which means a very good ORM, Authentication, Admin panel, template engine, and many other features most web apps use.

And if you need a REST API, Django REST Framework is an easy-to-install plugin that makes full use of Django’s built-in structures.

Flask

Flask is minimalistic, known as a micro framework, it gives you the bare minimum to start coding.

For most things, you will need to add a plugin and integrate it into Flask.

SQLAlchemy for ORM for instance is a must if you don’t want to work with raw SQL (which I personally prefer).

On the other hand, Flask is good for those who want full control of their web app and choose the freedom to use whatever they want.

With its version 2.0, Flask now has full support for Async and WebSockets.

FastAPI

I have been using FastAPI for some time now and I have been really enjoying it.

It is very similar to Flask in the sense that is very lean and simple to get started.

At the same time, it comes with full support for Async right from the start and a variety of tools to develop APIs easily, like the auto-generation of documentation with Swagger.

And if you want to develop a standard web app, you can just make use of Jinja 2, the same way Flask does.

Developer Time > Execution Time

When developing a new project, the time it takes to develop a new feature is the single most expensive item.

This is because the longer it takes to develop something, the more Developer Time it will take.

Being able to prototype something really fast is a huge advantage these days and Python and its ecosystem and frameworks are great tools to achieve things quickly.

This is the counterargument for people who say "Python is slow".

Slow for what?

Many languages are faster in execution time, but, as I said in the title "Developer Time > Execution Time".

Another thing to notice is that I/O operations are by far the slowest thing in an app, so good caching strategies ( by using Redis for example) and a better database design will give you better ROI than switching languages in many situations.

And finally, think in terms of Pareto’s 80/20, roughly 80% of consequences come from 20% of the causes

I remember in college when studying in this class of Computer Architecture and there was this chapter about optimization.

In one of the examples, there was a program written in C++, which is an extremely fast language for most purposes.

There was a small part of this program responsible for a huge part of the performance problems, simply because it was heavily used, more than other parts of the code.

What did they do?

They rewrote that single part in pure Assembly.

By Pareto’s logic, this small implementation was responsible for a good boost in performance.

For Python, you can follow the same logic.

In most cases, pure Python is more than enough and gives you the extra speed in development time.

When performance is a must, there are tons of Python libraries that are simply wrappers around C++ or C that are very performatic, which is the case for Pandas and Tensorflow.

And, if you have a specific use case, you can always implement the solution yourself in any other language and simply call it from Python.

There are many ways to do that, either by direct calls or by using another intermediate system like a message broker (Kafka for instance) to make the communication between systems even more transparent.

The content Why Python for Web Development is from Renan Moura - Software Engineering.