Python高阶序列赋值？

Question

Is there a way to group names together in python, to repeatedly assign to them en masse ?

While we can do:

a,b,c = (1,2,3)

I would like to be able to do something like:

names = a,b,c

*names = (3,2,1) # this syntax doesn't work

a,b,c == (3,2,1) #=> True

Is there a built-in syntax for this? If not, I assume it would be possible with an object that overloads its assignment operator. In that case, is there an existing implementation, and would this concept have any unexpected failure modes?

The point is not to use the names as data, but rather to be able to use the actual names as variables that each refer to their own individual item, and to be able to use the list as a list, and to avoid code like:

a = 1
b = 2
c = 3

sequence = (a,b,c)

Answer 1

You should go one level up in your data abstraction. You are not trying to access the entries by their individual names -- you rather use names to denote the whole collection of values, so a simple list might be what you want.

If you want both, a name for the collection and names for the individual items, then a dictionary might be the way to go:

names = "a b c".split()
d = dict(zip(names, (1, 2, 3)))
d.update(zip(names, (3, 2, 1)))

If you need something like this repeatedly, you might want to define a class with the names as attributes:

class X(object):
    def __init__(self, a, b, c):
        self.update(a, b, c)
    def update(self, a, b, c)
        self.a, self.b, self.c = a, b, c

x = X(1, 2, 3)
x.update(3, 2, 1)
print x.a, x.b. x.c

This reflects that you want to block a , b and c to some common structure, but keep the option to access them individually by name.

Answer 2

You should use a dict :

>>> d = {"a": 1, "b": 2, "c": 3}
>>> d.update({"a": 8})
>>> print(d)
{"a": 8, "c": 3, "b": 2}

Answer 3

I've realised that "exotic" syntax is probably unnecessary. Instead the following achieves what I wanted: (1) to avoid repeating the names and (2) to capture them as a sequence:

sequence = (a,b,c) = (1,2,3)

Of course, this won't allow:

*names = (3,2,1) # this syntax doesn't work

a,b,c == (3,2,1) #=> True

So, it won't facilitate repeated assignment to the same group of names without writing out those names repeatedly (except in a loop).

Answer 4

This?

>>> from collections import namedtuple
>>> names = namedtuple( 'names', ['a','b','c'] )

>>> thing= names(3,2,1)
>>> thing.a
3
>>> thing.b
2
>>> thing.c
1

Answer 5

Well, you shouldn't do this, since it's potentially unsafe, but you can use the exec statement

>>> names = "a, b, c"
>>> tup = 1,2,3
>>> exec names + "=" + repr(tup)
>>> a, b, c
(1, 2, 3)

Answer 6

Python has such an elegant namespace system:

#!/usr/bin/env python

class GenericContainer(object):
    def __init__(self, *args, **kwargs):
        self._names = []
        self._names.extend(args)
        self.set(**kwargs)
    def set(self, *args, **kwargs):
        for i, value in enumerate(args):
            self.__dict__[self._names[i]] = value
        for name, value in kwargs.items():
            if name not in self._names:
                self._names.append(name)
            self.__dict__[name] = value
    def zip(self, names, values):
        self.set(**dict(zip(names, values)))

def main():
    x = GenericContainer('a', 'b', 'c')
    x.set(1, 2, 3, d=4)
    x.a = 10
    print (x.a, x.b, x.c, x.d,)
    y = GenericContainer(a=1, b=2, c=3)
    y.set(3, 2, 1)
    print (y.a, y.b, y.c,)
    y.set(**dict(zip(('a', 'b', 'c'), (1, 2, 3))))
    print (y.a, y.b, y.c,)
    names = 'x', 'y', 'z'
    y.zip(names, (4, 5, 6))
    print (y.x, y.y, y.z,)

if __name__ == '__main__':
    main()

Each instance of GenericContainer is an isolated namespace. IMHO it is better than messing with the local namespace even if you are programming under a pure procedural paradigm.

Answer 7

Not sure whether this is what you want...

>>> a,b,c = (1,2,3)
>>> names = (a,b,c)
>>> names
(1, 2, 3)
>>> (a,b,c) == names
True
>>> (a,b,c) == (1,2,3)
True