Rating the 8 Top Python IDE’s in 2020

PyCharm has Competition

Photo by Hybrid on Unsplash

The IDE you use can completely change your experience when programming. Especially in the early days when you’re learning, you can find it quite challenging if the IDE you use isn’t geared towards solving the problem that you face.

At its best, programming is an expression of creativity because us, as researchers, we’re trying to solve big problems. And it’s that expression of creativity which keeps us wanting to solve problems, so we need good tools to do so.

An IDE (integrated development environment) is a software application that provides facilities to programmers for software development.

It’s what Microsoft Word is to Writers. It’s what Adobe Photoshop is to Creators. It’s where we do our work.

My own journey in programming started with the use of IDLE for years and years, before moving into Sublime Text Editor, then PyCharm and then Notebooks. However, there are a number of other IDE’s that we list below and are worth exploring.

In the following article, I’ll cover the following IDE’s for which I’ve given each a score based on my opinion. If you disagree with any, let me know!

  1. IDLE (5/10)
  2. Jupyter Notebooks (7/10)
  3. PyCharm (9/10)
  4. Sublime (6/10)
  5. Spyder (4/10)
  6. Atom (7/10)
  7. Eric (8/10)
  8. VScode (8.5/10)
Photo by 青 晨 on Unsplash


IDLE was my first development environment when I started programming. I favoured it for a long time because partly, it was already installed on my computer, and also it was just easy to use.

My local Python IDLE IDE

As a beginner, you want to be able to see the fruits of your labour quite quickly, and the command line interface allows for just that. By using the IDE as a quasi calculator and quasi script runner meant that I could physically see what I was creating and I could see how every line of my code was important.

Now IDLE stands for “Integrated Development and Learning Environment”. It’s coded in 100% pure Python (using tkinter), and is cross-platform: working mostly the same on Windows, Unix, and macOS. Its functionalities are as basic as they come, but include:

  • Colorising of code input, output, and error messages
  • multi-window text editor with multiple undo, smart indent, call tips, auto-completion, and other features
  • debugger with persistent breakpoints, stepping, and viewing of global and local namespaces

If you’re starting off on your journey into programming, I’d highly recommend using IDLE because you see the fruits of your labour quite quickly and as a beginner, you just want to be able to build quick, fail quick and iterate.

However, if you want to build anything substantive, it’s just a bit limited in what it offers. You’ll see later that your IDE should be geared towards the type of project you have (I’d split general coding into either scientific computing or production software) and IDLE is somewhere in between. Code debugging, project management, quick-searching, visual displays (and more) are all tasks that we regularly complete when coding and IDLE just doesn’t provide much in the way of these.

Given that, I give it a low score of 5/10. Easy to use, but not that expansive.

For the Visualisers: Jupyter Notebooks

Now if you want to work in a more structured manner (I think along with most of the Data Science community), I would highly recommend using Jupyter Notebooks.

Jupyter runs in your browser and is super lightweight. Its purpose is to present and structure the framework of your code in a report like a framework, which is aesthetically quite pleasing. Its interface is actually quite similar to Mathematica and SageMath, but has become much more popular.

Screenshot from my local Notebooks

Functionally, Jupyter does have limitations and you can’t really use anything you make here in a production environment (unless you ship it across to .py files) as Jupyter Notebooks are built using a JSON framework, so you need purpose python files for anything you want to take away. Moreover, broader functionalities that are less research and more software engineering focused is where Notebooks really lacks.

Take version control. It isn’t really a thing using notebooks (it’s not very natural at least). For example, if you want to share some code, you could send the notebook: but what if you update something on your side, or your colleague updates something on their side, would you have to keep sending notebooks to each other?

Moreover, features like autocomplete, automatic code refactoring, code profiling, version control integration, and database tools are all things you just don’t get in Notebooks. But do you care?

At the end of the day, it depends on how you use an IDE. For me, I use Notebooks more than anything else because I need to visualise my results and I need to continually monitor them in a manageable way. Given how comfortable I am in using Notebooks and given that it’s so geared towards research and less about production (if at all), then scoring it on production based tasks is futile, so as a pure research development environment, Notebooks is awesome. 8/10.

For the Production User: PyCharm

PyCharm is an IDE that’s been built to make programming in Python as efficient as possible. From searching through entire repositories, to debugging to deployment, PyCharm is built with programmers in mind. Hand on heart: PyCharm is a fantastic IDE.


As I’ve said before, every person codes a little bit differently but for me, I use PyCharm to code up my production software. The reason being is that tasks like debugging, testing, profiling, integrating, and all the other things you tasks involved in creating production level code just work right out of the box. You actually need to set up very little.

For example, PyCharm even has a shortcut to reformat code to make it more readable. It’s something I really feel strongly about so it makes me happy to see that so have the engineers at PyCharm.

Note: PyCharm does have both a Community and Professional edition and if you can afford, the Professional edition is worth it. However, the Community edition is still fantastic and would recommend learning to use it.

Now PyCharm is a bit difficult to get used to. I’d consider myself an OK coder at best and it even took me a long time to fully get to grips with debugging. It’s not that it’s particularly difficult: it’s more that PyCharm has so many features that at times you can feel overwhelmed.

However, over time, you’ll learn more and more on PyCharm and eventually you won’t be able to live without it. I symbiotically work between PyCharm and Notebooks which works very well for me. PyCharm even has a new native Notebooks tool (that I’ve not spent too much time with admittedly). Given that PyCharm can do everything you want and doesn’t cut any corners anywhere, I really do think its fantastic and so, I give it a 9/10.

