Ensuring that each column in your dataset has the correct data type is fundamental for accurate analysis and computation. When columns meant to represent numbers are stored as strings, calculations and statistical operations may fail or produce incorrect results. This is especially common when importing data from CSV files, spreadsheets, or external sources, where values such as numbers or dates are sometimes interpreted as text. Converting these columns to their appropriate data types ensures that you can perform mathematical operations, aggregations, and visualizations without unexpected errors or misleading outcomes.

import pandas as pd

# Sample data where the 'price' and 'quantity' columns are stored as strings
data = {
    'item': ['apple', 'banana', 'orange'],
    'price': ['1.20', '0.80', '1.00'],
    'quantity': ['10', '25', '15']
}

df = pd.DataFrame(data)

print(df)
print(df.dtypes)


import unittest
import user_code
import ast
import re   
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'product': ['A', 'B', 'C'],
            'cost': ['12.5', '9.8', '7.0'],
            'stock': ['100', '200', '150']
        }
        self.df = pd.DataFrame(self.data)

    def test_returns_series_with_float_dtype(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.convert_column_to_float(self.df.copy(), 'cost')
        _dynamic_test(
            self,
            isinstance(result, pd.Series) and result.dtype == float,
            "Returned Series has float dtype.",
            f"Returned value is not a Series with float dtype: {type(result)}, {getattr(result, 'dtype', None)}"
        )

    def test_all_values_are_floats(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.convert_column_to_float(self.df.copy(), 'cost')
        all_floats = all(isinstance(x, float) for x in result.tolist())
        _dynamic_test(
            self,
            all_floats,
            "All values in the returned Series are floats.",
            f"Not all values are floats: {result.tolist()}"
        )

    def test_other_columns_unchanged(self):
        import user_code
        importlib.reload(user_code)
        df_original = self.df.copy()
        _ = user_code.convert_column_to_float(df_original, 'cost')
        unchanged = (
            df_original['stock'].tolist() == self.data['stock'] and
            df_original['product'].tolist() == self.data['product']
        )
        _dynamic_test(
            self,
            unchanged,
            "Other columns remain unchanged.",
            f"Other columns were modified: {df_original}"
        )

    def test_numeric_strings(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'x': ['1.0', '2.5', '3.7'],
            'y': ['a', 'b', 'c']
        })
        result = user_code.convert_column_to_float(df, 'x')
        expected = [1.0, 2.5, 3.7]
        _dynamic_test(
            self,
            result.tolist() == expected,
            "Function correctly converts numeric strings.",
            f"Expected {expected}, got {result.tolist()}"
        )

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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

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


test_main.py

Master essential data cleaning techniques in Python using powerful libraries and practical tasks. This course is designed for learners with intermediate Python skills who want to efficiently prepare and clean data for analysis and machine learning.

Explore the core concepts of data cleaning, why it matters, and the essential tools and techniques in Python.

Delve deeper into techniques for managing missing and duplicate data using pandas and numpy.

Focus on techniques for making data consistent, correcting errors, and detecting outliers.

Challenge: Convert Data Types

Ratkaisu

Awesome!

Challenge: Convert Data Types

Ratkaisu