Construisez des applications à base de LLM de qualité avec Pyndanticai

Dans le paysage rapide du développement de logiciels en évolution, l'intersection de l'intelligence artificielle, de la validation des données et de la gestion des bases de données a ouvert des possibilités sans précédent. Ce billet de blog explore une approche innovante de la génération de code SQL et de l'explication du code SQL en utilisant le dernier cadre de Pyndanticai et le modèle GEMINI-1.5 de Google, démontrant comment les technologies d'IA de pointe peuvent rationaliser et améliorer le développement de la requête de la base de données.

Pour les développeurs, les scientifiques des données et les analystes de données, cette exploration offre un aperçu de l'avenir de la génération de code intelligente à partir du traitement du langage naturel, où des requêtes complexes de base de données peuvent être créées avec facilité et précision.

Objectifs d'apprentissage

• Comprendre les principes fondamentaux de Pydantic et de Pyndanticai.
• Apprenez à implémenter un système de génération de code SQL alimenté par AI.
• Explorez les capacités de Gemini-1.5-Flash en langage naturel pour la traduction SQL.
• Gardez un aperçu de la construction d'agents d'IA intelligents pour les interactions de base de données.

Cet article a été publié dans le cadre du Blogathon de la science des données.

Table des matières

• Qu'est-ce que Pyndanticai?
• Exemples de Pyndanticai en action
• Qu'est-ce qu'un agent d'IA?
• Qu'est-ce que le flux de travail agentique?
• Utilisation moderne des agents de l'IA et des flux de travail agentiques
• Qu'est-ce que le cadre de Pyndanticai?
• Commencer avec votre projet
• Guide étape par étape pour mettre en œuvre votre projet
• Conclusion
• Questions fréquemment posées

Qu'est-ce que Pyndanticai?

Pyndanticai est une puissante bibliothèque Python qui révolutionne la validation des données et la vérification des types. Il fournit une approche déclarative pour définir des modèles de données, ce qui facilite la création et la validation des structures de données complexes.

Les caractéristiques importantes du pydance comprennent:

Personnalisation

• Valide un large éventail de types de données, y compris des types primitifs et des structures imbriquées complexes.
• Prend en charge presque tous les objets Python pour la validation et la sérialisation

Flexibilité

Permet de contrôler la rigueur de la validation des données:

• Coerce les données au type attendu
• Appliquer une vérification stricte du type en cas de besoin

Sérialisation

• Soutenez la conversion transparente entre l'objet pydatique, le dictionnaire et JSON.
• Permet les API d'auto-documentation et la compatibilité avec des outils qui utilisent le schéma JSON.

Performance

• La logique de validation de base est écrite en rouille pour une vitesse et une efficacité exceptionnelles.
• Idéal pour les applications à haut débit comme les API REST évolutives.

Écosystème

• Largement utilisé dans les bibliothèques Python populaires telles que Fastapi, Langchain, Llamaindex et bien d'autres.
• Modern Agenttic LLM ne peut pas être mis en œuvre sans pydance.

Exemples de Pyndanticai en action

Pyndanticai simplifie la validation des données et la vérification du type dans Python, ce qui en fait un outil puissant pour créer des modèles de données robustes. Explorons quelques exemples pratiques qui présentent ses capacités.

Validation de base des données

 de Pydantic Import Basemodel


Utilisateur de classe (BasEmodel):
    Nom: Str
    Âge: int


# Données valides
user = utilisateur (name = "Alice", âge = 30)
Imprimer (utilisateur)

Imprimer ("=====================================)
# Données non valides (l'âge est une chaîne)
essayer:
    user = user (name = "Alice", age = "trente")
sauf exception comme e:
    Imprimer (e)

Le code ci-dessus définit un modèle d'utilisateur utilisant BasEmodel de Pyndantique, appliquant le nom comme une chaîne et un âge comme entier. Il valide les données correctes mais soulève une erreur de validation lorsque des données non valides (une chaîne pour l'âge) est fournie.

Sortir:

Coercition de type automatique

 de Pydantic Import Basemodel
Produit de classe (Basemodel):
    Prix: flotter
    quantité: int

# Données avec des types décalés
produit = produit (prix = "19,99", quantité = "5")
Imprimer (produit)

imprimer (type (produit.price))
imprimer (type (produit.quantity))

