Related questions

Dynamic generation of Python function with given parameter names

2018-07-12 07:33 beldaz imported from Stackoverflow

I would like to create functions in my Python3 code, making use of data supplied during run-time. I'm stuck on how I can write a function along the lines of

def foo(varname1, varname2):
    return varname1 + varname2

where the strings varname1 and varname2 that give the parameter names are specified as arguments to some constructor function, e.g.:

def makeNewFooFunc(varname1, varname2):
    # do magic
    return foo

fooFunc = makeNewFooFunc('first', 'second')

print(fooFunc(first=1, second=2))
# should return 3

what would be the #do magic step? Is this a job for eval, or is there an alternative?

1 answer

  • answered 2018-07-12 07:58 Ilya Miroshnichenko

    You don't need to write a function like that. just use **kwargs

    def foo_func(**kwargs):
    return sum(kwargs.values())

foo_func(any_name=1, any_name_2=2)

    but if you still need to do what you want, you can try

    def make_new_func(var_name_1, var_name_2):
    def foo(**kwargs):
        # make sure in kwargs only expected parameters
        assert set(kwargs) == {var_name_1,  var_name_2}
        return kwargs[var_name_1] + kwargs[var_name_2]
    return foo

foo_func = make_new_func('a', 'b')

foo_func(a=1, b=2)

See also questions close to this topic

  • Python script communicate with server

    I am trying to write a python script that can communicate with a server running on port 9999. To be able to set ut the communication with the server, I have to provide a secret code for the server.

    How do I set up communication with the server using python? And where in the set-up process should I provide the secret code?

    I'm also supposed to solve different "puzzles" on the server, how do I find the information on the server when the communication is set up?

    Hope anyone can help!!

  • read file block by block in python

    I have file that has this format

    MACRO L20_FDPQ_TV1T8_1
 FIXEDMASK ;
 CLASS CORE ;
 ...
 ...
END L20_FDPQ_TV1T8_1
MACRO INV_20
...
...
END INV_20

    I want to read the file as blocks such that each MACRO to end of its name form a block in python. how this can be done in an efficient way?

  • what is the difference in these two isinstances() definitions?

    1. isinstance(list(), type(array))

    2. isinstance(array, list)

    Is there any difference apart from the speed? I can see 2 is faster.

  • How to crawl 3 websites with beautifulsoup and add its items in single csv

    I have and project to crawl 3 websites with almost similar information's from each product items.

    I have to use BeautifulSoup and Pandas.
    My question is how to crawl three websites in single beautifulSoup file, and add them all together in single project?

    I have to add and export all items from websites in single csv file or jsnon file, because client have compare prices and items.

    Any help of guide or suggestion will be appreciate. Thanks a lot!

  • Python 3 equivalent of Python 2 str.decode('hex')

    I'm trying to convert IEEE 754 floats in hex to standard python floats.

    The following works in Python 2.x : 

    foo ='4074145c00000005'
conv_pound = struct.unpack('!d', foo.decode('hex'))[0]
print(conv_pound)

    and produces the following output (which is indeed the number that I want):

    321.272460938

    However, python 3 does not have a str.decode method and I'm struggling to find how to do this. Any tips ?

  • How does this name resolution work with an implementator function and a fallback function?

    A project I'm working on requires multiple targets to be compiled for. Per target the underlying implementation may vary as the device requires hardware to be configured differently.

    In order to force target implementations to follow a interface/design contract system was designed. If a target does not implement said interface accordingly, an error will be thrown upon usage.

    The following code is compiled correctly by gcc, arm-none-eabi-gcc and clang

    #include <iostream>

namespace hwstl {
    namespace interface_contracts {
        namespace pin {
            void set(bool a) {
                // Report the dissatisfaction
                // Eventually this should happen during compilation
                std::cout << "contract not satisfied" << std::endl;
            }
        }
    }

