Bir genellikle bu sonucu elde etmek için locals() kullanır, ancak tam işlevselliği size kalmış.

>>> print apple
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'apple' is not defined
>>> print banana
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'banana' is not defined

>>> variables = {"apple" : "a rigid, juicy fruit", "banana" : "a soft, fleshy fruit"}
>>> for variable,value in variables.iteritems():
...  locals()[variable] = value
... 
>>> print apple
a rigid, juicy fruit
>>> print banana
a soft, fleshy fruit

DÜZENLEME

Özenle bu yaklaşımın kötülüklerden yorumladı herkese teşekkürler. Ben bütün kalbiyle o THIS IS A BAD APPROACH katılıyorum, ve bu sayfada rastlar herkes için gerçek yanıt olarak belirtilen hak ediyor. . (Ki asla küçümsemeyin; özel bir durumda zararsız olduğunu neden görebilirsiniz yerde bir kod parçasında bu tekniği gördüm, ama ben durumlar vardır sırf ben kötü bir metodoloji teşvik etrafında gidemem biliyorum ki bu olmaz içinde ara).

Belki size yapmak çalıştığınız ne açıklayan daha iyi olurdu. Ne istediğinizi yapmak için daha iyi bir yolu neredeyse kesin olduğu gibi doğrudan soru için herhangi bir çözüm oldukça unpythonic olacaktır.

EDIT (yorumlarınız başına):

Ve gerçekten de, daha iyi bir yolu yoktur.

Ne yapmaya çalışıyorsun ne unpacking argument lists olarak bilinir ve bu gibi yapılabilir:

self.__api_call__('POST', '/api/foobar/', **mydict)

>>> def a_plus_b(a,b):
...     return a+b
... 
>>> mydict = {'a':3,'b':4}
>>> a_plus_b(**mydict)
7

>>> def a_plus_b(**kwargs):
...     return kwargs['a'] + kwargs['b']
... 
>>> a_plus_b(**mydict)
7

hayır. neden ihtiyacınız var?

do (Yorum bakınız) aşağıdaki

def __api_call__(self, method, resource, **kwargs):
    print(kwargs)

def do_call(my_dict):
    self.__api_call__('POST', '/api/foobar/', **your_dict)   # double asterisk!

IMO, en azından güzel bir teorik soru: nasıl böyle inşaat uygulanabilir ve bir kez uygulandığında nasıl benziyor?

Örneğin, bir fonksiyonu olarak, bu olarak uygulanabilir

import inspect


def extract_attribute(obj, names):
    if type(names) == str:
        names = [names]
    # Get previous frame from the inspect stack.
    frame = inspect.stack()[1][0]
    try:        
        frame_locals = frame.f_locals        
        attributes = inspect.getmembers(
            obj, lambda attr: not inspect.ismethod(attr))        
        for name, attribute in attributes:
            if name.startswith('__') or name.endswith('__'):
                continue
            if name in names:
                frame_locals[name] = attribute
    finally:
        del frame
        del frame_locals

gibi el

class A(object):
    foo = 'bar'


a = A()
extract_attribute(a, 'foo')
assert locals()['foo'] == 'bar'
assert foo == 'bar

Not: PyLint son satırında şikayet edecek bekliyor. Bir extract_attribute * fonksiyon modülleri için işlevsellik ithal etmek biraz benzer şekilde nesne ile çalışmak * bulabilirsiniz. (Mevcut ithalat ile karışık) kapsam bağlantı ek tabaka olarak uygulanmasından neredeyse istisnasız kod karmaşıklığını artıracaktır.

PS Obvious enough manipulating built-in is a sign of doing something python was not designed to do. But self-flattering mantras like not-practical and "non-pythonic" are not really proper arguments to me. In general it is always much more "practical" to make an experiment and to see if: 1. Construction will enrich the expressiveness of the language (e.g. making it more readable and natural-like), give new functionality, etc. 2. Construction is too ugly and dangerous to be used, too flexible and unsafe, performance trade-offs are unacceptable, etc. Illustration and test by explicit example is a preferred alternative. Looking at code everyone is free to make his own opinion without sharing the "professional guts" or copy-pasting religious dogmas. Please don't.