Gains :
- Capacité à prendre du code SQL et pandas robuste, à le lire et à le vérifier ligne par ligne en donnant un schéma et un objectif clairs à l'intelligence artificielle
- Possibilité de détecter les erreurs silencieuses telles que le nombre de lignes, la fonction d'ajustement et le débit après la fusion/JOIN
- Capacité à résoudre le problème en débogage sans le faire taire et à éviter d'exécuter le code sans le tester dans l'environnement de production
La science des données a deux langages principaux : SQL (Structured Query Language — le langage permettant d'interroger les données des bases de données) et Python (en particulier, la bibliothèque pandas — l'outil standard pour manipuler les tables par programme). Dans cette unité, nous apprendrons à utiliser l'IA comme partenaire de code : en tirer du code SQL et pandas solide avec les bonnes questions, lire et valider ce code, le déboguer et ne jamais l'exécuter aveuglément. L'IA écrit du code répétitif en secondes au lieu de minutes ; Mais il est de votre devoir de vous assurer que le code qu'il produit traite la bonne colonne avec la bonne logique. Un code fonctionnel ne signifie pas un code correct.
Pourquoi produire du code avec l'IA est puissant mais risqué
L'IA offre trois grands avantages dans la génération de code : la vitesse (écrit une opération groupe par pivot de 30 lignes en quelques secondes), le rappel (vous rappelle une fonction pandas que vous avez oubliée) et l'enseignement (explique le code ligne par ligne). Mais cela comporte trois risques : une erreur logique silencieuse (le code qui additionne la mauvaise colonne s'exécute sans erreur), une fonction ajustée (suggère une méthode qui n'existe pas) et un piège de rendement (un code qui fonctionne sur de petites données mais plante à 10 millions de lignes). Donc la règle d'or : lisez le code de l'IA comme si vous l'aviez écrit vous-même. Ne lancez pas la ligne que vous ne comprenez pas.
SQL : traiter les données à la source
SQL vous permet de récupérer des données de la base de données et de les traiter là-bas ; Vous pouvez résumer des millions de lignes sans les extraire dans Python. Blocs de construction de base : SELECT (quelles colonnes), WHERE (quelles lignes), GROUP BY (regrouper et résumer), JOIN (joindre des tables), HAVING (filtre post-groupe). L'IA est très utile pour écrire des JOINs et des fonctions de fenêtre complexes, mais assurez-vous de vérifier deux choses : le JOIN est-il via la bonne clé (la mauvaise clé duplique les lignes) et la logique du filtre est-elle correcte (en particulier le comportement NULL et les plages de dates).
Attention : N'exécutez pas de requête SQL générée par l'IA directement sur la base de données de production. Testez d'abord avec une petite copie ou LIMIT. N'exécutez jamais une requête UPDATE/DELETE sans valider la condition WHERE ; Un mauvais WHERE peut supprimer la table entière.
Python/pandas : analyse flexible
pandas est le moyen standard de manipuler des tables (DataFrame) en Python. L’utilisation la plus efficace de l’IA est de lui donner un schéma et un objectif clairs. Opérations les plus couramment utilisées : filtrer, regrouper, fusionner, pivot_table, appliquer. L'IA les écrit rapidement ; Ce que vous voulez vérifier, c'est la logique : le regroupement est-il dans la bonne colonne, la fusion a-t-elle modifié le nombre de lignes de manière inattendue (vérifiez toujours le nombre de lignes après la fusion), les opérations en chaîne modifient-elles l'original.
opération
SQL
pandas
point de contrôle
Filtrage
OÙ
df[df.x > 5]
Comportement NULL/NaN
regroupement
GROUPER PAR
df.groupby()
Est-ce la bonne colonne ?
fusionner
REJOINDRE
df.merge()
Changement du nombre de lignes
Résumé
MOYENNE(), SOMME()
.mean(), .sum()
Quelle colonne a été collectée
Trier par
COMMANDER PAR
.sort_values()
Direction (ascendante/descendante)
déduplication
DISTINCT
.drop_duplicates()
Dans quelles colonnes ?
Débogage : avec l'IA
Lorsque le code échoue, l’IA est un excellent partenaire de débogage. Donnez-lui le message d'erreur complet et l'extrait de code correspondant. Mais attention à deux pièges. Premièrement, l’IA peut suggérer une solution qui « fait taire » l’erreur (par exemple, en masquant les alertes) – cela ne corrige pas l’erreur, elle la cache. Deuxièmement, l’IA modifie parfois silencieusement un autre comportement tout en « résolvant » un problème. Règle : comprenez le correctif, résolvez le problème et vérifiez que la sortie est toujours correcte après le correctif.
Vous voulez du code interprétable et maintenable
Lorsque vous achetez du code auprès d’IA, demandez un code lisible et maintenable, pas seulement un code qui « fonctionne ». Lorsque vous ou un collègue ouvrez ce code des mois plus tard, il devrait être capable de comprendre ce qu'il fait. Pour ce faire, prenez l'habitude que l'IA inclue trois choses : des noms de variables significatifs (orders_temiz, pas df2), de courtes lignes de commentaires aux étapes critiques (expliquant pourquoi, pas ce qui est fait), et une constante nommée au lieu d'un nombre magique (ACCEPT_ESIGI = 0,85 au lieu de 0,85 enfoui dans le code). Évitez également les longues chaînes sur une seule ligne (connectant cinq actions sur une seule ligne) ; cela rend le débogage difficile. Par défaut, l’IA produit souvent du code concis et « intelligent » ; Si vous dites clairement « lisible en écriture, interprétable, maintenable », vous obtiendrez un résultat beaucoup plus maintenable. C'est aussi la base de la reproductibilité (Unité 10) : un code qui n'est pas compris est un code qui ne peut pas être réexécuté en toute sécurité.
trois mini-cases
Cas 1 — Réplication JOIN. Un analyste a combiné les commandes avec le tableau des produits et a constaté que le chiffre d'affaires total était 3 fois plus élevé. Cause : chaque produit avait plusieurs lignes (couleurs différentes) dans le tableau des produits ; JOIN a dupliqué chaque commande. Le code de l'IA "fonctionnait", mais le nombre de lignes était passé de 240 000 à 690 000. Leçon : vérifiez toujours le nombre de lignes après la fusion/JOIN.
Cas 2 — Fonction de montage. Il a suggéré AI df.groupby('x').summarize() à un stagiaire ; Il n'existe pas de méthode de ce type dans les pandas (il existe .agg()). Le code n'a pas fonctionné, le stagiaire a été perdu pendant 20 minutes. Leçon : vérifiez une fonction que vous ne reconnaissez pas dans la doc ; L’IA peut inventer des méthodes.
Cas 3 – Effondrement des rendements. Un code interrogeait la base de données lors de l'application pour chaque ligne ; Il a fonctionné sur 5 000 lignes, a duré 9 heures sur 4 millions de lignes et s'est arrêté. Lorsque l’IA a proposé une solution vectorisée (batch), le délai a été réduit à 40 secondes. Leçon : un code qui fonctionne sur des petites données peut planter sur des données volumineuses ; Pensez à l’efficacité.
Quatre modèles copiables
1) Demande de SQL avec schéma :
Votre rôle : Assistant SQL (PostgreSQL). Tableaux : - commandes (id, customer_id, date timestamp, montant numérique) - clients (id, city text) Tâche : Obtenez le chiffre d'affaires total et le nombre de commandes par ville en 2024, triés par chiffre d'affaires par ordre décroissant. Expliquez comment vous gérez les villes NULL. Je vais d'abord tester la requête avec LIMIT ; Génération UPDATE/DELETE.
2) processus pandas avec point de contrôle :
J'ai des DataFrames df (commandes) et df_customers (clients). Calculez le montant moyen par ville. IMPORTANT : imprimez le nombre de lignes avant et après la fusion afin que je puisse voir s'il y a une duplication. Expliquez dans quelle colonne vous avez fusionné et pourquoi vous avez choisi intérieur/gauche.
3) Explication et vérification du code :
Expliquez le code pandas suivant ligne par ligne : que fait chaque ligne, quelles hypothèses fait-elle, dans quels cas pourrait-elle donner des résultats erronés ? Faites-moi savoir si j'ai utilisé une fonction fudge. Code : [coller]
4) Débogage :
Ce code donne cette erreur. Message d'erreur complet : [coller]. Code : [coller]. Expliquez la cause ROOT de l'erreur et corrigez-la. Résolvez-le en résolvant réellement le problème, et non en faisant taire l'alerte. Indiquez également si le correctif a modifié la sortie.
Invite faible/Invite forte
Invite faible :
Écrivez une requête qui me donne des ventes par ville.
Les noms de tables, les colonnes, le type de base de données et le comportement NULL ne sont pas clairs. L'IA est courante, elle produira probablement une requête qui ne correspond pas à votre table.
Invite puissante :
Votre rôle : Assistant SQL (MySQL 8). Tableau : ventes (id, ville varchar, montant décimal, date date). Tâche : Obtenir le montant total et moyen, le nombre de commandes par ville pour l'année 2024 ; Tri décroissant par montant total ; Afficher uniquement les villes avec plus de 100 commandes (HAVING). NULL exclut la ville. Expliquez la requête ; Je vais tester avec LIMIT.
Ici, la base de données, le schéma, le filtre, le tri et la règle NULL sont évidents.
Erreurs courantes
- Exécuter le code sans le lire. Le code de travail n’est pas un code correct ; Le code qui manipule la mauvaise colonne s’exécute également sans erreur.
- Ne pas vérifier le nombre de lignes après la fusion/JOIN. Une mauvaise clé duplique silencieusement les lignes et gonfle les totaux.
- Ne pas vérifier la fonction de montage. L’IA peut suggérer des méthodes qui n’existent pas ; Confirmez à partir du document que vous ne le reconnaissez pas.
- Ne pas penser à l'efficacité. appliquer/boucler travailler sur de petits plantages de données sur des millions de lignes ; vectoriser.
- Exécutez directement sur la base de données de production. Surtout exécuter UPDATE/DELETE sans WHERE ou tester est désastreux.
Astuce : prenez l'habitude d'ajouter une « ligne de validation » à chaque morceau de code que vous recevez de l'IA : un nombre de lignes avant et après traitement, quelques exemples de lignes et un total critique à la main. Ces trois vérifications détectent la plupart des erreurs logiques silencieuses.
En résumé
L'IA est un partenaire puissant qui produit rapidement du code SQL et pandas, mais ce n'est pas une autorité aveugle. Donnez-lui clairement le plan et le but ; Lisez le code qu'il produit comme si vous l'aviez écrit vous-même ; Vérifiez le nombre de lignes, les fonctions d'ajustement et le débit après la fusion/JOIN ; Ne l'exécutez pas sans le tester sur la base de données de production. Lors du débogage, essayez de résoudre le problème et non de le faire taire. Le code qui fonctionne n’est pas le bon code ; Vous seul pouvez garantir l’exactitude.
Tâche de candidature
Choisissez une question d'analyse (par exemple « chiffre d'affaires mensuel par canal ») et demandez du code à l'IA avec SQL et pandas. Lisez les deux codes ligne par ligne, vérifiez le nombre de lignes après la fusion/JOIN et vérifiez manuellement au moins une somme critique. Comparez si les deux codes produisent le même résultat ; Si différent, découvrez pourquoi.
liste de contrôle
- [ ] Ai-je clairement donné le tableau/schéma et le but à l'IA ?
- [ ] Ai-je lu et compris le code produit ligne par ligne ?
- [ ] Ai-je vérifié le nombre de lignes après la fusion/JOIN ?
- [ ] Ai-je vérifié les fonctions que je ne reconnais pas dans la documentation ?
- [ ] Ai-je d'abord testé le code sur des données sûres/petites et non dans l'environnement de production ?