# Hvordan bruke Pandas DataFrame til å manipulere tabeller raskt i Python

Pandas DataFrame er en Python-datastruktur som kan brukes til å opprette og manipulere tabeller. Vi forklarer strukturen til datastrukturen og dens viktigste metoder og egenskaper.

## Hvordan fungerer Pandas DataFrame?

Pandas DataFrames er kjernen i Python Pandas-biblioteket og muliggjør effektiv og fleksibel dataanalyse i Python. En Pandas DataFrame er en **todimensjonal tabellstruktur** med **nummererte rader og merkede kolonner**. Denne strukturen gjør det mulig å organisere data på en lett forståelig og håndterbar måte, på samme måte som i regnearkprogrammer som Excel eller [LibreOffice](https://www.libreoffice.org/ "LibreOffice website"). Hver kolonne i en DataFrame kan inneholde forskjellige [Python-datatyper](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-datatyper/), noe som betyr at en DataFrame kan lagre **heterogene data** – for eksempel numeriske verdier, strenger og boolske verdier i en enkelt tabell.

Tip Pandas DataFrames er basert på NumPy-matriser, som muliggjør effektiv håndtering av data og beregning av verdier. Pandas DataFrames skiller seg imidlertid fra [NumPy-datastrukturer](https://numpy.org/ "NumPy website") på noen punkter, for eksempel når det gjelder heterogenitet og antall dimensjoner. Av denne grunn er NumPy-datastrukturer egnet for å manipulere store mengder numeriske verdier, mens Pandas datastrukturer er mer egnet for generell datamanipulering.

### Strukturen til Pandas DataFrames

En DataFrame har tre hovedkomponenter: dataene, radindeksene og kolonnenavnene. Radindeksen (eller bare indeksen) identifiserer hver rad unikt. Som standard er radene indeksert med numeriske verdier, men disse kan erstattes med strenger. Det er viktig å merke seg at Pandas DataFrames er **nullindekserte**, noe som betyr at indeksene starter på 0.

[![Image: The structure of a Pandas DataFrame](https://www.ionos.com/nb-no/digitalguide/fileadmin/_processed_/e/9/csm_pandas-dataframe-structure_0ab3bff2f5.webp "The structure of a Pandas DataFrame")](https://www.ionos.com/nb-no/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 Selv om Pandas DataFrames er blant de mest populære og nyttige datastrukturene i Python, er de ikke en del av basisspråket og må **importeres separat**. Dette gjøres ved hjelp av linje `import pandas` eller `from pandas import DataFrame` i begynnelsen av filen. Alternativt kan du bruke `import pandas as pd` hvis du vil referere til modulen med et kortere navn (i dette tilfellet «pd»).

## Bruk av Pandas DataFrames

Pandas DataFrames tilbyr ulike teknikker og metoder for effektiv databehandling, analyse og visualisering. Nedenfor lærer du om viktige konsepter og metoder for datamanipulering ved hjelp av Pandas DataFrames.

### Hvordan lage en Pandas DataFrame

Hvis du allerede har lagret ønsket data i en Python-liste eller Python-ordbok, kan du enkelt opprette en DataFrame fra den. Bare send den eksisterende datastrukturen til DataFrame-konstruktøren ved hjelp av `pandas.DataFrame([data])`. Hvordan Pandas tolker dataene dine, avhenger av strukturen du oppgir. Du kan for eksempel opprette en Pandas DataFrame fra en Python-liste på følgende måte:

```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 enkle lister bare opprette DataFrames med en **enkelt, umerket kolonne**. Av denne grunn anbefales det å opprette DataFrames fra **ordbøker som inneholder lister**. Nøklene tolkes som kolonnenavn og listene som tilhørende 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 å bruke denne metoden får DataFrame umiddelbart ønsket format og ønskede overskrifter. Hvis du ikke ønsker å bruke de innebygde Python-datastrukturene, kan du også laste inn dataene dine **fra en ekstern kilde**, for eksempel en CSV-fil eller en [SQL-database](https://www.ionos.com/nb-no/digitalguide/server/kunnskap/hva-er-sql/). Bare bruk den aktuelle Pandas-funksjonen:

```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 eksemplet ovenfor inneholder nå alle dataene fra `data.csv` og SQL-tabellen `table`. Når du oppretter en DataFrame fra en ekstern kilde, kan du spesifisere tilleggsdetaljer, for eksempel om de numeriske indeksene skal inkluderes i DataFrame eller ikke. Finn ut mer om tilleggsargumentene til de to funksjonene på den [offisielle Pandas DataFrame-dokumentasjonssiden.](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html "Official Pandas DataFrame documentation page")

Tip For å opprette en Pandas DataFrame fra en SQL-tabell, må du bruke Pandas sammen med et Python SQL-modul, for eksempel *SQLAlchemy*. Opprett en forbindelse til databasen ved hjelp av det valgte SQL-modulet, og send den til `read_sql_query()`.

### Hvordan vise data i Pandas DataFrames

Med Pandas DataFrames kan du ikke bare vise hele tabellen, men også enkeltrader og -kolonner. Du kan velge bestemte rader og kolonner som du vil vise. Følgende eksempel illustrerer hvordan du viser enkeltrader eller flere rader 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 refereres det til en kolonne ved å bruke navnet i enkeltparenteser, på samme måte som når du henter verdier i Python-ordbøker. Derimot brukes attributtet `loc` til å referere til rader. Med `loc` kan du også bruke logiske betingelser for å filtrere data. Følgende kodeblokk viser hvordan du kun kan vise rader der verdien for «age» er større enn 30:

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

Du kan imidlertid også bruke attributtet `iloc` til å velge rader og kolonner **basert på deres posisjon i DataFrame**. Du kan for eksempel vise cellen som ligger i tredje rad 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
```

### Hvordan iterere over linjer med Pandas DataFrames

Når man behandler data i Python, er det ofte nødvendig å iterere over radene i en Pandas DataFrames for å bruke den samme operasjonen på alle dataene. Pandas tilbyr to metoder for dette formålet: `itertuples()` og `iterrows()`. Hver metode har sine egne fordeler og ulemper når det gjelder **ytelse og brukervennlighet**.

Metoden `iterrows()` returnerer en **tuple med indeks og serie** for hver rad i DataFrame. En serie er en Pandas- eller NumPy-datastruktur som ligner på en Python-liste, men som gir bedre ytelse. Du kan få tilgang til enkeltelementer i serien ved å bruke **kolonnenavnet**, noe som forenkler datahåndteringen.

Selv om Pandas Series er mer effektive enn Python-lister, medfører de likevel en viss ytelsesoverhead. Derfor anbefales metoden `itertuples()` spesielt for **svært store DataFrames**. I motsetning til `iterrows()` returnerer `itertuples()` **hele raden, inkludert indeks**, som tupler, som har bedre ytelse enn Series. Med tupler kan du få tilgang til individuelle elementer ved hjelp av punktnotasjon, på samme måte som når du får tilgang til attributter til et objekt.

En annen viktig forskjell mellom serier og tupler er at **tupler ikke er mutable**. Så hvis du vil iterere over en DataFrame ved hjelp av `itertuples()` og endre verdier, må du referere til DataFrame med `at` og indeksen til tuplen. Dette attributtet fungerer på samme måte som `loc`. Følgende eksempel illustrerer forskjellene mellom `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/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-dataframe/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-pandas-dataframe/) for AI/LLM consumption.