Summary  
This chapter covers how to read delimited text files into a pandas DataFrame using `pd.read_csv()` with the `sep`, `header`, and `names` parameters to control parsing, and how to extract individual rows via `.iloc[]`.  

General domain of usage  
Data analysis

Watch this video for a step-by-step explanation of how to read TXT files using pandas. You'll see how to use the `pd.read_csv()` function, set the correct `sep` parameter for text files, and handle files without column headers. This visual guide will reinforce the concepts from the chapter and help you confidently read and process TXT data in your own projects.

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 in korrekt är det dock viktigt att använda en extra parameter som heter `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 **rubrikrad** med kolumnnamn, ange parametern `header` till `None`. Detta informerar `pandas` om att inte behandla den första raden som kolumnnamn.

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

Observera

### Extrahera en enskild rad

När din textfil har lästs in i en `DataFrame` kan du komma åt enskilda rader med hjälp av `.iloc[]` och ange positionen för den rad du vill ha:

```python
# Extracting the first row
first_row = text_data.iloc[0]
```



När du väljer en enskild rad (eller en enskild kolumn) från en `DataFrame`, returnerar inte `pandas` en ny `DataFrame` — det returnerar en **`Series`**. En `Series` är en endimensionell märkt array, vilket innebär att den innehåller en enda sekvens av värden tillsammans med ett index, men ingen separat kolumnstruktur. Det är därför `first_row` kommer att se ut och fungera lite annorlunda än `text_data`: den har inte `.columns`, och när du skriver ut den visas indexet tillsammans med varje värde istället för en tabellayout.

Notering

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 mycket 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 inom Data Science. I denna guide kommer du att bekanta dig med olika statistiska funktioner, inklusive hur man hittar korrelationer, typvärden, medianer samt maximala och minimala värden i en datamängd. Du kommer även att lära dig hur man hanterar saknade värden och manipulerar specifika värden, samt hur man tar bort dem.

Fördjupa dig i grunderna för pandas-biblioteket. Skapa och manipulera Series och DataFrames, utforska deras struktur och bygg upp förtroende för att utföra grundläggande dataoperationer.

Bemästra hur du läser in och hanterar data från CSV- och TXT-filer. Få praktisk erfarenhet av att importera dataset och förbereda dem för vidare analys med hjälp av pandas verktyg.

Lär dig att utforska, rensa och sammanfatta data på ett effektivt sätt. Förstå hur man hanterar saknade värden, extraherar insikter och utför grundläggande statistiska operationer med pandas.

TXT-Filer

Extrahera en enskild rad

Lösning