Debugging performance problems using a standard debugger is almost hopeless since the level of detail is too high. Other ways are using a profiler, but they seldom give me good information, especially when there is GUI and background threads involved, as I never know whether the user was actually waiting for the computer, or not. A different way is simply using Control + C and see where in the code it stops.
What I really would like is to have Fast Forward, Play, Pause and Rewind functionality combined with some visual repressentation of the code. This means that I could set the code to run on Fast Forward until I navigate the GUI to the critical spot. Then I set the code to be run in slow mode, while I get some visual repressentation of, which lines of are being executed (possibly some kind of zoomed out view of the code). I could for example set the execution speed to something like 0.0001x. I believe that I would get a very good visualization this way of whether the problem is inside a specific module, or maybe in the communication between modules.
Does this exist? My specific need is in Python, but I would be interested in seeing such functionality in any language.
The methods you're describing, and many of the comments, seem to me to be relatively weak probabilistic attempts to understand the performance impact.  Profilers do work perfectly well for GUIs and other idle-thread programs, though it takes a little practice to read them.  I think your best bet is there, though -- learn to use the profiler better, that's what it's for.  
The specific use you describe would simply be to attach the profiler but don't record yet.  Navigate the GUI to the point in question.  Hit the profiler record button, do the action, and stop the recording.  View the results.  Fix.  Do it again.
Debugging visually using >>, >, >|, ||, |<, <, <<