There is a very common suggestion that is thrown around every time the subject of IDEs comes up, and that is the notion that Python doesn't need anything other than a text editor and a good shell. This is often accompanied by suggestions of Sublime Text or Vim (Which, up until a few hours ago, I would have suggested too).

I bring this up, as I just finished a few month long excursion back into Java land for work, and thus spent all of that time in Eclipse -- which I generally dislike for its clumsiness, but its productivity boost cannot be denied. Upon firing up Sublime and pulling up a Python project, I felt a little lost without the fast auto-complete, documentation windows, refactoring tools, etc... that a 'proper' IDE would offer. And it was about the 3rd time that I called dir on a library's object to remember what the hell the name was of the function I needed that I realized how much I miss the tooling available to Java (though not the language).

I feel like my eyes were peeled open to how unproductive I am when working on my larger Python projects. A ton of my time is spent tracking down usages while refactoring, or manually inspecting to figure out what the function names are, etc, etc..

I currently feel like the text editor + shell aren't viable anymore for the size of projects I work on. However, I haven't yet found an IDE that I like (though my sample size is small).

The first thing I installed was Python Tools for Visual Studio, but so far, results have been... underwhelming. Intellisense seems to be a crapshoot at best. First thing I imported was os and the only thing Intellisense could crank out was an error message that it wasn't up to date (even after going through every stackoverflow answer I could find).

So, I ask you, fellow Python Devs. Do you use an IDE with Python, and if so, which one?

Big project and Emacs here. While my emacs setup provides all useful IDE features, I find complexity management the biggest benefit of using a text editor instead of an IDE. A good IDE allows you to spawn much more complex design than your brain is able to cope with. The popularity of IDEs in Java world (combined with their nasty support for generating boilerplate code) may be the main reason, why much of Java code is so needlessly complex. If all you have is a simple text editor, you are forced to produce simpler, less verbose and more modularized code.

My project is fairly large (in terms of both lines of code and participating programmers), but it's surprisingly easy to start hacking it, when you join the team. The popularity of vim and emacs in our teams may be a big contributing factor, in my opinion.

I think if you can use "patterns" properly in your project with an editor and good naming, structure and some decent docs, then you are good to go as good as an IDE. The thing is that a lot of Java IDE's produce all the repeat / regulation code at the press of a button - making programmers lazy and / or productive (depends on the programmer).

Just curious ... does your project use a lot of the official "patterns"?

Yes, we try to follow common idioms and keep the code base pythonic, if that's what you mean. If you ask if we use "design patterns" in classic sense, then of course as Python programmers we love patterns like iterator or decorator. ;)

Yes, design patterns is what I meant. The thing i wanted to get from your post was that with a good editor (+ plugins), educated developers, and organised code, one can write "enterprise" code, without IDEs.

I LOVE PyCharm. It handles multiple virtualenvs well, introspects code well, and formatting works well. I've used the paid one for a few years but just switched to the community edition because I usually run my programs in a shell outside the IDE.

If you are on windows python tools for visual studio is really slick now. PyDev in Eclipse has made improvements too. When i started with python almost two years ago, PyCharm was not free. Im not even sure what has been stripped out for the "community edition." But, free was really important.

After using PyCharm for two months: auto-completion is awful and much worse then a simple vim-like auto-completion. And I don't know what PyCharm is doing, but when I start it, my music player stutters. During the day, my average CPU usage is about 40% for just typing text. Nope, PyCharm is not my favourite IDE.

I have never had trouble with any of the things you've mentioned. Did you happen to report those problems to the PyCharm team? They are very responsive and I'm sure they'd be interested.

It is a Java application, so depending on your platform it may not run well. I know that I've heard it runs poorly on OpenJDK (as do pretty much all complex GUI applications).

The auto-complete is quite a bit more sophisticated than a typical text editor plugin like the ones people tend to use with VIM, so I'm not sure what you mean that it's awful. My experience with auto-completion in VIM is that it just does some basic symbol matching, and it can only symbol match in the currently open buffers. I.E. If there is a class definition in a file that isn't in an open buffer, instances of that class won't be getting auto-complete.

