You have probably seen cases when you can do splits of strings
into multiple parts based on a pattern that is observed in the
string. For example, let us say that we want to save all the
words that are part of a sentence.
To do that, we usually try to do split the sentence into words
based on the spaces that we find, such as:
If you are working with many numbers in Python, you probably
need to do some rounding to cut off some digits that you may
not need at all.
For example, let us say that you are calculating an average
salary in a company and the average number that you have found
is around 54,334.218
This may not be a number that can look good in a final report
you want to submit to someone. You should instead round it.
Let us do it in Python:
As you can see, the number 2 after the comma represents the
number of digits we want to keep. The thing is, we can also
use negative numbers to specify the number of digits we want
to keep.
If we use -1, we are doing the rounding to the nearest ten:
When we need to do the rounding to the nearest hundert, we use
-2:
If we want to do the rounding to the nearest thousand, we use
-3:
This may seem something quite trivial, but I also got to learn
it just recently.
If you are implementing a new class, but do not have time now,
or simply want to postpone it for later, then you can use the
pass statement.
I have seen it being used all over the place, and I think it
is a good idea to use it when you are writing a class that
does not have any bodies of any methods, or when you are
implementing a class that is not yet complete.
You can use it to do test-driven development when you
initially write a failing test that calls a method that is not
implemented yet, which you can then implement and fix the
failing test.
Another scenario when I saw it being used was in coding
assignments that are part of homework.
Testing your code is a great way to check whether you have
implemented everything correctly. No matter how much you try,
no matter how hard you analyze all the cases, sometimes, just
the smallest mistake can lead to a big problem which could
have maybe been avoided writing tests.
When you write tests, you are obviously not going to use data
from production. We need to use some dummy data that does not
belong to anyone who is actually using the project. This is
called faking the data.
Since you don’t have a predefined type for a variable in
Python, you may notice a lot of bugs that can arise. As such,
it is very important that you pay a lot of attention in cases
when you have to make sure that you are using the correct type
of variable.
This can also be the case when you expect a variable to be a
number, but you get a string or any other type instead.
There can be cases when you may need to find the difference
between 2 sets in Python. If you do not remember from high
school, the difference between 2 sets means that we get the
elements from the first set that are not in the second set.
We can do that quite easily in Python using the minus
operator.