Ici, le modèle de produit avec prix comme flottant et quantité comme entier. Pydontic contraigne automatiquement les entrées de chaîne («19,99» et «5») dans les types corrects (float et int), démontrant sa fonction de conversion de type.

Sortir:

Modèle imbriqué

 de Pydantic Import Basemodel
Adresse de classe (BasEmodel):
    rue: str
    Ville: Str
Utilisateur de classe (BasEmodel):
    Nom: Str
    adresse: adresse

# Données valides
user = user (name = "bob", adresse = {"Street": "123 Main st", "ville": "Wonderland"})
Imprimer (utilisateur)

# Accès aux attributs imbriqués
print (user.address.city)

Ici, nous définissons un modèle d'utilisateur imbriqué contenant un modèle d'adresse . Pyndantic permet les dictionnaires de validation nichés et d'auto-convertir en modèles. Les données valides initialisent un objet utilisateur et vous pouvez accéder aux attributs imbriqués comme « user.address.city» directement.

Sortir:

Validation avec règle personnalisée

 De Pydantic Import Basemodel, Field, Field_Validator

Utilisateur de classe (BasEmodel):
    Nom: Str
    Âge: int = champ (..., gt = 0, description = "L'âge doit être supérieur à zéro")

    @field_validator ("nom")
    def name_must_be_non_empty (cls, valeur):
        Si pas de valeur.strip ():
            augmenter ValueError ("Le nom ne peut pas être vide")
        valeur de retour

# Données valides
user = user (name = "Charlie", âge = 25)
Imprimer (utilisateur)

# données non valides
essayer:
    user = user (name = "", age = -5)
sauf exception comme e:
    Imprimer (e)

Ici, nous définissons un modèle utilisateur avec une règle de validation, l'âge doit être supérieur à 0 et le nom ne peut pas être vide (validé via la méthode name_must_be_non_empty ). Les données valides crée une instance utilisateur , tandis que les données non valides (nom vide ou âge négatif) augmentent les erreurs de validation détaillées, démontrant les capacités de validation de Pyndantique.

Sortir:

Ce sont quelques-uns des principaux exemples de pydance j'espère qu'ils vous aideront à comprendre le principe de base de la validation des données.

Qu'est-ce qu'un agent d'IA?

Les agents de l'IA sont des systèmes intelligents conçus pour effectuer de manière autonome des tâches, prendre des décisions et interagir avec leur environnement pour atteindre des objectifs spécifiques. Ces agents ne sont pas nouveaux, mais un développement rapide récent dans une IA générative et le combiner avec des agents fait du développement de logiciels agentiques sur la nouvelle ère. Maintenant, les agents peuvent traiter les entrées, exécuter des actions et s'adapter dynamiquement. Leur comportement imite la résolution de problèmes de type humain, leur permettant de fonctionner dans divers domaines avec une intervention humaine minimale.

Qu'est-ce que le flux de travail agentique?

Un flux de travail agentique fait référence aux structures, séquence de tâches axée sur les objectifs gérée et exécutée par un ou plusieurs agents d'IA. Flux de travail traditionnel rigide non linéaire, flux de travail agentique présente l'adaptabilité, l'autonomie et la sensibilisation au contexte. Les agents de l'IA dans ces flux de travail peuvent prendre des décisions indépendamment, déléguer des sous-tâches et apprendre des commentaires, conduisant à des résultats efficaces et optimisés.

Utilisation moderne des agents de l'IA et des flux de travail agentiques

L'intégration des agents d'IA et des flux de travail agentiques a révolutionné les industries en automatisant des tâches complexes, en améliorant la prise de décision et en stimulant l'efficacité. Ces systèmes intelligents s'adaptent dynamiquement, permettant des solutions plus intelligentes dans divers domaines.

Automatisation des affaires

Les agents de l'IA automatisent les tâches répétitives comme le support client via les chatbots, la gestion des e-mails et l'optimisation des pipelines de vente. Ils améliorent la productivité en libérant des ressources humaines des tâches de plus grande valeur.

Développement de logiciels

Les agents alimentés par l'IA accélèrent les cycles de vie des logiciels en générant, en testant et en débogage du code, réduisant ainsi le temps de développement et l'erreur humaine.

Soins de santé

