Review: 7 Python IDEs go to the mat

Of all the metrics you could use to gauge the popularity and success of a language, one surefire indicator is the number of development environments available for it. Python’s rise in popularity over the last several years has brought with it a strong wave of IDE support, with tools aimed at both the general programmer and those who use Python for tasks like scientific work and analytical programming.

These seven IDEs with Python support cover the gamut of use cases. Some are built exclusively for Python, while others are multilanguage IDEs that support Python through an add-on or have been retrofitted with Python-specific extensions. Each benefits a slightly different audience of Python developer, although many strive to be useful as universal solutions.

A good number of the IDEs today are frameworks outfitted with plug-ins for specific languages and tasks, rather than apps written from the inside out to foster development in a given language. To that end, your choice of IDE may be determined by whether or not you have experience with another IDE from the same family.

Related video: Why Python makes programming easy

For those who don’t have such experience, PyCharm is one of the best places to start. It’s friendly to newcomers, but not hamstrung in its feature set. In fact, it sports some of the most useful features among all of the IDEs profiled here. Many of those features are available only in the for-pay version of the product, but there is plenty in the free version to help a fledgling developer get started.

LiClipse and the Python Tools for Visual Studio (PTVS) are good choices for developers already intimately familiar with Eclipse and Microsoft Visual Studio, respectively. Both are full-blown development environments—as full-blown as you’re going to find—that integrate Python quite nicely. However, they’re also sprawling, complex applications that come with a lot of cognitive overhead. If you’ve already mastered either of them, you’ll find it a great choice for Python work.

Microsoft’s Visual Studio Code editor, equipped with Microsoft’s Python extension, is a far more lightweight option than Visual Studio. VS Code has become immensely popular thanks to its wide range of extensions, which allow developers in projects that use not only Python but HTML and JavaScript, for instance, to assemble a collection of extensions to complement their workflow for that project.

The Python incarnation of ActiveState’s Komodo IDE is a natural fit for those who have already used the Komodo IDE for some other language, and it has unique features (like the regular expression evaluator) that ought to broaden its appeal. Komodo deserves a close look from novices and experts alike.

Spyder is best suited to working with Jupyter notebooks or other scientific computing tools in distributions like Anaconda, rather than as a development platform for Python generally. Finally, IDLE is best reserved for quick-and-dirty scripting, and even on that count, it might take a back seat to a standalone code editor with a Python syntax plug-in. That said, IDLE is always there when you need it.

IDLE

IDLE, the integrated development and learning environment included with most every installation of Python, could be considered the default Python IDE. However, IDLE is by no means a substitute for a full-blown IDE; it’s more like a fancy file editor. Still, IDLE remains one of the default options for Python developers to get a leg up with the language, and it has improved incrementally with each release of Python, especially with Python 3.5. (See this page for an interesting discussion of the recent efforts to improve IDLE.)

IDLE is built entirely with components that ship with a default installation of Python. Aside from the CPython interpreter itself, this includes the Tkinter interface toolkit. One advantage of building IDLE this way: It runs cross-platform with a consistent set of behaviors. As a downside, the interface can be terribly slow. Printing large amounts of text from a script into the console, for instance, is many orders of magnitude slower than if the script is run directly from the command line.

IDLE has a few immediate conveniences. It sports a built-in read-eval-print loop (REPL), or interactive console, for Python. In fact, this interactive shell is the first item presented to the user when IDLE is launched, rather than an empty editor. IDLE also includes a few tools found in other IDEs, such as providing suggestions for keywords or variables when you hit Ctrl-Space, and an integrated debugger. But the implementations for most of these features are primitive compared to other IDEs and hidebound by Tkinter’s limited selection of UI components. And the collection of third-party add-ons available for IDLE (one such project is IdleX) is nowhere near as rich as you’ll find with other IDEs.

IDLE also has no concept of a project, and thus no provisions for working with a Python virtual environment. The only discernible way to do this is to create a virtual environment and invoke IDLE from its parent installation of Python. Using any other tooling, like test suites, can only be done manually.

In sum, IDLE is best for two scenarios. The first is when you want to hack together a quick Python script, and you need a preconfigured environment to do so. The second is for beginners who are just getting their legs. Even beginners will need to graduate to a more robust option before long.

