Recherche de site Web

Comment recevoir une entrée utilisateur en Python : Guide du débutant

Introduction

La réception des entrées utilisateur est fondamentale en programmation Python, permettant aux développeurs de créer des applications interactives. Que vous travailliez sur des scripts en ligne de commande, des applications basées sur une interface graphique, ou des applications web, bien gérer les entrées utilisateur garantit un logiciel efficace et sécurisé.

Dans ce tutoriel, vous apprendrez diverses façons de recevoir des entrées utilisateur en Python, y compris la fonction input(), les arguments de ligne de commande, la gestion des entrées basée sur l'interface graphique et les meilleures pratiques pour la validation et la gestion des erreurs.

1. Utilisation de la fonction input()

La manière la plus simple de recevoir des entrées utilisateur est par la fonction intégrée input() de Python. Elle lit une chaîne depuis le clavier et la retourne.

Exemple :

name = input("Enter your name: ")
print("Hello, " + name + "!")

Prendre une entrée entière

Puisque input() renvoie une chaîne, vous devez la convertir en entier si nécessaire :

age = int(input("Enter your age: "))
print("You are", age, "years old.")

Gestion des entrées à virgule flottante

Lorsqu'il s'agit d'entrées numériques nécessitant une précision décimale, comme des prix ou des mesures, vous devez convertir l'entrée de l'utilisateur en un nombre à virgule flottante. Cela se fait à l'aide de la fonction float(), qui convertit une chaîne en un nombre à virgule flottante.

Voici un exemple de la façon de gérer l'entrée float en Python :

price = float(input("Enter the price: "))
print("The price is", price)

Validation de l'entrée utilisateur

Lorsqu'il s'agit de l'entrée utilisateur, il est essentiel de gérer les erreurs potentielles qui peuvent survenir lorsque les utilisateurs saisissent des données invalides. Une manière efficace de le faire est d'utiliser des blocs try-except. Cette approche vous permet d'attraper et de gérer les exceptions qui pourraient être levées pendant le processus d'entrée, garantissant ainsi que votre programme reste robuste et convivial.

while True:
    try:
        number = int(input("Enter an integer: "))
        break
    except ValueError:
        print("Invalid input! Please enter a valid integer.")

Pour en savoir plus sur la gestion des différents types de données, consultez notre tutoriel sur les types de données en Python.

2. Gestion de plusieurs entrées utilisateur

Lorsqu'on travaille avec des saisies utilisateur, il est courant d'exiger plusieurs valeurs de la part de l'utilisateur. Python fournit un moyen pratique de gérer cela en utilisant la méthode split(), qui divise une chaîne en une liste de sous-chaînes en fonction d'un séparateur spécifié. Dans le cas de la saisie utilisateur, nous pouvons utiliser split() pour séparer plusieurs valeurs saisies par l'utilisateur.

Voici un exemple de la façon d'utiliser split() pour recevoir deux chaînes de caractères en entrée de l'utilisateur :

x, y = input("Enter two numbers separated by space: ").split()
print("First number:", x)
print("Second number:", y)

Cependant, si vous devez effectuer des opérations numériques sur ces entrées, vous devrez les convertir en types numériques. Cela peut être réalisé en utilisant la fonction map(), qui applique une fonction donnée à chaque élément d'un itérable (dans ce cas, la liste de chaînes de caractères renvoyée par split()). Voici comment modifier l'exemple précédent pour convertir les entrées en entiers :

x, y = map(int, input("Enter two numbers: ").split())
print("Sum:", x + y)

En utilisant map() pour convertir les entrées en entiers, vous pouvez effectuer des opérations arithmétiques sur elles si nécessaire.

3. Lecture des entrées à partir des arguments de ligne de commande

Lorsque vous exécutez un script Python depuis la ligne de commande, il est souvent nécessaire de passer des informations ou des paramètres supplémentaires au script. Cela se fait à travers des arguments de ligne de commande, qui sont des valeurs fournies après le nom du script lors de son exécution. La méthode sys.argv de Python vous permet d'accéder à ces arguments dans votre script.

Voici un exemple de la façon d'utiliser sys.argv pour lire des arguments de la ligne de commande :

Enregistrez le script suivant sous script.py :

import sys

sys.argv is a list that contains the script name and all arguments passed to it
print("Script name:", sys.argv[0])  # sys.argv[0] is the script name itself