    namespace target {
        namespace pin {
            using namespace interface_contracts::pin;

            void set(bool v) {
                std::cout << "target" << std::endl;
            }
        }
    }

    namespace unsatisfied_target {
        namespace pin {
            using namespace interface_contracts::pin;

            // No implementation provided for `set(bool)`
            // Usage of unsatisfied_target::set(bool) will direct
            // all function calls to interface_contracts::pin::set(bool);
        }
    }

    namespace device = target;
    namespace unsatisfied_device = unsatisfied_target;
}

int main() {
    hwstl::device::pin::set(true); // prints: target
    hwstl::unsatisfied_device::pin::set(true); // prints: contract not satisfied
    return 0;
}

    Demo 1

    Now there are multiple questions that arise when reasoning why this code would compile or not:

    Why does the compiler not report unresolved ambiguity between target::set(bool) and interface_contracts::set(bool)?

    Why does the following code not compile, since my theory is that the same naming structure is achieved but on a different manner:

    #include <iostream>

namespace hwstl {
    namespace interface_contracts {
        namespace pin {
            void set(bool a) {
                // Report the dissatisfaction
                // Eventually this should happen during compilation
                std::cout << "contract not satisfied" << std::endl;
            }
        }
    }

    namespace target {
        using namespace interface_contracts;

        namespace pin {
            void set(bool v) {
                std::cout << "target" << std::endl;
            }
        }
    }

    namespace unsatisfied_target {
        using namespace interface_contracts;

        namespace pin {
            // No implementation provided for `set(bool)`
            // Usage of unsatisfied_target::set(bool) will direct
            // all function calls to interface_contracts::pin::set(bool);
        }
    }

    namespace device = target;
    namespace unsatisfied_device = unsatisfied_target;
}

int main() {
    hwstl::device::pin::set(true); // prints: target
    hwstl::unsatisfied_device::pin::set(true); // prints: contract not satisfied
    return 0;
}

    Note the slight difference at 'using namespace interface_contracts'

    Demo 2

  • ISO a good way to let a function accept a mix of supplied arguments, arguments from a list, and defaults

    I would like to have a function accept arguments in the usual R way, most of which will have defaults. But I would also like it to accept a list of named arguments corresponding to some or some or all of the formals. Finally, I would like arguments supplied to the function directly, and not through the list, to override the list arguments where they conflict.

    I could do this with a bunch of nested if-statements. But I have a feeling there is some elegant, concise, R-ish programming-on-the-language solution -- probably multiple such solutions -- and I would like to learn to use them. To show the kind of solution I am looking for:

    > arg_lst <- list(x=0, y=1)
> fn <- function(a_list = NULL, x=2, y=3, z=5, ...){
   <missing code>
   print(c(x, y, z))
  }

> fn(a_list = arg_list, y=7)

    Desired output:

    x  y  z
0  7  5
  • How does short-circuiting work in std::conjunction

    Given the following code (https://wandbox.org/permlink/Eof3RQs49weJMWan)

    #include <tuple>
#include <type_traits>
#include <utility>

template <typename T>
inline constexpr auto always_false = false;

template <typename T>
class HardError {
    static_assert(always_false<T>);
};

int main() {
    std::ignore = std::conjunction<std::false_type, HardError<int>>{};
}

    I am trying to understand why this does not error out with std::conjunction as used above. I understand that it is meant to allow short-circuiting so this does not happen, and that this is by design.

    However, I don't understand the language rules that allow this to happen. Given the implementation of std::conjunction below

    template<class...> struct conjunction : std::true_type { };
template<class B1> struct conjunction<B1> : B1 { };
template<class B1, class... Bn>
struct conjunction<B1, Bn...> 
    : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};

    We end up inheriting from this specialization of std::conditional

    template<class T, class F>
struct conditional<false, T, F> { typedef F type; };

    This requires both class types for instantiation. Then how is the conjunction<Bn...> elided by the language?