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

Rendere il codice più comodo e leggibile. È fondamentale che il codice sia comprensibile anche per i colleghi.



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.

Per semplificare il codice, è possibile scrivere prima la condizione e poi inserirla nella funzione `.loc[]`; osserva l'esempio del capitolo precedente:
```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]
```

Il primo e il secondo metodo producono lo stesso risultato, ma il secondo è molto più comprensibile perché permette di lavorare con due condizioni separatamente e l'istruzione all'interno della funzione `.loc[]` occupa meno spazio.

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

Questo corso contiene molte funzioni utili per un futuro data analyst. Imparerai diversi modi per estrarre dati e persino impostare condizioni su di essi. Successivamente, conoscerai i metodi di raggruppamento dei dati. Inoltre, apprenderai come preprocessare i dati. Ogni sezione ha il proprio set di dati, rendendo il corso coinvolgente.

Questa sezione ti insegnerà come visualizzare colonne specifiche in base ai loro titoli o indici. Inoltre, verranno illustrate le modalità per selezionare le righe tramite gli indici.

Qui imparerai come estrarre dati che soddisfano condizioni specifiche. Inoltre, imparerai come combinarle e persino crearne di proprie.

In questa sezione, amplierai le tue conoscenze sull'impostazione di diverse condizioni sui dati. Imparerai a verificare se i tuoi dati sono presenti in un elenco definito di valori o compresi tra due valori. Imparerai anche come trovare i valori più grandi e più piccoli.

Questa sezione è una delle più affascinanti del corso. Qui imparerai come raggruppare i dati in diversi modi. Ti aiuterà a lavorare come data analyst per individuare informazioni su specifici gruppi di dati.

Questa sezione è una delle più significative per un data analyst perché, se i dati contengono valori mancanti o in un formato errato, sarà impossibile lavorarci. Pertanto, qui imparerai come gestire tali valori inappropriati.

Rendere il Tuo Codice Bello

Soluzione