Check if any arguments were passed
if len(sys.argv) > 1:
    print("Arguments:", sys.argv[1:])  # sys.argv[1:] contains all arguments except the script name

Pour exécuter le script avec des arguments, utilisez la commande suivante dans votre terminal ou invite de commandement :

python script.py Hello World

Dans cet exemple, Hello et World sont les arguments passés au script. Le script affichera le nom du script et les arguments fournis.

Comprendre comment travailler avec des arguments de ligne de commande est essentiel pour créer des scripts qui peuvent être facilement personnalisés ou configurés sans modifier le script lui-même. Cette approche est particulièrement utile pour les scripts qui doivent exécuter différentes tâches en fonction des entrées utilisateur ou de la configuration.

4. Recevoir des entrées dans les applications GUI

Lors de la création d'applications d'interface utilisateur graphique (GUI), Python propose une gamme de bibliothèques pour faciliter la gestion des entrées interactives. L'un des frameworks GUI les plus populaires et les plus faciles à utiliser est Tkinter, qui est inclus dans la bibliothèque standard de Python. Tkinter vous permet de créer de simples applications GUI avec un minimum de code.

Voici un exemple de la façon d'utiliser Tkinter pour recevoir des entrées de l'utilisateur dans une application GUI :

import tkinter as tk

def get_input():
    # Retrieve the text entered by the user in the Entry field
    user_input = entry.get()
    # Update the Label to display the user's input
    label.config(text=f"You entered: {user_input}")

Create the main window of the application
root = tk.Tk()
Create an Entry field for user input
entry = tk.Entry(root)
entry.pack()  # Add the Entry field to the window
Create a Button to trigger the get_input function
btn = tk.Button(root, text="Submit", command=get_input)
btn.pack()  # Add the Button to the window
Create a Label to display the user's input
label = tk.Label(root, text="")
label.pack()  # Add the Label to the window
Start the Tkinter event loop
root.mainloop()

Cet exemple montre comment créer une application GUI simple qui demande à l'utilisateur une saisie, traite cette saisie et l'affiche à l'utilisateur.

Meilleures pratiques pour gérer les entrées utilisateur

Lors de la gestion des saisies utilisateur en Python, il est essentiel de suivre les meilleures pratiques pour garantir que votre application est robuste, sécurisée et conviviale. Les entrées utilisateur peuvent prendre différentes formes, telles que des arguments de ligne de commande, des entrées provenant de fichiers ou des saisies interactives des utilisateurs. Voici cinq lignes directrices clés à garder à l'esprit, accompagnées de codes d'exemple pour illustrer chaque point :

1. Valider l'entrée

Valider l'entrée utilisateur est crucial pour éviter les erreurs et s'assurer que les données reçues sont au format attendu. Cela peut être réalisé en utilisant des blocs try-except pour intercepter et gérer les exceptions qui peuvent survenir lors du traitement des entrées. Par exemple, lorsque vous demandez à l'utilisateur d'entrer un entier, vous pouvez utiliser un bloc try-except pour gérer les cas où l'utilisateur entre une valeur non entière.

This code block is designed to repeatedly prompt the user for an integer input until a valid integer is entered.
while True:  # This loop will continue indefinitely until a break statement is encountered.
    try:
        # The input() function is used to get user input, which is then passed to int() to convert it to an integer.
        # If the input cannot be converted to an integer (e.g., if the user enters a string or a float), a ValueError is raised.
        num = int(input("Enter an integer: "))
        # If the input is successfully converted to an integer, the loop is exited using the break statement.
        break
    except ValueError:
        # If a ValueError is raised, it means the input cannot be converted to an integer.
        # In this case, an error message is printed to the user, prompting them to enter a valid integer.
        print("Invalid input! Please enter a valid integer.")

After the loop is exited, the program prints out the valid integer entered by the user.
print("You entered:", num)

2. Gérez les erreurs avec grâce

La mise en œuvre de mécanismes de gestion des erreurs est essentielle pour prévenir les pannes d'application et offrir une meilleure expérience utilisateur. Les blocs try-except peuvent être utilisés pour attraper et gérer les erreurs de manière à ne pas perturber le flux de l'application. Par exemple, lors de la lecture d'un fichier, vous pouvez utiliser un bloc try-except pour traiter les cas où le fichier n'existe pas ou ne peut pas être lu.

Try to open the file "example.txt" in read mode
try:
    with open("example.txt", "r") as file:
        # Read the content of the file
        content = file.read()
        # Print the content of the file
        print("File content:", content)
