How to perform performance optimization on Python

Critics of Python claim that Python is inefficient and slow, but this is not the case: try these 6 tips to speed up your Python applications.

Python is a very cool language because very little Python code can do a lot of things in a short time, and Python easily supports multitasking and multiprocessing.

#py

1. Key codes can rely on extension packages

Python makes many programming tasks simple, but Doesn't always provide the best performance for very critical tasks. Using C, C++ or machine language extension packages to perform critical tasks can greatly improve performance. These packages are platform-dependent, meaning you must use packages specific to the platform you are using. In short, this solution provides some application portability in exchange for performance that you can only gain by programming directly to the underlying host. The following extension packages you can consider adding to your personal extension library:

Cython
PyInlne
PyPy
Pyrex

These packages have different functions and execution methods . For example, Pyrex makes it easy and efficient for Python to handle some memory tasks; PyInline allows you to directly use C code in Python applications. Although the inline code is compiled separately, if you can use the C code efficiently, it can be used at the same time. One place for everything.

2. Use keyword sorting

There are a lot of old Python codes that will spend extra time creating a custom sortingFunction. The best way to sort is to use keywords and the default sort() method, take a look at the following example:

import operator
somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(0))
somelist
#Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(1))
somelist
#Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]
somelist.sort(key=operator.itemgetter(2))
somelist
#Output = [(6, 2, 4), (9, 7, 5), (1, 5, 8)],

The list of each case is sorted according to the index you choose as the keyword argument, this The method is also applicable to string and numerical sorting.

3. Optimizing loops

Every programming language emphasizes the optimization of loop statements, and Python is the same. Although you can rely on a wealth of techniques to make loops run faster, however, one method that developers often overlook is to avoid using dotted strings inside the loop. For the following example:

lowerlist = ['this', 'is', 'lowercase']
upper = str.upper
upperlist = []
append = upperlist.append
for word in lowerlist:
    append(upper(word))
    print(upperlist)
    #Output = ['THIS', 'IS', 'LOWERCASE']

Every time str.upper is called, Python will find the value of this method. But if you put the evaluation result into a variable, you can improve the performance of the program. The key is to reduce the number of loops executed within Python, since Python is slower to parse these instances.

4. Use the new version

Anyone who searches for Python information online will find countless information about Python version migration. Usually, each version of Python has been optimized and improved on the previous version to make Python run faster. The limiting factor is whether your favorite library has been improved for the new version of Python.

When you use a new function library and get a new version of Python, you need to ensure that the code can still run, check the application, and correct the differences.

Then, if you just ensure that the application can run on the new version, you may miss the update of new features. Once you make improvements, configure your application under the new version, check for problem areas and prioritize updates with new features, users will see even greater performance improvements over previous upgrades.

5. Try a variety of programming methods

Every time you create an application, use the same programming method. In some cases, the program will run slower. Expectedly slow. Do some small experiments during the analysis. For example, when managing data items in a dictionary, you can use a safe method to determine whether the data item already exists and need to update it, or you can directly add the entry and then handle the case where the item does not exist at all.

n = 16
myDict = {}
for i in range(0, n):
    char = 'abcd'[i%4]
    if char not in myDict:
        myDict[char] = 0
        myDict[char] += 1
        print(myDict)

The above code will usually run faster when myDict is empty. But when myDict is already filled with data, there is a better way to choose:

n = 16
myDict = {}
for i in range(0, n):
    char = 'abcd'[i%4]
    try:
        myDict[char] += 1
    except KeyError:
        myDict[char] = 1
    print(myDict)

In both cases, output {'d': 4, 'c': 4, 'b': 4, 'a': 4}, the only difference is how the output is obtained. Thinking outside the box and creating new programming techniques can make your programs run faster.

6. Cross-compiler

Developers sometimes forget that the computer does not recognize any current application language, it only recognizes machine code. In order to run a program, an application is needed to convert human-readable code into code that the computer can understand. When writing a program in one language, such as Python, and then running it in another language, such as C++, it makes sense from a performance perspective. This depends on what you want to do with the application and what resources the host system can provide.

        An interesting cross-compiler, Nuitka, can convert Python into C++ code. The result is that you can execute the application in native mode instead of relying on the interpreter. Depending on the platform and task, you may see significant performance improvements.

The above is the detailed content of How to perform performance optimization on Python. For more information, please follow other related articles on the PHP Chinese website!