The notion that Python&#39;s stack and C stack in a running Python program are intermixed can be misleading.

The Python stack is something completely separated than the actual C stack used by the interpreter. The data structures on Python stack are actually full Python &quot;frame&quot; objects (that can even be introspected and have some attributes changed at run time). This stack is managed by the Python virtual machine, which itself runs in C and thus have a normal C program, machine level, stack.

When using generators and iterators, the interpreter simply stores the respective frame object somewhere else than on the Python program stack, and pushes it back there when execution of the generator resumes. This &quot;somewhere else&quot; is the generator object itself.Calling the method &quot;next&quot; or &quot;send&quot; on the generator object causes this to happen.



The `yield` instruction takes the current executing context as a closure, and transforms it into an own living object. This object has a `__iter__` method which will continue after this yield statement.

So the call stack gets transformed into a heap object.

How do people deal with a scheduled NSTimer when an app is in the background?

Let&#39;s say I update something in my app every hour. 

    updateTimer = [NSTimer scheduledTimerWithTimeInterval:60.0*60.0 
    target:self 
    selector:@selector(updateStuff) 
    userInfo:nil 
    repeats:YES];

When in the background, this timer obviously doesn&#39;t fire(?). What should happen when the user comes back to the app..? Is the timer still running, with the same times?

And what would would happen if the user comes back in over an hour. Will it trigger for all the times that it missed, or will it wait till the next update time?

What I would like it to do is update immediately after the app comes into the foreground, if the date it should have fired is in the past. Is that possible?

Scheduled NSTimer when app is in background?

I have set up the following code to save a file to the documents directory:

    NSLog(@&quot;Saving File...&quot;);
    
    NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@&quot;http://www.reddexuk.com/logo.png&quot;]];
    AFHTTPRequestOperation *operation = [[[AFHTTPRequestOperation alloc] initWithRequest:request] autorelease];
    
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *path = [[paths objectAtIndex:0] stringByAppendingPathComponent:@&quot;logo.png&quot;];
    operation.outputStream = [NSOutputStream outputStreamToFileAtPath:path append:NO];
    
    [operation setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
        NSLog(@&quot;Successfully downloaded file to %@&quot;, path);
    } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
        NSLog(@&quot;Error: %@&quot;, error);
    }];
    
    [operation start];

However, I wish to add each file to a UITableView when it is successfully saved. When the file in the UITableView is tapped, I&#39;d like a UIWebView to navigate to that file (all offline). 

Also - how can I just get the filename and ending such as &quot;logo.png&quot; instead of http://www.reddexuk.com/logo.png?

How can I do this?

List saved files in iOS documents directory in a UITableView?

I&#39;ve read that in CPython, the interpreter stack (the list of Python functions called to reach this point) is mixed with the C stack (the list of C functions that were called in the interpreter&#39;s own code). If so, then how are generators and coroutines implemented? How do they remember their execution state? Does CPython copy each generator&#39;s / coroutine&#39;s stack to and from an OS stack? Or does CPython simply keep the generator&#39;s topmost stack frame on the heap, since the generator can only yield from that topmost frame?

How are generators and coroutines implemented in CPython?

<p>I've read that in CPython, the interpreter stack (the list of Python functions called to reach this point) is mixed with the C stack (the list of C functions that were called in the interpreter's own code). If so, then how are generators and coroutines implemented? How do they remember their execution state? Does CPython copy each generator's / coroutine's stack to and from an OS stack? Or does CPython simply keep the generator's topmost stack frame on the heap, since the generator can only yield from that topmost frame?</p>


Is there a way to stop a function from calling `print`?

---
I am using the [`pygame.joystick`][1] module for a game I am working on.

I created a `pygame.joystick.Joystick` object and in the actual loop of the game call its member function `get_button` to check for user input. The function does everything I need it to do, but the problem is that it also calls `print`, which slows down the game considerably. 

Can I *block* this call to `print`?

  [1]: http://pygame.org/docs/ref/joystick.html

How to block calls to print?

I wanted the `imshow()` function in `matplotlib.pyplot` to display images the opposite way, i.e upside down. Is there a simple way to do this? 

