Как вызвать функцию с не-родным global namespace?

Не-а. Есть тонкая тонкость - eval и exec позволяют менять намеспайсы для выражения. Если в выражении стоит 'f()' то для самой f намеспайс останется какой был. Если только тело f загнать в exec - так я как раз этого делать не хочу (откуда я тело ф-ии возьму), а exec(f.func_code) ведет себя странно и не позвляет наймспейсы менять...

Тогда exec.

>>> def f(): print a
>>> exec "a = 1; f()"
1

Дык в том то все и дело, что я вместо глобал наймеспайсе хочу подсунуть свой объект, который довольно специфически работает. Так как Вы предлагаете этого точно сделать не получиться...

Дык в том то все и дело, что я вместо глобал наймеспайсе хочу подсунуть свой объект, который довольно специфически работает.

Развернуть этот объект в последовательность Python-операторов нельзя?

Кстати, продолжая тему «в Python ничего спрятать нельзя»:

>>> def f(): print x
... 
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in f
NameError: global name 'x' is not defined
>>> f.func_globals["x"] = 123
>>> f()
123
>>> 

Этот объект генерит новое значение по ключу в зависимости от ключа. Ну скажем _2012_10_03 - дата третье октября сего года и т.д.;-)

Так что увы - заранее набить все потенциальные значения в наймспасе не получиться... хотя, в f.func_code.co_names есть все имена функции, так что это в принципе возможно.

Но таки хотелось бы сделать через эмуляцию namespace, это очень многое упростит.

АГа... ничего что x при этом оказывается в глобальном пр-ве имен?

>>> x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> def f(): return x
... 
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in f
NameError: global name 'x' is not defined
>>> f.func_globals['x'] = 123
>>> f()
123
>>> x
123
>>> 

Вообще, подумав - хочется даже не с не-родным local namespace!

ничего что x при этом оказывается в глобальном пр-ве имен?

Эээ... ты у меня спрашиваешь? %) Если это неприемлемо, сделай del x после вызова функции.

Use FunctionType, Luke!

In [1]: def f(): return x

In [6]: from types import FunctionType

In [7]: new_env = f.func_globals.copy()

In [8]: fl = FunctionType(f.func_code, new_env, f.func_name, f.func_defaults, f.func_closure)

In [9]: fl()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/home/max/<ipython-input-9-d41bee4190f2> in <module>()
----> 1 fl()

/home/max/<ipython-input-1-4d3cc9596328> in f()
----> 1 def f(): return x

NameError: global name 'x' is not defined

In [10]: x
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/home/max/<ipython-input-10-401b30e3b8b5> in <module>()
----> 1 x

NameError: name 'x' is not defined

In [11]: new_env['x'] = 42

In [12]: fl()
Out[12]: 42

In [13]: x
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/home/max/<ipython-input-13-401b30e3b8b5> in <module>()
----> 1 x

NameError: name 'x' is not defined

Вообще, подумав - хочется даже не с не-родным local namespace!

По идее это уже с изменением func_closure, но я сам такого не делал.

Да, это замечательный способ что то спрятать! Я кстати могу предложить идеальную команду для защиты информации: rm -rf ... ;-)

Блин... какая то очень скудная информация про эту func_closure... оно должны быть tuple, но чего tuple?

Да, это замечательный способ что то спрятать!

Не спрятать, а почистить.

Дык почистить не проблема, проблема закрыть какие то поля от внешнего доступа. Точнее и это не проблема (прятать что то в памяти своего процесса от себя же довольно странная идея), - проблема в том что бы закрыть данные хотя бы символически. Я обычно не заморачиваюсь, то что для внутреннего пользования начинается с подчеркивания.

проблема в том что бы закрыть данные хотя бы символически.

Задай отдельные глобалы через FunctionType (а не используй общие, как в моем примере с f.func_globals), и дело сделано. Хотя насчет «с измененным локальным namespace-ом» я просто не понял. Как звучит настоящий вопрос?

Так примерно и звучит как ни странно. Ок, от печки:

Есть некая система занимающаяся кодогенерацией для числодробилок и еще черти чем. Там встречается код типа:

section('CCC')
a[1,-3,2] = a[0,-2,3]+b[1,3,4]*c ...
...
section('LLC')
...

Хочется поменять это на

def CCC() :
    a1_32 = a0_23+b134*c ...
...
def LLC() :
...

Гипотетически это возможно - надо тело ф-ии запустить с пользовательским объектом эмулирующим локальный намеспайс, со специального вида __getitem__/__setitem__

ВОпрос технический - КАК запустить тело ф-ии... Вариант загнать тело в виде строки в exec можно, но не хочется, т.к. теряется подсветка синтаксиса и вообще...

