import unittest
import user_code
import ast
import re   
import importlib
import csv
import polars as pl

class TestTask(unittest.TestCase):
    def setUp(self):
        # Local layout representation to test validation logic
        self.df = pl.DataFrame({
            "Required age": [0, 16, 0, 16],
            "Is_Free": [True, False, True, True],
            "Peak CCU": [5000, 12000, 3000, 4500]
        })

    def test_pivot_matrix_columns_exist(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "pivot_game_metrics", None)
        _dynamic_test(
            self,
            callable(func),
            "pivot_game_metrics function exists and is callable.",
            "pivot_game_metrics function is missing or not callable."
        )
        result = func(self.df)
        
        _dynamic_test(
            self,
            result is not None and "Required age" in result.columns,
            "Reshaped DataFrame preserves the row tracking index 'Required age'.",
            "Reshaped DataFrame is missing required index column 'Required age'."
        )
        _dynamic_test(
            self,
            "true" in result.columns or "True" in result.columns,
            "Pivot engine successfully shifted pricing boolean categories into column headers.",
            f"Expected pricing categories as headers, but found columns: {result.columns}"
        )

    def test_pivot_matrix_values_are_accurate(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "pivot_game_metrics", None)
        result = func(self.df)
        
        if result is not None:
            true_col = "true" if "true" in result.columns else "True"
            false_col = "false" if "false" in result.columns else "False"
            
            # Isolate Mature Rating row (Age 16) for calculation verification
            mature_row = result.filter(pl.col("Required age") == 16)
            
            # Age 16 Free mean: 4500
            # Age 16 Paid mean: 12000
            actual_free_ccu = mature_row[true_col][0]
            actual_paid_ccu = mature_row[false_col][0]
            
            _dynamic_test(
                self,
                actual_free_ccu == 4500,
                "Pivot aggregation engine accurately calculated mean values across matching indices.",
                f"Incorrect cell value calculated. Expected 4500, Got: {actual_free_ccu}"
            )
            _dynamic_test(
                self,
                actual_paid_ccu == 12000,
                "Pivot aggregation engine accurately isolated independent column configurations.",
                f"Incorrect cell value mapped. Expected 12000, Got: {actual_paid_ccu}"
            )
        else:
            _dynamic_test(self, False, "", "Reshaping validation skipped due to missing return references.")

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

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

test_main.py

Ein praxisorientierter, mittlerer Kurs für Python-Entwickler zur Beherrschung des Data Wrangling mit Polars anhand von realen Steam-Spieldatensätzen. Vermittelt wird das spaltenorientierte Paradigma von Polars, Selektion, Aggregation, Verknüpfung, Umformung sowie grundlegende Operationen mit Zeichenketten, Datumswerten und fehlenden Daten.

Untersuchung der grundlegenden Unterschiede zwischen Polars und traditionellen zeilenbasierten DataFrames mit Schwerpunkt auf spaltenbasierten Operationen, Selektion und bedingter Logik anhand des Steam-Games-Datensatzes.

Erwerben Sie ein fundiertes Verständnis der parallelen Group-by-, Aggregations-, Join- und Umformungsfunktionen von Polars anhand der Steam-Spiele- und Spy-Insights-Datensätze.

Erkunden Sie die Grundlagen der Datenbereinigung: Textnormalisierung, Datumsanalyse und robuste Behandlung fehlender Werte in Polars.

Challenge: Umgestaltung von Layouts

Lösung