Recherche de site Web

Comment recevoir des entrées utilisateur en Python : Guide du débutant

Introduction

La réception des entrées de l’utilisateur est fondamentale dans la programmation Python, car elle permet aux développeurs de créer des applications interactives. Que vous travailliez sur des scripts de ligne de commande, des applications basées sur des interfaces graphiques ou des applications Web, la gestion correcte des entrées utilisateur garantit l’efficacité et la sécurité des logiciels.

Dans ce tutoriel, vous allez apprendre différentes façons de recevoir des entrées utilisateur en Python, notamment 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 façon la plus simple de recevoir des entrées utilisateur est d’utiliser la fonction input() intégrée de Python. Il lit une chaîne du clavier et la renvoie.

Exemple:

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

Prise d’une entrée d’entier

Comme 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 de l’entrée du flotteur

Lorsque vous traitez des entrées numériques qui nécessitent une précision décimale, telles que des prix ou des mesures, vous devez convertir l’entrée de l’utilisateur en un nombre à virgule flottante. Ceci est réalisé à l’aide de la fonction float(), qui convertit une chaîne en un nombre à virgule flottante.

Voici un exemple de gestion de l’entrée float en Python :

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

Validation de l’entrée utilisateur

Lors du traitement des entrées utilisateur, il est essentiel de gérer les erreurs potentielles qui peuvent se produire lorsque les utilisateurs saisissent des données non valides. Une façon efficace de le faire est d’utiliser des blocs try-except. Cette approche vous permet d’intercepter et de gérer les exceptions qui peuvent être levées au cours du processus d’entrée, ce qui garantit 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 Python.

2. Gestion de plusieurs entrées utilisateur

Lorsque vous utilisez une entrée 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 basée sur un séparateur spécifié. Dans le cas de l’entrée utilisateur, nous pouvons utiliser split() pour séparer plusieurs valeurs saisies par l’utilisateur.

Voici un exemple de comment utiliser split() pour recevoir deux entrées de chaîne de caractères de l’utilisateur :

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

Toutefois, 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 des chaînes renvoyées 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 celles-ci si nécessaire.

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

Lors de l’exécution d’un script Python à partir de la ligne de commande, il est souvent nécessaire de transmettre des informations ou des paramètres supplémentaires au script. Ceci est réalisé à l’aide d’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 d’utilisation de sys.argv pour lire les arguments de ligne de commande :

Enregistrez le script suivant sous la forme 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 votre invite de commande :

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 utiliser les 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 effectuer différentes tâches en fonction de l’entrée de l’utilisateur ou de la configuration.

4. Réception d’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 interactive des entrées. L’un des frameworks d’interface graphique les plus populaires et les plus faciles à utiliser est Tkinter, qui est inclus dans la bibliothèque standard Python. Tkinter vous permet de créer des applications graphiques simples avec un minimum de code.

Voici un exemple d’utilisation de Tkinter pour recevoir des entrées utilisateur dans une application graphique :

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 windowCreate a Button to trigger the get_input function
btn = tk.Button(root, text="Submit", command=get_input)
btn.pack()  # Add the Button to the windowCreate a Label to display the user's input
label = tk.Label(root, text="")
label.pack()  # Add the Label to the windowStart the Tkinter event loop
root.mainloop()

Cet exemple montre comment créer une application graphique simple qui invite l’utilisateur à entrer une entrée, traite cette entrée et l’affiche à son tour.

Meilleures pratiques pour la gestion des entrées utilisateur

Lorsque vous utilisez des entrées utilisateur en Python, il est essentiel de suivre les bonnes pratiques pour vous assurer que votre application est robuste, sécurisée et conviviale. Les entrées utilisateur peuvent se présenter sous différentes formes, telles que des arguments de ligne de commande, des entrées à partir de fichiers ou des entrées interactives des utilisateurs. Voici cinq directives clés à garder à l’esprit, ainsi qu’un exemple de code pour illustrer chaque point :

1. Valider les données saisies

La validation des entrées de l’utilisateur est cruciale pour éviter les erreurs et s’assurer que les données reçues sont dans le format attendu. Cela peut être réalisé à l’aide de blocs try-except pour intercepter et gérer les exceptions qui peuvent se produire pendant le 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 élégance

