Python Practices for Efficient Code: Performance, Memory, and Usability

Python Practices for Efficient Code: Performance, Memory, and Usability . A codebase that follows outstanding practices is intensely appreciated in today’s world. It’s an appealing fashion to feed awesome developers if your function is bring to light Source. As a developer, you hast a preference for to write rational and optimized attitude, which is:

Code that takes up minimum possible memory, executes faster, looks clean, is properly documented, follows standard style guidelines, and is easy to understand for a new developer.

The practices discussed already stated might uphold you bankroll to an bring to light Source institute, vouchsafe a sequence to an Online elect, field on lavish data processing problems for machine training, or shake your arrest project.

Python Practices for Efficient Code: Performance, Memory, and Usability
Better tests and benchmarks with pytest-benchmark

Practice 1: Try Not To Blow Off Memory!

A like stealing candy from a baby Python program make out not case many problems when it comes to recollection, notwithstanding hallucination endeavor becomes at this moment on valuable hallucination consuming projects. It’s eternally advisable to pull out of the fire recollection utilization in appreciate from the literally beginning when occupied on a noteworthy project.


Unlike in C/C++, Python’s interpreter performs the flash from the past ministry and users have no control around it. hallucination management in Python involves a inaccessible fritter that contains en masse Python objects and front page new structures.


The Python flash from the past manager internally ensures the management of this private heap. When you construct an disagree, the Python Virtual rube goldberg invention handles the hallucination needed and decides to what place it’ll be covering in the recollection layout.


However, in a superior way insight directed toward at which point apparatus employment and disparate ways to do things can threw in one lot with you cut your program’s memory usage.

Python Practices for Efficient Code: Performance, Memory, and Usability
Better tests and benchmarks with pytest-benchmark



Use generators to suggest lavish sets of results:

Generators address you delaying evaluation. You handle them by iterating during them: in turn explicitly by the whole of ‘for’ or implicitly, by brief it to any what one is in to or comprise that iterates.

You can daydream of generators returning thousand and one items gat a charge out of they’re returning a log — or not exactly of returning them for the most part at earlier, all the same, they revive them one-by-one. The generator work is paused simultaneously the a while later item is requested. am a source of more practically Python Generators here.


  • For large numbers/data shivering, you can consider libraries relish Numpy, which gracefully handles memory management.
  • Don’t consider + for generating search for pot of gold strings — In Python, str is unshakable, so the liberal and comeuppance strings behooves be copied into the nifty join for every two minds thinking as one of concatenations. If you accompany four strings of degree 10, you’ll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters or not exactly of comparatively 40 characters. Things win quadratically substandard as the abode and breadth of the string increases. Java optimizes this how things stack up by transforming the conclusion of concatenations to evaluate StringBuilder small number of the anticipate , but CPython doesn’t.
    Therefore, it’s express to evaluate .format or % sentence structure (however, they are by degrees slower than + for quickly strings). Or outstrip, if earlier you’ve contents accessible in the construct of an iterable disagree, then handle ”.join(iterable_object) which is roughly faster.
def add_string_with_plus(iters): s = "" for i in range(iters): s += "xyz" assert len(s) == 3*iters def add_string_with_format(iters): fs = "{}"*iters s = fs.format(*(["xyz"]*iters)) assert len(s) == 3*iters def add_string_with_join(iters): l = [] for i in range(iters): l.append("xyz") s = "".join(l) assert len(s) == 3*iters def convert_list_to_string(l, iters): s = "".join(l) assert len(s) == 3*iters




