Comment créer des applications Python qui mémorisent les entrées de l'utilisateur En savoir plus sur le stockage de données pour assurer le succès des applications
À l'ère numérique d'aujourd'hui, l'expérience utilisateur joue un rôle essentiel dans le succès de toute application. Un aspect qui affecte grandement la satisfaction des utilisateurs est la capacité d'une application à mémoriser les entrées de l'utilisateur même lorsqu'elle est fermée.
Qu'il s'agisse d'une application de prise de notes, d'un gestionnaire de liste de tâches ou d'un assistant d'achat, la capacité à conserver les données des utilisateurs est essentielle.
Dans cet article, nous allons approfondir les différentes manières de procéder en explorant l'utilisation de fichiers et de bases de données pour stocker et récupérer les entrées utilisateur. En comprenant ces méthodes, vous pouvez améliorer les fonctionnalités de votre application et offrir une expérience transparente à vos utilisateurs.
Comment y parvenir ?
Nous devons stocker la même entrée utilisateur afin que l'application puisse se souvenir de l'entrée utilisateur. L'entrée de l'utilisateur n'est que des données, qu'il s'agisse d'un bouton enfoncé, d'une valeur entrée dans une zone de saisie, d'un fichier enregistré ou d'un message envoyé, ce sont des données qui peuvent être stockées et manipulées.
Le concept est simple : il faut stocker des données, puis il faut les récupérer et les remettre au bon endroit dans l'application.
Chaque langage de programmation a des variables qui peuvent stocker des données. Mais ils conservent ces données jusqu'à la fermeture de l'application. Après la fermeture, les données sont réinitialisées à la valeur d'origine de la variable, même si la valeur a changé lors de la dernière exécution du programme.
exemple:
Ici, nous avons une variable avec une valeur d'origine de 10. Nous imprimons ces données, puis incrémentons la valeur de 2 et imprimons à nouveau la valeur de la variable. Nous en avons reçu 12 comme prévu.
data = 10
print(data)
data += 2
print(data)
Mais une fois que nous exécutons à nouveau le programme, nous obtenons les mêmes résultats : 10 et 12 au lieu de 12 et 14 comme prévu. Cela signifie que nous devons stocker les données ailleurs, pas dans le script.
document
Stocker des données dans des fichiers, plus précisément des fichiers texte, est un moyen très simple de faire en sorte que votre application se souvienne des entrées de l'utilisateur.
Le langage de programmation fournit des fonctions, des modules et des bibliothèques intégrés conçus pour gérer les tâches liées aux fichiers texte, ce qui le rend facile à utiliser. Ces fonctions vous permettent d'ouvrir, de lire, d'écrire et de fermer des fichiers texte dans le code.
Pour stocker les données, nous devons ouvrir le fichier texte et y écrire les mêmes données au format texte.
Lorsque l'utilisateur ouvre à nouveau l'application, les données seront stockées dans le fichier texte, il nous suffit de les récupérer et de les mettre à leur place.
Exemple 1:
Il s'agit d'un processus d'inscription simple où vous créez un compte ou vous connectez à votre compte.
def welcome():
choice = input("1. Sign up\n2. Login\n")
if choice == "Sign up":
sign_up()
elif choice == "Login":
login()
def sign_up():
name = input("Name: ")
age = input("Age: ")
gender = input("Gender: ")
with open("data.txt", "w") as file:
file.write(name + "\n")
file.write(age + "\n")
file.write(gender + "\n")
def login():
with open("data.txt", "r") as file:
name = file.readline()
age = file.readline()
gender = file.readline()
print("Your name is:", name)
print("Your age is:", age)
print("You are a:", gender)
welcome()
第一个函数询问用户是否有帐户并想要登录或是否要创建一个帐户。第二个函数询问用户的姓名、年龄和性别。
然后，这三条信息存储在名为“data.txt”的文本文件中。最后一个函数打开文件，逐行读取其内容，并在控制台中打印用户的姓名、年龄和性别。
现在假设我想创建一个帐户。对于名字，我会写Maks，对于年龄我会写20岁，对于性别，我会写男性。
在此之后，程序将关闭，不会发生任何事情。但是，如果我再次运行该程序并选择“登录”，则输出将如下所示：
输出：
你的名字是：马克斯
您的年龄是： 20
你是：男
即使在我关闭程序后，我也会得到我输入的数据。让我们看第二个例子：
示例 2：
这是一个生成 1 到 1 万之间的随机数的程序。
import random as rd
def welcome():
choice = input("1. Generate number\n2. Retrieve number\n")
if choice == "Generate number":
generate_number()
elif choice == "Retrieve number":
retrieve_number()
def generate_number():
random_number = rd.randint(1, 1000000)
print(random_number)
with open("data.txt", "w") as file:
file.write(str(random_number))
def retrieve_number():
with open("data.txt", "r") as file_reading:
print("The random number is:", file_reading.read())
welcome()
第一个函数询问用户是否要生成或检索号码。第二个是创建数字并将其保存到文本文件中，第三个是检索和打印数字。
如果我选择生成一个数字，这里有一个可能的输出：
输出：
316393
这是我关闭程序，再次运行它并选择检索数字后的输出：
输出：
随机数为：316393
数据库
这个名字不言自明。将数据存储在数据库中提供了一种可靠且结构化的方法，用于在应用程序中保留用户输入。
数据库为数据管理、查询和可伸缩性提供了高级功能。使用数据库的最流行的编程语言是SQL。在开始项目之前，必须了解关系数据库管理系统的工作原理。
了解这一点后，您就可以在项目中实现数据库了。必须分析要存储在数据库中的所有数据，创建表，并在必要时在其中插入值。
创建数据库后，现在必须使用特定模块和框架在代码中实现它。
概念保持不变，您将数据存储在数据库中，并在需要时将其检索回来。但是数据库比文件复杂得多。
示例 1：
在这里，我创建了一个包含 3 列的表的数据库： “名称”、“hobbie1”和“hobbie2”。
第一列是一个人的名字，另外两列是他们最喜欢的爱好。我已经使用 MySQL 创建了数据库。
USE hobbies;
CREATE TABLE Hobbies (
names VARCHAR(20),
hobbie1 VARCHAR(20),
hobbie2 VARCHAR(20)
);
我将编写一个 Python 程序，它允许您在数据库中输入值并检索值。
import mysql.connector as mc
def welcome():
choice = input("1. Input data\n2. Get data\n")
if choice == "Input data":
input_data()
elif choice == "Get data":
get_data()
def input_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
name = input("Name: ")
hobbie1 = input("First hobby: ")
hobbie2 = input("Second hobby: ")
req = "INSERT INTO Hobbies VALUES (%s, %s, %s);"
values = (name, hobbie1, hobbie2)
cursor.execute(req, values)
conn.commit()
cursor.close()
conn.close()
def get_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
req = "SELECT * FROM Hobbies;"
cursor.execute(req)
for row in cursor.fetchall():
print('\n'.join(row))
conn.commit()
cursor.close()
conn.close()
welcome()
为了在Python代码和数据库之间创建交互，我们使用“mysql.connector”模块。首先，我们询问用户是否要输入或获取数据。
如果他想输入数据，他会写入必要的信息，然后我们向数据库发出请求，将这些信息插入到数据库的表中。如果他想检索数据，那么“get_data”函数会自动向数据库发出请求并打印结果。
首先，我将输入以下数据：“Musk”、“游泳”和“Cycling”。该程序将关闭而不给出任何结果。我将再次运行该程序，但这次我将获取数据。这是我收到的输出：
输出：
Musk
游泳
自行车
如您所见，我取回了我输入的值。这证明我提供的数据已成功保存并存储在数据库中。
示例 2：
通过第二个示例，我将向您展示数据库的优势。这是我们将添加到主程序的两个功能。
def update_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
name = input("Your name: ")
cursor.execute("SELECT names FROM Hobbies WHERE names = %s", (name,))
result = cursor.fetchone()
if result:
first_hobbie = input("Update first hobby: ")
second_hobbie = input("Update second hobby: ")
req = "UPDATE Hobbies SET hobbie1 = %s, hobbie2 = %s WHERE names = %s"
values = (first_hobbie, second_hobbie, name)
cursor.execute(req, values)
conn.commit()
print("Data updated successfully!")
else:
print("This name doesn't exist")
update_data()
cursor.close()
conn.close()
def delete_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
name = input("Your name:")
cursor.execute("SELECT names FROM Hobbies WHERE names = %s", (name,))
result = cursor.fetchone()
if result:
req = "DELETE FROM Hobbies WHERE names = %s"
value = (name,)
cursor.execute(req, value)
conn.commit()
print(name, "'s hobbies successfully deleted")
else:
print("This name doesn't exist")
delete_data()
第一个函数允许用户更改他的爱好。他被要求输入自己的名字。如果这个名字在数据库中存在,那么他输入新的爱好,自动替换之前的爱好。
如果这个名字在数据库中不存在,则通知用户并要求输入有效的名字。
第二个函数的工作方式相同,但是这次当用户输入有效的名字时,他的名字和爱好会从数据库中删除。
import mysql.connector as mc
def welcome():
choice = input("1. Input data\n2. Get data\n3.Update data\n4. Delete data\n")
if choice == "Input data":
input_data()
elif choice == "Get data":
get_data()
elif choice == "Update data":
update_data()
elif choice == "Delete data":
delete_data()
def input_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
name = input("Name: ")
hobbie1 = input("First hobby: ")
hobbie2 = input("Second hobby: ")
req = "INSERT INTO Hobbies VALUES (%s, %s, %s);"
values = (name, hobbie1, hobbie2)
cursor.execute(req, values)
conn.commit()
cursor.close()
conn.close()
def get_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
req = "SELECT * FROM Hobbies;"
cursor.execute(req)
for row in cursor.fetchall():
print('\n'.join(row))
conn.commit()
cursor.close()
conn.close()
def update_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
name = input("Your name: ")
cursor.execute("SELECT names FROM Hobbies WHERE names = %s", (name,))
result = cursor.fetchone()
if result:
first_hobbie = input("Update first hobby: ")
second_hobbie = input("Update second hobby: ")
req = "UPDATE Hobbies SET hobbie1 = %s, hobbie2 = %s WHERE names = %s"
values = (first_hobbie, second_hobbie, name)
cursor.execute(req, values)
conn.commit()
print("Data updated successfully!")
else:
print("This name doesn't exist")
update_data()
cursor.close()
conn.close()
def delete_data():
conn = mc.connect(
host="localhost",
user="root",
password="hack_dinosavarcheto_#262",
database="hobbies"
)
cursor = conn.cursor()
name = input("Your name:")
cursor.execute("SELECT names FROM Hobbies WHERE names = %s", (name,))
result = cursor.fetchone()
if result:
req = "DELETE FROM Hobbies WHERE names = %s"
value = (name,)
cursor.execute(req, value)
conn.commit()
print(name, "'s hobbies successfully deleted")
else:
print("This name doesn't exist")
delete_data()
welcome()
如您在前面的示例中看到的，我输入了以下值：“Musk”、“游泳”和“骑行”。让我们再次运行脚本并选择“update_data”。
该程序要求我提供我的名字。当然，我写“马斯克”。然后，它要求我写下我的新爱好。
让我们写“画画”和“看电影”。更改现在已保存并存储。当我在关闭程序后取回数据时，这是我得到的：
输出：
Musk
绘画
看电影
“delete_data”功能的工作方式相同。我写下我的名字，然后程序关闭。再次运行它并选择获取数据后，我看不到屏幕上打印的任何内容，这很正常，因为我刚刚删除了相同的数据。
文件 VS 数据库
我们现在将分析哪一个最好：文件或数据库。文件简单易用。他们不需要任何额外的知识。在代码中实现它们很容易，并且在其中输入数据也很容易。但是，它们不是为复杂的项目和应用程序设计的。
数据不以任何方式排序。没有任何行、列或其他元素旨在以正确的方式对数据进行排序，这使得数据检索非常复杂。查询功能非常有限。大量数据也可能成为一个问题。
数据库使用起来很复杂。您必须具备执行数据库存储所需的知识和经验。您必须知道如何在 SQL 中创建表、如何执行查询、如何避免风险等等。
但它们提供了一种非常结构化的方式来管理数据。数据存储和组织良好，易于输入，最重要的是检索特定信息。
它们可以处理非常大量的数据，非常适合大型项目和应用程序。数据库还可以修改和删除数据，这两个功能在您处理严肃项目时非常重要。
所以我强烈建议你使用数据库而不是文件。一旦您了解了有关它们的所有必要内容，您就会发现它们比常规文件要好得多。
建议
我将与您分享您必须应用的两个重要提示。首先，在输入和检索数据时，必须充分利用函数和类。
这将使所有查询过程自动化，并帮助您管理代码。其次，在使用数据库时要注意安全性。它们可能包含有价值的个人信息，例如用户的密码、电子邮件等。因此，您必须小心避免SQL注入和数据窃取。
结论 在应用中保留用户输入对于提供无缝和个性化的用户体验至关重要。通过使用文件或数据库，您可以确保即使应用程序关闭，用户数据也能安全存储且随时可用。
无论你是选择将数据存储在文本文件、JSON 或 XML 等文件中，还是选择利用数据库的强大功能，考虑应用的特定要求和可伸缩性需求都至关重要。
当然，还有其他方法可以执行数据存储，但这两种方法非常流行且高效。了解这些不同的方法将使您能够做出明智的决策，并创建强大的、用户友好的应用程序，有效地记住和保留用户输入。
您现在已经了解了与此主题相关的两种最佳技术，请妥善使用它们。
本文由 mdnice 多平台发布