Python Pandas handledning: DataFrame, datumintervall och användning

Vad finns pandor i? Python?

pandas är ett bibliotek med öppen källkod som låter dig utföra datamanipulation och analys i Python, som täcker både numeriska tabeller och tidsserier. Den ger ett enkelt sätt att skapa, manipulera och sortera data, och den är byggd ovanpå numpy, så NumPy måste finnas närvarande för att Pandas ska fungera.

Varför använda pandor?

Dataforskare använder sig av pandor i Python för följande fördelar:

• Hanterar enkelt saknad data
• Den använder serier för endimensionell data och DataFrame för flerdimensionell data.
• Det ger ett effektivt sätt att dela upp data
• Det ger ett flexibelt sätt att slå samman, sammanfoga eller omforma data
• Den innehåller en kraftfull verktygslåda för tidsserier

Kort sagt, Pandas levererar kraftfulla, lättanvända datastrukturer plus möjligheterna att snabbt arbeta med dem, vilket är anledningen till att de flesta är förankrade. Python dataanalys arbete.

Hur man installerar pandor

Pandas levereras med Anaconda och de flesta hanterade anteckningsbokstjänster, så det är vanligtvis redan installerat. Om importen misslyckas lägger ett av kommandona nedan till det. Den inbyggda miljön Hur man installerar TensorFlow innehåller även pandor.

• pip: pip install pandas
• Anakonda: conda install -c anaconda pandas
• Inuti en Jupyter Notebook cell:

import sys
!conda install --yes --prefix {sys.prefix} pandas

Vad är en Pandas DataFrame?

En Pandas DataFrame är en tvådimensionell märkt datastruktur vars kolumner kan innehålla olika typer. Det är standardsättet att lagra data i tabellformat: rader innehåller observationerna och kolumner namnger informationen. Till exempel, pris kan vara namnet på en kolumn och 2, 3, 4 kan vara prisvärdena.

Dataramar är välkända för statistiker och andra dataexperter. Bilden nedan visar den formen – ett märkt radindex längs sidan och namngivna kolumner överst.

Vad är en serie?

En serie är en endimensionell datastruktur. Den kan innehålla alla datatyper, såsom heltal, flyttal eller sträng, och är användbar när du vill utföra en beräkning eller returnera en endimensionell array. En serie kan per definition inte ha flera kolumner; använd i så fall DataFrame-strukturen.

Pandas-seriens konstruktor tar följande parametrar:

• Data: kan vara ett listavärde, ett ordboksvärde eller ett skalärt värde

pd.Series([1., 2., 3.])

0    1.0
1    2.0
2    3.0
dtype: float64

Du kan lägga till ett index med indexDen namnger raderna, och dess längd måste vara lika med kolumnens storlek.

pd.Series([1., 2., 3.], index=['a', 'b', 'c'])

Nedan skapar du en Pandas-serie med ett saknat värde på den tredje raden. Saknade värden i Python visas som NaNoch np.nan från NumPy skapar en artificiellt.

pd.Series([1,2,np.nan])

Produktion

0    1.0
1    2.0
2    NaN
dtype: float64

Skapa Pandas DataFrame

Du kan konvertera en NumPy-array till en DataFrame med pd.DataFrame()Det motsatta är också möjligt: ​​för att konvertera en DataFrame tillbaka till en array, använd np.array(), eller df.to_numpy(), vilket rekommenderas av aktuell Pandas-dokumentation.

## Numpy to pandas
import numpy as np
h = [[1,2],[3,4]] 
df_h = pd.DataFrame(h)
print('Data Frame:', df_h)

## Pandas to numpy
df_h_n = np.array(df_h)
print('Numpy array:', df_h_n)
Data Frame:    0  1
0  1  2
1  3  4
Numpy array: [[1 2]
 [3 4]]

En ordbok fungerar lika bra som en inmatning till pd.DataFrame().

dic = {'Name': ["John", "Smith"], 'Age': [30, 40]}
pd.DataFrame(data=dic)

Pandas räckviddsdata

Pandas har ett bekvämt API för att skapa ett datumintervall, vilket blir indexet för en tidsserie. Anropet har följande form:

pd.date_range(start, periods, freq):

• Den första parametern är startdatumet
• Den andra parametern är antalet perioder (valfritt om slutdatumet anges)
• Den sista parametern är frekvensen: dag D, månad M och år Y

## Create date
# Days
dates_d = pd.date_range('20300101', periods=6, freq='D')
print('Day:', dates_d)

Produktion

Day: DatetimeIndex(['2030-01-01', '2030-01-02', '2030-01-03', '2030-01-04', '2030-01-05', '2030-01-06'], dtype='datetime64[ns]', freq='D')

