AI Prompt Engineering · Leçon

Demander des listes et des puces

Demandez à l’IA de produire des listes numérotées ou à puces comportant un nombre précis d’éléments.

Leçon 1 sur 413 étapes

Demander des listes et des puces est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Pourquoi les listes fonctionnent bien avec l’IA

Les listes sont l’un des formats de sortie les plus clairs à demander à une IA. Elles sont sans ambiguïté, faciles à parcourir et simples à vérifier : vous pouvez immédiatement compter si vous avez obtenu le nombre d’éléments demandé.

Connaître la syntaxe exacte des demandes de listes vous aide à obtenir une sortie au format constant, sans corrections ultérieures.

Demandes de listes de base

Les formulations les plus courantes pour demander une liste sont les suivantes :

  • « Donnez 5 façons de… »
  • « Donnez-moi 10 points à puces sur… »
  • « Citez 7 exemples de… »
  • « Donnez 3 raisons pour lesquelles… »

Indiquez toujours le nombre exact. Dire « donnez quelques façons de faire » produit un nombre variable d’éléments : parfois 3, parfois 12. Un nombre élimine cette variation.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=300,
    messages=[{
        'role': 'user',
        'content': 'List exactly 5 ways a developer can improve Python code performance. Each item: one sentence only.'
    }]
)
print(response.content[0].text)

Demandes sous forme de puces

Lorsque vous souhaitez spécifiquement une mise en forme en puces (plutôt qu'une liste numérotée), dites-le explicitement. Les puces Markdown (- ou •) s'affichent dans la plupart des interfaces de discussion, mais pas dans tous les environnements.

  • 'Donnez-moi 8 puces sur...'
  • 'Créez une liste à puces de...'
  • 'Présentez la réponse sous forme de puces, une par ligne...'

Ajoutez « chaque puce : X mots maximum » pour contrôler la densité.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Create a bulleted list of 8 best practices for writing REST APIs. '
            'Format: each bullet starts with a bold action verb. '
            'Each bullet: max 15 words. No sub-bullets.'
        )
    }]
)
print(response.choices[0].message.content)

Listes numérotées et étapes

Les listes numérotées sont particulièrement adaptées au contenu séquentiel, lorsque l'ordre est important :

  • Instructions étape par étape
  • Options classées (de la plus recommandée à la moins recommandée)
  • Listes de tâches prioritaires
  • Étapes de dépannage ordonnées

Utilisez : 'Numérotez chaque étape...', 'Énumérez dans l'ordre, de la plus importante à la moins importante...', 'Donnez-moi 6 étapes numérotées pour...'

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Give me 6 numbered steps to deploy a Python FastAPI app to AWS EC2. '
            'Order: from initial setup to app accessible via browser. '
            'Each step: 1-2 sentences + the specific command(s) to run. '
            'Assume a fresh Ubuntu 22.04 server.'
        )
    }]
)
print(response.content[0].text)

Listes de contrôle

Les listes de contrôle constituent un sous-type précis de liste : leurs éléments sont destinés à être cochés. Elles sont particulièrement adaptées aux situations suivantes :

  • Listes de contrôle de revue de code
  • Listes de contrôle de préparation au lancement
  • Listes de contrôle d'audit de sécurité
  • Listes de contrôle d'intégration des nouveaux arrivants

Demandez : 'Créez une liste de contrôle de...' ou 'Générez une liste de contrôle préalable au lancement pour...' Le modèle produira des éléments dans un format avec des cases à cocher - [ ] (standard Markdown).

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Create a pre-production launch checklist for a Python web API. '
            'Format: markdown checkboxes (- [ ] item). '
            'Group into sections: Security, Performance, Monitoring, Documentation. '
            '4 items per section. Each item: specific and actionable in under 12 words.'
        )
    }]
)
print(response.choices[0].message.content)

Contrôler la longueur et la densité des éléments

La qualité d'une liste s'améliore considérablement lorsque vous précisez la quantité de détails que chaque élément doit contenir :

  • 'Une phrase par élément' — concis et facile à parcourir
  • 'Deux phrases : la première décrit quoi, la seconde explique pourquoi' — détails structurés
  • 'Titre de l'élément + description d'une ligne' — en-tête et explication
  • '10 mots maximum par élément' — impose une concision extrême
import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Two-sentence structure per list item
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'List 5 common Python performance bottlenecks. '
            'For each item, use exactly 2 sentences: '
            'Sentence 1: describe the bottleneck. '
            'Sentence 2: state the fix in one specific action.'
        )
    }]
)
print(response.content[0].text)

Listes avec étiquettes et catégories

L'ajout d'étiquettes aux éléments d'une liste crée des listes catégorisées ou marquées, plus faciles à parcourir et à utiliser :

  • 'Étiquetez chaque élément avec EASY, MEDIUM ou HARD'
  • 'Ajoutez à chaque suggestion l'étiquette de l'équipe concernée : [FRONTEND] [BACKEND] [DEVOPS]'
  • 'Indiquez pour chacun l'investissement en temps prévu : (5 min) (2 h) (1 semaine)'

Les étiquettes transforment une liste plate en ressource exploitable et filtrable.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'List 8 ways to reduce AWS costs for a startup. '
            'Label each with: [IMMEDIATE] if doable today, [MEDIUM] if takes 1-2 weeks, or [LONG] if takes a month+. '
            'Also label each with estimated monthly savings: ($50-200) ($200-500) ($500+). '
            'Each item: one sentence.'
        )
    }]
)
print(response.choices[0].message.content)

Listes imbriquées

