Warum haben einige Python-Funktionen einen zusätzlichen Klammersatz um die Argumentliste?

Question

Ich habe einige Python-Funktionen wie folgt geschrieben gesehen:

def get_year((year,prefix,index,suffix)): 
    return year 

Wie unterscheiden, dass (wenn überhaupt) von anderen Funktionen ohne die zusätzlichen Klammern wie folgt aus:

def do_format(yr,pfx,id,sfx): 
    return "%s %s %s/%s"%(yr, id, pfx, sfx) 

Oder ist es nur eine Frage des Geschmacks in Stilen, oder wenn sie sich unterscheiden, kann get_year() umgeschrieben werden, um im Stil von do_format() oder umgekehrt zu sein, ohne die bestehende Syntax des Aufrufers zu beeinflussen?

Answer 1

Die get_year Funktion in Ihrem Beispiel verwendet einen automatisch entpackt Tupel Parameter (dies ist die Funktion von Python weg 3). Um es aufzurufen, geben Sie ihm einen einzelnen Parameter, und dieser Parameter wird voraussichtlich eine Sequenz sein, die vier Werte enthält.

# Invocation 
my_input = [2013, 'a', 'b', 'c'] # sequence does NOT have to be a tuple! 
my_year = get_year(my_input) # returns 2013 

Um dies zu umschreiben für Python 3, aber nicht den Aufruf ändern (in anderen Worten, um vorhandenen Code nicht zu brechen, die get_year ruft):

def get_year(input_sequence): 
    year, prefix, index, suffix = input_sequence 
    return year 

Die oben ist im Wesentlichen, was Tupel auspacken für tut du automatisch. In diesem speziellen Fall Sie einfach

def get_year(input_sequence): 
    return input_sequence[0] 

Für weitere Informationen schreiben könnte, lesen Sie PEP 3113.

Answer 2

Die erste Funktion benötigt ein einzelnes Tupelargument, während die zweite Funktion 4 Argumente benötigt. Sie können diese Parameter einzeln übergeben oder als Tupel mit dem Operator splat, der das Tupel in einzelne Parameter entpackt.

Z. B:

# Valid Invocations 
print do_format(*('2001', '234', '12', '123')) # Tuple Unpacking 
print do_format('2001', '234', '12', '123')  # Separate Parameter 
print get_year(('2001', '234', '12', '123')) 

# Invalid invocation. 
print do_format(('2001', '234', '12', '123')) # Passes tuple 

Answer 3

Diese sind alle gleichwertig (der Anrufer wird sich nicht ändern müssen):

# 2.x unpacks tuple as part of the function call, 3.x raises exception 
def get_year((year,prefix,index,suffix)): 
    """get year from (year, prefix, index, suffix) tuple""" 
    return year 

# 2.x and 3.x, you unpack tuple in the function call 
def get_year(year_tuple): 
    """get year from (year, prefix, index, suffix) tuple""" 
    year, prefix, index, suffix = year_tuple 
    return year 

# 2.x and 3.x, speedier because you don't unpack what you don't need 
def get_year(year_tuple): 
    """get year from (year, prefix, index, suffix) tuple""" 
    return year_tuple[0]