PyCharm on the other hand completes a static analysis of your entire project and it's dependencies (if you have a requirements.txt file) when your project loads and keeps on analyzing as you go. If it's possible to infer the type you're working with at the given moment you will see the members of the class (or module) available for for auto-completion before all others and when it doesn't it uses symbol matching. But even in that case it will match to symbols of other methods it knows have been used with that instance before.

Interesting.. maybe that's my problem. I tried out PyCharm on my laptop and it ran slow enough for me to just give up on it and go back to vim. I'll try installing oracle's jre and give it another go. I don't have any problems with vim, but people have spoken so highly of PyCharm and JetBrains' other products that I feel l should at least give it a try.

My experience with auto-completion in VIM is that it just does some basic symbol matching, and it can only symbol match in the currently open buffers. I.E. If there is a class definition in a file that isn't in an open buffer, instances of that class won't be getting auto-complete.

Does it support analyzing modules in the current virtualenv only? And what does it do if I change virtualenvs?

I don't change virtualenvs from within vim, but my understanding is that whatever environment you start vim from will be what it uses until you close it. I'm sure there are plugins or workarounds that exist for changing virtualenvs from within vim though.

As for pycharm, switching to oracle's jre was a huge improvement. So, thanks for that.

In my experience jedi-vim is awesome, better thatn YouCompleteMe (for python at least). But it has some drawbacks - poor py3 support and it can not do introspection. For example: flask 0.10 in virtualenv with py3, jedi-vim can't complete from flask import Flask, with py2 it can. On some places jedi-vim can understand from foo import bar but can not later complete bar.baz

My experience with auto-completion in VIM is that it just does some basic symbol matching, and it can only symbol match in the currently open buffers. I.E. If there is a class definition in a file that isn't in an open buffer, instances of that class won't be getting auto-complete.

jedi works in vim, it's more sophisticated then basic symbol matching in the open buffer. I would imagine that anyone using vim/emacs for python dev is using it or rope.

jedi-vim looks really good. I'm going to give it a try. Does it support analysis of modules in the current virtualenv (do I have to start VIM from within the virtualenv or something or is it virtualenv aware?)

PyCharm on the other hand completes a static analysis of your entire project and it's dependencies

Yes, it does static analysis to some degree. But when the application gets more advanced than a basic hello_world.py, it sometimes just fails to "analyze" at all. Most of my werkzeug functions are underlined because of superflous arguments... that's simply not true, but PyCharm does not evaluate slightly advanced getattr calls which dispatch functions.

when your project loads and keeps on analyzing as you go.

Always have fun with it. Especially when I run tox and PyCharm re-indexes all testing environments while tox is running.

I now use PyCharm for JavaScript now (not PyCharm CE) and there it really shines. It can analyze all my require.js stuff.

But when the application gets more advanced than a basic hello_world.py, it sometimes just fails to "analyze" at all.

I use it with several projects with over 200 source files representing ~30k LOC, and it has no problem, not to mention that it's also handling completion for all of the modules installed in my virtualenv.

PyPy dev here (which is a medium-sized project in terms of codebase). I personally use customized emacs with tons of addons. It's not ideal and why I would love a decent IDE, it just seems that most IDEs are not very well suited for Python. Their auto-completion is crappier than emacs text-only one, the file selection dialog sucks, etc. etc. I think a decent IDE would outperform even heavily customized emacs, but I just haven't seen one.

On the other hand for C#/Java Visual Studio/Eclipse is just irreplaceable, I can't imagine using emacs for that.

Could you elaborate on your emacs config? I have always used emacs, but I do often find myself wanting some IDE features, especially when someone is standing over my shoulder and I am flicking through buffers trying to find the right thing...

Jedi seems to do a decent job at the autocomplete thing. I have to do some per project things to get debugging and ipython in emacs working right but it's pretty much a matter of setting up some paths.

