Criar uma instância de uma classe com uma variável em Python

Se ainda não o encontrou, aqui está Mergulhe no capítulo do Python sobre programação orientada a objectos {[[5]}.

Aqui estão mais alguns exemplos , role to BankAccount.

Você pode chamar uma classe diretamente para criar uma instância. Os parâmetros são passados ao método __init__.

class Tamago(object):
    def __init__(self, name):
        self.name = name

imouto = Tamago('imouto')
oba = Tamago('oba')
oba.name # 'oba'
imouto.name # 'imouto'

Se você só quiser passar uma classe para uma função, de modo que esta função possa criar novas instâncias dessa classe, basta tratar a classe como qualquer outro valor que você daria como um parâmetro:

def printinstance(someclass):
  print someclass()

>>> printinstance(list)
[]
>>> printinstance(dict)
{}

Em vez de usar várias classes ou herança de classe, talvez uma única classe de brinquedo que sabe que "tipo" é:

class Toy:
    num = 0
    def __init__(self, name, kind, *args):
        self.name = name
        self.kind = kind
        self.data = args
        self.num = Toy.num
        Toy.num += 1

    def __repr__(self):
        return ' '.join([self.name,self.kind,str(self.num)])

    def playWith(self):
        print self

def getNewToy(name, kind):
    return Toy(name, kind)

t1 = Toy('Suzie', 'doll')
t2 = getNewToy('Jack', 'robot')
print t1
t2.playWith()

A correr:

$ python toy.py 
Suzie doll 0
Jack robot 1

def playWith(self, who=None):
    if who:  pass
    print self

t1.playWith(t2)

Você pode criar uma variável como esta:

x = 10 
print(x)

Ou isto:

globals()['y'] = 100
print(y)

class Foo(object):
    def __init__(self):
        self.name = 'John'

Você pode criar uma instância de classe desta forma:

instance_name_1 = Foo()

Ou por aqui:

globals()['instance_name_2'] = Foo()

Vamos criar uma função:

def create_new_instance(class_name,instance_name):
    globals()[instance_name] = class_name()
    print('Class instance '{}' created!'.format(instance_name))

Chama uma função:

create_new_instance(Foo,'new_instance') #Class instance 'new_instance' created!
print(new_instance.name) #John

Também podemos escrever a função do gerador:

def create_instance(class_name,instance_name):
    count = 0
    while True:
        name = instance_name + str(count)
        globals()[name] = class_name()
        count += 1
        print('Class instance: {}'.format(name))
        yield True

generator_instance = create_instance(Foo,'instance_') 

for i in range(5):
    next(generator_instance)

#out
#Class instance: instance_0
#Class instance: instance_1
#Class instance: instance_2
#Class instance: instance_3
#Class instance: instance_4

print(instance_0.name) #john
print(instance_1.name) #john
print(instance_2.name) #john
print(instance_3.name) #john
print(instance_4.name) #john

#print(instance_5.name) #error.. we only created 5 instances.. 

next(generator_instance) #Class instance: instance_5
print(instance_5.name) #John  Now it works.. 

Enemy1()
Enemy2()
Enemy3()

Mas isto também funcionará:

x = Enemy1
x()
x = Enemy2
x()
x = Enemy3
x()

mydictionary = dict()

Isto irá criar uma nova instância da estrutura de dados do dicionário e colocá-la na variável chamada mydictionary. Em alternativa, o construtor do dicionário também pode ter argumentos:

mydictionary = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

Finalmente, o python vai tentar descobrir a estrutura de dados que quero dizer a partir dos dados que lhe dou. IE

mydictionary = {'jack': 4098, 'sape': 4139}

Acho que podes usar eval. Algo assim.

def toclass(strcls):
    return eval(strcls)()