Komodo IDE

Komodo IDE, now in version 12, works as both a standalone multi-language IDE and as a point of integration with ActiveState’s language platform. Python is one of many languages supported in Komodo, and one of many languages for which ActiveState provides custom runtime builds.

On install, Komodo informs you about which programming languages, package managers, and other development tools it discovers on the system. This is a great way to get things configured out of the box. I could see, and be certain, that Komodo was using the right version of Python and the correct install of Git.

When you create a new project for a specific language, Komodo presents a slew of options to preconfigure that project. For Python projects, you can choose from one of several common web frameworks. A sample project contains examples and mini-tutorials for many of the supported languages, Python included. Navigation within files is nice and smooth, as there’s a drop-down search widget for all methods and functions within a file. Key bindings are configurable and can be added by way of downloadable packages that emulate other editors (e.g., Sublime Text).

One thing I like a great deal about Komodo is the inclusion of additional tools that are useful across languages, like the regular expression builder. Another powerful feature is the “Go to Anything” bar at the top center, where you can type to find most anything in your current project or the Komodo interface—a metaphor now common to many IDEs (Visual Studio Code, for instance) but always welcome when it shows up.

For linting, Komodo can integrate with PyChecker, Pylint, pep8, or Pyflakes, although support for each of these is hard-wired separately rather than available through a generic mechanism for integrating linting tools.

Some of Komodo 12’s most prominent new features revolve around integration with the ActiveState platform. Teams can configure and build custom runtimes for languages, with all the packages they need included. This is meant to ensure that members of a team don’t have to set up the runtime and dependencies for a project on their own; they can simply grab the same custom runtime with everything preloaded.

Now for the downsides. One of the biggest is the limited support for working with Python virtual environments. One has to manually create a venv, then associate the Python runtime for a project with that venv. Switching venvs for a given project requires digging into the settings for the project.

Komodo 12’s native Git integration is nowhere near as powerful as that of other IDEs. And while you can expand Komodo’s functionality with add-ons, there aren’t nearly as many add-ons for Komodo as there are for Visual Studio Code. What’s more, many of those add-ons don’t yet work in Komodo 12.

LiClipse / PyDev

The Eclipse Foundation’s Java-powered Eclipse editor supports many languages through add-ons. Python support comes by way of an add-on named PyDev, which you can use in two ways. You can add it manually to an existing Eclipse installation, or you can download a prepackaged version of Eclipse with PyDev called LiClipse. For this review I looked at the latter, since it provides the simplest and least stressful way to get up and running.

Aside from Python support, LiClipse also includes Git integration via Eclipse’s EGit add-on, support for Python’s Django web framework, and even support for Jython, the Python variant that runs on the JVM. This last seems fitting given Eclipse’s own Java roots, although Jython development has flagged as of late.

LiClipse makes good use of the stock features in the Eclipse UI. All keys can be remapped, and LiClipse comes with a stock set of key bindings for Emacs emulation. The “perspectives” view system lets you switch among a number of panel views depending on the task at hand—development, debugging, or working with the project’s Git repo.

Some of the best features come by way of plug-ins included in the LiClipse package. Refactoring History lets you track changes across a codebase whenever a formal refactoring takes place—something that in theory can be done with Git, but a dedicated tool like this comes in handy. Another truly nice feature is the ability to automatically trigger a breakpoint upon raising one or more exceptions, including exceptions you’ve defined.

LiClipse’s handling of virtual environments is hit-and-miss. While LiClipse doesn’t detect the presence of a venv in a project automatically, you can always configure and add venvs manually, and LiClipse integrates with Pipenv to create and manage them (assuming Pipenv is present in your base Python installation). There’s a nice GUI explorer to see which packages are installed in which Python venvs, and you can run pip from that GUI as well.

On the downside, it’s unnecesarily hard to do things like install new packages from a requirements.txt file, and it’s awkward to create a shell session with the environment activated in it—a common task that deserves its own tooling.

LiClipse comes with its own code analysis tools built-in, but can be configured to use Mypy and Pylint as well. As with Komodo, though, these choices are hard-wired into the application; there isn’t a simple way to integrate other linters not on that list. Likewise, the one test framework with direct integration into LiClipse is unittest, by way of creating a special run configuration for one’s project.