Other Python IDE’s


Sublime is a text editor that crosses the divide between PyCharm and IDLE. It has quite a few impressive tricks like multiple selection, split editing, impressive performance and is cross platform. However, its breadth of functionalities is nothing compared to PyCharm.

When you first play with Sublime, you’ll find yourself loving the feel of coding in it. Everything works quickly and it’s really easy to write a lot of code in it. This makes me wish that IDLE would actually use more of what Sublime has to offer but, to me, Sublime comes up a bit short in that it’s just not a native Python IDE.

For example, you can’t really do step-by-step debugging as you would in say PyCharm. After a while, this can become quite frustrating, especially when your projects are at an industrial scale. You’ll always find yourself coming back to PyCharm for one functionality or another.

Given that it absolutely smashes the aesthetics of coding, it’ll score highly on that front but as you suffer a bit on breadth of functionality, it’ll suffer there too. It’s more comparable to PyCharm than Notebooks I’d say, and as such, I’d have to give it 6/10.


Visually, Spyder is an awful lot like Matlab. It has the same variable explorer frame in the top right hand corner, a place for charts in the bottom right, and the coding pane to the left. It’s intended for use in scientific computing with Python which is reflected in its feature, the packaging, and the overall behaviour of the IDE. However for me, the whole feel of the product can often be clunky as compared to Notebooks or PyCharm.


Now Atom is something I haven’t used myself but have read fantastic reviews about it. Atom describes itself as a “hackable text editor for the 21st Century”. It’s maintained by GitHub, so as you’d expect it can do pretty much anything you can imagine. However, Atom isn’t really lightweight (it’s about 400MB (including its dependencies)) but even for the programmers on weaker systems, it runs fine assuming you can take the memory!

Now all in all, Atom looks great in the beginning and you could use it instead of say, Sublime or IDLE. However, Atom works with a lot of plug-ins so as you learn, it makes sense to load and install and search for these plug-ins. That helps you appreciate the significance of each, instead of being thrown into the deep end, like in PyCharm.

Given that, Atom is clean to use and beginner friendly, so if you’re thinking about using Sublime, it’s definitely worth a try using Atom as well. 7/10.


Eric is designed to be the everyday editor as well as being usable as a professional project management tool. It’s offering is pretty strong in that it offers real-time collaboration on code (how awesome?) and includes a plugin system that allows easy extension of the IDE functionality with plugins downloadable from the internet.

Now the IDE is a bit busy but its packed full of features. It supports standard tasks like code folding, code completion, brace matching. It also has an integrated class browser and pretty strong code debugger. It also has support for unit tests and can debug both multithreaded and multiprocessing programs. Moreover, it supports version control software like Mercurial and SVN version control natively, and Git support through plugins.

Given how broad its feature set is and how you can easily expand it with plugins, you’d want to compare this to PyCharm. But the problem with this comparison is that PyCharm is just so good: it’s the Barcelona Fc or Michael Jordan of IDE’s. Eric would struggle to be better given the resources that have been ploughed into PyCharm.

Never the less, Eric might be tough to get off the ground but once you get going it’s good, seriously good. 8/10.

Photo by Michael Lee on Unsplash

Updated to Include: VSCode

I’d like to thank the readers of the first edition of my article who noted that I hadn’t included VSCode. Here it is!

VSCode is a free and open source editor developed by Microsoft. Natively, it supports a few languages but with an extension, you can add Microsoft Python.

Here is where it get’s interesting.

VSCode is intended to have a broad feature set so PyCharm is its natural competitor. Both have Intelligent code completion, full text search, syntax highlighting and bracket matching, Git integration, code formatting and code linting, debugging, and the a lot more.

However, PyCharm is packed full of features and because of that, it runs with quite a high memory requirement: VSCode runs with about 30% less!

Moreover, PyCharm is part of the JetBrains family and so, plugins have to largely pass through the JetBrains family, over 3000 are currently on their website. VSCode on the other hand was designed to be a barebones editor, that is made into a full IDE via its extensions. Given how that’s developed, it means that VSCode can be customised a lot easier for the user.

This is quite an important point because VSCode genuinely has extensions for everything. I’ve looked into ease of Docker container usage, and IPython Notebook extensions and both are comfortable with both IDE’s. Event Reddit can’t decide which is better.

PyCharm is really the full production software and if your computer isn’t too bothered by the memory requirement, then it’s probably the better bet just because its an industry standard however, if you prefer something a bit more lightweight and versatile, VSCode is great.

Great, and maturing with time: 8.5/10

Given that, if you’re just starting out in coding you should really take a look at the projects you want to complete. If you want to build some funky Deep Learning networks and research into the latest tech, Jupyter Notebooks is going to be for you, and generally speaking, it’s the most widely used interface for research purposes.

However, if you intend to deploy software for a client and need some robust code that’s going to work 24/7 — you’re definitely better off using PyCharm. You’ll need the broad functionalities and the integrations with various databases or version control systems or libraries, so PyCharm makes all of this super easy. Shout out to VSCode, it’s also very good, extensible and free!

The IDE you choose is really important because depending on how you expect to code, an IDE can make it easier or a lot more difficult for you. For a long time, my research was impeded due to the fact I was using IDLE rather than something like Jupyter Notebooks. I even almost left Python all-together and used Matlab for a long period of time because it just felt so much more natural to code in Matlab.

So think about it a bit, what do you actually want to

Thanks for reading again!! Let me know if you have any questions and I’ll be happy to help.

Keep up to date with my latest work here!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Powered by WordPress.com.

Up ↑

%d bloggers like this: