|  | 
          def()
          is the function which can be used to expose C++ functions and callable
          objects as Python functions in the current
          scope.
        
template <class F> void def(char const* name, F f); template <class Fn, class A1> void def(char const* name, Fn fn, A1 const&); template <class Fn, class A1, class A2> void def(char const* name, Fn fn, A1 const&, A2 const&); template <class Fn, class A1, class A2, class A3> void def(char const* name, Fn fn, A1 const&, A2 const&, A3 const&);
name is an ntbs which conforms to Python's identifier naming rules.
Fn is [derived
                    from] object,
                    it will be added to the current
                    scope as a single overload. To be useful, fn should be callable.
                  
                    If a1 is the
                    result of an overload-dispatch-expression,
                    only the second form is allowed and fn
                    must be a pointer to function or pointer to member function whose
                    arity is the same as A1's maximum
                    arity.
                  
                    Effects: For each prefix P of Fn's
                    sequence of argument types, beginning with the one whose length
                    is A1's minimum
                    arity, adds a name(...) function overload to the
                    current
                    scope. Each overload generated invokes a1's call-expression
                    with P, using a copy of a1's call policies. If the longest valid
                    prefix of A1 contains N types and a1 holds M keywords, an initial
                    sequence of the keywords are used for all but the first N - M
                    arguments of each overload.
                  
Otherwise, fn must be a non-null function or member function pointer, and a single function overload built around fn is added to the current scope. If any of a1-a3 are supplied, they may be selected in any order from the table below.
| Mnemonic Name | Requirements/Type properties | Effects | 
|---|---|---|
| docstring | Any ntbs | 
                              Value will be bound to the  | 
| policies | A model of CallPolicies | A copy will be used as the call policies of the resulting method overload. | 
| keywords | 
                              The result of a keyword-expression
                              specifying no more arguments than the arity
                              of  | A copy will be used as the call policies of the resulting method overload. | 
#include <boost/python/def.hpp> #include <boost/python/module.hpp> #include <boost/python/args.hpp> using namespace boost::python; char const* foo(int x, int y) { return "foo"; } BOOST_PYTHON_MODULE(def_test) { def("foo", foo, args("x", "y"), "foo's docstring"); }