Python'；什么是等价？

是否有必要将Java中的以下代码转换为Python的等效代码

public class Animal{

public enum AnimalBreed{

    Dog, Cat, Cow, Chicken, Elephant
}

private static final int Animals = AnimalBreed.Dog.ordinal();

    private static final String[] myAnimal = new String[Animals];
    private static Animal[] animal = new Animal[Animals];

    public static final Animal DogAnimal = new Animal(AnimalBreed.Dog, "woff");
    public static final Animal CatAnimal = new Animal(AnimalBreed.Cat, "meow");
    private AnimalBreed breed;

public static Animal myDog (String name) {
        return new Animal(AnimalBreed.Dog, name);

      }
}

---

包含有关此主题的大量帮助。请注意，deepcopy支持可能无法与之配合使用。

直接翻译此代码将是浪费时间。从Java迁移到Python时，最困难的事情是放弃您所知道的大部分内容。但一个简单的事实是，逐行翻译并不会像你所期望的那样有效。最好是翻译算法，而不是代码，让Python做它擅长的事情。

这不是逐行翻译，而是大致上：

class Animal(object):
    animal_breeds = "Dog Cat Cow Chicken Elephant".split()
    animals = {}

    def __init__(self, breed, name):
        self._breed = breed
        self.name = name
        Animal.animals[name] = self

    @property
    def breed(self):
        return Animal.animal_breeds[self._breed]

    @staticmethod
    def myDog(name):
        return Animal(Animal.AnimalBreed.Dog, name)

# add enumeration of Animal breeds to Animal class
class Constants(object): pass
Animal.AnimalBreed = Constants()
for i,b in enumerate(Animal.animal_breeds):
    setattr(Animal.AnimalBreed, b, i)

# define some class-level constant animals
# (although "woff" and "meow" are not what I would expect
# for names of animals)    
Animal.DogAnimal = Animal(Animal.AnimalBreed.Dog, "woff")
Animal.CatAnimal = Animal(Animal.AnimalBreed.Cat, "meow")

# this code would be in a separate module that would import this
# code using
#     from animal import Animal
#
print Animal.myDog("Rex").breed
print Animal.animals.keys()

---

我不清楚Java的语义是什么。我猜你是在尝试模拟一组动物（顺便说一句，是物种，而不是品种），并根据动物的类型（粗略地说，每个动物发出的声音）向一组相关的类灌输不同的行为

在Python中，实现这一点的自然方式是通过元编程。创建一个类或工厂函数，通过将参数传递到模板中来返回每个类。因为函数和类是Python中的一阶对象，所以它们可以像任何其他对象一样传递。由于类本身就是对象，因此可以使用

setattr

（及其近亲：

hasattr

和

getattr

）访问它们的属性

下面是一个简单的例子：

#!/usr/bin/env python
def Animal(species, sound):
    class meta: pass

    def makeSound(meta, sound=sound):
        print sound
    setattr(meta, makeSound.__name__, makeSound)

    def name(meta, myname=species):
        return myname
    setattr(meta, 'name', name)
        return meta

if __name__ == '__main__':
    animal_sounds = (('Dog', 'woof'),
                     ('Cat', 'meow'),
                     ('Cow', 'moo'),
                     ('Chicken', 'cluck'),
                     ('Elephant', 'eraunngh'))

    menagerie = dict()
    for animal, sound in animal_sounds:
        menagerie[animal] = Animal(animal, sound)

    for Beast in menagerie:
        beast = Beast()
        print beast.name(), ' says ',
        beast.makeSound()

    Dog = menagerie['Dog']
    fido = Dog()   # equivalent to fido = menagerie['Dog']()
    fido.makeSound()
    # prints "woof"
    Cat = menagerie['Cat']
    felix = Cat()
    felix.makeSound()
    Mouse = Animal('Mouse', 'squeak')
    mickey = Mouse()
    mouse.makeSound()
    # prints "squeak"

---

这似乎是一个老生常谈的例子，但我希望它能说明问题。我可以创建一个表（在本例中是一个元组的元组），该表提供用于填充类的各种参数/行为的参数。Animal返回的类与任何其他Python类一样。我试着在这里的例子中说明这一点。

同意！理解算法并将其转换/实现为另一种语言比逐行翻译要好。