ido-mode, pyflakes, jedi-mode (maybe, currently turned off). This is really pretty much it. I used to have a lot of custom keys, but I seem not to use them a lot any more (alt-1 to the last visited buffer, alt-2 to the previous one etc.)

I'm a full time Python dev. My editor of choice is Sublime text. There are a few plugins that do auto-complete and linting for Python -- and they work incredibly well. I love the linting in particular; it highlights any typos or schoolboy errors with a red squiggly line.

You have a lot of suggestions here. I think you should try them all. There's no need to get possessive over your editor. I love sublime text at the moment, but if an editor comes along with a better feature set, I would dump sublime text in an instant.

I've been doing Python for 10+ years, professionally for 5+ (mostly Django) and I've stuck to the same tools for most of that time, which is screen + vim + ipython. The reason I've stuck with this is that I typically work inside of remote/virtual machines and being able to shell into any machine and put together a familiar environment is fantastic, particularly with the ability to detach/reattach sessions.

Screen doesn't have support for horizontal splits in the maintained package. There is a patch that adds it, but it is very inefficient. There are no plans to fix it, or to really accept it upstream into screen.

Eh, I use splits in my tmux and my vim. It's really nice to have a repl next to the editor, because I have editor plugins to send text to my repl. tmux has everything screen has, plus more, so you can only benefit by switching.

I've never really been a fan of IDEs. I prefer things to be very fast and 100% keyboard controlled. Also I move between machines a lot, so like I said, not depending on software on the host machine is key.

So no, I haven't used sublime or pycharm thoroughly enough to form a comparison, but I'm not particularly compelled to either. Also I'm one of those people that has a hard time trying new stuff, I'm very stuck in my ways lol.

Not OP, but I have used both and never found PyDev any slower than PyCharm. As far as how cluttered the UI is, they are both big bloated IDEs with hundreds of different options. If I wanted something minimal I would have started up vim.

Tramp is a way of avoiding having to open up a remote shell just to do an 'emacs -nw'. I find it's also useful to open a terminal on the remote machine to execute scripts and the like.

The way I set things up is to use Tramp to open up any files that I want to edit on the remote server and then split the frame and use "M-x eshell" to get a command line window inside of emacs. SSH into the remote server from that command line, then I can also be executing python scripts, moving files, etc. All from within one GUI Emacs frame that is running on my laptop.

Thanks for your thoughts - you can ssh into the remote server with eshell?? I thought it wasn't powerful enough...(I mean you can, but I thought using shell or eshell for remote access was advised against.)

I do use Tramp sometimes but I hate how it pauses when I C-x C-s out of habit...but I do like that you can use dired in the remote server with Tramp also, if I recall correctly.

Thanks! Pretty much the same setup as I have here, though I use rope for parsing; I really should look into tramp. Haven't used it much, but I'm just about fed up with the whole save - scp - test - edit thing.

I use WingIDE. It's got an incredible debugger, amazing introspection and great search capability. I've tried Pycharm and find it clunky since I do scientific programming and couldn't care less about web stuff. Same goes for PyDev, though I think it's a bit better.

I still keep a copy of Eclipse running for some of those terrific Eclipse plugins - mainly Apache Directory Studio. But I don't derive enough value from the shared window to actually edit any files in Eclipse.

The killer feature that keeps bringing me back to Vim is the target-action command chaining. It makes the most common types of code changes so much faster. I have considered switching to something with higher quality auto complete when typing in large amounts of new code, but I rarely have to do that in Python anyway.

When editing Java, I do switch back and forth with Eclipse for the wordy data entry bits, and Vim for the testing, debugging, and refactoring.

Like some of the others in this thread, I rely heavily on the Python shell for the exploration and experimentation phases of development. Whatever editor you use, I highly recommend setting up quick keys to launch the shell, memorizing the import readline; readline.dump('scratch.txt') command to dump the shell history, and a second quick command to pull the dumped code into an adjacent buffer in the editor. It makes a terrific workflow! :)