Les agents de l'IA aident au diagnostic médical, à la surveillance des patients et à la personnalisation du traitement, à l'amélioration de la prestation des soins de santé et de l'efficacité opérationnelle.

Finance

Les flux de travail agentiques dans les systèmes financiers automatisent la détection des fraudes, les évaluations des risques et l'analyse des investissements, permettant une prise de décision plus rapide et plus fiable.

Commerce électronique

Les agences de renseignement améliorent la personnalisation des expériences d'achat, l'optimisation des recommandations de produits et le service client.

La montée des agents d'IA et des flux de travail agentiques signifie un changement vers des systèmes hautement autonomes capables de gérer des processus complexes. Leurs capacités d'adaptabilité et d'apprentissage les rendent indispensables aux industries modernes, stimulant l'innovation, l'évolutivité et l'efficacité dans les domaines. Alors que l'IA continue d'évoluer, les agents de l'IA s'intégreront davantage dans nos flux de travail quotidiens, transformant la façon dont les tâches sont gérées et exécutées.

Qu'est-ce que le cadre de Pyndanticai?

Pyndanticai est un cadre d'agent Python développé par le créateur de Pyndantic, FastAPI pour rationaliser la construction d'applications de qualité de production en utilisant une IA générative, il met l'accent sur la sécurité du type, la conception d'agnostique du modèle et l'intégration transparente avec des modèles de langues importants (LLMS).

Caractéristiques clés de Pyndantic comprend:

• Prise en charge de l'agnostique du modèle: Pyndanticai est compatible avec divers modèles, notamment Openai, Antropic, Gemini, Groq, Mistral et Olllama, avec une interface simple pour incorporer des modèles supplémentaires.
• Sécurité de type: tirant parti des systèmes de type Python et des validations de Pydantique, Pyndanticai assure un développement d'agents robuste et évolutif.
• Système d'injection de dépendance: il introduit un nouveau mécanisme d'injection de dépendance TY-SAFE, améliorant les tests et le développement axé sur l'évaluation.
• Validation de la réponse structurée: L'utilisation des capacités de validation de Pyndantique assure des réponses de structure précises et fiables.
• Intégration LogFire: offre l'intégration avec Pyndantic LogFire pour un débogage et une surveillance améliorés des applications alimentées par LLM.

Voici un exemple minimal de Pyndanticai:

 Importer un système d'exploitation
de l'agent d'importation Pydantic_ai
de pyndantic_ai.models.gemini Import Geminimodel
à partir de Dotenv Import Load_Dotenv

load_dotenv ()

gemini_api_key = os.getenv ("<google_api_key>")

modèle = geminimodel (
    "Gemini-1.5-Flash",
    api_key = gemini_api_key,
)

agent = agent (
    modèle = modèle,
    System_Prompt = "Soyez concis, répondez avec une phrase.",
)

