Home > Article > Backend Development > What are the efficient techniques for Python programming?
There are usually two ways to reverse a list in Python: slicing or reverse()
function call. Both methods can reverse a list, but be aware that the built-in function reverse()
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 it should be noted that the built-in function reverse()
will change the original list, while the slicing method will create a new list.
Obviously, the built-in function reverse()
is faster than the list slicing method!
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 of variable_1
and variable_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.
We all like to create custom functions to perform our own specific tasks. Then use for
to loop through these functions, repeating the task multiple times.
However, using the function inside a for
loop takes longer execution time because the function is called on each iteration.
In contrast, if a for
loop 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 with for
loops inside and outside the function, start simple.
def only_function(x): new_string = x.capitalize() out_putstring = x + " " + new_string print(output_string)
And a for
function 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?
As you can see, using a for
loop inside a function is slightly faster.
When judging the type of an object, it is best to use isinstance()
, followed by the object type identifier id()
, Object value type()
last.
# 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
Do not put the contents of repeated operations as parameters in loop conditions to avoid repeated operations.
# 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
To use function or object Y in module X, use directly from X import Y
instead of import X; then X.Y
. This reduces one lookup when using Y (the interpreter doesn't have to first look up the X module and then look up Y in the X module's dictionary).
The above is the detailed content of What are the efficient techniques for Python programming?. For more information, please follow other related articles on the PHP Chinese website!