My team mostly uses Komodo IDE or the free Komodo Edit. The python autocompletion isn't as hot as some more python-centric ides, but it makes up for it with a good set of general editor features, and highlighting support for every language under the sun ... that last bit being a killer feature when your application isn't python, but python, C, javascript, html, rst, and js & html templates.

I've used Komodo in the past and I'm still not sure what happened with ActiveState. If you want an IDE, Komodo has had all the bells and whistles for years. Plus, it supports Perl, Ruby, PHP and JavaScript too. But for whatever reason, Komodo appears to have been overtaken by PyCharm and other IDE's in the past 5 years or so.

Anyway, that being said, I mostly just work on small-ish scripts these days so emacs works perfectly well for me.

Yup, +1 for Komodo Edit. I rarely do any scripting that has multiple .py files and this is perfect for me. The autocomplete is good, but it sometimes doesn't recognize third-party modules. It's pretty good for a free editor.

I can't say I've played with the alternatives very much in the last year or so (got my workflow situated), but I'm curious what the other IDEs are up to that I'm missing out on. Besides the autocomplete issues, what other features do PyCharm etc have which Komodo is lacking?

Yeah. That's a pain. I have to write a Makefile, and then once that's done - I have to basically rewrite a bunch of it in a .ycm_extra.py file? And after I do that, I can go ahead and keep changing both whenever I need to slightly change my build process.

Yeah, it is a pain, but YCM is so useful that I do it anyway. Besides, how often do you really edit a Makefile during the lifetime a project? The source will be edited so much more, and that's where you'll need the .ycm_extra.py.

I worked on a largish python project for a few years and I swear it was never a problem for me. Now I have to flit between java and other langs, I absolutely have to use eclipse to get anything done in java - and I can kind of feel the mental muscles atrophying. I really think if I had to stick java out for too long, I'd have the same problem you're describing.

IntelliJ is far, far better for Java IMO. I used to be an Eclipse guy too. I work with our Android team a lot, but also do some plug-ins for our Hadoop front-end, and I use it for both.

I haven't actually tried out their Python product yet, i.e. PyCharm. I keep meaning to but most of the Python projects I work on are data analysis type things, and I've found Spyder works best for that (for me). I'm only writing maybe 100 lines in Python at a time though.

