Überprüfen Sie, ob ein String in Python eine Zahl ist

1. Verwenden Sie die Funktion float(), um in Python zu prüfen, ob ein String eine Zahl ist
2. Verwenden Sie die Funktionen isdigit() und partition(), um in Python zu prüfen, ob ein String eine Zahl ist

Ein String ist eine Zeichenkette, die von doppelten oder einfachen Anführungszeichen eingeschlossen ist. Zeichenketten, die sich über mehrere Zeilen erstrecken, auch als mehrzeilige Zeichenketten bezeichnet, werden von dreifachen Anführungszeichen eingeschlossen.

Auf der anderen Seite sind Gleitkommazahlen einer der gebräuchlichsten integrierten numerischen Datentypen von Python. Ein float oder eine Gleitkommazahl kann als Zahl mit Dezimalpunkten beschrieben werden.

print(type(3.445))

Ausgabe:

<class 'float'>

Verwenden Sie die Funktion float(), um in Python zu prüfen, ob ein String eine Zahl ist

Python bietet vordefinierte Typkonvertierungsfunktionen, die einen Datentyp in einen anderen konvertieren. Diese Funktionen umfassen die Funktionen int(), str() und float() zum Konvertieren von Datentypen in Integer-, String- und Float-Datentypen.

Neben der Erzeugung einer Gleitkommazahl durch Einfügen eines Dezimalpunkts können Gleitkommazahlen auch durch die implizite oder explizite Umwandlung eines Strings in eine Gleitkommazahl erzeugt werden.

Die implizite Konvertierung wird von Python nur dann automatisch ohne Beteiligung des Benutzers durchgeführt, wenn die Werte kompatibel sind. Die explizite Konvertierung des String-Datentyps in eine Gleitkommazahl wird mit der Funktion float() ermöglicht, wie im folgenden Code gezeigt.

count = "22.23"
print(type(count))
r = float(count)
print(type(r))

Ausgabe:

<class 'str'>
<class 'float'>

Typkonvertierung ist ein wichtiges Konzept in Python und der Programmierung im Allgemeinen. Dies wird besonders deutlich, wenn die Notwendigkeit besteht, einen bestimmten Datentyp in einem Programm zu verwenden; In einem solchen Fall kann die Typkonvertierung beliebige Daten in den gewünschten Datentyp konvertieren.

Solche Fälle können häufig auftreten, wenn Dateioperationen wie das Lesen und Schreiben von Dateien in verschiedene Programme ausgeführt werden.

Während wir im obigen Code-Snippet mühelos die Ein-Parameter-Funktion float() verwendet haben, um den String-Datentyp in einen numerischen Float-Datentyp zu konvertieren, ist diese Methode nicht ohne Einschränkungen. Zu diesen Einschränkungen gehört der ValueError, der oft auftritt, um einen String mit einer Zeichenkette in einen Floating-Datentyp zu konvertieren.

Die Verwendung der Float-Funktion kann zu einem OverFlow-Fehler führen, wenn eine Zahl außerhalb des Bereichs der Funktion übergeben wird. Der folgende Code-Schnipsel veranschaulicht, wie der ValueError entsteht, wenn die float-Funktion einen ungültigen String umwandelt.

name = "developer"
rslt = float(name)
print(rslt)

Ausgabe:

Traceback (most recent call last):
  File "<string>", line 2, in <module>
ValueError: could not convert string to float: 'developer'

Der ValueError kann abgewendet werden, indem sichergestellt wird, dass der zur Konvertierung betrachtete String wie eine Gleitkommazahl aussieht.

Andere Instanzen können auch zum ValueError führen, der Leerzeichen, Kommas oder andere nicht-Sonderzeichen enthält. Daher muss beim Arbeiten mit Dateien vorher geprüft werden, ob Zeichenkettenwerte gültig und in Gleitkommazahlen umwandelbar sind.

Bei zu vielen Werten ist es jedoch ineffizient, jeden einzelnen Wert zu überprüfen. Alternativ können wir eine Funktion erstellen, die überprüft, ob ein String ein gültiger Float ist, der in eine Gleitkommazahl umgewandelt werden kann.

