Summary  
This chapter explains how to use the pandas DataFrame.insert() method to add a new column at a specified position within a DataFrame by providing its index, name, and values.

General domain of usage  
Data analysis

Next, explore another way to add a column to a `DataFrame` using the `insert()` method. This method allows you to **specify the position** of the new column within the `DataFrame`.


```python
df.insert(column_index, 'column_name', [value_1, value_2, value_3])
```

- `df`: the name of the existing DataFrame;
- `insert()`: the method used for adding new columns;
- `column_index`: the position where the new column will be inserted (keep in mind that indexing starts at **0**);
- `column_name`: the name for the new column;
- `[value_1, value_2, value_3]`: the values that will populate the new column.

Focus on the `countries` DataFrame and add a new column named `'population'`, which represents the populations of countries, right after the first column (`'country'`).


import pandas as pd
countries_data = {'country' : ['Thailand', 'Philippines', 'Monaco', 'Malta', 'Sweden', 'Paraguay', 'Latvia'],
          'continent' : ['Asia', 'Asia', 'Europe', 'Europe', 'Europe', 'South America', 'Europe'],
          'capital':['Bangkok', 'Manila', 'Monaco', 'Valletta', 'Stockholm', 'Asuncion', 'Riga']}
countries = pd.DataFrame(countries_data)

countries.insert(1, 'population', [61399000, 75967000, 39244, 380200, 10380491, 5496000, 2424200])
print(countries)

import unittest
import importlib


# Helper function to dynamically generate test names and assertions
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)


class TestUserCode(unittest.TestCase):

    def test_audi_cars_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'audi_cars'),
            "The `audi_cars` variable is declared.",
            "Expected `audi_cars` variable to be declared."
        )

    def test_audi_cars_is_dataframe(self):
        import user_code
        import pandas as pd
        try:
            condition = isinstance(user_code.audi_cars, pd.DataFrame)
            failure_message = f"Expected `audi_cars` to be a `DataFrame`, but got `{type(user_code.audi_cars).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `audi_cars` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `audi_cars` is a `DataFrame`.",
            failure_message
        )

    def test_audi_cars_columns_correct(self):
        import user_code
        try:
            expected_columns = ['model', 'year', 'price', 'fueltype']
            actual_columns = list(user_code.audi_cars.columns)
            condition = actual_columns == expected_columns
            failure_message = f"Expected `audi_cars` columns to be `{expected_columns}`, but got `{actual_columns}`."

        except TypeError:
            condition = False
            failure_message = f"`audi_cars` is not a `DataFrame`."

        except AttributeError:
            condition = False

            if not getattr(user_code, 'audi_cars', None):
                failure_message = "The `audi_cars` variable is not declared."
            else:
                failure_message = f"`audi_cars` is not a `DataFrame`."

        _dynamic_test(
            self,
            condition,
            f"`audi_cars` has the correct columns.",
            failure_message
        )

    def test_price_column_correct_values(self):
        import user_code
        expected_values = [12500, 16500, 16800, 17300, 13900]
        try:
            actual_values = user_code.audi_cars['price'].tolist()
            condition = actual_values == expected_values
            failure_message = f"Expected `price` column values to be `{expected_values}`, but got `{actual_values}`."

        except TypeError:
            condition = False
            failure_message = f"`audi_cars` is not a `DataFrame`."

        except AttributeError:
            condition = False
            failure_message = "The `audi_cars` variable is not declared."

        except KeyError:
            condition = False
            failure_message = "The `price` column is missing in the `audi_cars` `DataFrame`."

        _dynamic_test(
            self,
            condition,
            f"The `price` column contains the correct values.",
            failure_message
        )

    def test_insert_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        condition = ".insert(" in user_code_source
        failure_message = "Expected the `.insert()` method to be used to add the `'price'` column."

        _dynamic_test(
            self,
            condition,
            "The `.insert()` method is used to add the `'price'` column.",
            failure_message
        )


# Run the tests when executing the script
if __name__ == '__main__':
    unittest.main()

test_main.py

Build practical data manipulation skills using pandas. Learn to work with Series and DataFrames, read and explore datasets, select and filter data, perform aggregations, reshape tables, combine multiple DataFrames, and prepare data for analysis.

Inserting a New Column

Solution