Summary  
This chapter covers techniques for locating and retrieving targeted pieces of information from larger data structures by using pattern matching, selectors, or parsing libraries.

General domain of usage  
Web scraping

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 TestCondition1(unittest.TestCase):
    def test_condition_1(self):
        """
        1. 'condition_1' selects rows where 'Price' is between 15000 (inclusive) and 20000 (exclusive).
        """
        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["Price"].between(15000, 20000, inclusive="left")

        condition = hasattr(user_code, "condition_1") and user_code.condition_1.equals(ref)
        _dynamic_test(
            self,
            condition,
            "The variable 'condition_1' is defined correctly for Price between 15000 (inclusive) and 20000 (exclusive).",
            "'condition_1' is incorrect. Check the .between() bounds or inclusive parameter."
        )


class TestCondition2(unittest.TestCase):
    def test_condition_2(self):
        """
        2. 'condition_2' selects rows where 'Year' is between 2015 (exclusive) and 2020 (exclusive).
        """
        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["Year"].between(2015, 2020, inclusive="neither")

        condition = hasattr(user_code, "condition_2") and user_code.condition_2.equals(ref)
        _dynamic_test(
            self,
            condition,
            "The variable 'condition_2' is defined correctly for Year between 2015 and 2020 (exclusive).",
            "'condition_2' is incorrect. Check the .between() bounds or inclusive parameter."
        )


class TestCondition3(unittest.TestCase):
    def test_condition_3(self):
        """
        3. 'condition_3' selects rows where 'Fuel_type' is in ['Plug-in Hybrid', 'Hybrid'].
        """
        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["Fuel_type"].isin(["Plug-in Hybrid", "Hybrid"])

        condition = hasattr(user_code, "condition_3") and user_code.condition_3.equals(ref)
        _dynamic_test(
            self,
            condition,
            "The variable 'condition_3' is defined correctly for Fuel_type in ['Plug-in Hybrid', 'Hybrid'].",
            "'condition_3' is incorrect. Check the .isin() list or variable name."
        )


class TestCombinedCondition(unittest.TestCase):
    def test_data_extracted(self):
        """
        4. Combine all three conditions using '&' operator and extract data with .loc[].
        """
        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["Price"].between(15000, 20000, inclusive="left")
            & df["Year"].between(2015, 2020, inclusive="neither")
            & df["Fuel_type"].isin(["Plug-in Hybrid", "Hybrid"])
        ]

        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 DataFrame 'data_extracted' correctly combines all three conditions with '&'.",
            "The combination of conditions or the .loc[] filtering is incorrect."
        )


class TestOutput(unittest.TestCase):
    def test_print_output(self):
        """
        5. Print the first few rows of 'data_extracted' using .head().
        """
        import user_code

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

        output_text = captured_output.getvalue().strip()
        condition = len(output_text) > 0
        _dynamic_test(
            self,
            condition,
            "The output displays the first few rows of 'data_extracted' using .head().",
            "The 'data_extracted' DataFrame is not printed correctly. Use print(data_extracted.head())."
        )


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

test_code.py

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

Cette section vous apprendra à afficher des colonnes spécifiques par leurs titres ou indices. Vous découvrirez également 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 découvrirez également comment 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éfinies ou se situent entre deux valeurs. Vous découvrirez également comment identifier les valeurs les plus grandes et les plus petites.

Cette section est l'une des plus fascinantes du cours. Vous apprendrez ici à regrouper les 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.

Extraction de Données Spécifiques

Solution