La mise en œuvre de mécanismes de gestion des erreurs est essentielle pour éviter les pannes d’application et offrir une meilleure expérience utilisateur. Les blocs try-except peuvent être utilisés pour intercepter et gérer les erreurs d’une manière qui n’interrompt pas le flux de l’application. Par exemple, lors de la lecture d’un fichier, vous pouvez utiliser un bloc try-except pour gérer 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 durée de l’entrée utilisateur peut aider à prévenir les comportements inattendus, tels que les attaques par débordement de la mémoire tampon ou l’utilisation excessive de la mémoire. Cela peut être réalisé en utilisant le découpage de chaîne 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 d’entrer un nom d’utilisateur, vous pouvez limiter la longueur de 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. Désinfectez les intrants

Le nettoyage des entrées utilisateur est essentiel pour prévenir les risques de sécurité, tels que l’injection SQL ou le cross-site scripting (XSS). Il s’agit de supprimer ou d’échapper les caractères spéciaux qui pourraient être utilisés à des fins malveillantes. Le module html de Python offre un moyen pratique d’échapper les caractères HTML dans la saisie de l’utilisateur. Par exemple, lors de l’affichage d’une entrée utilisateur sur une page Web, vous pouvez utiliser html.escape() pour empêcher 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 les valeurs par défaut

La fourniture de valeurs par défaut pour la saisie par l’utilisateur peut améliorer considérablement la convivialité en réduisant la quantité d’informations que les utilisateurs doivent fournir. Cela peut être réalisé à l’aide de l’opérateur ou pour attribuer une valeur par défaut si l’entrée de l’utilisateur est vide ou non valide. Par exemple, lorsque vous demandez à l’utilisateur d’entrer son nom, vous pouvez fournir une valeur par défaut « 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 bonnes pratiques, vous pouvez vous assurer que votre application Python gère les entrées utilisateur de manière sécurisée, efficace et conviviale.

Foire aux questions

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

La réception des donné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 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 d’entier d’un utilisateur en Python, vous pouvez utiliser une boucle while pour inviter à plusieurs reprises l’utilisateur à entrer une entrée jusqu’à ce qu’un entier valide soit entré. 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 de saisir une entrée jusqu’à ce qu’un entier valide soit entré, ce qui en fait un moyen robuste de gérer la saisie de l’utilisateur en Python.

3. Puis-je recevoir plusieurs entrées utilisateur à la fois en Python ?

Oui, vous pouvez recevoir plusieurs entrées utilisateur à la fois 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 basées sur un séparateur spécifié, tel qu’un espace. La fonction map() peut ensuite être utilisée pour convertir chaque partie dans le type de données souhaité, tel qu’un entier.

Voici un exemple de bloc de code qui montre comment recevoir deux entrées entières de l’utilisateur à la fois :

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() ?

Lors de l’exécution d’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 la façon dont 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. Si ce n’est pas le cas, 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 à partir de la ligne de commande.

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

En Python, vous pouvez prendre des entrées de l’utilisateur à l’aide de la fonction input(). Cette fonction renvoie une chaîne, 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 imprime un message d’accueil avec son nom.

6. Comment prendre les entrées d’une variable en Python ?

En Python, vous ne pouvez pas prendre directement l’entrée d’une variable. Les variables sont utilisées pour stocker des valeurs, et non pour recevoir des entrées. Cependant, vous pouvez utiliser une variable pour stocker l’entrée reçue de l’utilisateur à l’aide de 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 imprimer un message d’accueil.

7. Comment saisir un nombre en Python ?

Pour saisir un nombre en Python, vous pouvez utiliser la fonction input() et convertir la chaîne d’entrée en entier ou en float à l’aide de 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 invite l’utilisateur à entrer son âge, convertit l’entrée en entier, puis imprime un message avec son âge.

Conclusion

Ce tutoriel a couvert plusieurs façons de recevoir des entrées utilisateur en Python, de l’entrée de base du terminal aux arguments de ligne de commande et aux interactions basées sur l’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. Lecture, écriture et copie de fichiers Python

  3. Fonction de type Python