Summary  
The chapter explains how to read delimited text files into a pandas DataFrame by using `pd.read_csv()` with a custom `sep` parameter (e.g., `'\r'`) and handling files without headers via `header=None`.  

General domain of usage  
Data analysis

För att läsa **textfiler** i `pandas` kan du använda samma funktion, `pd.read_csv()`. För att säkerställa att textfilen läses korrekt är det dock viktigt att använda en ytterligare parameter som kallas `sep`, vilket står för **separator** eller **avgränsare** i texten.

```python
# Importing pandas library
import pandas as pd

# Reading a text file into a DataFrame
text_data = pd.read_csv('file.txt', sep='\r', header=None)
```

Om din textfil inte har en **huvudrad** som innehåller kolumnnamn, sätt `header`-parametern till `None`. Genom att göra det informerar du `pandas` att inte behandla den första raden som kolumnnamn.

> Notera
> 
> För att använda en ny rad som separator i en fil, vilket är vanligt i textfiler, sätt `sep='\r'`. Här står `'\r'` för en vagnretur, vilket är ett specialtecken som används för att indikera en ny rad.

import unittest
import importlib
import pandas as pd


# 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)


def get_first_differing_row(expected_df, actual_df):
    expected_list = expected_df.astype(str).apply(tuple, axis=1)
    actual_list = actual_df.astype(str).apply(tuple, axis=1)

    for i, (row1, row2) in enumerate(zip(expected_list, actual_list)):
        if row1 != row2:
            return i, expected_df.iloc[i].values, actual_df.iloc[i].values

    if len(expected_df) > len(actual_df):
        return len(actual_df), expected_df.iloc[len(actual_df)].values, None
    else:
        return len(expected_df), None, actual_df.iloc[len(expected_df)].values


class TestUserCode(unittest.TestCase):

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

    def test_text_data_is_dataframe(self):
        import user_code

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

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

    def test_text_data_is_correct(self):
        import user_code
        row_1 = 'pandas is a software library written for the Python programming language for data manipulation and analysis. In particular, it offers data structures and operations for manipulating numerical tables and time series. It is free software released under the three-clause BSD license.[2] The name is derived from the term "panel data", an econometrics term for data sets that include observations over multiple time periods for the same individuals.[3] Its name is a play on the phrase "Python data analysis" itself.[4] Wes McKinney started building what would become pandas at AQR Capital while he was a researcher there from 2007 to 2010.[5]'
        row_2 = "taken from the site:"
        row_3 = "https://en.wikipedia.org/wiki/Pandas_(software)"
        expected_df = pd.DataFrame([row_1, row_2, row_3])

        variable = 'text_data'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

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

    def test_first_row_is_series(self):
        import user_code

        try:
            condition = isinstance(user_code.first_row, pd.Series)
            failure_message = f"Expected `first_row` to be a `Series`, but got `{type(user_code.first_row).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `first_row` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `first_row` is a `Series`.",
            failure_message
        )

    def test_first_row_is_correct(self):
        import user_code
        row_1 = 'pandas is a software library written for the Python programming language for data manipulation and analysis. In particular, it offers data structures and operations for manipulating numerical tables and time series. It is free software released under the three-clause BSD license.[2] The name is derived from the term "panel data", an econometrics term for data sets that include observations over multiple time periods for the same individuals.[3] Its name is a play on the phrase "Python data analysis" itself.[4] Wes McKinney started building what would become pandas at AQR Capital while he was a researcher there from 2007 to 2010.[5]'
        row_2 = "taken from the site:"
        row_3 = "https://en.wikipedia.org/wiki/Pandas_(software)"
        expected_df = pd.DataFrame([row_1, row_2, row_3])
        expected_value = expected_df.iloc[0]

        variable = 'first_row'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, pd.Series):
            condition = actual_value.equals(expected_value)
            if actual_value.empty:
                failure_message = f"`{variable}` is empty."
            else:
                failure_message = f"Expected `{variable}` to contain `{expected_value.values}`, but got `{actual_value.values}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `Series`."

        _dynamic_test(
            self,
            condition,
            f"`first_row` contains the correct values.",
            failure_message
        )


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

test_main.py

Pandas är ett extremt användarvänligt bibliotek för dataanalys. Det är också utformat för att hantera stora datamängder, med hjälp av datastrukturer som DataFrame och Series. Detta gör det till ett ovärderligt verktyg för Data Science. I denna guide kommer du att bekanta dig med en rad statistiska funktioner, inklusive hur man hittar korrelationer, lägen, medianer och maximala och minimala värden inom en dataset. Du kommer också att lära dig hur man hanterar saknade värden och manipulerar specifika värden, samt hur man tar bort dem.

I det här avsnittet kommer vi att utforska grunderna i Series och DataFrame-strukturer. Du kommer också att lära dig om skillnaderna mellan dessa två typer av strukturer.

Data kan hämtas i olika format, såsom CSV, JSON, SQL, HTML och fler. Med Pandas är du inte begränsad till ett enda format — du kan arbeta med data från en mängd olika filtyper. I detta kapitel kommer vi specifikt att fokusera på CSV- och TXT-formaten.

Här kommer du att lära dig hur man bearbetar rådata genom att ta bort överflödig information och hantera nullvärden i en dataset.

Txt-Filer

Lösning

Awesome!

Txt-Filer

Lösning

Awesome!