Vérifier si une chaîne est un nombre en Python

1. Utilisez la fonction float() pour vérifier si une chaîne est un nombre en Python
2. Utilisez les fonctions isdigit() et partition() pour vérifier si une chaîne est un nombre en Python

Une chaîne est une séquence de caractères entourée de guillemets simples ou doubles. Les chaînes qui s’étendent sur plusieurs lignes, également appelées chaînes multilignes, sont entourées de guillemets triples.

D’un autre côté, les nombres à virgule flottante sont l’un des types de données numériques intégrés les plus courants de Python. Un float ou un nombre à virgule flottante peut être décrit comme un nombre avec des virgules décimales.

print(type(3.445))

Production :

<class 'float'>

Utilisez la fonction float() pour vérifier si une chaîne est un nombre en Python

Python fournit des fonctions de conversion de type prédéfinies qui convertissent un type de données en un autre. Ces fonctions incluent les fonctions int(), str() et float() pour convertir les types de données en types de données entier, chaîne et flottant respectivement.

Outre la création d’un nombre à virgule flottante en insérant une virgule décimale, les nombres à virgule flottante peuvent également être créés via la conversion implicite ou explicite d’une chaîne en un nombre à virgule flottante.

La conversion implicite est effectuée automatiquement par Python sans intervention de l’utilisateur uniquement si les valeurs sont compatibles. La conversion explicite du type de données chaîne en un nombre à virgule flottante est rendue possible à l’aide de la fonction float() comme indiqué dans le code ci-dessous.

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

Production :

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

La conversion de type est un concept important en Python et en programmation en général. Ceci est particulièrement évident lorsqu’il est nécessaire d’utiliser un type de données particulier dans un programme ; dans un tel cas, la conversion de type peut convertir toutes les données dans le type de données souhaité.

De tels cas peuvent souvent être rencontrés lors de l’exécution d’opérations sur les fichiers telles que la lecture et l’écriture de fichiers dans divers programmes.

Alors que dans l’extrait de code ci-dessus, nous avons utilisé sans effort la fonction à un paramètre float() pour convertir le type de données chaîne en un type de données numérique flottant, cette méthode n’est pas sans limitations. Ces limitations incluent la ValueError, qui survient souvent pour convertir une chaîne avec une séquence de caractères en un type de données flottant.

L’utilisation de la fonction float peut entraîner une erreur OverFlow si un nombre hors de la plage de la fonction est passé. L’extrait de code ci-dessous illustre comment la ValueError se produit lorsque la fonction float convertit une chaîne invalide.

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

Production :

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

La ValueError peut être évitée en s’assurant que la chaîne considérée pour la conversion ressemble à un nombre à virgule flottante.

D’autres instances peuvent également conduire à la ValueError, qui inclut des espaces, des virgules ou tout autre caractère non spécial. Par conséquent, chaque fois que vous travaillez avec des fichiers, il est nécessaire de vérifier au préalable si les valeurs de chaîne sont valides et convertibles en nombres à virgule flottante.

Cependant, si les valeurs sont trop nombreuses, il est inefficace d’essayer de vérifier chaque valeur. Alternativement, nous pouvons créer une fonction qui vérifie si une chaîne est un flottant valide qui peut être converti en un nombre à virgule flottante.

Si la chaîne n’est pas valide, le programme doit lever une exception au lieu de générer une erreur.

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

La fonction ci-dessus accepte une chaîne comme argument et vérifie s’il s’agit d’une chaîne valide pouvant être convertie en un nombre à virgule flottante. La fonction renvoie false si la chaîne n’est pas une chaîne valide pouvant être convertie en un nombre à virgule flottante et true dans le cas contraire.

Utilisez les fonctions isdigit() et partition() pour vérifier si une chaîne est un nombre en Python

Alternativement, nous pouvons utiliser la fonction isdigit() au lieu de la fonction float(). La fonction isdigit() renvoie true si une chaîne ne contient que des chiffres et false si au moins un caractère n’est pas un chiffre.