result = agent.run_sync («D'où vient le« bonjour le monde »?»)
imprimer (résultat.data)</google_api_key>

Sortir:

Il est maintenant temps de faire de vraies choses. Nous allons construire une génération de requêtes SQL Postgres en utilisant le cadre de l'agent Pyndanticai.

Commencer avec votre projet

Posez les bases de votre projet avec un guide étape par étape pour configurer les outils et l'environnement essentiels.

Environnement de réglage

Nous créerons un environnement Conda pour le projet.

 #create an env
$ conda create --name sql_gen python = 3.12

# activer l'env
$ conda activer sql_gen

Maintenant, créez un dossier de projet

 # Créer un dossier
$ mkdir sql_code_gen
# Changement dans le dossier
$ CD SQL_CODE_GEN

Installez la base de données Postgres et chargez

Pour installer le Postgres, les outils PSQL-Command-Tools et PGADMIN-4, allez simplement sur EDBDown Téléchargez votre installateur pour vos systèmes et installez tous les outils en une seule fois.

Maintenant, téléchargez la base de données DVDRENTALE depuis HEREAD pour le charger à Postgres Suivez ces étapes

Étape 1: Ouvrez votre terminal

 PSQL -U Postgres

# Il demandera un mot de passe

Étape2: Créez une base de données

 # Dans le postgres = #

Créer une base de données DVDRENTAL;

Étape 3: Commande pour le terminal

Maintenant, sortez de la commande psql, puis saisissez le terminal

 PG_RESTORE -U Postgres -d dvdRental d: /sampledb/postgres/dvderalt.tar

Étape 4: lié à PSQL

Maintenant, connectez-vous au PSQL et vérifiez si votre base de données est chargée ou non.

 PSQL -U Postgres

# Connectez-vous avec DVDRENTAL
\ c dvDental

# Voyons les tables

\ dt

Sortir:

Si vous voyez les tables ci-dessus, vous allez bien. Nous sommes tous prêts à démarrer notre projet principal.

Installez maintenant les bibliothèques Python nécessaires dans le SQL_GEN Conda Env.

 conda activer sql_gen

# Installer des bibliothèques
PIP Installer Pyndantic Asyncpg asyncio Pyndantic-ai 

PIP Installer Python-Dotenv Fastapi Google-Generativeai

PIP Installer Devtools Annoted-Types Type-Extensions

Structure du projet

Notre projet a 4 fichiers, à savoir le principal, les modèles, le service et le schéma.

 SQL_QUERY_GEN /
|
| --main.py
| --models.py
| --schema.py
| --service.py
| -. env
| --__ init__.py
| -. Gitignore

Guide étape par étape pour mettre en œuvre votre projet

Plongez dans les étapes détaillées et les techniques pratiques pour ramener votre projet du concept à la réalité avec ce guide de mise en œuvre complet.

Modèles pydatiques

Nous allons commencer par créer des modèles de données dans le fichier Models.py

 à partir des classes de données importent la classe de données
de la frappe d'importation annotée
importer asyncpg
De annoted_types import minlen
de Pydantic Import Basemodel, champ

@dataclass
Class Deps:
    Conn: asyncpg.connection

Succès de classe (Basemodel):
    SQL_QUERY: annoté [Str, Minlen (1)]
    Explication: str = champ ("", description = "Explication de la requête SQL, comme marquage")

Classe InvaliDrequest (BasEmodel):
    error_message: str

Dans le code ci-dessus,

• La classe DEPS gère les dépendances de connexion de la base de données. @dataclass génère automatiquement des méthodes spéciales comme __init__ et __repr__. Conn est tapé sous le nom de `asyncpg.connection` et représente une connexion postgresql active. Cette conception suit les modèles d'injection de dépendance, ce qui rend le code plus testable et maintenable.
• La classe de réussite représente une génération SQL-Quey réussie, SQL_Query doit être une chaîne non vide ( Minlen (1)) et utiliser Annotated pour ajouter des contraintes de validation. L' explication est un champ facultatif avec une chaîne vide par défaut.
• La classe InvaliDrequest est le modèle de réponse d'erreur, représentant les tentatives de génération SQL-Quey échouées.

Ce code a établi les bases de la gestion de la connectivité de la base de données, de la validation des entrées, de la gestion structurée des réponses et de la gestion des erreurs.

Module de service

Maintenant, nous allons implémenter les services Pyndanticai pour la génération SQL dans le module de service.

Importer la bibliothèque et la configuration

 Importer un système d'exploitation
de la saisie du syndicat d'importation
à partir de Dotenv Import Load_Dotenv
importer asyncpg
à partir de Typing_Extensions Importer des typias
De l'agent d'importation Pydantic_ai, ModelRetry, RunContext
de pyndantic_ai.models.gemini Import Geminimodel
à partir du schéma important db_schema
à partir des modèles importations d'importation, succès, invalidrequest

Pour configurer, créer un fichier .env dans la racine du projet et mettre votre clé API Gemini là-bas

 # .env

Gemini_api_key = "asgfhkdhjy457gthjhajbsd"

Ensuite, dans le fichier Service.py:

 load_dotenv ()

gemini_api_key = os.getenv ("google_api_key")

Il chargera la clé API Google de la `. Env `fichier.

Création de modèle et d'agent

 Réponse: TypeAlias ​​= Union [Success, InvaliDrequest]

modèle = geminimodel (
    "Gemini-1.5-Flash",
    api_key = gemini_api_key,
)

agent = agent (
    modèle,
    result_type = réponse, # Type: Ignore
    DEPS_TYPE = DEPS,
)

• Définissez d'abord un type de réponse qui peut être un succès ou invalidrequest
• Initialise le modèle Flash Gemini 1.5 avec la touche API
• Créez un agent Pyndanticai avec les types de réponse et de dépendance spécifiés

Définition de l'invite du système

Nous allons maintenant définir l'invite du système pour notre génération de requête SQL.

 @ agent.system_prompt
async def system_prompt () -> str:
    retour f "" "\

Compte tenu du tableau des enregistrements postgresql suivant, votre travail consiste à
Écrivez une requête SQL qui convient à la demande de l'utilisateur.

Schéma de base de données:
{Db_schema}

Exemple
    Demande: Trouvez tous les films avec un taux de location supérieur à 4,00 $ et une note de «PG»
    Réponse: Sélectionnez le titre, Rental_rate
    Du film
    Où location_rate> 4,00 et note = 'pg';
Exemple
    Demande: Trouvez le (s) film (s) avec la plus longue longueur
    Réponse: Sélectionnez le titre, longueur
    Du film
    Où la longueur = (sélectionnez Max (longueur) dans le film);
Exemple
    Demande: Trouvez la durée de location moyenne des films dans chaque catégorie
    Réponse: Sélectionnez C.Name, AVG (F.Rental_Duration) comme moyen_Rental_Duration
    De la catégorie C
    Rejoignez Film_Category FC sur c.category_id = fc.category_id
    Rejoignez le film F sur fc.film_id = f.film_id
    Groupe par c.name
    Ordre par moyen_Rental_Duration desc;
"" "

Ici, nous définissons le contexte de base pour le modèle AI et fournissons des exemples de requêtes pour guider les réponses du modèle. Nous incluons également les informations de schéma de base de données dans le modèle afin que le modèle puisse analyser le schéma et générer une meilleure réponse.

Validation de la réponse

Pour faire la réponse à partir du modèle d'IA sans erreur et en hausse des exigences des projets, nous validons simplement les réponses.

 @ agent.result_validator
async def validate_result (ctx: runContext [DEPS], résultat: réponse) -> Réponse:
    Si Isinstance (résultat, invaliDrequest):
        Résultat de retour

    # Gemini ajoute souvent des contrecoups d'extraneos à SQL
    result.sql_query = result.sql_query.replace ("\\", "")
    Si non result.sql_query.upper (). startSwith ("SELECT"):
        River ModelRetry ("Veuillez créer une requête sélectionnée")

    essayer:
        attendre ctx.deps.conn.execute (f "Expliquez {result.sql_query}")
    sauf asyncpg.exceptions.postgreerror comme e:
        élever ModelRetry (f "invalide sql: {e}") de e
    autre:
        Résultat de retour

Ici, nous validerons et traiterons les requêtes SQL générées

Étapes de validation des clés:

• Revient immédiatement si le résultat est un invalidrequeste, nettoyez les barres à barres supplémentaires
• Assurez-vous que la requête est une déclaration sélectionnée
• Valide la syntaxe SQL à l'aide de PostgreSQL Expliquez
• Élever ModelRetry pour les requêtes non valides

Schéma de base de données

Pour obtenir votre schéma de base de données, ouvrez la PGADMIN4 que vous avez installée lors de la configuration de Postgres, accédez à la base de données ` DVDental ' , cliquez avec le bouton droit dessus et cliquez sur` ERD pour la base de données '.
Vous obtiendrez le diagramme ERD ci-dessous, générez désormais SQL à partir de l'ERD (voir le marquage noir rond sur l'image).