PyCharm

JetBrains makes a series of IDEs for various languages, all based on the same core source code. PyCharm is their Python IDE, and it’s built with an eye to support the characteristic work patterns and practices of Python developers.

This attention to workflow is evident from the moment you first create a PyCharm project. You’re given the option of setting up a virtual environment from the interpreter of your choice, with a sample main.py file in it. A convenient GUI lets you install modules to a virtual environment using pip, and the IDE will even autodetect requirements.txt files and offer to auto-install any missing dependencies. A fair amount of effort on Python projects gets eaten by wrangling virtual environments, so these features are very welcome.

You’ll find this same attention to workaday details throughout the IDE. For instance, if you run a file in your project with Alt-Shift-F10, PyCharm offers to remember that run configuration for future use. This is handy for projects that might have multiple entry points. When you kick open a command-line instance inside PyCharm with a project loaded, PyCharm automatically activates that project’s virtual environment. For users on low-powered notebooks, PyCharm’s “power save mode” disables background code analysis to keep the battery from being devoured.

Refactoring a project, another common source of tedium, also has a dedicated PyCharm tool. This goes beyond just renaming functions or methods; you can alter most every aspect of the code in question—change a function signature, for instance—and see a preview of what will be affected in the process. PyCharm provides its own code inspection tools, but a third-party plug-in makes it possible to use Pylint.

Python projects benefit from robust test suites, but developers often procrastinate on creating them because of the boilerplate involved. PyCharm’s automatic test-generation feature lets you generate skeleton test suites for existing code, then populate them with the tests as needed. If you already have tests, you can configure a run profile to execute them, with support for all of the popular testing frameworks (pytest, unittest, nose, etc.). There are other automated shortcuts as well. For a class, you can automatically look up which methods to implement or override when creating a subclass, again cutting down on boilerplate.

PyCharm can be expanded and tweaked greatly by way of the thousands of plugins available for it, which can be installed directly via PyCharm’s UI. This includes support for common data or text formats used with Python (CSV, Markdown), third-party tooling (Docker), and support for other languages (R, Rust).

PyCharm’s community edition should cover most use cases, but the professional edition (pricing here) adds some key features useful in enterprise settings, such as out-of-the-box Cython support, code coverage analysis tools, and profiling.

Python extension for Visual Studio Code

The explosive growth and popularity of Microsoft’s Visual Studio Code has fed development for add-ons that support just about every programming language and data format out there. VS Code’s best-known Python add-on is also developed by Microsoft, and together the editor and the add-on make for one of the best solutions available for Python development.

When installed, Microsoft’s Python extension also installs support for Jupyter notebooks, which can be opened and used directly in the editor. The Python extension also provides Pylance, a language server that provides linting and type checking by way of the Pyright tool. Together these components provide a solution that covers the vast majority of development scenarios.

One major drawback with Python extension for VS Code is the lack of a general setup process, like a wizard, for creating a new Python project and configuring all of its elements. Each step must be performed manually: creating the virtual environment, configuring paths, and so on. It also lacks full-blown integration for Python project management tools like Pipenv. It’s entirely possible to set those up by hand from the command line for a given project; there’s just no facility for using them in Python extension for VS Code. And while support for some individual frameworks exist —e.g., debug support for Django templates—those still must be configured manually.

On the plus side, VS Code automatically detects virtual environments in a project directory, and makes a best effort to use them whenever you open a terminal window in the editor. This saves the hassle of having to manually activate the environment. VS Code can also detect virtual environments created with Poetry, the Python project-management tool, although this feature was available only as a preview at the time of this writing.

Another powerful feature in VS Code, the command palette, lets you find just about any command or setting by simply typing a word or two. Prefix your search term with “Py” or “Python” and you’ll get even more focused results. And a broad variety of linters and code-formatting tools are supported natively in the Python extension.

One thing VS Code supports well with the Python extension is discovery and execution of unit testing. Both Python’s native unittest and the third-party pytest are supported. Run the “Python: Discover tests” command from the palette, and it will walk through the discovery of tests and set up a test runner button on the status bar at the bottom. Individual tests even have in-line annotations that let you re-run or debug them. It’s a model for how I wish many other things could be done with the Python extension.