Wenn die Zeichenkette nicht gültig ist, sollte das Programm eine Ausnahme auslösen, anstatt einen Fehler auszulösen.

def is_valid_float(element: str) -> bool:
    try:
        float(element)
        return True
    except ValueError:
        return False

Die obige Funktion akzeptiert einen String als Argument und prüft, ob es sich um einen gültigen String handelt, der in eine Gleitkommazahl umgewandelt werden kann. Die Funktion gibt false zurück, wenn der String kein gültiger String ist, der in eine Gleitkommazahl umgewandelt werden kann, andernfalls true.

Verwenden Sie die Funktionen isdigit() und partition(), um in Python zu prüfen, ob ein String eine Zahl ist

Alternativ können wir die Funktion isdigit() anstelle der Funktion float() verwenden. Die Funktion isdigit() gibt true zurück, wenn ein String nur Ziffern enthält und false, wenn mindestens ein Zeichen keine Ziffer ist.

Diese Funktion gibt jedoch false zurück, wenn eine Zeichenkette eine Gleitkommazahl enthält, obwohl eine Gleitkommazahl eine gültige Zeichenkette ist.

def is_valid_string(element):
    if element.isdigit():
        print("String is valid")
    else:
        print("String is not valid")


is_valid_string("4546.4646")

Ausgabe:

String is not valid

Wir verwenden die Funktion partition, um sicherzustellen, dass die Funktion isdigit() auch dann keine falsche Aussage zurückgibt, wenn ein String eine Gleitkommazahl enthält.

Mit dieser Funktion können wir die Zeichenkette mit einer Gleitkommazahl in Teile aufteilen, um zu überprüfen, ob es sich um Ziffern handelt. Wenn beide Teile Ziffern sind, teilt uns die Funktion mit, dass dies eine gültige Zeichenkette ist.

def check_float(element):
    partition = element.partition(".")

    if element.isdigit():
        newelement = float(element)
        print("string is valid")

    elif (
        (partition[0].isdigit() and partition[1] == "." and partition[2].isdigit())
        or (partition[0] == "" and partition[1] == "." and partition[2].isdigit())
        or (partition[0].isdigit() and partition[1] == "." and partition[2] == "")
    ):
        newelement = float(element)
        print(newelement)
        print("String is also valid !")
    else:
        print("string is not valid !")


check_float("234.34")

Ausgabe:

234.34
String is also valid !

Bitte beachten Sie, dass die Funktion die Zeichenkette nicht partitionieren muss, wenn die Zeichenkette eine Ziffer enthält, die keine Gleitkommazahl ist.

def check_float(element):
    partition = element.partition(".")

    if element.isdigit():
        newelement = float(element)
        print("string is valid")

    elif (
        (partition[0].isdigit() and partition[1] == "." and partition[2].isdigit())
        or (partition[0] == "" and partition[1] == "." and partition[2].isdigit())
        or (partition[0].isdigit() and partition[1] == "." and partition[2] == "")
    ):
        newelement = float(element)
        print(newelement)
        print("String is also valid !")
    else:
        print("string is not valid !")


check_float("234")

Ausgabe:

string is valid

Wenn die Zeichenkette andererseits eine Gleitkommazahl enthält, die ein oder mehrere Zeichen enthält, die nicht als Ziffern betrachtet werden können, ist die Gleitkommazahl keine gültige Zeichenkette. Ein gültiger String bezieht sich in diesem Fall auf einen String, der mit der Funktion float() in eine Gleitkommazahl umgewandelt werden kann.

def check_float(element):
    partition = element.partition(".")

    if element.isdigit():
        newelement = float(element)
        print("string is valid")

    elif (
        (partition[0].isdigit() and partition[1] == "." and partition[2].isdigit())
        or (partition[0] == "" and partition[1] == "." and partition[2].isdigit())
        or (partition[0].isdigit() and partition[1] == "." and partition[2] == "")
    ):
        newelement = float(element)
        print(newelement)
        print("String is also valid !")
    else:
        print("string is not valid !")