# Months
dates_m = pd.date_range('20300101', periods=6, freq='M')
print('Month:', dates_m)

Produktion

Month: DatetimeIndex(['2030-01-31', '2030-02-28', '2030-03-31', '2030-04-30','2030-05-31', '2030-06-30'], dtype='datetime64[ns]', freq='M')

Versionsnotering: månadens alias M som användes ovan är föråldrad från Pandas 2.2 och borttagen i Pandas 3.0. På nuvarande utgåvor passera freq='ME' för månadsslutet; det resulterande indexet är identiskt.

Inspektera data

Du kan kontrollera huvudet eller svansen på en datauppsättning med head() or tail() anropade DataFrame, som Pandas-exemplet nedan visar.

Steg 1) Skapa en slumpmässig sekvens med NumPy. Sekvensen har 4 kolumner och 6 rader.

random = np.random.randn(6,4)

Steg 2) Sedan skapar du en DataFrame med hjälp av Pandas.

Använda dates_m som index, så varje rad får ett namn som motsvarar ett datum, och namnge de fyra kolumnerna med columns argument.

# Create data with date
df = pd.DataFrame(random,
                  index=dates_m,
                  columns=list('ABCD'))

Därför att np.random.randn() körs utan ett frö, kommer dina siffror att skilja sig från de som skrivs ut här. Ring np.random.seed(0) först om du vill reproducera en fast mängd.

Steg 3) Använda huvudfunktionen

df.head(3)

Steg 4) Använda svansfunktionen

df.tail(3)

Steg 5) Ett utmärkt sätt att få en uppfattning om data är describe()Den rapporterar antal, medelvärde, std, min, max och percentiler för datamängden.

df.describe()

Dela data

Slicing hämtar en delmängd av rader eller kolumner från en DataFrame. Du kan använda kolumnnamnet för att t.ex.tract en kolumn, som Pandas-exemplet nedan visar.

## Slice
### Using name
df['A']

2030-01-31   -0.168655
2030-02-28    0.689585
2030-03-31    0.767534
2030-04-30    0.557299
2030-05-31   -1.547836
2030-06-30    0.511551
Freq: M, Name: A, dtype: float64

För att markera flera kolumner behöver du en dubbel parentes, [[..,..]]Det första paret betyder att du vill välja kolumner; det andra paret anger vilka kolumner som ska returneras.

df[['A', 'B']]

Du kan segmentera raderna med ett kolon. Koden nedan returnerar de tre första raderna.

### using a slice for row
df[0:3]

Ocuco-landskapet loc Accessorn väljer kolumner efter namn. Som vanligt står värdet före kommatecknet för raderna och värdet efter det för kolumnerna, och hakparenteser behövs för att välja mer än en kolumn.

## Multi col
df.loc[:,['A','B']]

Det finns en annan metod för att välja flera rader och kolumner. iloc[] använder heltalspositioner istället för kolumnnamn, så koden nedan returnerar samma DataFrame som ovan.

df.iloc[:, :2]

Släpp en kolumn

Du kan släppa kolumner med df.drop(), skickar namnen i columns argument.

df.drop(columns=['A', 'C'])

sammanlänkning

Du kan sammanfoga två DataFrames med pd.concat()Skapa först de två ramarna.

import numpy as np
df1 = pd.DataFrame({'name': ['John', 'Smith','Paul'],
                     'Age': ['25', '30', '50']},
                    index=[0, 1, 2])
df2 = pd.DataFrame({'name': ['Adam', 'Smith' ],
                     'Age': ['26', '11']},
                    index=[3, 4])  

Sedan sammanfoga dem.

df_concat = pd.concat([df1,df2]) 
df_concat

Släpp dubbletter

När en datauppsättning innehåller duplicerad information, drop_duplicates() är ett enkelt sätt att utesluta upprepade rader. df_concat innehåller en dubblettobservation: Smith förekommer två gånger i name kolonn.

df_concat.drop_duplicates('name')

Sortera värden

Du kan sortera en ram med sort_values(). Anteckna det Age skapades som text här, så raderna sorteras i strängordning.

df_concat.sort_values('Age')

Byt namn på kolumner

Använda rename() för att byta namn på en kolumn i Pandas. I varje par är det första värdet det aktuella kolumnnamnet och det andra är det nya.

df_concat.rename(columns={"name": "Surname", "Age": "Age_ppl"})

Snabbreferens för Pandas metoder

Den här tabellen mappar varje vanlig uppgift till Pandas-metoden som utför den.

Vanliga frågor