Handle the case where the file is not found
except FileNotFoundError:
    print("File not found!")
Handle any other exceptions that may occur
except Exception as e:
    print("An error occurred:", str(e))

3. Limiter la longueur d'entrée

Limiter la longueur des saisies utilisateur peut aider à prévenir des comportements inattendus, tels que des attaques par débordement de tampon ou une utilisation excessive de la mémoire. Cela peut être réalisé en utilisant la découpe de chaînes ou d'autres méthodes pour tronquer les chaînes d'entrée au-delà d'une certaine longueur. Par exemple, lorsque vous demandez à l'utilisateur de saisir un nom d'utilisateur, vous pouvez limiter la longueur de la saisie à 20 caractères.

This code block prompts the user to enter a username, with a maximum length of 20 characters.
username = input("Please enter your username (maximum 20 characters): ")
If the length of the username is greater than 20, it is truncated to 20 characters.
if len(username) > 20:
    username = username[:20]
    print("Your username has been truncated to 20 characters.")
The program then prints the username entered by the user.
print("Your username is:", username)

4. Assainir les entrées

La désinfection des entrées utilisateur est essentielle pour prévenir les risques de sécurité, tels que l'injection SQL ou le cross-site scripting (XSS). Cela implique de supprimer ou d'échapper les caractères spéciaux qui pourraient être utilisés de manière malveillante. Le module html de Python fournit un moyen pratique d'échapper les caractères HTML dans les entrées utilisateur. Par exemple, lors de l'affichage d'entrées utilisateur sur une page web, vous pouvez utiliser html.escape() pour prévenir les attaques XSS.

This code block imports the 'html' module to use its 'escape' function for sanitizing user input.
import html

It then prompts the user to enter a string using the 'input' function.
user_input = html.escape(input("Enter a string: "))

The 'html.escape' function is used to escape any HTML characters in the user's input to prevent XSS attacks.
This ensures that any special characters in the input are replaced with their HTML entity equivalents, making the input safe to display in a web page.

Finally, the sanitized user input is printed to the console.
print("Sanitized input:", user_input)

5. Utiliser des valeurs par défaut

Fournir des valeurs par défaut pour les entrées des utilisateurs peut améliorer considérablement l'utilisabilité en réduisant la quantité d'informations que les utilisateurs doivent fournir. Cela peut être réalisé en utilisant l'opérateur or pour attribuer une valeur par défaut si l'entrée de l'utilisateur est vide ou invalide. Par exemple, lorsque vous demandez à l'utilisateur d'entrer son nom, vous pouvez fournir une valeur par défaut de « Invité » si l'utilisateur n'entre pas de nom.

This code block prompts the user to enter their name and then prints a greeting message.
The input function is used to get user input, and the or "Guest" part ensures that if the user doesn't enter anything, the default name "Guest" is used.
name = input("Enter your name: ") or "Guest"
The f-string is used to format the greeting message with the user's name.
print(f"Hello, {name}!")

En suivant ces meilleures pratiques, vous pouvez vous assurer que votre application Python gère les entrées utilisateur de manière sécurisée, efficace et conviviale.

FAQ

1. Comment puis-je recevoir des entrées utilisateur en Python ?

Recevoir des entrées de l'utilisateur est un aspect fondamental de tout programme interactif. En Python, vous pouvez utiliser la fonction intégrée input() pour demander à l'utilisateur de saisir des données et stocker sa réponse dans une variable. Voici un exemple simple :

user_input = input("Enter something: ")
print("You entered:", user_input)

2. Comment puis-je obtenir une entrée entière d'un utilisateur en Python ?

Pour obtenir une entrée entière d'un utilisateur en Python, vous pouvez utiliser une boucle while pour demander à l'utilisateur de manière répétée jusqu'à ce qu'un entier valide soit saisi. Voici un exemple de bloc de code qui le démontre :

This code block repeatedly prompts the user to enter an integer until a valid integer is entered.
while True:  # This loop will continue to run indefinitely until a valid integer is entered.
    user_input = input("Enter an integer: ")  # This line prompts the user to enter an integer and stores the input in the 'user_input' variable.
    if user_input.isdigit():  # This condition checks if the user's input consists only of digits, indicating a valid integer.
        num = int(user_input)  # If the input is a valid integer, it is converted to an integer and stored in the 'num' variable.
        print("You entered:", num)  # This line prints a message to the console indicating the valid integer entered by the user.
        break  # This line breaks out of the loop, ending the program.
    else:
        print("Invalid input! Please enter a valid integer.")  # If the input is not a valid integer, this message is printed to the console, prompting the user to enter a valid integer.

