Criar uma instância de uma classe com uma variável em Python
Eu criei uma classe Toy
e quero criar uma função, getNewToy(name, data1, data2, data3, data4, data5)
.
quero que esta função crie uma nova instância da classe Toy
, e quero que a função seja capaz de ser chamada várias vezes de cada vez criando uma nova instância.
class Toy:
def __init__(self, name, data1, data2, data3, data4, data5):
pass
myToy = Toy(myToy, 1, 2, 3, 4, 5)
depois usar métodos da classe com:
myToy.method1()
visto que quero ter a capacidade de ter vários brinquedos, cada um com um método playWith()
quero que a instância reflicta o nome do Toy
cada vez que um é chamado.
quero que a instância seja diferente cada vez que chamo o método getNewToy(,...)
e a instância reflicta o nome.
8 answers
class Foo(object):
pass
class Bar(object):
pass
dispatch_dict = {"Foo": Foo, "Bar": Bar}
dispatch_dict["Foo"]() # returns an instance of Foo
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()
Resultado:
>>> 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
Como pode ver, getNewToy
é realmente desnecessário. Agora você pode modificar playWith
para verificar o valor de self.kind
e mudar o comportamento, você pode redefinir playWith
para designar um companheiro:
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)
Vamos criar uma nova classe:
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()
Era isto que querias dizer?
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}
Estes exemplos foram tirados daqui.
Acho que podes usar eval
. Algo assim.
def toclass(strcls):
return eval(strcls)()