Question

我经常发现自己处于一种我想要迭代的一组逻辑连接符号的情况。显而易见的解决方案是将这些符号添加到列表中，但复制是一种难以维护的问题，我必须相信，如果我的伙伴改变一个，他们也会改变另一个。

有没有办法创建符号，同时将它们的值添加到列表中？

例如

# A group of like symbols that can be used independently in this scope
hippo = 'hippo'
gator = 'gator'
mouse = 'mouse'

# To loop across them I have to put them into a list 
valid_animals = [hippo, gator, mouse]  # Maintain me separately, fool!

我想要的Psuedo代码

# Data structure that declares symbols whose values can be iterated over
valid_animals = {  # Even your mom could maintain this
    hippo = 'hippo'
    gator = 'gator'
    mouse = 'mouse'
}

# Use the symbols by themselves
print "I had a", mouse, "in my house"

# Iterate over the symbols
print mouse in valid_animals  # True

Answer 1

这听起来像是面向对象的编程：

class Animal(object):
    list = []
    def __init__(self,name):
        self.name = name
        Animal.list.append(self.name)


mouse = Animal("mouse")
cat = Animal("cat")

print(mouse)      # <test.Animal object at 0x7f835e146860>
print(mouse.name)   # 'mouse'
print(cat.name)    # 'cat'
print(Animal.list)   # ['mouse', 'cat']

通常，在Python中，类具有 init 方法。这看起来很神秘，但实际上它只是在基于类实例化对象时调用的一些代码。（将该类视为创建对象的模板，并在创建对象时运行 init 方法。）

在课堂内，制作一个空列表。这是一个类级列表，可以使用Animal.list在代码中访问。它没有与任何特定的实例化对象（即猫或鼠标）连接。

调用 init 方法时，新创建的对象的名称将添加到类级别列表中。因此，如果您创建了十只动物（动物（＆＃39; ocelot＆＃39;），动物（＆＃39;袋鼠＆＃39;）等），您可以调用Animal.list来查看所有动物的名称。 / p> 编辑：您要求为您的问题提供更通用的解决方案：

class Symbol(object):
    types = []
    def __init__(self,name):
        self.name = name
        Symbol.types.append(self.name)
        self.item_list = []


    def add(self,item):
        self.item_list.append(item)


animal = Symbol('animal')

print(animal.item_list)    # []

animal.add('tiger')
animal.add('llama')

print(animal.item_list)    # ['tiger', 'llama']

food = Symbol('food')

food.add('carrot')
food.add('beans')

print(food.item_list)   # ['carrot', 'beans']

print(Symbol.types)   # ['animal', 'food']

Answer 2

只想维护列表：valid=['foo','bar','baz']。

如果您希望方便地定义具有相同名称的变量，locals().update(zip(valid,valid))将执行此操作。

但在严肃的项目中，这肯定是一个坏主意。

Answer 3

我不确定这对于任何大型项目是否是一个好主意，但您可以执行以下操作：

def varsFromStrings(*strings):
    newVars = []
    for s in strings:
        globals()[s] = s
        newVars.append(s)
    return newVars

该函数将获取字符串列表，为每个字符串创建变量，将这些变量输入globals字典，并将字符串分配给每个变量，并返回字符串列表作为结果。那么即使你的妈妈也可以打字：

valid_animals = varsFromStrings('hippo','gator','mouse')

之后，

print("I had a", mouse, "in my house")

for critter in valid_animals: print(critter)

都按预期工作。

这可能对某些小型程序有所帮助，但如果程序维护是一个问题 - 为什么不只使用有效动物的常规字典？

Answer 4

<强> @T。 Arboreus 是对的;解决方案是面向对象的编程。为了在局部范围内声明符号，同时将它们添加到迭代中，我需要的只是追加操作的返回值，然后可以将其分配给我的符号。

我是通过继承list并添加bind方法来实现此目的的。

# Iterable object that has a return on append
class SymGroup(list):
    def add(self, value):
        self.append(value)
        return value



# Create my list that represents a group of symbol values
valid_animals = SymGroup()

# Assign and append values at the same time
hippo = valid_animals.bind("hippo")
gator = valid_animals.bind("gator")
mouse = valid_animals.bind("mouse")



# Symbol can be used by itself
print "There is a", mouse, "in my house"

# Can iterate across the symbol values
print mouse in valid_animals  # True
print "horse" in valid_animals  # False

现在我只需要保留一个声明。

Python：迭代一组符号

4 个答案: