# Hvordan indeksere pandas DataFrames

Indekseringen av Python pandas DataFrames gir effektiv og direkte tilgang til data. Det gjør det enklere å velge bestemte rader og kolonner, noe som forenkler dataanalyseoppgaver.

## Hva er indeksering i pandas?

Indeksering i pandas refererer til ulike metoder du kan bruke for å velge rader eller kolonner. Ved å bruke etiketter på rader og kolonner eller deres numeriske posisjon i DataFrame, kan du **enkelt velge elementer i en DataFrame**. En indeks fungerer som en **slags adressesystem for dataene dine**, og hjelper deg med å finne og administrere dataene dine mer effektivt.

## Hva er pandas `DataFrame.index`?

Du kan vise indeksetikettene til en DataFrame i pandas ved hjelp av attributtet `index`. Syntaksen ser slik ut:

```python
DataFrame.index
```

## Hva er syntaksen for indeksering av DataFrames i pandas?

Det finnes flere måter å indeksere pandas DataFrames på, og syntaksen varierer avhengig av operasjonen du ønsker å utføre.

### Indeksering med etiketter (kolonneetiketter)

Du kan bruke kolonnenavn til å indeksere pandas DataFrames. Her er et eksempel på hvordan du oppretter 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)
```

Slik ser DataFrame ut:

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

For å få tilgang til alle verdiene i en kolonne, kan du bruke kolonnenavnet sammen med indekseringsoperatoren `[]`. Bare skriv inn kolonnenavnet som en Python-streng inne i 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 å hente data fra mer enn én kolonne, skriver du kolonnenavnene i indekseringsoperatoren og setter komma mellom dem for å skille dem.

### Indeksering med `loc[]` (radetiketter)

Hvis du trenger å få tilgang til en bestemt rad i DataFrame, kan du bruke [pandas loc-indekseren](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-dataframe-loc/). Du kan sende radetiketten eller radnummeret til indekseren. I dette eksemplet skal vi bruke samme DataFrame som ovenfor og trekke ut **verdiene fra den første raden** (rad 0):

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

Koden ovenfor viser verdiene for Alice, som finnes i første rad i DataFrame:

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

### Indeksering med `iloc[]` (rad- og kolonnenummer)

En annen måte å få tilgang til bestemte elementer i DataFrame på er gjennom rad- og kolonnenumre. Dette er sannsynligvis den mest populære måten å finne elementer i en DataFrame på. For å bruke det numeriske indekset trenger du [DataFrame-attributtet iloc](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/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 du arbeider med `iloc[]`:

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

### Tilgang til individuelle verdier

Hvis du bare vil ha tilgang til en enkelt verdi, er `at` en rask og enkel måte å gjøre det på. Med denne indekseren kan du definere rader og kolonner **ved hjelp av etikettene deres**. Hvis du for eksempel vil finne ut hvor Bob bor, skriver du «1» for raden og «City» for kolonnen:

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

Her får vi utdataen London.

Alternativt kan du bruke **20-indekseren**, som fungerer på samme måte som `at`, men bruker **kolonneposisjonen** basert på heltall **i stedet for navnet**. Koden nedenfor gir samme resultat som forrige eksempel:

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

### Boolsk indeksering

Du kan også opprette delmengder av en DataFrame basert på en betingelse. Dette kalles **boolsk indeksering**. Betingelsen skal evaluere til enten `True` eller `False` og plasseres direkte i indekseringsoperatoren. Hvis du for eksempel vil velge rader som inneholder personer som er over 30 år, kan du bruke følgende kode:

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

Den eneste personen som er over 30 år er Charlie, noe som gir følgende resultat:

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

Note Husk at når du utfører boolsk indeksering, kan du bruke alle boolske sammenligningsoperatorer som gir verdien `True` eller `False`. Les mer om forskjellige Python-operatorer i vår dedikerte artikkel om emnet.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-indeksering-av-dataframe/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-indeksering-av-dataframe/) for AI/LLM consumption.