Les listes imbriquées ajoutent un niveau de hiérarchie — ce qui est utile pour organiser des idées ayant des regroupements naturels :

  • Catégories principales au niveau 1
  • Exemples précis ou sous-points au niveau 2

Demandez : 'Créez un plan à deux niveaux avec 4 sections principales et 3 sous-points pour chacune.' Soyez prudent : au-delà de 2 niveaux, la lecture devient difficile dans la plupart des contextes.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Create a 2-level outline for a "Python for Data Science" beginner course. '
            'Level 1: exactly 4 module titles. '
            'Level 2: exactly 3 lesson titles under each module. '
            'Format as nested markdown bullets. '
            'Lesson titles should be specific — not generic like "Introduction".'
        )
    }]
)
print(response.content[0].text)

Listes classées et ordonnées

Lorsque l'ordre a une signification, indiquez explicitement le critère de classement :

  • 'Classez du plus important au moins important'
  • 'Ordonnez du plus rapide au plus long à mettre en œuvre'
  • 'Énumérez par niveau de risque, en commençant par le risque le plus élevé'
  • 'Triez par ordre alphabétique'

Sans ordre explicite, le modèle peut énumérer les éléments dans l'ordre où ils lui sont venus à l'esprit, ce qui n'est pas forcément l'ordre le plus utile pour vous.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'List 6 database indexing strategies for PostgreSQL. '
            'Order: from most commonly needed to most specialized. '
            'Each item: strategy name in bold, followed by a 10-word description, '
            'then a note of when NOT to use it in parentheses.'
        )
    }]
)
print(response.choices[0].message.content)

Anti-modèles : les listes qui échouent

Erreurs courantes dans les demandes de listes, qui produisent de mauvais résultats :

  • Pas de nombre indiqué : 'Donnez-moi quelques puces' → longueur variable, souvent trop courte ou trop longue
  • Aucune structure pour les éléments : le modèle choisit lui-même un mélange d'éléments longs et courts
  • Trop d'éléments demandés : 'Énumérez 50 idées' → les 30 dernières sont du remplissage artificiel
  • Imbrication trop profonde : 3 niveaux ou plus → la sortie devient illisible

Bonne pratique : 5 à 15 éléments avec une structure précisée pour chacun constituent l'équilibre idéal dans la plupart des cas d'utilisation.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Anti-pattern: no count, no structure
bad_prompt = 'Give me some ideas for blog posts about Python.'

# Good pattern: count + structure + ordering
good_prompt = (
    'Generate 8 Python blog post title ideas. '
    'Target audience: intermediate Python developers (2-3 years experience). '
    'Mix: 4 practical how-to titles, 4 conceptual deep-dive titles. '
    'Label each [HOW-TO] or [DEEP DIVE]. '
    'Each title: max 10 words. No clickbait.'
)

for label, prompt in [('BAD', bad_prompt), ('GOOD', good_prompt)]:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'--- {label} ---')
    print(response.content[0].text.strip())
    print()

Sortie de listes dans des contextes programmatiques

Lorsque vous utilisez l'IA pour générer des listes qui seront traitées par du code, demandez une sortie dans un format analysable par une machine :

  • Tableau JSON : 'Présentez la réponse sous forme de tableau JSON de chaînes de caractères'
  • Un élément par ligne : 'Présentez exactement un élément par ligne, sans puces ni nombres'
  • CSV : 'Présentez la réponse sur une seule ligne séparée par des virgules'

Cela évite de devoir analyser les puces Markdown dans la chaîne de réponse.

import openai
import json

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'List 8 Python standard library modules that every developer should know. '
            'Output as a valid JSON array of strings only. '
            'No explanation, no formatting, no markdown — just the raw JSON array.'
        )
    }]
)

raw = response.choices[0].message.content.strip()
try:
    modules = json.loads(raw)
    print(f'Parsed successfully: {len(modules)} modules')
    for m in modules:
        print(f'  - {m}')
except json.JSONDecodeError as e:
    print(f'Parse error: {e}')
    print('Raw output:', raw)

Vérification des connaissances

Un responsable d'équipe souhaite générer une liste de tâches à réaliser à partir d'un assistant d'IA. Il envoie : 'Donnez-moi quelques tâches à réaliser.' Le résultat contient 4 puces vagues. Quelle reformulation produit la sortie la plus utile ?

Récapitulatif — demander des listes

Les listes constituent l'un des formats de sortie les plus clairs à demander. Maîtriser les demandes de listes signifie préciser :

  • Le nombre exact : indiquez toujours un nombre, et non « quelques » ou « un petit nombre »
  • Le format : puces, nombres, liste de contrôle, liste imbriquée
  • La structure de chaque élément : une phrase, deux phrases, titre et description
  • Les étiquettes : difficulté, durée, équipe, catégorie
  • L'ordre : le plus important en premier, classé selon X, ordre alphabétique
  • Le format machine : tableau JSON ou un élément par ligne pour une utilisation programmatique
Gratuit pour commencer

Apprends AI Prompt Engineering avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
53
Leçons
199

Questions Fréquemment Posées

La leçon « Demander des listes et des puces » est-elle gratuite ?

Oui — le texte complet de « Demander des listes et des puces » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Demander des listes et des puces » ?

Demandez à l’IA de produire des listes numérotées ou à puces comportant un nombre précis d’éléments. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Demander des listes et des puces » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Demander des listes et des puces
  2. Demander des tableaux et des données structurées
  3. Mise en forme Markdown dans les invites
  4. Texte brut ou sortie mise en forme
← Retour à AI Prompt Engineering