DOOOO IITTT!
Seriously, I used to use N++. I was like, meh, its good enough.
Then I started using Sublime for little things. Then the plugins came, sweet baby Jesus. Comparing N++ vs sublime is like comparing IE vs Firefox (except it uses about the same amount of memory as N++, with like 5x the flexibility.

I use it for everything from notes written in Markdown, to light code editing.
Honestly, I've become very fond of Jetbrains products (PyCharm, IdeaJ) as of late. I used to use PyDev, but it's just not up to snuff. Eclipse is fine though, but on a small screen I prefer the Jetbrains stuff.

As a side note, my friend that works as a PHP / web dev turned me on to it.

I've been using Spyder a lot. However, I use it for data analysis type projects. I write short scripts or utility modules for the most part, as such I haven't tried using it to manage a large project. It does have all the features of an IDE, however I just haven't tested all of them out in much depth.

The best way to get it for my purposes was to install the Anaconda python distribution, however that might be a bit heavy for someone working on a project.

Some time ago I started working on a mid-size Python project. Right from the beginning I was using SublimeText + some plugins and really liked it. After some thousand lines of code I switched to Pycharm and found my productivity even higher than with SublimeText.

I prefer using PyCharm because it doesn't feel like a allround text editor/IDE with some mediocre Python plugins but rather like a IDE that was made by Python developers and for Python developers. I can only recommend to give it a shot.

I come from more of a server side .Net / Java background and got thrown into an existing rather large python (django) project.

I tried Aptana, Python Tools for VS, Sublime and PyCharm. Eventually settled on PyCharm and I'm quite happy with it. For me, a good debugger is invaluable for figuring out what the hell is going on in an existing, poorly documented code base like that.

Actually on a side note, I was pleasantly surprised by Python Tools for VS. I kind of expected it to suck but it turned out to be a pretty nice add in. Obviously many / most python developers don't use VS but in a shop that does a lot of .Net work where the team is already used to the IDE, Python Tools is a very usable option that lets them work in a familiar environment.

I'm comfortable and productive with vim and few plugins (mainly static code analysis, access to pydoc and some minor extra stuff such as closing the current buffer without closing the window -that perhaps should work that way by default!-). I don't usually use the mouse (I think mostly for code review -scroll wheel-), so vim allows me to do what I want without getting in the way.

I'm full time Sr. Python(Django) developer. I'm working on 5 y.o. project(excluding years of php). Currently, I'm working with team of 5 ppl. Personally, I'm working more than 1 year on it, with great success: now we have some test, refactored a lot old code, updated to django 1.6, bootstrap, etc.

So, I prefer Sublime text 2 with Sublime linter. Also, I'm using Ubuntu with Unity to manage my windows, Sakura as terminal. The important part in my environment is easy windows management with virtual desktops: I can use multiple tools with fullscreen in same time. This is why it is enough for me to use editor+terminal+browser.

2 of my co-workers use PyCharm. Yea, it has some great things like autocomplete, goto, autoimport, better highlighting in pyhaml. But I can't use it simply because it has no multiple cursor and it's interface bloated. And yea, of cause, java.

I had the same thought. I've been using grepedit (https://pypi.python.org/pypi/grepedit) for years to change multiple files simultaniously. It is simple and works really well. Especially when you want to change some occurances of a string and not others.

I think there is a real kernel of truth in the comment. Every so often I try out an IDE, and I always end up back in a text editor (in my case one I wrote over two decades ago, but it could just as well be vim or emacs), and its always the same two reasons. The trivial one is I'm used to a certain set of keybindings. The important one is, I end up jumping off into a shell to do stuff (ie., I use the unix tool chain) so often, the IDE is just getting in the way (and having a shell inside the IDE doesn't count, once I'm in a built-in shell I'm effectively out of the IDE so I may as well do it properly).

I have a sneaking suspicion that there is something fundamental here, analagous to the difference between regexps on the one hand and (say) python on the other: both are languages but only the latter is Turing-complete. IDEs are sort-of like regexps, a text editor plus the Unix command line is sort-of like a turing-complete language.

Most of the functions I've seen an IDE handle are compensations for lower-level problems.

Java needs refactoring tools due to high levels of boiler plate, projects need project handling tools because they lack decent build systems, you need an IDE to manage java source files because the directories are nested so deeply, you need completion because there are too many types with names that are too long. You need an IDE because XML isn't human readable, and who can get the schema right? XML being a compensation for a problem at an even lower level anyway.

You need to integrate to the enterprise server because starting it up takes so long, and the scripts to restart it don't work or are non-existant (hey JBOSS).

You need to integrate running your compile cycle because the project takes too long to compile from scratch, and so does running all the tests.

Interdependencies also matter; for example, people on Windows almost always demand an IDE because there's really only one way to create programs on that platform; the Visual Studio IDE. So when all you have is a hammer, ...

Also, if your Python component is part of a wider application that's not necessarily in Python, for example something with an embedded Python interpreter for whatever reason, you may find it easier to work in the team using the same toolset as everyone else. For example a large project I had was mostly in Java and the team was using Eclipse so it became stupidly easy for me to plug in PyDev and be able to interact with the same code repository in the same tool, everyone is on level footing.

Personal preference: Vim. REPL languages don't need an IDE, and frankly their shoe-horning always feels wrong. There's also no substitute for the simple yet powerful editing capabilities of Vi, especially when all existing IDE's are essentially glorified Windows Notepad (hammer keys repeatedly because there's no concept of motion and repetition, poor (if it even exists) and complex external tool integration, constantly have to refer back to the mouse to do simple stuff, ...)

Newer to Python so I don't think my opinion is worth a whole lot, yet I do love Intellij, and I write Go, JS, PHP, and now Python in it. Diddled with some Ruby, yet I went back to Python. Also use JetBrains AppCode for Objective-C, so I like having a similar IDE feel between languages. Keeps it nice and consistent.

