Summary  
This chapter demonstrates how to use a method to retrieve the rows with the smallest values in one or more columns of a tabular data structure, including multi-column sorting and duplicate-handling options.  

General domain of usage  
Data analysis

Watch this video for a step-by-step walkthrough on using the pandas `.nsmallest()` method to quickly find the smallest values in a DataFrame column. You'll see how to use this function to extract rows with the lowest values, sort by multiple columns, and handle duplicate values with the `keep='all'` argument. This visual guide will reinforce the concepts from the chapter and help you confidently apply `.nsmallest()` in your own data analysis tasks.

**generation rule: pronounce .nsmallest() as "N smallest"**

Présentation d'une autre fonction essentielle, permettant d'obtenir les plus petites ou les plus grandes valeurs. Vous savez déjà que l'on peut trier des valeurs puis extraire un nombre spécifique de lignes. Sans surprise, **pandas** permet de le faire en une seule ligne de code. Exemple pour récupérer les quinze voitures les plus anciennes :

import pandas as pd
data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/cars.csv', index_col = 0)
data_smallest = data.nsmallest(15, 'Year')
print(data_smallest.head(15))

Pour trier selon une colonne puis une autre, il suffit de placer une liste contenant les noms des colonnes dans l'ordre souhaité. Exemple : nous allons d'abord trier par `'Year'`, puis par `'Engine_volume'`. Ce code extraira d'abord les `5` voitures les plus anciennes, puis, en cas d'années identiques, la voiture ayant la plus petite valeur dans la colonne `'Engine_volume'` sera prioritaire :

import pandas as pd
data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/cars.csv', index_col = 0)
data_smallest = data.nsmallest(5, ['Year', 'Engine_volume'])
print(data_smallest.head())

Essayez de comparer les deux exemples ci-dessous. Nous allons maintenant approfondir un peu la fonction. Revenons à nos exemples avec les valeurs de la colonne `'Year'`. Dans notre colonne, les valeurs `'Year'` peuvent être répétées, donc si nous voulons afficher les dix voitures les plus anciennes avec la syntaxe précédente, notre fonction ne prendra que dix valeurs. Elle ne tient pas compte du fait que la 11e ou la 12e valeur soit identique à la 10e. Nous pouvons ajouter l'argument `keep = 'all'` à la méthode `.nsmallest()` pour éviter de tels cas. Regardez l'exemple et essayez de l'exécuter pour voir la différence :

import pandas as pd
data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/cars.csv', index_col = 0)
# Case without using `keep = 'all'` argument
data_smallest = data.nsmallest(6, 'Year')
print(data_smallest)

data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/cars.csv', index_col = 0)
# Case with using `keep = 'all'` argument
data_smallest = data.nsmallest(6, 'Year',
                             keep = 'all')
print(data_smallest)

import unittest
import pandas as pd
import io
import sys


def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)


def frames_equal_ignore_col_order(df1, df2):
    """ÐÐµÑÐµÐ²ÑÑÑÑ ÑÑÐ²Ð½ÑÑÑÑ DataFrame Ð½ÐµÐ·Ð°Ð»ÐµÐ¶Ð½Ð¾ Ð²ÑÐ´ Ð¿Ð¾ÑÑÐ´ÐºÑ ÐºÐ¾Ð»Ð¾Ð½Ð¾Ðº."""
    if set(df1.columns) != set(df2.columns):
        return False
    common_cols = sorted(df1.columns)
    df1_sorted = df1[common_cols].reset_index(drop=True)
    df2_sorted = df2[common_cols].reset_index(drop=True)
    return df1_sorted.equals(df2_sorted)


class TestRetrieveYear(unittest.TestCase):
    def test_year_filter(self):
        """
        1. Retrieve data on cars where 'Year' > 2010.
        """
        import user_code
        df = pd.read_csv(
            "https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/cars.csv",
            index_col=0,
        )
        ref = df.loc[df["Year"] > 2010]

        condition = (
            hasattr(user_code, "data_extracted")
            and isinstance(user_code.data_extracted, pd.DataFrame)
            and frames_equal_ignore_col_order(user_code.data_extracted, ref)
        )

        _dynamic_test(
            self,
            condition,
            "The 'data_extracted' DataFrame correctly includes cars with Year > 2010.",
            "The filtering by Year > 2010 is incorrect. Check your .loc[] condition."
        )


class TestCheapestCars(unittest.TestCase):
    def test_cheapest_15(self):
        """
        2. Extract the 15 cheapest cars (including duplicates) using .nsmallest().
        """
        import user_code
        ref = user_code.data_extracted.nsmallest(15, "Price", keep="all")

        condition = (
            hasattr(user_code, "data_cheapest")
            and isinstance(user_code.data_cheapest, pd.DataFrame)
            and frames_equal_ignore_col_order(user_code.data_cheapest, ref)
        )

        _dynamic_test(
            self,
            condition,
            "The 'data_cheapest' DataFrame correctly includes the 15 cheapest cars (duplicates included).",
            "The extraction of the 15 cheapest cars is incorrect. Use .nsmallest(15, 'Price', keep='all')."
        )


class TestOutput(unittest.TestCase):
    def test_output_print(self):
        """
        3. Output all values of the 'data_cheapest' DataFrame.
        """
        import user_code

        captured_output = io.StringIO()
        sys.stdout = captured_output
        print(user_code.data_cheapest)
        sys.stdout = sys.__stdout__

        output_text = captured_output.getvalue().strip()
        condition = len(output_text) > 0
        _dynamic_test(
            self,
            condition,
            "The output displays all rows of 'data_cheapest' correctly.",
            "The 'data_cheapest' DataFrame is not printed. Use print(data_cheapest)."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Ce cours contient de nombreuses fonctions utiles pour un futur analyste de données. Vous apprendrez différentes méthodes d'extraction de données et pourrez même y appliquer des conditions. Ensuite, vous vous familiariserez avec les méthodes de regroupement des données. De plus, vous découvrirez comment prétraiter les données. Chaque section dispose de son propre ensemble de données, rendant le cours captivant.

Cette section vous apprendra comment afficher des colonnes spécifiques par leurs titres ou indices. Vous vous familiariserez également avec les différentes méthodes de sélection des lignes par indices.

Ici, vous apprendrez à extraire des données répondant à des conditions spécifiques. Vous apprendrez également à les combiner et même à créer vos propres conditions.

Dans cette section, vous approfondirez vos connaissances sur la définition de différentes conditions de données. Vous apprendrez à vérifier si vos données figurent dans une liste de valeurs définie ou se situent entre deux valeurs. Vous apprendrez également à identifier les valeurs les plus grandes et les plus petites.

Cette section est l'une des plus fascinantes du cours. Ici, vous apprendrez à regrouper des données de différentes manières. Cela vous aidera à travailler en tant qu'analyste de données pour obtenir des informations sur des groupes de données spécifiques.

Cette section est l'une des plus importantes pour un analyste de données, car si les données contiennent des valeurs manquantes ou sont dans un format incorrect, il sera impossible de les exploiter. Ainsi, vous apprendrez ici comment traiter de telles valeurs inappropriées.

Trouver les plus petites valeurs d'une colonne

Solution