check_float("234.rt9")

Ausgabe:

string is not valid !

Die Funktion isdigit() gibt auch true für ganze Zahlen und Ziffern in Exponentialform und Unicode-Zeichen einer beliebigen Ziffer zurück.

def is_valid_string(element):
    if element.isdigit():
        print("String is valid")
    else:
        print("String is not valid")


is_valid_string("4546")

Ausgabe:

String is valid

Wir haben die Methode isdigit() zusammen mit einer Funktion verwendet, die eine positive Nachricht zurückgibt, wenn der String im obigen Beispielcodeblock nur Zahlen enthält. Wenn die Funktion jedoch mit einem Argument aufgerufen wird, das keine Zahl enthält, gibt die Funktion eine negative Nachricht aus, wie im folgenden Code gezeigt.

def is_valid_string(element):
    if element.isdigit():
        print("String is valid")
    else:
        print("String is not valid")


is_valid_string("Pal Alto")

Ausgabe:

String is not valid

Daher können wir mit der Funktion isdigit() leicht feststellen, ob ein String gültig ist und in Gleitkommazahlen umgewandelt werden kann. Eine Zeichenkette, die Leerzeichen und Symbole enthält, kann nicht in eine Gleitkommazahl umgewandelt werden.

Mit der Methode isdigit() können wir auch feststellen, ob ein String, der Leerzeichen enthält, gültig ist, wie im folgenden Code gezeigt.

def is_valid_string(element):
    if element.isdigit():
        print("String is valid")
    else:
        print("String is not valid")


is_valid_string("$4546.343")

Ausgabe:

String is not valid

Eine Zeichenkette mit Leerzeichen ist ebenfalls keine gültige Zeichenkette und kann nicht in eine Gleitkommazahl umgewandelt werden.

def is_valid_string(element):
    if element.isdigit():
        print("String is valid")
    else:
        print("String is not valid")


is_valid_string("45 8")

Ausgabe:

String is not valid

Komplexe Zahlen gehören gleichermaßen zu den drei integrierten numerischen Datentypen in Python. Wir können neben der Funktion complex() auch die Funktion float() verwenden, um festzustellen, ob ein String mit einer komplexen Zahl auch in einen Gleitkomma-Datentyp umgewandelt werden kann.

Die Funktion complex() wandelt ganze Zahlen und Strings in komplexe Zahlen um. Daher können wir mit beiden Funktionen bestätigen, dass eine Zeichenkette, die eine Zeichenkette enthält, weder in eine Gleitkommazahl noch in eine komplexe Zahl umgewandelt werden kann.

Die Funktionen können auch prüfen, ob eine Zeichenkette mit einer komplexen Zahl in eine Gleitkommazahl umgewandelt werden kann, wie im folgenden Code gezeigt.

def is_valid_string(str):
    try:
        float(str)
        return True
    except ValueError:
        try:
            complex(str)
        except ValueError:
            return False


print(is_valid_string("hello"))

Ausgabe:

False

Im Gegensatz dazu kann ein String, der aus einer ganzen Zahl oder einer Gleitkommazahl besteht, in eine Gleitkommazahl und eine komplexe Zahl umgewandelt werden. Wenn wir also ein Argument mit der obigen Beschreibung übergeben, wird die Funktion wahrscheinlich stattdessen True zurückgeben.

def is_valid_string(str):
    try:
        float(str)
        return True
    except ValueError:
        try:
            complex(str)
        except ValueError:
            return False


print(is_valid_string("456.45"))

Ausgabe:

True

Ein String bestehend aus einer ganzen Zahl ist gleichermaßen gültig und kann in Gleitkommazahlen und komplexe Zahlen umgewandelt werden. Daher erhalten wir auch eine True-Aussage.

def is_valid_string(str):
    try:
        float(str)
        return True
    except ValueError:
        try:
            complex(str)
        except ValueError:
            return False


print(is_valid_string("456"))

Ausgabe:

True