Introduction

Une fois une table de données chargée en mémoire, l’étape suivante consiste à y rechercher des informations précises. Cette capacité est centrale pour toute analyse : il peut s’agir de trouver les individus remplissant un critère, de combiner des conditions, ou de repérer des anomalies, comme des doublons ou des incohérences. Pour cela, on mobilise des parcours ligne par ligne, des opérateurs logiques et des comparaisons ciblées. Ces techniques permettent non seulement d'extraire des résultats, mais aussi de préparer les données pour des traitements ultérieurs comme le tri ou la fusion.

Rechercher des lignes selon un critère

La recherche la plus directe consiste à extraire toutes les lignes correspondant à une condition simple sur un champ. Cela peut être une égalité, une inégalité ou un test d’appartenance.

Exemple : à partir d’une table représentant des élèves, extraire ceux de la classe « 1A ».

resultat = []

for ligne in table:
    if ligne['classe'] == '1A':
        resultat.append(ligne)

Ce principe est identique pour un tableau doublement indexé, en remplaçant les noms de champs par des indices de colonnes.

indice_classe = 2
resultat = [ligne for ligne in table if ligne[indice_classe] == '1A']

À retenir
Une recherche consiste à parcourir toutes les lignes d’une table et à sélectionner celles qui satisfont un critère précis. Le test porte généralement sur une valeur de champ.

Combiner des conditions avec la logique propositionnelle

Il est fréquent de devoir appliquer plusieurs conditions en même temps : par exemple, extraire les élèves de « 1A » ayant plus de 16 ans. On utilise pour cela la logique propositionnelle, c’est-à-dire l’enchaînement de tests logiques à l’aide de connecteurs :

and : les deux conditions sont vraies.
or : au moins une est vraie.
not : inverse la condition.

Exemple :

for ligne in table:
    if ligne['classe'] == '1A' and int(ligne['age']) > 16:
        resultat.append(ligne)

Autre exemple : élèves qui ne sont pas en « 1C » :

if ligne['classe'] != '1C':

Ou élèves en « 1A » ou « 1B » :

if ligne['classe'] in ['1A', '1B']:

Ces combinaisons permettent de décrire avec précision des situations complexes.

À retenir
La logique propositionnelle permet d’exprimer des critères combinés à l’aide de and, or et not. Ces connecteurs permettent des filtres très ciblés.

Vérifier les valeurs absentes ou incorrectes

Lorsqu’on traite des données issues de fichiers, il n’est pas rare de rencontrer des valeurs manquantes, incomplètes ou mal formatées. Ces anomalies peuvent empêcher les recherches de fonctionner correctement. Il faut donc vérifier les champs avant d’appliquer un test.

Exemple : rechercher les élèves de plus de 16 ans en vérifiant que la valeur d’« âge » est bien présente et utilisable.

for ligne in table:
    age = ligne.get('age', '')
    if age.isdigit() and int(age) > 16:
        resultat.append(ligne)

Ce type de vérification évite les erreurs d’exécution lors des traitements automatisés.

On peut aussi repérer les lignes incohérentes :

for ligne in table:
    if not ligne['age'].isdigit():
        print("Incohérence détectée :", ligne)

À retenir
Les recherches doivent intégrer des vérifications sur la validité des champs. Cela permet d’identifier les anomalies et de renforcer la robustesse du traitement.

Repérer les doublons dans une table

Une autre forme de recherche utile est la détection de doublons, c’est-à-dire de lignes contenant des informations identiques sur certains champs. Cette opération permet d’éviter les redondances ou les erreurs de saisie.

Exemple : détecter les doublons sur les colonnes « nom », « prenom » et « classe » :

vus = set()
doublons = []

for ligne in table:
    cle = (ligne['nom'], ligne['prenom'], ligne['classe'])
    if cle in vus:
        doublons.append(ligne)
    else:
        vus.add(cle)

Les doublons détectés peuvent ensuite être supprimés ou traités à part.

À retenir
Identifier les doublons permet de repérer des lignes répétées dans une table. On les compare en créant une clé composée de champs discriminants.

Extraire des sous-ensembles et faire des regroupements

Il est parfois utile de construire une liste extraite de la table à partir d’un seul champ, ou de faire des comptages par groupe. Ces opérations sont utiles pour produire des résumés statistiques ou repérer des cas particuliers.

Exemple : extraire les prénoms des élèves de « 1A » :

prenoms = [ligne['prenom'] for ligne in table if ligne['classe'] == '1A']

Exemple : compter le nombre d’élèves par classe :

compteur = {}

for ligne in table:
    classe = ligne['classe']
    if classe in compteur:
        compteur[classe] += 1
    else:
        compteur[classe] = 1

print(compteur)

Ces regroupements permettent de repérer des valeurs rares, c’est-à-dire celles qui apparaissent peu souvent.

Exemple : trouver les prénoms apparaissant une seule fois :

frequences = {}

for ligne in table:
    prenom = ligne['prenom']
    frequences[prenom] = frequences.get(prenom, 0) + 1

rares = [prenom for prenom, nb in frequences.items() if nb == 1]

À retenir
On peut extraire une colonne d’une table ou compter les occurrences des valeurs. Ces regroupements servent à produire des synthèses ou repérer des cas particuliers.

Conclusion

Rechercher des informations dans une table, ce n’est pas seulement filtrer des lignes : c’est aussi croiser des critères, détecter des incohérences, identifier des doublons ou produire des regroupements. Ces opérations sont indispensables pour comprendre et structurer des données. Elles constituent une étape essentielle avant de passer au tri des lignes ou à la fusion de plusieurs tables, qui seront abordés dans les prochaines leçons.

Chercher des informations dans une table