Was ist die pythischste Art zu überprüfen, ob ein Objekt eine Zahl ist?

Sie wollen, um zu überprüfen, ob ein Objekt

wirkt wie eine Zahl in bestimmten
Umstände

Wenn Sie mit Python 2.5 oder älter, die einzige wirkliche Möglichkeit ist, zu überprüfen, einige dieser "bestimmten Umständen" und zu sehen.

In 2,6 oder besser, Sie nutzen kann isinstance mit zahlen.Anzahl -- eine abstrakte Basis-Klasse (ABC) , existiert genau für diesen Zweck (viel mehr Alphabeten existieren in der collections - Modul für verschiedene Formen von collections/Container, wieder beginnend mit 2.6; und auch nur in diesen Versionen können Sie leicht fügen Sie Ihre eigenen abstrakten Basis-Klassen, wenn Sie benötigen).

Bach bis 2.5 und früher
"können Hinzugefügt werden, um 0 und ist nicht durchsuchbar" könnte eine gute definition in einigen Fällen. Aber,
Sie wirklich brauchen, um sich zu Fragen, was es ist, dass Sie sich Fragen, was Sie wollen, zu prüfen, "Anzahl" muss definitiv in der Lage sein, um tun, und was muss es unbedingt sein nicht zu tun-und zu überprüfen.

Dies kann auch erforderlich sein, in 2.6 oder später, vielleicht mit der Absicht, Ihre eigenen Registrierungen hinzufügen-Typen, die Sie interessieren, die noch nicht bereits registriert auf numbers.Numbers - wenn Sie möchten ausschließen einige Typen, die behaupten, Sie zahlen, aber Sie können einfach nicht damit umgehen, das braucht noch mehr Pflege, als das ABC haben keine unregister Methode [[Sie können zum Beispiel machen Sie Ihre eigenen ABC - WeirdNum und registrieren dort alle so komisch-für-Sie-Typen, dann prüfen Sie, ob isinstance davon zu retten, bevor Sie fortfahren zu überprüfen für isinstance von der normalen numbers.Number weiterhin erfolgreich.

BTW, wenn und wenn Sie brauchen, um zu überprüfen, ob x können oder etwas nicht tun können, haben Sie in der Regel, um zu versuchen, so etwas wie:

try: 0 + x
except TypeError: canadd=False
else: canadd=True

Anwesenheit von __add__ per se sagt Sie nichts nützlich, da e.g alle Sequenzen haben es für die Zwecke der Verkettung mit anderen Sequenzen. Diese Prüfung entspricht der definition "eine Zahl etwas, so dass eine Sequenz von solchen Dingen ist eine gültige einzige argument der builtin-Funktion sum", zum Beispiel. Total schräge Typen (z.B. diejenigen, die Erhöhung der "falsch" - Ausnahme, wenn deren Summe 0 ist, wie, sagen wir, ein ZeroDivisionError oder ValueError &c) propagiert Ausnahme, aber das ist OK, damit der Benutzer wissen, so bald wie möglich, dass solche verrückten Typen sind einfach nicht akzeptabel in guter Gesellschaft; -), aber ein "Vektor" ist summierbare einen Skalar (Python-standard-Bibliothek nicht haben, aber natürlich sind Sie beliebt als third-party-extensions) auch das falsche Ergebnis hier, also (z.B.) diese Prüfung sollte kommen nach "darf nicht iterierbar" (z.B., überprüfen, dass iter(x) wirft TypeError oder für die Anwesenheit von speziellen Methode __iter__ -- wenn Sie in 2.5 oder früher und müssen daher Ihre eigenen Kontrollen).

Einen kurzen Blick auf solche Komplikationen können ausreichend sein, um zu motivieren, Sie zu verlassen, statt auf abstrakten Basisklassen, Wann immer möglich...;-).

InformationsquelleAutor der Antwort Alex Martelli

Umformulieren Ihre Frage, die Sie versuchen, zu bestimmen, ob etwas eine Sammlung oder einen einzelnen Wert. Versuchen, um zu vergleichen, ob etwas ist ein Vektor oder eine Zahl ist äpfel mit Birnen vergleichen - ich kann ein Vektor von Zeichenketten oder zahlen, und ich kann eine einzelne Zeichenfolge oder einzelne Zahl. Sie sind daran interessiert, wie viele Sie haben (1 oder mehr), nicht was für ein Typ Sie eigentlich sind.

meine Lösung für dieses problem ist es, zu überprüfen, ob die Eingabe ist ein einzelner Wert oder eine Sammlung durch die überprüfung der Anwesenheit von __len__. Zum Beispiel:

def do_mult(foo, a_vector):
    if hasattr(foo, '__len__'):
        return sum([a*b for a,b in zip(foo, a_vector)])
    else:
        return [foo*b for b in a_vector]

Oder, für die duck-typing-Ansatz, können Sie versuchen, die Iteration auf foo erste:

def do_mult(foo, a_vector):
    try:
        return sum([a*b for a,b in zip(foo, a_vector)])
    except TypeError:
        return [foo*b for b in a_vector]

Letztlich ist es einfacher zu testen, ob etwas ist der Vektor-wie als zu testen, ob etwas Skalar-like. Wenn Sie Werte unterschiedlicher Typen (z.B. string, numerisch, etc.) kommen durch, dann ist die Logik des Programms kann einige arbeiten - wie haben Sie am Ende versucht, sich zu vermehren eine Zeichenfolge einen numerischen Vektor in den ersten Platz?

InformationsquelleAutor der Antwort Gordon Bean

Wahrscheinlich ist es besser, es einfach zu tun die andere Weise herum: Sie prüfen, ob es ein Vektor. Wenn es ist, Sie tun eine dot-Produkt und in allen anderen Fällen können Sie versuchen die Skalare Multiplikation.

Überprüfung der für die vector ist einfach, da sollte es von der Vektor-Klasse Typ (oder übernommen). Man könnte auch einfach versuchen, den ersten zu tun, ein dot-Produkt, und wenn das fehlschlägt (= es war nicht wirklich ein Vektor), dann wieder fallen zu skalaren Multiplikation.

InformationsquelleAutor der Antwort sth

Zusammenfassen /bewerten die bestehenden Methoden:

Candidate    | type                      | delnan | mat | shrewmouse | ant6n
-------------------------------------------------------------------------
0            | <type 'int'>              |      1 |   1 |          1 |     1
0.0          | <type 'float'>            |      1 |   1 |          1 |     1
0j           | <type 'complex'>          |      1 |   1 |          1 |     0
Decimal('0') | <class 'decimal.Decimal'> |      1 |   0 |          1 |     1
True         | <type 'bool'>             |      1 |   1 |          1 |     1
False        | <type 'bool'>             |      1 |   1 |          1 |     1
''           | <type 'str'>              |      0 |   0 |          0 |     0
None         | <type 'NoneType'>         |      0 |   0 |          0 |     0
'0'          | <type 'str'>              |      0 |   0 |          0 |     1
'1'          | <type 'str'>              |      0 |   0 |          0 |     1
[]           | <type 'list'>             |      0 |   0 |          0 |     0
[1]          | <type 'list'>             |      0 |   0 |          0 |     0
[1, 2]       | <type 'list'>             |      0 |   0 |          0 |     0
(1,)         | <type 'tuple'>            |      0 |   0 |          0 |     0
(1, 2)       | <type 'tuple'>            |      0 |   0 |          0 |     0

(Ich kam hier durch diese Frage)

Code

#!/usr/bin/env python

"""Check if a variable is a number."""

import decimal


def delnan_is_number(candidate):
    import numbers
    return isinstance(candidate, numbers.Number)


def mat_is_number(candidate):
    return isinstance(candidate, (int, long, float, complex))


def shrewmouse_is_number(candidate):
    try:
        return 0 == candidate * 0
    except:
        return False


def ant6n_is_number(candidate):
    try:
        float(candidate)
        return True
    except:
        return False

# Test
candidates = (0, 0.0, 0j, decimal.Decimal(0),
              True, False, '', None, '0', '1', [], [1], [1, 2], (1, ), (1, 2))

methods = [delnan_is_number, mat_is_number, shrewmouse_is_number, ant6n_is_number]

print("Candidate    | type                      | delnan | mat | shrewmouse | ant6n")
print("-------------------------------------------------------------------------")
for candidate in candidates:
    results = [m(candidate) for m in methods]
    print("{:<12} | {:<25} | {:>6} | {:>3} | {:>10} | {:>5}"
          .format(repr(candidate), type(candidate), *results))

InformationsquelleAutor der Antwort Martin Thoma

Ich hatte ein ähnliches Problem, bei der Umsetzung eine Art der Vektor-Klasse. Eine Möglichkeit zu prüfen, eine Zahl zu konvertieren, um, D. H. durch die Verwendung

float(x)

Diese ablehnen sollten Fälle, in denen x nicht in eine Zahl umgewandelt werden; kann aber auch ablehnen, andere Arten von Zahl-wie Strukturen, die könnte gültig sein, zum Beispiel komplexe zahlen.

InformationsquelleAutor der Antwort Ant6n