Refresh your knowledge! I use these six bad habits that slow down my Python programs all the time!

In this article, I summarized 6 cases of Python writing methods.

1. Don’t import the root module

When using Python, one thing we cannot avoid is importing modules, whether they are built-in modules or third-party modules. Sometimes, we may only need one or a few functions or objects from the module. In this case we should try to import only the functions or objects we need instead of importing the root module.

This is a simple example. Suppose we need to calculate the square root of some numbers in a program.

Slower Example

#In the bad example, we import the math module and use math.sqrt() to access the function. Of course, there's nothing wrong with it, but if we could import the sqrt() function, the performance would be better.

Faster Example

2. Avoid using dot/dot chains

Using dot is very intuitive. Access properties or functions of an object in Python. Most of the time, no problem. However, if we could avoid using dots or even linking dots, the performance would actually be better.

The example below shows appending numbers to a list and then removing them.

Slower example

Faster example

If you don't believe this actually does the same thing, we can verify it.

I can expect many Python developers to jump out and say that the technique in this example is a bit ridiculous. In fact, even myself, I rarely write code like the one above. However, it's nice to know that we can program it this way and even make it faster.

If we want to append to a list and remove items from it millions of times, we should probably consider using this trick. That's why we need to balance performance and readability of our code.

3. Do not use connection strings

Strings are immutable in Python. Therefore, when we use " " to concatenate multiple strings into one long string, each substring is operated individually.

Slower example

Specifically, for each substring, it needs to request a memory address and then combine it with that memory address The raw strings are concatenated, which becomes an overhead.

Faster example

However, when we use the join() function, the function knows all the substrings in advance, and the memory address is allocated The length is suitable for the final concatenated string. Therefore, there is no overhead of allocating memory for each substring.

It is strongly recommended to use the join() function whenever possible. However, sometimes we may just want to concatenate two strings. Or, just for convenience, we want to use " ". In these cases, using " " will result in better readability and less code length.

4. Do not use temporary variables for value exchange

Many algorithms require the value exchange of two variables. In most other programming languages, this is usually done by introducing a temporary variable, as shown below.

Slower example

Faster example

But, in Python, we don’t have to use the temp variable. Python has a built-in syntax to implement this value exchange, as shown below.

5. Use If-Condition to short-circuit

"Short-circuit" evaluation exists in many programming languages, and the same is true for Python. Basically, it refers to the behavior of certain Boolean operators where the second argument is executed or evaluated only if the first argument is not sufficient to determine the value of the entire expression.

Let's demonstrate this in an example. Suppose we have a list as follows.

my_dict = [
{
'name': 'Alice',
'age': 28
},
{
'name': 'Bob',
'age': 23
},
{
'name': 'Chris',
'age': 33
},
{
'name': 'Chelsea',
'age': 2
},
{
'name': 'Carol',
'age': 24
}
]

Our job is to filter the list and find all people whose names start with "C" and whose age is 30 years or older.

Slower example

There are two conditions that need to be met at the same time:

• Name starts with "C"
• Age ≥ 30 Therefore , we can write the following code.

Faster Example

There is nothing wrong with the code in the previous example. However, in this particular fictional example, only "Chris" is over 30 years old.

If we first write the condition for checking names, then three names (Chris, Chelsea and Carol) are met. The second condition regarding age is then checked again for all 3 individuals.

However, because of short-circuit evaluation, if we write the age condition first, only Chris's age is above 30, and it will be checked again whether his name starts with "C".

In this case it's almost 100% faster.

6. Don’t use While Loop if you can use For Loop

Python uses a lot of C to improve performance, that is, CPython. In terms of loop statements, a For-Loop in Python has relatively fewer steps, more of which are run as C code than a While-Loop.

So, while we can use For-Loop in Python, we should not use while loop. This is not only because For-Loop is more elegant in Python, but also performs better.

Slower example

Faster example

The above is the detailed content of Refresh your knowledge! I use these six bad habits that slow down my Python programs all the time!. For more information, please follow other related articles on the PHP Chinese website!