> Hi,

> Having a file called funcs.py, I would like to read it into a string,
> and then import from that string.
> That is instead of importing from the fie system, I wonder if it's
> possible to eval the text in the string and treat it as a module.

> For example

> with file('funcs.py') as f: txt = r.read()
> string_import(txt, 'funcs')  # is string_import possible?

> to have now a module called funcs with the functions defined in
> funcs.py.

> > Hi,

> > Having a file called funcs.py, I would like to read it into a string,
> > and then import from that string.
> > That is instead of importing from the fie system, I wonder if it's
> > possible to eval the text in the string and treat it as a module.

> > For example

> > with file('funcs.py') as f: txt = r.read()
> > string_import(txt, 'funcs')  # is string_import possible?

> > to have now a module called funcs with the functions defined in
> > funcs.py.

> You can do something like this:

> import types
> import sys

> mymodule = types.ModuleType("mymodule", "Optional Doc-String")

> with file('funcs.py') as f:
>     txt = f.read()
> exec txt in globals(), mymodule.__dict__
> sys.modules['mymodule'] = mymodule

> Note that you shouldn't exec untrusted code.
> You might also look at the __import__ funciton, which can import by python path.
> You might also look at the imp module.

> Matt

>> > Having a file called funcs.py, I would like to read it into a string,
>> > and then import from that string.
>> > That is instead of importing from the fie system, I wonder if it's
>> > possible to eval the text in the string and treat it as a module.
>> mymodule = types.ModuleType("mymodule", "Optional Doc-String")
>> with file('funcs.py') as f:
>>     txt = f.read()
>> exec txt in globals(), mymodule.__dict__
>> sys.modules['mymodule'] = mymodule

> Thanks, it seems simpler than I thought.
> I don't fully understand , though, the exec statement, how it causes
> the string execute in the context of mymodule.

> > On Nov 3, 7:49 pm, Matt McCredie <mccre...@gmail.com> wrote:
> >> iu2 <israelu <at> elbit.co.il> writes:

> >> > Having a file called funcs.py, I would like to read it into a string,
> >> > and then import from that string.
> >> > That is instead of importing from the fie system, I wonder if it's
> >> > possible to eval the text in the string and treat it as a module.
> >> mymodule = types.ModuleType("mymodule", "Optional Doc-String")
> >> with file('funcs.py') as f:
> >>     txt = f.read()
> >> exec txt in globals(), mymodule.__dict__
> >> sys.modules['mymodule'] = mymodule

> > Thanks, it seems simpler than I thought.
> > I don't fully understand , though, the exec statement, how it causes
> > the string execute in the context of mymodule.

> Sometimes you don't even require a module, and this is simpler to  
> understand. Suppose you have a string like this:

> txt = """
> def foo(x):
>    print 'x=', x

> def bar(x):
>    return x + x
> """

> you may execute it:

> py> namespace = {}
> py> exec txt in namespace

> The resulting namespace contains the foo and bar functions, and you may  
> call them:

> py> namespace.keys()
> ['__builtins__', 'foo', 'bar']
> py> namespace['foo']('hello')
> x= hello

> exec just executes the string using the given globals dictionary as its  
> global namespace. Whatever is present in the dictionary is visible in the  
> executed code as global variables (none in this example). The global names  
> that the code creates become entries in the dictionary. (foo and bar;  
> __builtins__ is an implementation detail of CPython). You may supply  
> separate globals and locals dictionaries.

> --
> Gabriel Genellina- Hide quoted text -

> - Show quoted text -

>> def bar(x):
>>    return x + x
>> """

>> py> namespace = {}
>> py> exec txt in namespace
>> py> namespace.keys()
>> ['__builtins__', 'foo', 'bar']
>> py> namespace['foo']('hello')
>> x= hello
> What happens if both global and local dictionaries are supplied: where
> are the newly created entities created? In the local dict?

>>> txt = """
>>> def foo(x):
>>>    print 'x=', x

>>> def bar(x):
>>>    return x + x
>>> """

>>> py> namespace = {}
>>> py> exec txt in namespace
>>> py> namespace.keys()
>>> ['__builtins__', 'foo', 'bar']
>>> py> namespace['foo']('hello')
>>> x= hello

>> What happens if both global and local dictionaries are supplied: where
>> are the newly created entities created? In the local dict?

> The amazing thing about Python is how easy is to experiment in the
> interpreter.
> Just see it by yourself!

> >>> txt = """
> >>> def foo(x):
> >>>    print 'x=', x

> >>> def bar(x):
> >>>    return x + x
> >>> """

> >>> py> namespace = {}
> >>> py> exec txt in namespace
> >>> py> namespace.keys()
> >>> ['__builtins__', 'foo', 'bar']
> >>> py> namespace['foo']('hello')
> >>> x= hello

> >> What happens if both global and local dictionaries are supplied: where
> >> are the newly created entities created? In the local dict?

> > The amazing thing about Python is how easy is to experiment in the
> > interpreter.
> > Just see it by yourself!

> Hint: they are created in the same namespace they always are (ignoring
> nested functions and nonlocal namespaces). But I agree with Gabriel:
> just try it. n1,n2={},{}; exec....

> Terry Jan Reedy- Hide quoted text -

> - Show quoted text -