Cependant, cette fonction renvoie false si une chaîne contient un nombre flottant même si un nombre à virgule flottante est une chaîne valide.

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


is_valid_string("4546.4646")

Production :

String is not valid

Nous utiliserons la fonction partition pour nous assurer que la fonction isdigit() ne renverra pas de fausse déclaration même lorsqu’une chaîne contient un nombre à virgule flottante.

Cette fonction nous permet de séparer la chaîne contenant un nombre à virgule flottante en parties pour vérifier s’il s’agit de chiffres. Si les deux parties sont des chiffres, la fonction nous indiquera qu’il s’agit d’une chaîne valide.

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")

Production :

234.34
String is also valid !

Veuillez noter que si la chaîne contient un chiffre qui n’est pas une virgule flottante, la fonction n’aura pas besoin de partitionner la chaîne.

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")

Production :

string is valid

D’un autre côté, si la chaîne contient un nombre à virgule flottante qui contient un ou plusieurs caractères qui ne peuvent pas être considérés comme des chiffres, alors la virgule flottante ne sera pas une chaîne valide. Une chaîne valide, dans ce cas, fait référence à une chaîne qui peut être convertie en un nombre à virgule flottante à l’aide de la fonction float().

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")

Production :

string is not valid !

La fonction isdigit() renvoie également true pour les entiers et les chiffres représentés sous forme exponentielle et les caractères Unicode de n’importe quel chiffre.

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


is_valid_string("4546")

Production :

String is valid

Nous avons utilisé la méthode isdigit() avec une fonction qui renvoie un message positif si la chaîne ne contient que des nombres dans l’exemple de bloc de code ci-dessus. Cependant, lorsque la fonction est invoquée avec un argument ne contenant aucun nombre, la fonction imprime un message négatif, comme indiqué dans le code ci-dessous.

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


is_valid_string("Pal Alto")

Production :

String is not valid

Par conséquent, en utilisant la fonction isdigit(), nous pouvons facilement déterminer si une chaîne est valide et peut être convertie en nombres à virgule flottante. Une chaîne qui contient des espaces et des symboles ne peut pas être convertie en nombre à virgule flottante.

En utilisant la méthode isdigit(), nous pouvons également déterminer si une chaîne contenant des espaces est valide, comme indiqué dans le code ci-dessous.

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


is_valid_string("$4546.343")

Production :

String is not valid

Une chaîne contenant un espace blanc n’est pas non plus une chaîne valide et ne peut pas être convertie en un nombre à virgule flottante.

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


is_valid_string("45 8")

Production :

String is not valid

Les nombres complexes font également partie des trois types de données numériques intégrés à Python. Nous pouvons également utiliser la fonction float() avec la fonction complex() pour déterminer si une chaîne contenant un nombre complexe peut également être convertie en un type de données à virgule flottante.

La fonction complex() convertit les entiers et les chaînes en nombres complexes. Par conséquent, en utilisant les deux fonctions, nous pouvons confirmer qu’une chaîne qui contient une séquence de caractères ne peut pas être convertie en nombre à virgule flottante, ni en nombre complexe.

Les fonctions peuvent également vérifier si une chaîne contenant un nombre complexe peut être convertie en un nombre à virgule flottante, comme indiqué dans le code ci-dessous.

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


print(is_valid_string("hello"))

Production :

False

Au contraire, une chaîne constituée d’un entier ou d’un nombre à virgule flottante peut être convertie en un nombre à virgule flottante et un nombre complexe. Par conséquent, si nous passons un argument avec la description ci-dessus, la fonction retournera probablement True à la place.

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"))

Production :

True

Une chaîne constituée d’un entier est également valide et peut être convertie en nombres à virgule flottante et complexes. Par conséquent, nous obtiendrons également une déclaration True.

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


print(is_valid_string("456"))

Production :

True