# Sådan bruges Pandas DataFrame til hurtigt at manipulere tabeller i Python

Pandas DataFrame er en Python-datastruktur, der kan bruges til at oprette og manipulere tabeller. Vi forklarer datastrukturens opbygning og dens vigtigste metoder og egenskaber.

## Hvordan fungerer Pandas DataFrame?

Pandas DataFrames er kernen i Python Pandas-biblioteket og muliggør effektiv og fleksibel dataanalyse i Python. En Pandas DataFrame er en **todimensional tabelstruktur** med **nummererede rækker og mærkede kolonner**. Denne struktur gør det muligt at organisere data i en letforståelig og manipulerbar form, svarende til regnearksprogrammer som Excel eller [LibreOffice](https://www.libreoffice.org/ "LibreOffice website"). Hver kolonne i en DataFrame kan indeholde forskellige [Python-datatyper](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-datatyper/), hvilket betyder, at en DataFrame kan gemme **heterogene data** – for eksempel numeriske værdier, strenge og booleske værdier i en enkelt tabel.

Tip Pandas DataFrames er baseret på NumPy-arrays, hvilket muliggør effektiv håndtering af data og beregning af værdier. Pandas DataFrames adskiller sig dog fra [NumPy-datastrukturer](https://numpy.org/ "NumPy website") på nogle punkter, for eksempel med hensyn til deres heterogenitet og antal dimensioner. Af denne grund er NumPy-datastrukturer velegnede til at manipulere store mængder numeriske værdier, mens Pandas datastrukturer er mere velegnede til generel datamanipulation.

### Strukturen i Pandas DataFrames

En DataFrame har tre hovedkomponenter: data, rækkeindekser og kolonnenavne. Rækkeindekset (eller blot indekset) identificerer hver række entydigt. Som standard indekseres rækker med numeriske værdier, men disse kan erstattes med strenge. Det er vigtigt at bemærke, at Pandas DataFrames er **nulindekserede**, hvilket betyder, at indekserne starter ved 0.

[![Billede: The structure of a Pandas DataFrame](https://www.ionos.com/da-dk/digitalguide/fileadmin/_processed_/e/9/csm_pandas-dataframe-structure_0ab3bff2f5.webp "The structure of a Pandas DataFrame")](https://www.ionos.com/da-dk/digitalguide/fileadmin/DigitalGuide/Schaubilder/pandas-dataframe-structure.png) Pandas DataFrames have a tabular structure and are therefore very similar to Excel or SQL tables.  Note Selvom Pandas DataFrames er blandt de mest populære og nyttige Python-datastrukturer, er de ikke en del af basissproget og skal **importeres separat**. Dette gøres ved hjælp af linje `import pandas` eller `from pandas import DataFrame` i begyndelsen af din fil. Alternativt kan du bruge `import pandas as pd`, hvis du vil henvise til modulet med et kortere navn (i dette tilfælde ‘pd’).

## Brug af Pandas DataFrames

Pandas DataFrames tilbyder forskellige teknikker og metoder til effektiv databehandling, analyse og visualisering. Nedenfor kan du læse om de vigtigste begreber og metoder til databehandling ved hjælp af Pandas DataFrames.

### Sådan oprettes en Pandas DataFrame

Hvis du allerede har gemt de ønskede data i en Python-liste eller Python-ordbog, kan du nemt oprette en DataFrame ud fra dem. Du skal blot overføre den eksisterende datastruktur til DataFrame-konstruktoren ved hjælp af `pandas.DataFrame([data])`. Hvordan Pandas fortolker dine data afhænger af den struktur, du angiver. Du kan f.eks. oprette en Pandas DataFrame fra en Python-liste på følgende måde:

```python
import pandas
lists = ["Ahmed", "Beatrice", "Candice", "Donovan", "Elisabeth", "Frank"]
df = pandas.DataFrame(list)
print(df)
# Output:
#            0
# 0     	Ahmed
# 1      	Beatrice
# 2     	Candice
# 3    		Donovan
# 4  	  	Elisabeth
# 5  		Frank
```

Som du kan se i eksemplet ovenfor, kan du med simple lister kun oprette DataFrames med en **enkelt, umærket kolonne**. Af denne grund anbefales det at oprette DataFrames fra **ordbøger, der indeholder lister**. Nøglerne fortolkes som kolonnenavne, og listerne som de tilknyttede data. Følgende eksempel illustrerer dette:

```python
import pandas
datA = {
    'Name': ['Arthur', 'Bruno', 'Christoph'],
    'Age': [34, 30, 55],
    'Income': [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(data)
print(df)
# Output:
#         Name  Age   Income
# 0     Arthur     34  75000.0
# 1      Bruno     30  60000.5
# 2  Christoph     55  90000.3
```

Ved hjælp af denne metode får DataFrame straks det ønskede format og de ønskede overskrifter. Hvis du ikke ønsker at benytte de indbyggede Python-datastrukturer, kan du også indlæse dine data **fra en ekstern kilde**, f.eks. en CSV-fil eller en [SQL-database](https://www.ionos.com/da-dk/digitalguide/server/know-how/hvad-er-sql/). Du skal blot kalde den relevante Pandas-funktion:

```python
import pandas
import sqlalchemy
# DataFrame of CSV:
csv = pandas.read_csv("csv-data/files.csv")
# DataFrame of SQL:
engine = create_engine('postgresql://username:password@localhost:5432/mydatabase')
sql = pandas.read_sql_query('SELECT * FROM table', engine)
```

DataFrames `csv` og `sql` i ovenstående eksempel indeholder nu alle data fra `data.csv` og SQL-tabellen `table`. Når du opretter en DataFrame fra en ekstern kilde, kan du angive yderligere detaljer, f.eks. om de numeriske indekser skal medtages i DataFrame eller ej. Få mere at vide om de yderligere argumenter for de to funktioner på den [officielle Pandas DataFrame-dokumentationsside.](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html "Official Pandas DataFrame documentation page")

Tip For at oprette en Pandas DataFrame fra en SQL-tabel skal du bruge Pandas sammen med et Python SQL-modul, f.eks. *SQLAlchemy*. Opret en forbindelse til databasen ved hjælp af det valgte SQL-modul, og send den til `read_sql_query()`.

### Sådan vises data i Pandas DataFrames

Med Pandas DataFrames kan du ikke kun vise hele tabellen, men også enkelte rækker og kolonner. Du kan vælge bestemte rækker og kolonner, som du vil se. Følgende eksempel viser, hvordan du viser enkelte eller flere rækker og kolonner:

```python
# Output 0-th line
print(df.loc[0])
# Output lines 3 to 6
print(df.loc[3:6])
# Output lines 3 and 6
print(df.loc[[3, 6]])
# Output "Occupation" column
print(df["Occupation"])
# Output "Occupation" and "Age" columns
print(df[["Occupation", "Age"]])
# Selection of multiple rows and columns
print(df.loc[[3, 6], ['Occupation', 'Age']])
```

I eksemplet henvises der til en kolonne ved at bruge dens navn i enkeltparenteser, på samme måde som man får adgang til værdier i Python-ordbøger. Derimod bruges attributten `loc` til at henvise til rækker. Med `loc` kan man også anvende logiske betingelser til at filtrere data. Følgende kodeblok viser, hvordan man kun udskriver de rækker, hvor værdien for ‘age’ er større end 30:

```python
print(df.loc[df['Age'] > 30])
```

Du kan dog også bruge attributten `iloc` til at vælge rækker og kolonner **baseret på deres position i DataFrame**. Du kan f.eks. vise cellen, der er i tredje række og fjerde kolonne:

```python
print(df.iloc[3, 4]) 
# Output: 
# London
 
print(df.iloc[[3, 4, 6], 4]) 
# Output: 
# 3 London
# 4 Birmingham
# 6 Preston
```

### Sådan gentages linjer med Pandas DataFrames

Når man behandler data i Python, er det ofte nødvendigt at gentage rækkerne i en Pandas DataFrames for at anvende den samme operation på alle data. Pandas tilbyder to metoder til dette formål: `itertuples()` og `iterrows()`. Hver metode har sine egne fordele og ulemper med hensyn til **ydeevne og brugervenlighed**.

Metoden `iterrows()` returnerer en **tuple af indeks og serie** for hver række i DataFrame. En serie er en Pandas- eller NumPy-datastruktur, der ligner en Python-liste, men som tilbyder bedre ydeevne. Du kan få adgang til individuelle elementer i serien ved hjælp af **kolonnenavnet**, hvilket forenkler datahåndteringen.

Selvom Pandas Series er mere effektive end Python-lister, medfører de stadig en vis ydelsesoverhead. Derfor anbefales metoden `itertuples()` især til **meget store DataFrames**. I modsætning til `iterrows()` returnerer `itertuples()` **hele rækken inklusive indeks** som tuples, som er mere effektive end Series. Med tuples kan du få adgang til individuelle elementer ved hjælp af priknotation, svarende til adgang til attributter for et objekt.

En anden vigtig forskel mellem serier og tupler er, at **tupler ikke er mutable**. Så hvis du vil iterere over en DataFrame ved hjælp af `itertuples()` og ændre værdier, skal du henvise til DataFrame med attributten `at` og tuplens indeks. Dette attribut fungerer meget lig `loc`. Følgende eksempel illustrerer forskellene mellem `iterrows()` og `itertuples()`:

```python
import pandas
df = pandas.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'], 
    'Age': [25, 30, 35], 
    'Income ': [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Income'] += 1000
        print(f"Index: {index}, Age: {row['Age']}, Income: {row['Income']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Income'] += 1000 # Change value directly in the DataFrame using at[] 
       print(f “Index: {tup.Index}, Age: {tup.Age}, Income: {df.loc[tup.Index, 'Income']}”)
# Both loops have the same output
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-dataframe/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-dataframe/) for AI/LLM consumption.