Ausnahmen separat in Pythons gleiche Typs

Question

Sagen, ich habe die folgenden vier Variablen Handhabung:

>>> f1 = (print, 1, 2 ,3 ,4) 
>>> f2 = (exit, 1, 2 ,3 ,4) 
>>> f3 = (1, 2, 3, 4) 
>>> f4 = 4 

In einem hypothetischen Programm erwarte ich, dass jeder dieser Variablen ein Tupel halten, erstes Element, das sollte der Name sein, Funktion, und deren nachfolgende Elemente sollten die Funktion Parameter in der Reihenfolge sein.

ich eine Funktion auf diese Weise wie so gespeichert nennen könnte:

>>> f1[0](*f1[1:]) 
1 2 3 4 

Allerdings sind die meisten dieser Variablen sind nicht im ausgenommen Format, und ich möchte die Berufung von ihnen in der Lage sein innen zu kapseln try/except Blöcke, um diese Situationen zu behandeln.

Nun, obwohl die Funktionsaufrufe von f2, f3 und f4 Pause radikal anderen Grund, sie alle die gleiche Art von Ausnahme auslösen, ein TypeError:

>>> f2[0](*f2[1:]) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: __call__() takes from 1 to 2 positional arguments but 5 were given 
>>> f3[0](*f3[1:]) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: 'int' object is not callable 
>>> f4[0](*f4[1:]) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: 'int' object is not subscriptable 

Damit ein generisches Tun:

try: 
    f[0](*f[1:]) 
except TypeError: 
    # handle exception 

Würde mir nicht genügend Informationen zur Verfügung stellen, um jede Ausnahme entsprechend zu behandeln.

Was wäre der richtige Weg, um zwischen verschiedenen Ausnahmen desselben Typs in Python zu unterscheiden?

Answer 1

So müssen Sie eine andere Methode des Aufrufs als function(*tuple) verwenden. Hier ist ein Beispiel für eine Funktion fun_apply, die eine bestimmte Funktion mit Positions- und Schlüsselwortargumenten aufruft. Es fügt eine explizite Überprüfung hinzu, um sicherzustellen, dass args iterierbar ist und kwargs von collection.Mapping erbt.

from collections import Mapping 

def fun_apply(f, args=None, kwargs=None):                     
    if args is None: 
     args = [] 
    if kwargs is None: 
     kwargs = {} 

    try: 
     args = iter(args) 
    except TypeError: 
     # handle args being non-iterable 
     pass 

    if isinstance(kwargs, collections.Mapping): 
     pass 
    else: 
     # handle kwargs being a non-mapping 
     pass 

    if hasattr(f, '__call__'): 
     pass 
    else: 
     # handle f being non-callable 
     pass 

    try: 
     f(*args, **kwargs) 
    except TypeError as e: 
     raise TypeError(e) 

Die andere Option ist die message Zeichenfolge explizit zu verarbeiten, aber die unbeabsichtigte Folge und die Fehlermeldungen haben könnte, sich zwischen den Versionen von Python unterscheiden könnte.