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

This article will explain in detail what are the six tips for improving the operational efficiency of Python. The content of the article is of high quality, so the editor will share it with you for reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

Python is an excellent language that allows you to do a lot of things with very little code in a short period of time. Not only that, it also easily supports multitasking, such as multi-processes.

People who don't like Python often complain that Python runs too slowly. However, this is not the case. Try the following six tips to speed up your Python app.

Tip 1: key code uses external feature packs

Python simplifies many programming tasks, but for some time-sensitive tasks, its performance is often not satisfactory. It can effectively improve the running efficiency of the application to deal with time-sensitive tasks by using the external function pack of C _ + or machine language. These feature packs are often attached to a specific platform, so you have to choose the right one according to the platform you use. In short, this trick requires you to sacrifice the portability of the application in exchange for efficiency that can only be achieved through direct programming of the underlying host. Here are some feature packs you can choose to use to improve efficiency:

Cython

Pylnlne

PyPy

Pyrex

The usefulness of these feature packs varies. For example, using data types in the C language can make tasks involving memory operations more efficient or intuitive. Pyrex can help Python extend the display of such features. Pylnline enables you to use C code directly in Python applications. Inline code is compiled independently, but it saves all the compiled files somewhere and can take full advantage of the efficiency provided by the C language.

Tip 2: use keys when sorting

Python contains many ancient collations that take up a lot of time when you create custom sorting methods, and they also slow down the actual speed of the program when they run. The sorting method for * is to use as many keys and the built-in sort () method as possible. For example, take the following code:

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)]

In each example, list sorts according to the index you choose to use as the key parameter. This method works not only for numeric types, but also for string types.

Tip 3: optimization for loops

Every programming language emphasizes a cyclical solution. When using Python, you can use a wealth of techniques to make loops run faster. However, a technique that developers often forget is to avoid accessing variable properties in loops as much as possible. For example, take the following code:

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 you call str.upper, Python calculates the value of this equation. However, if you assign this evaluation to a variable, the result of the evaluation will be known in advance, and the Python program will run faster. Therefore, the key is to minimize the workload of Python in the loop. Because Python interprets the nature of execution, it slows it down significantly in the above example.

(note: there are many other ways to optimize loops, and this is just one of them. For example, many programmers will think that list derivation is a way to increase the speed of loops. The key point is that optimizing the loop scheme is a good choice to improve the speed of the application.)

Tip 4: use the newer version of Python

If you search Python on the Internet, you will find countless information about how to upgrade the Python version. Typically, each version of Python contains optimizations to make it run faster than previous versions. However, the limiting factor is whether your favorite library is synchronously updated to support the new version of Python. Instead of debating whether the function library should be updated, the key is whether the new version of Python is efficient enough to support this update.

You need to make sure that your code still works in the new version. You need to use the new library to experience the new version of Python, and then you need to check your application when making critical changes. Only after you have made the necessary corrections can you realize the difference of the new version.

However, if you just make sure that your application works in the new version, you are likely to miss out on the new features provided by the new version. Once you decide to update, please analyze the performance of your application under the new version, check the parts that may go wrong, and then give priority to applying the new version's features to these parts. Only in this way can users be aware of the improvement in application performance at the beginning of the update.

Tip 5: try multiple coding methods

Almost without exception, using the same coding method when creating an application will lead to the unsatisfactory running efficiency of the application. You can try some experimental methods in program analysis. For example, when dealing with data items in a dictionary, you can either use secure methods to ensure that the data items already exist before updating them, or you can update the data items directly and treat the non-existing data items separately as special cases. Please see the following * section code:

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)

This code runs faster when the myDict is empty at first. However, in general, myDict is filled with data, at least most of the data, and it is more efficient to use another approach.

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

The output is the same in both methods. The difference is how the output is obtained. Jumping out of the conventional mindset and creating new programming skills can make your application more efficient.

Tip 6: cross-compile your application

Developers sometimes forget that computers do not understand the programming language used to create modern applications. Computers understand machine language. In order to run your application, you use an application to convert your human-readable code into machine-readable code. Sometimes it's possible to write an application in a language like Python and run it in a language like C++. The key is what you want your application to accomplish and what resources your mainframe system can provide.

Nuitka is an interesting cross-compiler that converts your Python code into C++ code. In this way, you can execute your application in native mode without relying on the interpreter program. You will find that the efficiency of your application has been greatly improved, but this will vary depending on the platform and task.

(note: Nuitka is still in the testing stage, so please pay more attention to it in practical application. In fact, it is still used in experiments at the moment. In addition, there is room for discussion as to whether cross-compilation is an efficient way to improve running efficiency. Developers have been using cross-compilation for years to improve the speed of applications. Remember, every solution has its pros and cons, so weigh it carefully before using it in a production environment.)

When using a cross compiler, remember to make sure it supports the version of Python you are using. Nuitka supports Python2.6, 2.7,3.2 and 3.3. For the solution to work, you need a Python interpreter and a C++ compiler. Nuitka supports many C++ compilers, including Microsoft Visual Studio, MinGW and Clang/LLVM.

Cross-compilation can cause some serious problems. For example, when using Nuitka, you will find that even a Mini Program consumes a lot of drive space. Because Nuitka uses a series of dynamic link libraries (DDLs) to perform the functions of Python. Therefore, if you are using a system with limited resources, this approach may not be feasible.

Conclusion

All of the six tips above can help you create Python applications that run more efficiently. But silver bullets don't exist. These tips don't always work. Some tricks may perform better than others under a particular version of Python, but sometimes it even depends on the platform. You need to summarize and analyze your application, find the inefficient parts of it, and then try these tips to find solutions to the problem.

This is the end of the six tips on improving the efficiency of Python. I hope the above can be helpful to you and learn more. If you think the article is good, you can share it for more people to see.

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.