Что ты вообще хочешь получить? Все переменные не определённые в точке определения функции являются глобальными, и только к глобальным переменным обращение идёт по именам, к локальным и захваченным из внешних областей видимости - по индексам (см. func.func_code.co_cellvars).

А интерпретировать напрямую? Приведенные примеры - валидный Python.

надо тело ф-ии запустить с пользовательским объектом эмулирующим локальный намеспайс

Тебе нужно отдельное _глобальное_ пространство имён - замена func_globals, то что я показал.

Я кстати могу предложить идеальную команду для защиты информации: rm -rf ...

открой для себя shred -uzn666

Мне надо что бы в моем пр-ве имен создавались новые переменные, это только локалс. Но я понял, там с индексами ловить нечего, только exec похоже... или патчить питон;-)

прятать что то в памяти своего процесса от себя же довольно странная идея

это хорошая, годная идея. Я по вашему должен count1, count2, count3... и так Over9000 count'ов делать?

Ес-но валижный питон, мы за это боролись... не очень хочется связываться с exec-ом, но похоже других альтернатив нету.

Вы? По моему? По моему Вам не надо писать не по теме в треде (для начала).

Непонятно. Если код ваш, или всё равно его предполагается переписать, что мешает переписать ту же f таким образом, чтобы она явно брала переменные не из глобального неймспейса, а из спец. объекта.

Была и такая мысль. Будет много лишних букв - этот объект каждый раз придется указывать.

Ес-но валижный питон, мы за это боролись...

Кхм. Валидный Python - это

section('CCC')
a[1,-3,2] = a[0,-2,3]+b[1,3,4]*c ...
...
section('LLC')

его точно нельзя интерпретировать напрямую, строка за строкой?

Ну во первых там есть и многострочные конструкции, во вторых если файл подымать так лучше execfile (как раз туда пр-ва имен передаются).

И в третьих Вы можете предложить вариант перехода в построчный разбор и потом обратно? Т.е. вот сунул я питону файл (как обычно), он его жует, потом хопа - меняет алгоритм разбора а потом хопа - возвращается к старому? Я че то не понял про построчный разбор...

Не насилуй питон, пиши на руби.

в третьих Вы можете предложить вариант перехода в построчный разбор и потом обратно?

Я, наверное, чего-то не понимаю, но:

for l in file("whatever").readlines():
  if l.startswith("XXX"):
    eval(l)

Мне надо что бы в моем пр-ве имен создавались новые переменные, это только локалс

Ну эти же функции ты сам генеришь: добавь в конец копирование всех переменных из locals() в globals() твоей функции.

Много букв? О_о. Сомнительно. Одна строчка, не более. И это решение хотя бы не выглядит черезжопно-универсальным как те, что представлены в треде.

Я че то не понял про построчный разбор...

скорее всего имеется ввиду модуль parser.

скорее всего имеется ввиду модуль parser.

Если заходить настолько далеко, можно просто сделать трансформацию исходников и не заморачиваться с подсовыванием namespace-ов :)

ЧЕм это лучше execfile? Чем хуже понятно - никакие многострочные конструкции не проходят.

execfile тоже не комильфо, но видать это меньшее из всех зол.

для КАЖДОГО индентификатора придется писать var.a123

Ну эти же функции ты сам генеришь: добавь в конец копирование всех переменных из locals() в globals() твоей функции.

Вообще то для меня имеет значение порядок создания переменных... но мысль хорошая, спасибо, я ее подумаю;-)

ЧЕм это лучше execfile?

Тем, что позволяет выбирать строки. Но, если _весь_ файл - валидный Python, то можно и execfile.

Только сейчас доперло. ТОгда лучше выбрать нужные строки и ехекнуть весь кусок. СПасибо, это наверное оптимально... только вот как узнать последнюю строку функции? Первую я знаю, f.func_code.co_firstlineno ;-)

только вот как узнать последнюю строку функции?

section() или конец файла? Ну и если текст вы сами генерите, пометьте конец функции как-то.

section()

Файл как раз не генериться а вводиться юзером, на его основе генериться С++.

ЗЫ как раз с секциями проблем нет - все работает, но код кривоват. Хочется секии заменить обычными ф-ями.

Хм. Я-то думал, локальные переменные f заранее известны. Тогда можно было бы просто написать в начале функции
vars().update(подготовленный_неймспейс)

Или это не работает? Проверить не могу :-(

Извращенной задаче - извращенное решение.

Декоратор получает код функции, разбирает на токены, затем меняет переменные на нужные вам объекты, снова собирает код и выполняет.

Вообще то как раз так делать НЕ хочется - переменных много.

Да уж... месье определенно знает толк в !;-)

перепиши код чтобы не хотелось ничего заменять. Это сэкономит деньги, время и нервы.

КОнечно сэкономит - тогда эта шутка нафик будет никому не нужна.