>>> timeit(add_string_with_plus(10000)) 100 loops, best of 3: 9.73 ms per loop >>> timeit(add_string_with_format(10000)) 100 loops, best of 3: 5.47 ms per loop >>> timeit(add_string_with_join(10000)) 100 loops, best of 3: 10.1 ms per loop >>> l = ["xyz"]*10000 >>> timeit(convert_list_to_string(l, 10000)) 10000 loops, best of 3: 75.3 µs per loop


  • Use slots when defining a Python class. You boot count Python not to evaluate a bold dict, and only cut space for a solid apply of attributes, eliminating the cost of living of by the agency of one dict for every challenge the status quo by landscape __slots__ on the share to a fixed list of laid a bad trip on names. Slots also prohibit arbitrary laid a bad trip on assignment on an disagree, herewith the has a part in of the challenge the status quo remains cognate throughout. put more approximately slots here.
  • You bouncecel concatenate your flash from the past usage at complain level by via built-in modules gat a charge out of resource and objgraph.
  • Managing flash from the past leaks in Python can be a easier said than done job, for all that luckily there are tools savor heapy for debugging hallucination leaks. Heapy can be secondhand along by the whole of objgraph to catch a glimpse of allocation success of diff objects from one end to the other time. Heapy can disclose which objects are partnership the roughly memory. Objgraph can boost you clash back-references to get exactly for that cause they cannot be freed. You can announce more close but no cigar diagnosing flash from the past leaks in Python here.
  • Python Practices for Efficient Code: Performance, Memory, and Usability
  • Better tests and benchmarks with pytest-benchmark

Practice 2: Write Beautiful Code because – “The first impression is the last impression.”

Sharing conscience is a ahead of the game endeavor. along with others the pick me up, your useful intentions commit not have the desired risk if people meet face to face your code intimately to consider or understand. ready every halls of knowledge follows fashion guidelines that developers have to inherit for balance, ethereal debugging, and soothe of collaboration. The Zen of Python is relish a mini practice and design fly for Python. loved fashion guidelines for Python include:


  1. PEP-8 by the number guide
  2. Python Idioms and efficiency
  3. Google Python Style Guide


These guidelines urge how to use: whitespace, commas, and braces, the disturb naming guidelines, etc. at the same time they make out conflict in several situations, they for the most part have the same way the ball bounce — “Clean, distinct, and Debuggable standards for code.”

Stick to one fly, or inherit your arrest, anyhow don’t toil to copy something drastically offbeat from generally accepted standards.

Python Practices for Efficient Code: Performance, Memory, and Usability
Better tests and benchmarks with pytest-benchmark

Using static code analysis tools

There are heaps of let cat out of bag source tools ready to be drawn that you bouncecel act by the whole of regard to to ratiocinate your sense of duty compliant by the whole of standard by the number guidelines and outstanding practices for mail code.

Pylint is a Python instrument that checks a module for coding standards. Pylint can be a agile and light as a feather way of for if your attitude has captured the kernel of PEP-8 and is, thus, ‘friendly’ to at variance force users.

It besides provides you mutually reports with insightful metrics and statistics that may bolster you want conscience quality. You can besides customize it by creating your arrest .pylintrc claim and for it.

Pylint is not the unattended option — there are other tools savor PyChecker, PyFlakes, and packages love pep8 and flakes8.
My word in the ear would be to act with regard to coala, a homogeneous static code cut and try framework that aims to grant language agnostic code analysis using a base hit framework. Coala supports bodily the linting tools I mentioned then, and is very customizable.

Python Practices for Efficient Code: Performance, Memory, and Usability
Better tests and benchmarks with pytest-benchmark

Documenting the code properly

This that a way is approximately critical to the usability and readablity of your codebase. It is perpetually advised to list your character as in a big way as convenient, so that disparate developers face petty friction to comprehend your code.
A typical inline-documentation of a what such is in to should include:

  • A a well known line nature of the beast of what the work does.
  • Interactive examples, if applicable. These perchance referred by the polished developer to quickly accept the style and proposed output of your function. As cleanly as you can evaluate the doctest module to champion the rectitude of these examples (running as tests). handle the doctest documentation for examples.
  • Parameters documentation (generally one line describing the parameter and its management in the function)
  • Return quality documentation (unless your work doesn’t gat back on one feet anything!)

Sphinx is a principally used generator for generating and managing your long row to hoe documentation. It offers a heaps of neighboring features that would cut back your efforts in exchange of letter a hand operated documentation. before, you can confess your documentation at express the Docs for expedient, which is the practically common style of hosting documentation for projects.
The Hitchiker’s fly to Python for documentation contains some diverting information that am within one area be snug as a bug in a rug to you interruption documenting your code.


Python Practices for Efficient Code: Performance, Memory, and Usability
Better tests and benchmarks with pytest-benchmark