Popular recipes tagged "stack"

Simple Infix Expression Evaluation (Python)

2015-11-07T18:44:05-08:00

Python recipe 579122 by FB36 (algorithm, algorithms, math, mathematics, stack).

Simple infix expression evaluation using a stack.

Infix Expression Evaluation (Python)

2015-11-08T05:08:26-08:00

Python recipe 579123 by FB36 (algorithm, algorithms, math, mathematics, stack).

Infix expression evaluation using two stacks.

small stack language (Python)

2013-07-22T23:53:44-07:00

Python recipe 578617 by Andrew Wayne Teesdale Jr. (language, stack).

a small language in python

Peek at Python value stack (Python)

2013-01-08T22:15:21-08:00

Python recipe 578412 by Dima Tisnek (python, python2, stack).

Poking at value stack, a.k.a. evaluation stack is not allowed in Python, however everything is doable with ctypes.

I think this could be useful in debugging complex statements.

Stack Environment (Python)

2017-06-22T10:24:05-07:00

Python recipe 578147 by Alfe (environment, global, stack, stackenv, variable). Revision 3.

The environment variables of processes get inherited by their children who can modify them and pass them on to their children. The tree of processes is similar to the call tree of a running Python process, but a similar mechanism like the environment variables is missing. I'm offering a solution for this; each stack frame takes the place of a process, hence I call it StackEnv. It comes in handy if you want to pass information from one frame to a frame far below without patching all the calls in between to pass the data (which might belong to a framework you don't want to change).

Usecases:

You call a framework which calls back your code before returning (e. g. in passed objects you provide). You want to pass some information to your code without relying on global variables or similar constructs which weren't thread-safe nor re-entrant.
You want to pass pseudo-global but in fact situation-related information (e. g. the verbosity based on the situation the call comes from) without handing the information down in each and every call which can happen below yours.
You want to give called methods the option to override the decision of the caller method regarding this information. (E. g. the caller decides that verbosity should be True, but the called method then calls another method and decides that the verbosity in this case should be False.)

Alike processes, called frames cannot influence the values for calling frames (but of course mutable values can be used to pass information upwards; this normal kind of "abuse" isn't prevented).

Importing:

from stackEnv import stackEnv

Setting a stackEnv variable:

stackEnv.verbose = True

Using the value of a stackEnv variable:

if stackEnv.verbose: print "being verbose now"

Testing a stackEnv variable:

if 'verbose' in stackEnv: print "having information on verbosity"

Overriding a stackEnv variable's value for the rest of this frame and its calls:

stackEnv.verbose = False

Removing a stackEnv variable for the rest of this frame and its calls:

del stackEnv.verbose

Some more useful API of this class can be found in the unit test included.

How to debug (deadlocked) multi threaded programs (Python)

2010-07-26T15:39:15-07:00

Python recipe 577334 by Laszlo Nagy (dead, debug, lock, stack, thread, trace).

Simple module that allows you to explore deadlocks in multi threaded programs.

backtrace2line - stack traces with source file name and line numbers (Python)

2010-12-20T06:57:29-08:00

Python recipe 534147 by Jean Brouwers (backtrace, backtrace_symbols_fd, files, linux, stack, stacktrace). Revision 3.

This recipe reads a file containing stack traces from Linux' backtrace functions and extends each stack frame line with the source file name and line number. Usage and an example are included.