Summary  
Breaking down complex conditional logic into individual named boolean variables and then combining them with logical operators to produce clearer, more maintainable code.

General domain of usage  
Data analysis

Rendons notre code plus pratique et plus lisible. Il est d'ailleurs essentiel de rendre votre code compréhensible pour vos collègues.



In this video, you will learn how to make your pandas code more readable and maintainable by separating complex conditions into clear, named variables before applying them with the `.loc[]` function. Watch a step-by-step walkthrough of filtering a DataFrame using multiple conditions, and see how breaking down each condition improves clarity. You will also see best practices for combining logical operators, making your code easier to understand for both you and your coworkers. This approach will help you write professional, beautiful code when working with real-world data in pandas.

Pour simplifier le code, il est possible d'écrire d'abord la condition, puis de l'utiliser dans la fonction `.loc[]` ; consultez l'exemple du chapitre précédent :
```python
# The first way
import pandas as pd
data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/planet', index_col = 0)
data_extracted = data.loc[(data['est_diameter_min'] > 3.5) & (data['hazardous'] == True)]

# The second way
import pandas as pd
data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/planet', index_col = 0)
condition_1 = data['est_diameter_min'] > 3.5
condition_2 = data['hazardous'] == True
data_extracted = data.loc[condition_1 & condition_2]
```

Les deux méthodes produisent le même résultat, mais la seconde est bien plus facile à comprendre car il est possible de travailler avec deux conditions séparément, et l'expression dans la fonction `.loc[]` occupe moins d'espace.

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 TestConditions(unittest.TestCase):
    def test_condition_1(self):
        """
        1. 'condition_1' selects rows where 'est_diameter_min' < 0.01.
        """
        import user_code
        df = pd.read_csv(
            "https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/planet",
            index_col=0,
        )
        ref = df["est_diameter_min"] < 0.01
        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 est_diameter_min < 0.01.",
            "'condition_1' is incorrect. Check your comparison for est_diameter_min."
        )

    def test_condition_2(self):
        """
        2. 'condition_2' selects rows where 'absolute_magnitude' > 20.
        """
        import user_code
        df = pd.read_csv(
            "https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/planet",
            index_col=0,
        )
        ref = df["absolute_magnitude"] > 20
        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 absolute_magnitude > 20.",
            "'condition_2' is incorrect. Check your comparison for absolute_magnitude."
        )

    def test_condition_3(self):
        """
        3. 'condition_3' selects rows where 'hazardous' == False.
        """
        import user_code
        df = pd.read_csv(
            "https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/planet",
            index_col=0,
        )
        ref = df["hazardous"] == False
        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 hazardous == False.",
            "'condition_3' is incorrect. Check your equality condition for hazardous."
        )


class TestGeneralCondition(unittest.TestCase):
    def test_general_condition_result(self):
        """
        4. Apply the general condition: (condition_1 & condition_2) | condition_3.
        """
        import user_code
        df = pd.read_csv(
            "https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/planet",
            index_col=0,
        )
        ref = df.loc[(df["est_diameter_min"] < 0.01) & (df["absolute_magnitude"] > 20) | (df["hazardous"] == False)]
        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 general condition combining all three subconditions is implemented correctly.",
            "The general condition or filtering logic is incorrect. Check the use of '&' and '|'."
        )


class TestOutput(unittest.TestCase):
    def test_print_output(self):
        """
        5. Print the first few rows of the resulting DataFrame 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 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.

Rendre Votre Code Élégant

Solution