Pourquoi foo (*arg, x) n'est pas autorisé en Python?

Je ne vais pas vous expliquer pourquoi le déballage de tuple multiple ne fait pas partie de Python, mais je vous ferai remarquer que vous ne faites pas le lien entre votre classe et vos données dans votre exemple.

Vous avez le code suivant:

point = (1, 2)
size = (2, 3)
color = 'red'

class Rect(object):
    def __init__(self, x, y, width, height, color):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.color = color

mais une meilleure façon d'exprimer vos Rect objet serait comme suit:

class Rect:
    def __init__(self, point, size, color):
        self.point = point
        self.size = size
        self.color = color

r = Rect(point, size, color)

en général, si vos données sont en tuples, demandez à votre constructeur de prendre tuples. Si vos données sont dans un dict, demandez à votre constructeur de prendre un dict. Si vos données est une objet, demandez à votre constructeur de prendre un objet, etc.

En général, vous voulez travailler avec les idiomes de la langue, plutôt que d'essayer de travailler autour d'eux.

modifier Vu la popularité de cette question, je vais vous donner un décorateur qui vous permet d'appeler le constructeur comme vous voulez.

class Pack(object):

    def __init__(self, *template):
        self.template = template

    def __call__(self, f):
        def pack(*args):
            args = list(args)
            for i, tup in enumerate(self.template):
                if type(tup) != tuple:
                    continue
                for j, typ in enumerate(tup):
                    if type(args[i+j]) != typ:
                        break
                else:
                    args[i:i+j+1] = [tuple(args[i:i+j+1])]
            f(*args)
        return pack    


class Rect:
    @Pack(object, (int, int), (int, int), str)
    def __init__(self, point, size, color):
        self.point = point
        self.size = size
        self.color = color

maintenant vous pouvez initialiser votre objet comme vous le souhaitez.

r1 = Rect(point, size, color)
r2 = Rect((1,2), size, color)
r3 = Rect(1, 2, size, color)
r4 = Rect((1, 2), 2, 3, color)
r5 = Rect(1, 2, 2, 3, color)

bien que je ne recommande pas de l'utiliser dans la pratique (il viole le principe que vous ne devriez avoir qu'une seule façon de le faire), il sert à démontrer qu'il y a habituellement une façon de faire quelque chose en Python.

*point dit que vous êtes de passage dans toute une série d'éléments - quelque chose comme tous les éléments dans une liste, mais pas comme une liste.

dans ce cas, vous ne pouvez pas limiter le nombre d'éléments transmis. Par conséquent, il n'existe aucun moyen pour l'interprète de savoir quels éléments de la séquence sont partie de *points et *size

Par exemple, si vous avez passé le suivant en entrée: 2, 5, 3, 4, 17, 87, 4, 0 pouvez-vous me dire lesquels de ces nombres sont représentés par *points et par *size? C'est le même problème que l'interprète visage

Espérons que cette aide

Python est plein de ces petits problèmes subtils. Par exemple, vous pouvez faire:

first, second, last = (1, 2, 3)

Et vous ne pouvez pas faire:

first, *others = (1, 2, 3)

mais en Python 3 vous pouvez maintenant.

votre suggestion sera probablement suggérée dans un PEP et intégrée ou rejetée un jour.

Eh bien, en Python 2, Vous pouvez dire:

point = 1, 2
size = 2, 3
color = 'red'

class Rect(object):
    def __init__(self, (x, y), (width, height), color):
        pass

Alors vous pouvez dire:

a_rect= Rect(point, size, color)

en prenant soin que les deux premiers arguments soient des séquences de len == 2.

NB: cette capacité a été retirée de Python 3.