Invert image displayed by imshow in matplotlib

When initializing a dictionary with `d = {}` Pycharm&#39;s code inspector generates a warning, saying

&gt; This dictionary creation could be rewritten as a dictionary literal.

If I rewrite it `d = dict()` the warning goes away. Since `{}` already *is* a dictionary literal, I&#39;m pretty sure the message is erroneous. Furthermore, it seems like both `d = {}` and `d = dict()` are valid and Pythonic. 

This related question seems to conclude that the choice is just a matter of style/preference:
https://stackoverflow.com/questions/2745008/differences-between-d-dict-and-d

Why would Pycharm complain about `d = {}`?

*UPDATE:*

Mac nailed it. The warning actually applied to multiple lines, not just the one that was flagged.

Pycharm seems to look for a sequence of consecutive statements where you initialize a dictionary and then set values in the dictionary. For example, this will trigger the warning:

    d = {}
    d[&#39;a&#39;] = 1

But this code will not:

    d = {}
    pass
    d[&#39;a&#39;] = 1

Why does Pycharm&#39;s inspector complain about &quot;d = {}&quot;?

I have changed the name of an app in Django by renaming its folder, imports and all its references (templates/indexes). But now I get this error when I try to run `python manage.py runserver`

    Error: Could not import settings &#39;nameofmynewapp.settings&#39; (Is it on sys.path?): No module named settings

How can I debug and solve this error? Any clues?

How to change the name of a Django app?

I have used Matplotlib to plot lines on a figure. Now I would now like to set the style, specifically the marker, for individual points on the line. How do I do this?

To clarify my question, I want to be able to set the style for individual markers on a line, not every marker on said line.

Set markers for individual points on a line in Matplotlib

I&#39;ve got some example Python code that I need to mimic in C++. I do not require any specific solution (such as co-routine based yield solutions, although they would be acceptable answers as well), I simply need to reproduce the semantics in some manner.

Python
------

This is a basic sequence generator, clearly too large to store a materialized version.

    def pair_sequence():
        for i in range(2**32):
            for j in range(2**32):
                yield (i, j)

The goal is to maintain two instances of the sequence above, and iterate over them in semi-lockstep, but in chunks. In the example below the `first_pass` uses the sequence of pairs to initialize the buffer, and the `second_pass` regenerates the *same exact sequence* and processes the buffer again.

    def run():
        seq1 = pair_sequence()
        seq2 = pair_sequence()

        buffer = [0] * 1000
        first_pass(seq1, buffer)
        second_pass(seq2, buffer)
        ... repeat ...

C++
---

The only thing I can find for a solution in C++ is to mimic `yield` with C++ coroutines, but I haven&#39;t found any good reference on how to do this. I&#39;m also interested in alternative (non general) solutions for this problem. I do not have enough memory budget to keep a copy of the sequence between passes.

Equivalent C++ to Python generator pattern

Monads can do many amazing, crazy things. They can create variables which hold a superposition of values. They can allow you to access data from the future before you compute it. They can allow you to write destructive updates, but not really. And then the continuation monad allows you to _break people&#39;s minds!_ Ususally your own. ;-)

But here&#39;s a challenge: Can you make a monad which can be _paused_?

&lt;pre&gt;
data Pause s x
instance Monad (Pause s)
mutate :: (s -&gt; s) -&gt; Pause s ()
yield :: Pause s ()
step :: s -&gt; Pause s () -&gt; (s, Maybe (Pause s ()))
&lt;/pre&gt;

The `Pause` monad is a kind of state monad (hence `mutate`, with the obvious semantics). Normally a monad like this has some sort of &quot;run&quot; function, which runs the computation and hands you back the final state. But `Pause` is different: It provides a `step` function, which runs the computation until it calls the magical `yield` function. Here the computation is paused, returning to the caller enough information to resume the computation later.

For extra awesomness: Allow the caller to modify the state between `step` calls. (The type signatures above ought to allow this, for example.)

&lt;hr/&gt;

Use case: It&#39;s often easy to write code that does something complex, but a total PITA to transform it to also _output_ the intermediate states in its operation. If you want the user to be able to _change_ something mid-way through execution, things get complex really fast.

Implementation ideas:

* _Obviously_ it can be done with threads, locks and `IO`. But can we do better? ;-)

* Something insane with a continuation monad?

* Maybe some kind of writer monad, where `yield` just logs the current state, and then we can &quot;pretend&quot; to `step` it by iterating over the states in the log. (Obviously this precludes altering the state between steps, since we&#39;re not really &quot;pausing&quot; anything now.)


The Pause monad

I understand the principle of coroutines. I know how to get the standard `StartCoroutine` / `yield return` pattern to work in C# in Unity, e.g. invoke a method  returning `IEnumerator` via `StartCoroutine` and in that method do something, do `yield return new WaitForSeconds(1);` to wait a second, then do something else.

My question is: what&#39;s really going on behind the scenes? What does `StartCoroutine` really do? What `IEnumerator` is `WaitForSeconds` returning? How does `StartCoroutine` return control to the &quot;something else&quot; part of the called method? How does all this interact with Unity&#39;s concurrency model (where lots of things are going on at the same time without use of coroutines)?

How does StartCoroutine / yield return pattern really work in Unity?

I am new to gevents and greenlets. I found some good documentation on how to work with them, but none gave me justification on how and when I should use greenlets!

* What are they really good at?
* Is it a good idea to use them in a proxy server or not?
* Why not threads?

What I am not sure about is how they can provide us with concurrency if they&#39;re basically co-routines.

Greenlet Vs. Threads

**Background:**

I&#39;m asking this because I currently have an application with many (hundreds to thousands) of threads. Most of those threads are idle a great portion of the time, waiting on work items to be placed in a queue. When a work item comes available, it is then processed by calling some arbitrarily-complex existing code. On some operating system configurations, the application bumps up against kernel parameters governing the maximum number of user processes, so I&#39;d like to experiment with means to reduce the number of worker threads. 

**My proposed solution:**

It seems like a coroutine-based approach, where I replace each worker thread with a coroutine, would help to accomplish this. I can then have a work queue backed by a pool of actual (kernel) worker threads. When an item is placed in a particular coroutine&#39;s queue for processing, an entry would be placed into the thread pool&#39;s queue. It would then resume the corresponding coroutine, process its queued data, and then suspend it again, freeing up the worker thread to do other work.

**Implementation details:**

In thinking about how I would do this, I&#39;m having trouble understanding the functional differences between stackless and stackful coroutines. I have some experience using stackful coroutines using the [Boost.Coroutine](http://www.boost.org/doc/libs/1_57_0/libs/coroutine/doc/html/index.html) library. I find it&#39;s relatively easy to comprehend from a conceptual level: for each coroutine, it maintains a copy of the CPU context and stack, and when you switch to a coroutine, it switches to that saved context (just like a kernel-mode scheduler would).

What is less clear to me is how a stackless coroutine differs from this. In my application, the amount of overhead associated with the above-described queuing of work items is very important. Most implementations that I&#39;ve seen, like [the new CO2 library](https://github.com/jamboree/co2) suggest that stackless coroutines provide much lower-overhead context switches. 

Therefore, I&#39;d like to understand the functional differences between stackless and stackful coroutines more clearly. Specifically, I think of these questions:

- [References like this one](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3708.pdf) suggest that the distinction lies in where you can yield/resume in a stackful vs. stackless coroutine. Is this the case? Is there a simple example of something that I can do in a stackful coroutine but not in a stackless one?

- Are there any limitations on the use of automatic storage variables (i.e. variables &quot;on the stack&quot;)? 

- Are there any limitations on what functions I can call from a stackless coroutine?

- If there is no saving of stack context for a stackless coroutine, where do automatic storage variables go when the coroutine is running?

Content Type	Original Author	Original Content on Stackoverflow
Question	A. Jesse Jiryu Davis	View Question on Stackoverflow
Solution 1 - Python	jsbueno	View Answer on Stackoverflow
Solution 2 - Python	Rudi	View Answer on Stackoverflow

How are generators and coroutines implemented in CPython?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

List saved files in iOS documents directory in a UITableView?

Scheduled NSTimer when app is in background?

Attributions