Copiez le schéma sur le module schéma.py:

 # schema.py
Db_schema = "" "
COMMENCER;


Créer une table s'il n'existe pas publique.acteur
(
    Actor_id Serial Not Null,
    First_name Caractère variant (45) Collate PG_CATALOG. "Par défaut" pas nul,
    Last_name Caractère variant (45) Collate PG_CATALOG. "Par défaut" pas nul,
    Last_update Timestamp sans que le fuseau horaire n'est pas nul par défaut maintenant (),
    CONSTRAINT CLACT PRIMATIQUE ACTOR_PKEY (Actor_ID)
));
.
.
.
  
.
.
.
"" "

Le bloc de code ci-dessus est fortement tronqué , pour obtenir le code complet, veuillez visiter le dépôt du projet.

Maintenant, que tous les modules nécessaires ont été terminés, il est temps d'implémenter la méthode principale et le test.

Implémentation principale

Nous ferons la définition de la fonction principale et la manipulation rapide.

 importer asyncio
Importer un système d'exploitation
importer sys
de la saisie du syndicat d'importation
à partir de Dotenv Import Load_Dotenv
importer asyncpg
De Devtools Import Debug
à partir de Typing_Extensions Importer des typias
de l'agent d'importation Pydantic_ai
de pyndantic_ai.models.gemini Import Geminimodel
à partir des modèles importations d'importation, succès, invalidrequest

