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.

You won’t go to jail if you don’t do TDD (Test-Driven Design), or even write tests for your code.

Your system can work just fine if you don’t follow any agile method.

You could deploy your next app in a bare-metal Linux machine instead of setting up Kubernetes on a cloud provider to autoscale your pods, and no one will complain about performance and such.

We have all read Clean Code, Clean Architecture, and some other "bibles" of the software development world which tell us what are the "best practices".

We have all spent hours learning about Scrum or some similar methodology to manage a software project as opposed to old-fashioned cascade-like project management because that’s what works "best".

We do tons of meetings, in Scrum alone we have: sprint planning, daily scrum, sprint review, and sprint retrospective.

There are days when I wonder if I attend meetings for a living instead of developing software.

So, what is all this rant about?

It is about not following blindly the so-called "best practices".

I do X because Google does, I use Y because Facebook uses it.

This is a silly reason to do or use anything.

If you are not working with lots of people, in a huge project, with thousands of simultaneous users, following all the "best practices" can be a drawback instead of an advantage.

If you are working alone, in a small app with a handful of users, it is ok to commit directly into the main branch in your GitHub repo.

If your project is not database intensive, or only has to deal with very little data, you can use an embedded H2 database stored directly in your file system and it will work more than fine.

There are projects and teams where it makes sense to follow every single piece of advanced architecture and people management processes there are, but that’s totally not the case for your startup of three people.

It is easy to be misled by reading about the latest tech and thinking "everybody is using this", when in fact they are not.

FOMO (Fear Of Missing Out) as a Developer is real and you should be aware of this.

Choose the right tech for the right context in a rational way.

Choose the right project methodology for the right context in a rational way.

You don’t have to ditch Scrum in its entirety, you can adapt it and do only 2 of the meetings described instead of all of them.

You can spawn a cheap Linux VM and deploy your app by hand instead of spending hours setting up CI/CD for something you can do manually in 2 minutes.

If your app screen is a simple feature with one text field and a button (like Google’s home page), React/Angular/Vue is an overkill.

Learn all of those things, read the books, but use your best judgment to adapt the "best practices" to take advantage of what makes sense to your project and team, and not just because someone else said you should use it.

The content Beware of excess of “best practices” is from Renan Moura - Software Engineering.

Anything for a while is easy:

• Work out for a while
• Study for a while
• Diet for a while
• Work right for a while
• Take good care of the family for a while
• Save for a while
• Programming for a while

For a while, everything is a piece of cake.

But what will get you there is not being brilliant for a while.

What takes you there is being consistent for a LONG time.

James Clear has an interesting take on this.

On the image below you can see how a tiny gain makes such a huge difference when compounded for long enough.

And also the opposite, how a tiny loss will throw you to 0 in the long run.

Liz Fosslien also illustrates this very well.

How seemingly small steps lead to big changes over time:

And finally, an illustration by Jack Butcher.

Where you can see how you put in a lot of work for some time and see no results and thinks "This is pointless", and then, all of a sudden, you get some traction (this is especially true on the internet):

Most people will never see curves like this in their own lives because they give up too soon.

The urge to give up quickly comes from the several examples of other people on the internet having results much faster, so one thinks that, if they are not getting results fast, they are just doing it wrong.

This is totally not the case.

These people are outliers, they just seem common because their word spreads fast on the web and makes you think that’s the norm when it’s not.

Everyone talks about their successes, few talk about their failures, simple human nature.

Everyone has their own rhythm, and the rule of thumb here is that you have to give a lot before asking for anything.

It’s very easy to get started when we’re excited.

Then it becomes a routine and the excitement is gone.

Only those with the discipline to go through the excitement abyss will reap the rewards of their effort.

Learning Programming is Non-Linear, so you might feel stuck here and there, but this shouldn’t discourage you from learning and persevering.

By showing up every day you are already ahead of the majority of people.

You have to survive long enough in any game to start being noticed.

And a big chunk of any success is being present.

So don’t give up too quickly.

The hard part is to continue.

The content The hard part is to continue 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.

It is very common to see people asking in groups, Reddit, and other forum-like places "What path should I take to become a Software Developer".

Unfortunately, learning programming is not linear.

You will find many lists and articles giving you a path like: learn HTML, CSS, JavaScript…

They are not wrong in the sense that you should learn JavaScript before React, but they don’t warn you that you should not worry about mastering the previous topic before jumping to the next.

Those topics are all interconnected, which means they will "click" in your head only after you have some knowledge of each topic.

Learn some JavaScript and then some React.

If you decide to "master" Python before trying Django, good luck, you will never get to Django.

Python is a massive language, you can learn the basics very quickly, but mastering it is another matter.

That is what I had in mind when I wrote The Python Guide for Beginners.

You can learn the core of the language as fast as possible, and then move on to dive into Web Development, Data Science, or general use of Python as a programming language to automate your everyday tasks.

If you choose, say, Machine Learning, you will need to understand some details of the language specifically for some tasks, but you will have enough knowledge of the basics to google yourself out of any situation.

The "click" also happens as you expand your arsenal of tools.

Learn More Than One Programming Language and some concepts that you learned in language X will make much more sense after you learn language Y.

I’m challenging myself at the moment to dive more into web3, which is a new realm of software development and solutions revolving around blockchain and the crypto space.

Adaptation is The Top Skill for a Software Developer and you have to keep improving yourself as new opportunities arise.

This means I won’t waste hundreds of hours to learn Solidity or understand every single concept about Smart Contracts.

The Only Way To Learn Programming is to take action with what you know.

So I will learn some things, apply them to a project and then I will be able to adapt myself to any situation that comes to me.

If you wait until you are 100% prepared, you will be already too late to take the best opportunities.

The content Learning Programming is Non-Linear 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.