The Python extension concentrates on the most broadly used parts of Python, and leaves the more esoteric corners to third parties. For instance, there is no support for the Cython superset of Python, which lets you compile Python into C. A third-party extension provides Cython syntax highlighting, but no actual integration of Cython workflow.

What’s best about the Python extension for Visual Studio Code is how it benefits from the flexibility and broad culture of extensions available for VS Code generally. Key bindings, for instance, can be freely remapped, and any number of themes are available to make VS Code’s fonts or color palettes more palatable.

Python Tools for Visual Studio 2019

If you already use Visual Studio in some form and are adding Python to the mix, using the Python Tools for Visual Studio add-on makes perfect sense. Microsoft’s open source plug-in provides prepackaged access to a number of common Python frameworks, and it makes Python debugging and deployment functions available through Visual Studio’s interface in the same manner as any other major language.

When Visual Studio 2015 came along, InfoWorld’s Martin Heller was impressed by its treatment of open source languages as first-class citizens right next to Microsoft’s own. Those languages included Python, and with the heartening level of support Visual Studio now provides for Python, it’s worth taking seriously as a dev environment for the language, no matter what kind of project you’re building.

There are two ways to get set up with Python on Visual Studio. You can add the Python Tools to an existing installation of Visual Studio, or you can download a stub that installs Visual Studio from scratch and adds Python Tools automatically. Both roads lead to the same Rome: A Visual Studio installation with templates for many common Python application types.

Out of the box, Python for Visual Studio can create projects that use some of the most widely used Python web frameworks: Flask, Flask with Jade (a templating language), Django, and the Bottle microframework. Also available are templates for generic web services, a simple command-line app, a Windows IoT core app that uses Python, and an option to create Visual Studio projects from existing Python code. I was pleased to see templates for IronPython, the revitalized Python port that runs on the .NET framework.

Python runtimes also can be installed automatically (Python 3.7.8 and Python 2.7.18, 32-bit or 64-bit). You can even install Miniconda, the slender version of Anaconda, for projects that need that distribution of Python. Also available are templates for Scikit-learn projects, using the cookiecutter project templating system. That said, it would be nice to see more options for other machine learning systems, like PyTorch.

When you create a new project using one of these frameworks, Visual Studio checks to make sure you have the dependencies already available. If not, it presents you with a few choices. You can create a Python virtual environment and have the needed packages placed there. You can have the packages installed into the Python interpreter available systemwide. Or you can add the dependencies to the project manually.

One nice touch is that Visual Studio logs all the steps it takes when it sets up a project, so you know what changes have been made and where everything is located. Visual Studio also smartly detects the presence of requirements.txt files, and can create a virtual environment for your project with those requirements preinstalled. If you’re porting an existing project that includes virtual enviromments, they too will be automatically detected and included.

Visual Studio’s Solution Explorer contains not only the files associated with each of your Python projects, but also the accompanying Python environment, as well as any Python packages installed therein. Right-click on the environment and you can install packages interactively, automatically generate a requirements file, or add folders, Zip archives, or files to the project’s search path. Visual Studio automatically generates IntelliSense indexes for Installed environments, so the editor’s on-the-fly suggestions are based on what’s installed in the entire Python environment you’re using, not only the current file or project.

Smart techniques for working with Visual Studio’s metaphors abound. When you launch a web app for testing, through the green arrow launch icon in the toolbar, Visual Studio’s app launcher pops open the default web browser (or the browser you select) and points it at the app’s address and port. The Build menu has a Publish option that can deploy your app on a variety of cloud services, including Microsoft’s Azure App Service.

Python Tools for Visual Studio provides a built-in facility for running the Pylint and Mypy code analyzers. As with other Visual Studio features that depend on external packages, Visual Studio will attempt to install either of those packages if you haven’t yet set them up. You can also set up the linters by hand in your virtual environment; in fact I prefer this option because it is the most flexible.

I was disappointed by the absence of support for Cython, the project that allows Python modules to be compiled into C extensions, DLLs, and standalone executables. Cython uses Visual Studio as one of its compilers, but there’s no support for Cython-format files in the Python Tools for Visual Studio, nor direct support for compiling Cython modules in Visual Studio.