What are the efficient techniques for Python programming?

Reverse a list

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!

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 ​​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.

Looping inside a function

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.

Reduce the number of function calls

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!