Four efficient tips in Python!

Reverse a list

There are usually two ways to reverse a list in Python: slicing orreverse()function call . Both methods can reverse a list, but be aware that the built-in functionreverse()changes the original list, while the slicing method creates a new list.

But what about their performance? Which way is more effective? Let’s look at the following example:

Using slices:

$ python -m timeit -n 1000000 -s 'import numpy as np' 'mylist=list(np.arange(0, 200))' 'mylist[::-1]' 1000000 loops, best of 5: 15.6 usec per loop

Using reverse():

$ python -m timeit -n 1000000 -s 'import numpy as np' 'mylist=list(np.arange(0, 200))' 'mylist.reverse()' 1000000 loops, best of 5: 10.7 usec per loop

These two Both methods can reverse a list, but be aware that the built-in functionreverse()will change the original list, while the slicing method will create a new list.

Obviously, the built-in functionreverse()is faster than the list slicing method!

Swap two values

Swapping two variable values with one line of code is a more Pythonic approach.

Unlike other programming languages, Python does not require the use of temporary variables to exchange two numbers or values. To give a simple example:

variable_1 = 100 variable_2 = 500

To exchange the values ofvariable_1andvariable_2, only one line of code is needed.

variable_1, variable_2 = variable_2, variable_1

You can also use the same trick with dictionaries:

md[key_2], md[key_1] = md[key_1], md[key_2]

This trick avoids multiple iterations and complex data transformations, thus reducing execution time.

Looping inside a function

We all like to create custom functions to perform our own specific tasks. Then useforto loop through these functions, repeating the task multiple times.

However, using a function inside aforloop requires longer execution time because the function is called on each iteration.

In contrast, if aforloop is implemented inside a function, the function will only be called once.

To explain more clearly, let’s give an example!

First create a simple list of strings:

list_of_strings = ['apple','orange','banana','pineapple','grape']

Create two functions withforloops inside and outside the function, start simple .

def only_function(x): new_string = x.capitalize() out_putstring = x + " " + new_string print(output_string)

And aforfunction with a loop:

def for_in_function(listofstrings): for x in list_of_strings: new_string = x.capitalize() output_string = x + " " + new_string print(output_string)

Obviously, the output of these two functions is the same.

Then, let’s compare, which one is faster?

如您所见，在函数内使用for循环会稍微快一些。

减少函数调用次数

判断对象的类型时，使用isinstance()最好，其次是对象类型标识id()，对象值type()最后。

# Check if num an int type type(num) == type(0) # Three function calls type(num) is type(0) # Two function calls isinstance(num,(int)) # One function call

不要将重复操作的内容作为参数放在循环条件中，避免重复操作。

# Each loop the len(a) will be called while i < len(a): statement # Only execute len(a) once m = len(a) while i < m: statement

要在模块 X 中使用函数或对象 Y，请直接使用from X import Y而不是import X; then X.Y。这减少了使用 Y 时的一次查找（解释器不必先查找 X 模块，然后在 X 模块的字典中查找 Y）。

总而言之，你可以大量使用 Python 的内置函数。提高 Python 程序的速度，同时保持代码简洁易懂。

如果想进一步了解 Python 的内置函数，可以参考下表，或查看以下网站（https://docs.python.org/3/library/functions.html）：

The above is the detailed content of Four efficient tips in Python!. For more information, please follow other related articles on the PHP Chinese website!