# Sådan indekseres pandas DataFrames

Indeksering af Python pandas DataFrames giver mulighed for effektiv og direkte adgang til data. Det gør det nemmere at vælge bestemte rækker og kolonner, hvilket forenkler dataanalyseopgaver.

## Hvad er indeksering i pandas?

Indeksering i pandas henviser til forskellige metoder, du kan bruge til at vælge rækker eller kolonner. Ved hjælp af etiketter på rækker og kolonner eller deres numeriske position i DataFrame kan du **nemt vælge elementer i en DataFrame**. Et indeks fungerer som en **slags adressesystem for dine data, der** hjælper dig med at finde og administrere dine data mere effektivt.

## Hvad er pandas `DataFrame.index`?

Du kan se indeksmærkerne for en DataFrame i pandas ved hjælp af attributten `index`. Syntaksen ser således ud:

```python
DataFrame.index
```

## Hvad er syntaksen for indeksering af DataFrames i pandas?

Der er flere måder at indeksere pandas DataFrames på, og syntaksen varierer afhængigt af den operation, du ønsker at udføre.

### Indeksering med etiketter (kolonneetiketter)

Du kan bruge kolonnenavne til at indeksere pandas DataFrames. Her er et eksempel på, hvordan du opretter en eksempel-DataFrame:

```python
import pandas as pd
# Creating a sample DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['Nottingham', 'London', 'Cardiff']
}
df = pd.DataFrame(data)
print(df)
```

Sådan ser DataFrame ud:

```none
Name  Age       City
0    Alice   25     Nottingham
1    Bob   30  	London
2  Charlie   35    Cardiff
```

For at få adgang til alle værdierne i en kolonne kan du bruge kolonnenavnet sammen med indekseringsoperatoren `[]`. Indtast blot kolonnenavnet som en Python-streng inden for indekseringsoperatoren:

```python
# Access the Age column
print(df['Age'])
```

Resultatet er en liste over aldre:

```none
0    25
1    30
2    35
Name: Age, dtype: int64
```

For at hente data fra mere end én kolonne skal du skrive kolonnenavnene i indekseringsoperatoren og adskille dem med kommaer.

### Indeksering med `loc[]` (rækkeetiketter)

Hvis du har brug for at få adgang til en bestemt række i din DataFrame, kan du bruge [pandas loc-indekseringen](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-dataframe-loc/). Du kan overføre rækkeetiketten eller rækkens nummer til indekseringen. I dette eksempel bruger vi den samme DataFrame som ovenfor og udtrækker **værdierne fra den første række** (række 0):

```python
print(df.loc[0])
```

Ovenstående kode udskriver værdierne for Alice, som findes i den første række i DataFrame:

```none
Name        Alice
Age            25
City      Nottingham
Name: 0, dtype: object
```

### Indeksering med `iloc[]` (række- og kolonnenumre)

En anden måde at få adgang til specifikke elementer i din DataFrame er via række- og kolonnenumre. Dette er sandsynligvis den mest populære måde at finde elementer i en DataFrame. For at bruge det numeriske indeks skal du bruge [DataFrame-attributten iloc](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-pandas-dataframe-iloc/).

```python
# Access the first row
print(df.iloc[0])
# Access the value in the first row and second column
print(df.iloc[0, 1])
```

Her er resultatet, når man arbejder med `iloc[]`:

```none
Name        Alice
Age            25
City      Nottingham
Name: 0, dtype: object
25
```

### Adgang til individuelle værdier

Hvis du kun vil have adgang til en enkelt værdi, er `at` en hurtig og enkel måde at gøre det på. Med denne indeksering kan du definere rækker og kolonner **ved hjælp af deres etiketter**. Hvis du f.eks. vil finde ud af, hvor Bob bor, skal du skrive ‘1’ for rækken og ‘City’ for kolonnen:

```python
print(df.at[1, 'City'])
```

Her får vi resultatet London.

Alternativt kan du bruge **20-indekseringen**, som fungerer på samme måde som `at`, men bruger den heltalbaserede **kolonneposition i stedet for navnet**. Koden nedenfor giver det samme resultat som det foregående eksempel:

```python
print(df.iat[1, 2])
```

### Boolsk indeksering

Du kan også oprette delmængder af en DataFrame baseret på en betingelse. Dette kaldes **boolsk indeksering**. Betingelsen skal evaluere til enten `True` eller `False` og placeres direkte i indekseringsoperatoren. Hvis du f.eks. vil vælge rækker, der indeholder personer, der er over 30 år, kan du bruge følgende kode:

```python
# Select rows where Age is greater than 30
print(df[df['Age'] > 30])
```

Den eneste person, der er over 30, er Charlie, hvilket resulterer i følgende output:

```none
Name  Age     City
2  Charlie   35    Cardiff
```

Note Husk, at når du udfører boolsk indeksering, kan du bruge alle boolske sammenligningsoperatorer, der evalueres til `True` eller `False`. Få mere at vide om forskellige Python-operatorer i vores artikel om emnet.


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