Popular recipes tagged "function" but not "linux" and "math"

Implementing function-based callbacks in Python (Python)

2017-04-19T18:03:11-07:00

Python recipe 580787 by Vasudev Ram (callback, function, functions, python, techniques).

This recipe shows a simple way of implementing callbacks in Python. There are a few ways this can be done. The way shown here uses a simple function-based approach.

In a nutshell, a callback can be informally described like this: function a calls function b, and wants to make b run a specific independent chunk of code at some point during b's execution. We want to be able to vary which chunk of code gets called in different calls to b, so it cannot be hard-coded inside b. So function a passes another function, c, to b, as one argument, and b uses that parameter c to call the functionality that a wants b to call. (Function b may pass some parameters to the function represented by c, when it calls it. These could be either internally generated, passed from a, or a combination of both). So, by changing the value of the function c that gets passed to b (on different calls to b), a can change what chunk of code b calls.

More details and full code, description and output here:

https://jugad2.blogspot.in/2017/04/implementing-and-using-callbacks-in.html

Function guards for Python 3 (Python)

2016-05-01T13:11:05-07:00

Python recipe 580658 by Dmitry Dvoinikov (call, decorator, dispatch, function, guard).

This module implements a function guard - facility to redirect the the call to one of several function implementations at run time based on the actual call arguments.

Wrap each of the identically named functions in a @guard decorator and provide a _when parameter with a default value set to guarding expression.

See samples at the top of the module.

Guess a number (Python)

2014-11-15T09:06:05-08:00

Python recipe 578962 by Benoit (function, game, random, sample).

This is just a little game to explain some very basic function in Python for beginner. RANDOM, Loop, Try and except...

Two Versions Of Bash One Liner INKEY$ Functions... (Bash)

2013-03-28T17:51:32-07:00

Bash recipe 578502 by Barry Walker (bash, function, inkey, shell). Revision 2.

This is probably common knowledge to the professionals but not so much for amateurs like myself.

This is a code snippet for the equivalent of BASIC's...

LET char$=INKEY$

As the timeout parameter cannot be less than 1 second then this is the only limitation...

It is a single line function which has a variable "char"...

Read the code for more information...

There are now two versions, edit out and choose which is best for you...

All [iter] is Instance of [class/type/tuple] (Python)

2012-07-26T18:09:30-07:00

Python recipe 578226 by Jonathan Frere (function, instance, isinstance). Revision 2.

So it turned out that I needed a way of ensuring that all members of an iterable are instances of a certain class. Here, therefore, is the isallinstance() function.

Smarter Default Arguments (Python)

2011-08-12T23:06:57-07:00

Python recipe 577786 by Eric Snow (default_arguments, deferred, function, functions). Revision 3.

Improved handling of mutable and deferred default arguments. After the recipe you'll find an explanation of what that means.

Works for 2.7 with minor tweaks (getfullargspec --> getargspec).

Decorator to expose local variables of a function after execution (Python)

2010-07-07T22:01:23-07:00

Python recipe 577283 by Pietro Berkes (decorator, function, inner, local, scope, variables). Revision 2.

Decorator to expose the local variables defined in the inner scope of a function. At the exit of the decorated function (regular exit or exceptions), the local dictionary is copied to a read-only property, locals.

The main implementation is based on injecting bytecode into the original function, and requires the lightweight module byteplay (available here). See below for an alternative implementation that only uses the standard library.

Change a Function's Closure! (Python)

2011-08-12T23:25:55-07:00

Python recipe 577760 by Eric Snow (closure, function). Revision 2.

This is a hack to get around the read-only nature of __closure__ on function objects. Watch your step!

Simple recursive function to non-recursive function (Python)

2011-05-27T01:47:37-07:00

Python recipe 577724 by Sunjay Varma (function, list, recursive, substitute).

This recipe is a simple solution for turning a recursive function into a non-recursive function.

A simple function benchmarking module (Python)

2010-08-27T09:26:48-07:00

Python recipe 577377 by Timothee Cezard (benchmark, debugging, function).

This module enable its user to monitor the amount of time spend in between two commands start and stop. The module is fairly imprecise if the monitored task is quick as the start and stop commands are fairly slow (2e-07 - 5e-07 second)

Decorator to expose local variables of a function after execution [alternative implementation] (Python)

2010-07-08T09:44:28-07:00

Python recipe 577295 by Andrea Maffezzoli (decorator, function, inner, local, scope, variables). Revision 6.

Please note that the present is a fork of the recipe 577283 "Decorator to expose local variables of a function after execution" of Pietro Berkes, available at http://code.activestate.com/recipes/577283-decorator-to-expose-local-variables-of-a-function-/ , and aiming only to report the alternative implementation "persistent_locals2", whose I'm co-author with Pietro Berkes, and which was submitted together to the original recipe. Refer to the latter for an exhaustive description and discussion.

