Funktion, die sowohl erweiterte Argumente und Tupel akzeptiert

Question

Gibt es eine Pythonic Möglichkeit, eine Funktion zu erstellen, die sowohl separate Argumente akzeptiert und ein Tupel? d. h., um etwas wie dieses zu erreichen:

def f(*args): 
    """prints 2 values 
      f(1,2) 
       1 2 
      f((1,2)) 
       1 2""" 
    if len(args) == 1: 
     if len(args[0]) != 2: 
      raise Exception("wrong number of arguments") 
     else: 
      print args[0][0],args[0][1] 
    elif len(args) == 2: 
     print args[0],args[1] 
    else: 
      raise Exception("wrong number of arguments") 

Answer 1

Zunächst einmal weiß ich nicht, ob es sehr klug ist, dies zu tun. Angenommen, eine Person ruft folgende Funktion auf:

Wie Sie sehen können, enthält das Tupel zwei Elemente. Aber jetzt aus irgendeinem Grund ruft die Person, die sie mit nur einem Element (weil beispielsweise der Generator nicht zwei Elemente erzeugt haben):

f(*((1,4),)) 

Dann würde der Benutzer wahrscheinlich Ihre Funktion, dies zu melden, aber jetzt wird es akzeptiere es einfach (was zu einem komplizierten und unerwarteten Verhalten führen kann). Okay, das Drucken der Elemente wird natürlich nicht viel schaden. Aber in einem allgemeinen Fall könnten die Konsequenzen schwerwiegender sein.

Trotzdem ein eleganter Weg, dies zu tun, um eine einfache Dekorateur macht dass zuerst überprüft, ob ein Element gespeist wird es überprüft, ob ein Tupelelement feeded ist und wenn ja, dehnt er sich: es

def one_tuple(f): 
    def g(*args): 
     if len(args) == 1 and isinstance(args[0],tuple): 
      return f(*args[0]) 
     else: 
      return f(*args) 
    return g 

und anwenden auf Ihre f:

@one_tuple 
def f(*args): 
    if len(args) == 2: 
     print args[0],args[1] 
    else: 
     raise Exception("wrong number of arguments") 

Der Dekorateur one_tuple somit überprüft, ob ein Tupel zugeführt wird, und wenn ja auspackt es für Sie b bevor Sie es an Ihre f Funktion übergeben.

Als Ergebnis f nicht den Tupel Fall in Rechnung zu tragen hat: es wird immer erweitert Argumente zugeführt werden und diese behandelt (natürlich das Gegenteil so gut gemacht werden könnte).

Der Vorteil der Definition eines Dekorators ist seine Wiederverwendung: Sie können diesen Dekorator auf alle Arten von Funktionen anwenden (und machen es so einfacher, diese zu implementieren).

Answer 2

Ich stimme der Idee selbst nicht zu (obwohl ich die Tatsache mag, dass Python die Definition von Variablentypen nicht benötigt und somit so etwas erlaubt), aber es könnte Fälle geben, in denen so etwas benötigt wird. Also los gehts:

def my_f(a, *b): 

    def whatever(my_tuple): 
     # check tuple for conformity 
     # do stuff with the tuple 
     print(my_tuple) 
     return 

    if hasattr(a, '__iter__'): 
     whatever(a) 
    elif b: 
     whatever((a,) + b) 
    else: 
     raise TypeError('malformed input') 
    return 

Neu strukturiert es ein bisschen, aber die Logik bleibt gleich. Wenn "a" ein iterabler Wert ist, betrachten Sie es als Ihr Tupel, wenn Sie nicht auch "b" berücksichtigen. wenn „a“ ist kein durchsuchbar und „b“ nicht definiert ist, heben TypeError

my_f((1, 2, 3)) # (1, 2, 3) 
my_f(1, 2, 3) # (1, 2, 3) 

Answer 3

Die Pythonic Weg wäre Ente eingeben zu verwenden. Dies funktioniert nur, wenn Sie sicher sind, dass keines der erweiterten Argumente iterierbar ist.

def f(*args): 
    def g(*args): 
     # play with guaranteed expanded arguments 

    if len(args) == 1: 
     try: 
      iter(args[0]) 
     except TypeError: 
      pass 
     else: 
      return g(*args[0]) 
    return g(*args) 

Diese Implementierung bietet eine leichte Verbesserung auf @ Ev.Kounis Antwort für Fälle, in denen ein einzelnen nicht-Tupel Argument übergeben wird. Es kann auch leicht in die entsprechende Dekorateur von @WillemVanOnsem beschrieben gedreht werden.Verwenden Sie die Decorator-Version, wenn Sie mehr als eine Funktion wie diese haben.