Ce bloc de code garantit que le programme continuera à demander à l'utilisateur une entrée jusqu'à ce qu'un entier valide soit saisi, ce qui en fait une méthode robuste pour gérer les entrées utilisateur en Python.

3. Puis-je recevoir plusieurs entrées d'utilisateur en même temps en Python ?

Oui, vous pouvez recevoir plusieurs entrées utilisateur en même temps en Python. Une façon de le faire est d'utiliser la méthode split() pour diviser la chaîne d'entrée en plusieurs parties en fonction d'un séparateur spécifié, tel qu'un espace. La fonction map() peut ensuite être utilisée pour convertir chaque partie en le type de données souhaité, comme un entier.

Voici un exemple de bloc de code qui montre comment recevoir deux entrées entières de l'utilisateur en même temps :

x, y = map(int, input("Enter two numbers separated by space: ").split())
print("First number:", x)
print("Second number:", y)

4. Comment puis-je gérer les arguments de ligne de commande au lieu de input() ?

Lorsque vous exécutez un script Python à partir de la ligne de commande, vous pouvez passer des arguments au script. Ces arguments sont stockés dans la liste sys.argv. Le premier élément de cette liste, sys.argv[0], est le nom du script lui-même. Le reste des éléments sont les arguments passés au script.

Voici un exemple de comment vous pouvez gérer les arguments de ligne de commande dans votre script Python :

import sys

Check if any command-line arguments were provided
if len(sys.argv) > 1:
    # Print the arguments received
    print("Command-line arguments received:", sys.argv[1:])
else:
    # Inform the user if no arguments were provided
    print("No command-line arguments provided.")

Dans cet exemple, le script vérifie si des arguments ont été fournis en vérifiant la longueur de sys.argv. S'il y a plus d'un élément dans sys.argv (c'est-à-dire qu'au moins un argument a été fourni), il affiche les arguments reçus. Sinon, il informe l'utilisateur qu'aucun argument n'a été fourni.

Cette approche est particulièrement utile lorsque vous souhaitez rendre votre script plus flexible et permettre aux utilisateurs de personnaliser son comportement en passant des arguments depuis la ligne de commande.

5. Comment prenez-vous des entrées en Python ?

En Python, vous pouvez prendre des entrées de l'utilisateur en utilisant la fonction input(). Cette fonction renvoie une chaîne de caractères, qui peut être stockée dans une variable pour un traitement ultérieur. Voici un exemple :

user_input = input("Please enter your name: ")
print("Hello, " + user_input + "!")

Ce code invite l'utilisateur à entrer son nom puis affiche un message de bienvenue avec son nom.

6. Comment prenez-vous l'entrée d'une variable en Python ?

En Python, vous ne pouvez pas directement prendre une entrée d'une variable. Les variables sont utilisées pour stocker des valeurs, pas pour recevoir des entrées. Cependant, vous pouvez utiliser une variable pour stocker l'entrée reçue de l'utilisateur en utilisant la fonction input(). Par exemple:

name = input("Please enter your name: ")
print("Hello, " + name + "!")

Dans cet exemple, la variable name stocke l'entrée reçue de l'utilisateur, puis elle est utilisée pour afficher un message de salutation.

7. Comment saisir un nombre en Python ?

Pour entrer un nombre en Python, vous pouvez utiliser la fonction input() et convertir la chaîne d'entrée en entier ou en flottant en utilisant la fonction int() ou float(), respectivement. Voici un exemple:

age = int(input("Please enter your age: "))
print("You are " + str(age) + " years old.")

Ce code demande à l'utilisateur d'entrer son âge, convertit l'entrée en entier, puis affiche un message avec son âge.

Conclusion

Ce tutoriel a couvert plusieurs manières de recevoir des entrées utilisateur en Python, de l'entrée terminale de base aux arguments de ligne de commande et aux interactions basées sur une interface graphique. En mettant en œuvre la validation des entrées et la gestion des erreurs, vous pouvez créer des applications Python robustes et conviviales.

Pour plus de tutoriels Python, consultez :

  1. Types de données Python

  2. Lire, écrire et copier des fichiers en Python

  3. Fonction type de Python