A new method for computing the hypergeometric function 1F1(a,b,t) (Python)

2010-03-22T05:00:20-07:00

Python recipe 577133 by Fernando Nieuwveldt (function, hypergeometric, laplace_inversion). Revision 3.

I present a method of computing the 1F1(a,b,x) function using a contour integral. The method is based on a numerical inversion, basically the Laplace inversion. Integral is 1F1(a,b,x) = Gamma(b)/2\pi i \int_\rho exp(zx)z^(-b)(1+x/z)^(-a)dz, \rho is taken as a Talbot contour. The Talbot method is applied with the use of the midpoint rule for numerical integration. Here the user must give the number of function evaluations and this may vary from problem to problem. It is very easy to implement with only a few lines of code and it is very accurate even for large arguments.

Simple Function Overloading with Decorator (Python)

2010-04-06T00:59:52-07:00

Python recipe 577064 by Ryan Lie (decorator, function, overloading, python). Revision 3.

The recipe presents a simple decorator for function overloading in python. The @overloaded function searches for the first overloads that doesn't raise TypeError when called. Overloads are added to the overloads list by using the @func.overload_with decorator. The order of function definition determines which function gets tried first and once it founds a compatible function, it skips the rest of the overloads list.

Type-Checking Function Overloading Decorator (Python)

2010-04-11T11:16:48-07:00

Python recipe 577065 by Ryan Lie (checkng, decorator, function, overloading, python, type). Revision 2.

The recipe presents a function overloading decorator in python that do type check. The type signature is marked with the @takes and @returns decorator, which causes the function to raise an InputParameterError exception if called with inappropriate arguments. The @overloaded function searches for the first overloads that doesn't raise TypeError or InputParameterError when called. Alternative overloads are added to the overloads list by using the @func.overload_with decorator. The order of function definition determines which function gets tried first and once it founds a compatible function, it skips the rest of the overloads list.

Exception handling in a single line (Python)

2009-10-09T01:07:52-07:00

Python recipe 576872 by Radek Szklarczyk (exception, expression, function, list_comprehension, wrapper). Revision 16.

The rules of duck typing in python encourage programmers to use the "try...except..." clause. At the same time python with new versions enables to use more powerful list comprehensions (for example Conditional Expressions). However, it is impossible to write the "try...except..." clause in a list comprehension. The following recipe "protects" a function against exception and returns a default value in the case when exception is thrown.

C function decorator (Python)

2009-04-29T23:55:03-07:00

Python recipe 576731 by geremy condra (cpp, ctypes, decorator, function). Revision 6.

This recipe provides an easy-to-use, decorator-based solution to the problem of using functions from other languages, especially C, in Python. It takes advantage of Python's new annotations to provide simple type checking and automatic conversion. If you like it, you may also want to check out my C structure decorator

Reevaluate functions when called, v3 (Python)

2009-05-14T15:18:41-07:00

Python recipe 576754 by geremy condra (annotations, decorator, function). Revision 3.

This small snippet came about as a result of this discussion on python-ideas, requesting a new syntax for dynamically reevaluating a function each time it is called.

It is a minor alteration of version 2 of this recipe that, instead of calling eval() on string annotations, simply requires that the annotations be callable and calls them at runtime.

Reevaluate functions when called (Python)

2009-05-13T15:53:28-07:00

Python recipe 576751 by geremy condra (decorator, function). Revision 2.

This small snippet came about as a result of this discussion on python-ideas, requesting a new syntax for dynamically reevaluating a function each time it is called.

This snippet implements a simple decorator to do so without added syntax.

Reevaluate functions when called, v2 (Python)

2009-05-14T15:10:51-07:00

Python recipe 576753 by geremy condra (annotations, decorator, function).

As with version 1 of this recipe, it was sparked by a discussion on python-ideas about adding a special syntax to function signatures for reevaluating the arguments to a function at runtime. The below is a decorator and annotation based solution to this problem which stores the code to be evaluated as a string in the annotations, rather than reevaluating the entire function every time it is called.

Parse call function for Py2.6 and Py2.7 (Python)

2009-02-28T20:13:15-08:00

Python recipe 576671 by Jervis Whitley (ast, call, function, namedtuple, nodevisitor, parsing). Revision 14.

In some cases it may be desirable to parse the string expression "f1(*args)" and return some of the key features of the represented function-like call.

This recipe returns the key features in the form of a namedtuple.

e.g. (for the above)

>>> explain("f1(*args)")
[ Call(func='f1', starargs='args') ]

The recipe will return a list of such namedtuples for "f1(*args)\nf2(*args)" Note that while the passed string expression must evaluate to valid python syntax, names needn't be declared in current scope.