Generator als Funktion argument

Beide 3. und 4. sollte werden syntax-Fehler, die auf alle Python-Versionen. Aber Sie haben einen Fehler gefunden und betrifft die Python-Versionen 2.5 - 3.4, und die anschließend veröffentlicht auf der Python-Problem-tracker. Weil der bug, ein unparenthesized generator expression angenommen wurde, als argument an eine Funktion, wenn es war, begleitet nur von *args - und/oder **kwargs. Während Python 2.6+ erlaubt beiden Fällen 3. und 4., Python 2.5 nur zulässig, Fall 3. - und doch waren beide gegen die dokumentiert Grammatik:

call    ::=     primary "(" [argument_list [","]
                            | expression genexpr_for] ")"

d.h. die Dokumentation sagt, dass ein Funktionsaufruf besteht aus primary (der Ausdruck, der ausgewertet wird, um ein callable), gefolgt von in Klammern, die entweder ein argument-Liste oder nur ein unparenthesized generator-Ausdruck;
und in der argument-Liste, alle generator-Ausdrücke müssen in Klammern.

Dieser bug (obwohl es scheint, es sei noch nicht bekannt), war fest in Python 3.5 prereleases. In Python 3.5 Klammern sind immer erforderlich, um einen generator-Ausdruck, es sei denn, es ist das einzige argument für die Funktion:

Python 3.5.0a4+ (default:a3f2b171b765, May 19 2015, 16:14:41) 
[GCC 4.9.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> f(1 for i in [42], *a)
  File "<stdin>", line 1
SyntaxError: Generator expression must be parenthesized if not sole argument

Dies ist nun dokumentiert in der Was ist Neu in Python 3.5, Dank DeTeReR entdecken dieser Fehler.

Analyse der Fehler

Gab es eine änderung zu Python 2.6 erlaubt die Verwendung von Schlüsselwort-Argumente nach *args:

Es ist auch legal, bieten keyword-Argumente nach *args
argument bei einem Funktionsaufruf.

>>> def f(*args, **kw):
...     print args, kw
...
>>> f(1,2,3, *(4,5,6), keyword=13)
(1, 2, 3, 4, 5, 6) {'keyword': 13}

Zuvor hätte dies zu einem syntax-error. (Beigetragen von Amaury
Forgeot d ' Arc; Ausgabe 3473.)

Jedoch die Python 2.6 Grammatik macht keinen Unterschied zwischen keyword-Argumente, positionale Argumente, oder bare-generator-Ausdrücke - Sie sind alle vom Typ argument an den parser.

Als pro Python-Regeln, ein generator-Ausdruck muss in Klammern, wenn er nicht das alleinige argument für die Funktion. Dies ist validiert in der Python/ast.c:

for (i = 0; i < NCH(n); i++) {
    node *ch = CHILD(n, i);
    if (TYPE(ch) == argument) {
        if (NCH(ch) == 1)
            nargs++;
        else if (TYPE(CHILD(ch, 1)) == gen_for)
            ngens++;
        else
            nkeywords++;
    }
}
if (ngens > 1 || (ngens && (nargs || nkeywords))) {
    ast_error(n, "Generator expression must be parenthesized "
              "if not sole argument");
    return NULL;
}

Allerdings ist diese Funktion nicht nicht betrachten die *args an alle - es speziell nur für den normalen positions-und Schlüsselwort-Argumente Argumente.

Weiter unten in die gleiche Funktion, es wird eine Fehlermeldung generiert, für non-keyword arg after keyword arg:

if (TYPE(ch) == argument) {
    expr_ty e;
    if (NCH(ch) == 1) {
        if (nkeywords) {
            ast_error(CHILD(ch, 0),
                      "non-keyword arg after keyword arg");
            return NULL;
        }
        ...

Aber das gilt wieder für Argumente, die nicht unparenthesized generator-Ausdrücke als belegt durch die else if - Anweisung:

else if (TYPE(CHILD(ch, 1)) == gen_for) {
    e = ast_for_genexp(c, ch);
    if (!e)
        return NULL;
    asdl_seq_SET(args, nargs++, e);
}

Somit eine unparenthesized generator expression durfte slip-pass.

Nun in Python 3.5 kann man die *args irgendwo in einer Funktion aufgerufen wird, so dass
die Grammatik wurde geändert, um Platz für dieses:

arglist: argument (',' argument)*  [',']

und

argument: ( test [comp_for] |
            test '=' test |
            '**' test |
            '*' test )

und die - Schleife geändert wurde zu

for (i = 0; i < NCH(n); i++) {
    node *ch = CHILD(n, i);
    if (TYPE(ch) == argument) {
        if (NCH(ch) == 1)
            nargs++;
        else if (TYPE(CHILD(ch, 1)) == comp_for)
            ngens++;
        else if (TYPE(CHILD(ch, 0)) == STAR)
            nargs++;
        else
            /* TYPE(CHILD(ch, 0)) == DOUBLESTAR or keyword argument */
            nkeywords++;
    }
}

Damit beheben des Fehlers.

Jedoch die unbeabsichtigte änderung ist, dass der gültige aussehende Konstruktionen

func(i for i in [42], *args)

und

func(i for i in [42], **kwargs)

wo ein unparenthesized generator vor *args oder **kwargs jetzt aufgehört zu arbeiten.

Suchen Sie diese Fehler, ich habe versucht, verschiedene Python-Versionen. Bei 2.5 würden Sie bekommen SyntaxError:

Python 2.5.5 (r255:77872, Nov 28 2010, 16:43:48) 
[GCC 4.4.5] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> f(*[1], 2 for x in [2])
  File "<stdin>", line 1
    f(*[1], 2 for x in [2])

Und dies konnte behoben werden, bevor eine Vorabversion von Python 3.5:

Python 3.5.0a4+ (default:a3f2b171b765, May 19 2015, 16:14:41) 
[GCC 4.9.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> f(*[1], 2 for x in [2])
  File "<stdin>", line 1
SyntaxError: Generator expression must be parenthesized if not sole argument

Jedoch die in Klammern gesetzten generator-Ausdruck, es funktioniert in Python 3.5, aber es funktioniert nicht, nicht in Python 3.4:

f(*[1], (2 for x in [2]))

- Und das ist der clue. In Python 3.5 *splatting ist verallgemeinert; Sie können es verwenden, irgendwo in einer Funktion aufrufen:

>>> print(*range(5), 42)
0 1 2 3 4 42

Also den eigentlichen Fehler (generator arbeiten mit *star ohne Klammern) war zwar Feste in Python 3.5, und der bug konnte gefunden werden, dass das, was geändert zwischen Python 3.4 und 3.5

InformationsquelleAutor Antti Haapala