I work on a very large Python framework at my job, and we used WingIDE for a new years. The auto-completion, code re-factoring and debugging features are nice. But I've switched to using Sublime text with a few select plugins for most of what I do now.

I use Pycharm, Notepad++, and Sublime. Sublime and Notepad++ can both be 'upgraded' to do syntax highlighting, code completion, and so on, but bigger projects need different tools- I end up missing the feedback from the dev console in pycharm, the more-intuitive navigation among files, etc. That said, I'm a novice-level dev and don't do much except grok open source projects code and my own personal projects.

They are the same, I picked up IntelliJ to do some Android/Java dev so I have licenses for both, I use pycharm for the web part of our application because the UI looks different and it's easy to tell which project I'm looking at the color scheme.

I pretty much stick to highly customized vim and use bpython to brain storm but if you're looking for an IDE to try there's an open source ide called Ninja-IDE (Ninja-IDE Is Not Just Another IDE) that is quite nice. Has some decent features and there's a fair amount of community support with plugins. Auto completes and what not that you're probably used to in Eclipse are unfortunately pretty non-existent.

I have worked on a number of medium to large projects, and I use the following editors on a monthly basis:

Chocolat

SublimeText

IntelliJ

Vim

LightTable

I use all of these alongside a terminal with tmux. Sometimes I mess around in Haskell, Go, Clojure or some other language - but I mostly stick to C++, Python, and JavaScript for producing real projects.

I'm not going to tell you which one is better, because the sad truth is that they all have major problems. Most of them do one thing very well, and everything else poorly.

I only use LightTable, because I am hopeful (but without high expectations) that it will finally do the job well when it's more stable. It's pretty much bad at everything at this point, although it's inline results are a bit interesting. That is, if you can get them working properly.

IntelliJ is great at refactoring, but it's a terrible excuse for a text editor.

Vim is a great text editor, but it's a terrible excuse for anything more than small projects - even with the huge list of plugins I use regularly.

Emacs is an interesting mix between the two, but it isn't good at solving either problem. Some people just happen to deal with it because it at least tries to solve both problems.

SublimeText sounds great from a theoretical standpoint. You can write plugins in Python, instead of some obscure languages like VimScript; but it has an extremely limited plugin system with an extremely poor API that exposes half of everything in the least useful way possible. The other half of everything, of course, isn't exposed at all.

Chocolat solves the UI problem well (for the most part) but then it has the problem that it crashes all the time for no reason. Still, it's UI has some weirdness - like it's confusing splits support by holding command/alt when selecting files depending on split direction.

Text editors and IDEs haven't evolved in any revolutionary way in a long time, and I feel like it's one of the biggest problems in computer science that isn't going to be solved any time soon. Programming efficiently requires that - for every task you perform - you have to choose the right tool for the job. So, I find myself in a position where I have to use all of these at different times depending on the task at hand.

Most mates in my team use vim only. I use it for little jobs or if it's over ssh. For larger project I prefer use eclipse+pydev+egit+... Using an IDE improve productivity. That's it.
I use pycharm on my laptop because eclipse requires a bigger resolution.

Notepad++ with a few plugins. I work with XML a lot and XMLTools is godly.

In my experience, IDEs get in the way more than they help. "No, I don't need a goddamn dropdown with a full help description of the function I am halfway through typing, why are you drawing over the 3 lines below it that I need to read right now..."

I fell in love with PyCharm but my current code environment is HUGE and PyCharm could not cope. So I returned to my editor of more than 20 years Emacs.

Also, we do some odd things mixing virtual file systems with version control that would take a bit of tinkering with the PyCharm run-profiles thing to get working.

And we run a custom version control system which is a front-end to a commercial VCS and an in-house VCS (again because the commercial one could not cut it). So I wrote a bunch of emacs commands to navigate this gigantic sea of custom unique functionality and left both WingIDE and PyCharm by the wayside.