Question

我正在为我的妹妹创造一个游戏。这是一种虚拟宠物，宠物可以玩玩具。

我创建了一个类Toy，并希望创建一个函数getNewToy(name, data1, data2, data3, data4, data5)。

我希望此函数创建类Toy的新实例，并且我希望每次创建新实例时都能够多次调用该函数。

根据我的经验，您使用以下命令创建实例：

class Toy:
    def __init__(self, name, data1, data2, data3, data4, data5):
        pass

myToy = Toy(myToy, 1, 2, 3, 4, 5)

然后使用类中的方法：

myToy.method1()

看到我希望能够拥有多个玩具，每个玩具都有一个playWith()方法，我希望实例在每次调用时都反映Toy的名称。

每次调用方法getNewToy(,...)和实例来反映名称时，我希望实例不同。

Answer 1

鉴于您的编辑我假设您将类名作为字符串并想要实例化该类？只需使用字典作为调度程序。

class Foo(object):
    pass

class Bar(object):
    pass

dispatch_dict = {"Foo": Foo, "Bar": Bar}
dispatch_dict["Foo"]() # returns an instance of Foo

Answer 2

如果您还没有找到，请点击Dive into Python's chapter on object-oriented programming。

以下是一些examples，滚动到BankAccount。

您可以直接调用类来创建实例。参数传递给__init__方法。

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

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

Answer 3

假设您有三个类：Enemy1，Enemy2，Enemy3。这是您直接实例化它们的方式：

Enemy1()
Enemy2()
Enemy3()

但这也有效：

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

这是你的意思吗？

Answer 4

如果您只想将一个类传递给一个函数，以便该函数可以创建该类的新实例，那么只需将该类视为参数的任何其他值：

def printinstance(someclass):
  print someclass()

结果：

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

Answer 5

不是使用多个类或类继承，也许是一个知道它是什么“类型”的玩具类：

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()

运行它：

$ python toy.py 
Suzie doll 0
Jack robot 1

如您所见，getNewToy实际上是不必要的。现在，您可以修改playWith以检查self.kind的值并更改行为，您可以重新定义playWith以指定玩伴：

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

t1.playWith(t2)

Answer 6

您可以像这样创建变量：

x = 10 
print(x)

或者这个：

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

让我们创建一个新类：

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

您可以这样创建类实例：

instance_name_1 = Foo()

或者这样：

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

让我们创建一个函数：

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

调用函数：

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

我们也可以编写生成器函数：

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..

Answer 7

这是一个非常奇怪的问题，特别是python，所以更具体一定肯定会帮助我回答它。我会试着去试一试。

我将假设你要做的是创建一个新的数据结构实例并给它一个变量。对于这个例子，我将使用字典数据结构和变量mydictionary。

mydictionary = dict()

这将创建一个字典数据结构的新实例，并将其放在名为mydictionary的变量中。或者，字典构造函数也可以使用参数：

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

最后，python将尝试从我给出的数据中找出我的意思是什么数据结构。 IE

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

这些示例来自Here

Answer 8

我认为您可以使用eval。像这样的东西

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

使用Python中的变量创建类的实例

8 个答案: