Funkcja akceptująca zarówno rozszerzone argumenty, jak i krotkę

Question

Czy istnieje sposób utworzenia funkcji, która akceptuje zarówno oddzielne argumenty, jak i krotkę, w postaci Pythonic? tj. osiągnąć coś takiego:

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

Po pierwsze nie wiem, czy to bardzo mądre. Powiedzmy, że dana osoba dzwoni na przykład:

f(*((1,4),(2,5))) 

Jak widać krotka zawiera dwa elementy. Ale teraz z jakiegoś powodu, osoba nazywa to tylko jeden element (bo na przykład generator nie generowane dwa elementy):

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

Następnie użytkownik prawdopodobnie chcesz, aby funkcja zgłosić to, ale teraz to będzie po prostu ją zaakceptuj (co może prowadzić do skomplikowanego i nieoczekiwanego zachowania). Dobra drukowanie elementów oczywiście nie zaszkodzi. Ale w ogólnym przypadku konsekwencje mogą być bardziej poważne.

Niemniej elegancki sposób to zrobić czyni prostą dekorator że najpierw sprawdza, czy jeden element jest zasilany sprawdza, czy jeden element krotki jest karmione, a jeśli tak rozszerza go:

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 

i stosować go Aplikacje f:

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

dekorator one_tuple ten sposób sprawdza, czy jeden krotka jest podawany, a jeśli tak rozpakowuje to dla ciebie b przed przekazaniem go do swojej funkcji f.

Wskutek f nie musi wziąć pod uwagę przypadek krotny: będzie zawsze być karmione rozszerzonych argumentów i obsługiwać te (oczywiście odwrotnie można zrobić również).

Zaletą definiowania dekoratora jest jego ponowne użycie: można zastosować ten dekorator do wszystkich funkcji (i tym samym ułatwić ich realizację).

Answer 2

Nie zgadzam się z tym pomysłem (mimo że podoba mi się to, że pyton nie wymaga definicji typów zmiennych, a tym samym pozwala na coś takiego), ale mogą istnieć przypadki, w których takie rzeczy są potrzebne. Więc tutaj:

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 

Restrukturyzacja to trochę, ale logika pozostaje taka sama. jeśli "a" jest wartością iteracyjną, uważaj ją za swoją krotkę, jeśli nie weź pod uwagę "b". jeśli „a” nie jest iterable i „b” nie jest zdefiniowany, podnieść TypeError

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

Answer 3

pythonowy sposób byłoby użyć kaczka wpisywanie. Będzie działać tylko wtedy, gdy masz pewność, że żaden z rozwiniętych argumentów nie będzie możliwy do sprawdzenia.

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) 

Ta implementacja oferuje lekką poprawę na odpowiedź użytkownika @ Ev.Kounis dla przypadków, w których jeden non-krotka argumentem jest przekazywana w. To może również być łatwo przekształcony równoważnej dekoratora opisanej przez @WillemVanOnsem.Użyj wersji dekoratora, jeśli masz więcej niż jedną taką funkcję.