load_dotenv ()

gemini_api_key = os.getenv ("google_api_key")


Réponse: TypeAlias ​​= Union [Success, InvaliDrequest]

modèle = geminimodel (
    "Gemini-1.5-Flash",
    api_key = gemini_api_key,
)

agent = agent (
    modèle,
    result_type = réponse, # Type: Ignore
    DEPS_TYPE = DEPS,
)


asynchrone def main ():
    Si Len (Sys.argv) == 1:
        inside = "Veuillez créer une requête sélectionnée"
    autre:
        invite = sys.argv [1]

    # Connexion à la base de données
    Conn = attendre asyncpg.connect (
        user = "Postgres",
        mot de passe = "Avizyt",
        host = "localhost",
        port = 5432,
        database = "dvDental",
    )
    essayer:
        DEPS = DEPS (Conn)
        résultat = attendre agent.run (invite, DEPS = DEPS)
        résultat = débogage (résultat.data)
        Print ("========= Votre requête =========")
        print (debug (result.sql_query))
        print ("========= Explication =========")
        print (débogage (result.explanation))

    enfin:
        attendre Conn.close ()


Si __name__ == "__main__":
    asyncio.run (main ())

Ici, d'abord, définissez une fonction principale asynchrone et vérifiez l'argument de la ligne de commande pour la requête client. Si aucun ARGS n'est fourni, utilisez l'invite par défaut.

Ensuite, nous définissons les paramètres de connexion Postgres pour nous connecter avec le service de base de données DVDRENTAL.

Dans le bloc Try, créez une instance DEPS avec une connexion de base de données, exécutez les agents AI avec l'invite, traite les résultats à l'aide de la fonction de débogage ( PIP install Devtools ). Imprime ensuite la sortie formatée, y compris la requête SQL générée et l'explication de la requête. Après cela, nous avons finalement fermé la connexion de la base de données.

Maintenant, exécutez le module principal comme ci-dessous:

 # dans le terminal
Python main.py "Obtenez le nombre total de locations pour chaque client"

Sortir:

Après avoir testé la requête SQL dans le PGADMIN4:

Ouah! Cela fonctionne comme nous le voulons. Testez plus de requêtes comme celle-ci et profitez de l'apprentissage.

Conclusion

Ce projet représente un pas en avant significatif pour rendre les interactions de base de données plus intuitives et accessibles. En combinant la puissance de l'IA avec des principes de génie logiciel robustes, nous avons créé un outil qui non seulement génère des requêtes SQL, mais le fait d'une manière sécurisée, éducative et pratique pour une utilisation réelle.

Le succès de cette implémentation démontre le potentiel d'IA pour améliorer plutôt que de remplacer les opérations traditionnelles de la base de données, fournissant un outil précieux pour l'apprentissage et la productivité.

Project Repo - Tout le code utilisé dans ce projet est disponible ici.

Principaux à retenir

• Pyndanticai permet la génération de code intelligente et consciente du contexte.
• Gemini-1.5-Flash fournit une compréhension avancée du langage naturel pour les tâches techniques.
• Les agents d'IA peuvent transformer la façon dont nous interagissons avec les bases de données et générons du code.
• Une validation robuste est cruciale dans les systèmes de code générés par l'IA.

Questions fréquemment posées

Q 1. Quel est l'avantage de Pyndanticai pour la génération SQL?

A. Pyndanticai offre une génération de code validée et validée avec vérification des erreurs intégrée et compréhension contextuelle.

Q 2. Comment Gemini-1.5-Flash contribue-t-il au projet?

A. Le modèle Gemini fournit un traitement avancé du langage naturel, traduisant des requêtes humaines complexes en instructions SQL précises.

Q 3. Ce projet peut-il être étendu à d'autres applications d'IA?

A. Absolument! L'architecture peut être adaptée pour la génération de code, la transformation des données et l'automatisation intelligente dans divers domaines.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!