Shulou(Shulou.com)06/02 Report--

This article shows you how to eliminate tedious if judgments in Python dictionaries. The content is concise and easy to understand, and it will definitely brighten your eyes. I hope you can get something through the detailed introduction of this article.

It is a common requirement to carry out different calculations or operations according to different conditions. Python has if statements that can be implemented. But once there are many branches, multiple if can dazzle you.

We have many tricks to simplify the process. I will write several articles in succession, from simple to complex, to teach you how to understand and apply these skills.

Dynamically call different functions

Let's look at the data first:

Column [calculation method], which determines the calculation result of column [adjustment].

Each method of calculation is as follows:

After reading my previous article, "Why can't you always learn Python, the four traps of Python ython, because you've all fallen into the trap", my friends have learned to be smart and have defined functions for each calculation separately:

But how do you call these functions?

"it's very simple, judge, and then call":

Line 9: to prevent omissions in the calculation

This looks good, but every time you add a new way, you have to add a judgment here, and once there are many branches, the code here will be very lengthy:

Why do I keep every piece of code as short as possible?

Because we deal with a small independent problem at a time is much more efficient than dealing with a big problem, which means a lot of small problems are involved. Solving multiple small problems at the same time will short-circuit our brains.

Declare the mapping relationship separately

It would be comfortable if we could define the relationship between the calculation and the function in this way:

"it looks familiar. Isn't it a dictionary?"

Yes, a dictionary is the best structure used to express this one-to-one relationship.

You can think of the dictionary as a memory master who never forgets. As long as he goes through the data and you give him a key value, he can immediately find out the corresponding value value to you.

Therefore, we can give him the memory of each function that is calculated and defined:

Next, when you really process each row of data, you just need to ask him (dictionary) to take out the function and call it:

Line 2-4: in particular, we only give the name of the function to the value of the dictionary. Do not put parentheses after it. Parentheses indicate the execution of the function. Now we don't need to execute the function.

When calling, don't forget to pass in the metrics to be calculated to the function

Not only is the code simple, but if you pay attention to the running time in the lower left corner, you will find that this method is faster than the previous one.

Now our code is pretty good. If a new method of calculation appears in the data, but we forget to add the dictionary, the code will run with an error:

Line 4: comment out, which means we forget to define the calculation method C.

You can see the error message, which reminds us of the reason immediately.

"it's perfect to kill two birds with one stone!"

However, if you learn pandas from me, you will know that pandas avoids traversing and processing data as much as possible.

The simplicity and computational efficiency of pandas are not comparable to our own traversal processing.

Is the handling of pandas really perfect?

In this example, the difference between each method of calculation lies only in the following coefficients:

In this case, we can first take out the corresponding coefficients of each row in batches, and then calculate them directly:

Pay attention to the execution time and speed up again.

Don't think that this is just pandas writing the for traversal for you, it is based on numpy, while numpy is based on C++ calls, so the performance is very fast.

In fact, this approach also has its shortcomings:

The Series.map method does do what the dictionary does, but it won't report an error when he can't find the key. We need to check later by judging the nan.

Sometimes the calculation logic is not so simple, for example, it needs to see if the sales volume exceeds the average of the same region to make different calculation branches. At this point, using pandas will feel like the logic is scattered (we'll take a look at how to deal with this in the next section)

"so, is the previous dictionary declaration the most common way in this scenario?"

Thinking questions

It's actually very good to declare the correspondence in a dictionary, but it's also good if you can directly mark the correspondence where the function is defined:

You no longer need to define dictionary relationships.

How can this effect be achieved? Interested friends might as well give it a try.

The above content is how to eliminate tedious if judgment in Python dictionaries. Have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.