Kuinka käyttää Pandas DataFrame -so­vel­lus­ta tau­lu­koi­den nopeaan kä­sit­te­lyyn Pyt­ho­nis­sa

Pandas DataFrame on Python-tie­to­ra­ken­ne, jota voidaan käyttää tau­lu­koi­den luomiseen ja muok­kaa­mi­seen. Selitämme tie­to­ra­ken­teen rakenteen sekä sen tär­keim­mät me­ne­tel­mät ja omi­nai­suu­det.

Miten Pandas DataFrame toimii?

Pandas Da­taFra­mes ovat Python Pandas -kirjaston ydin ja mah­dol­lis­ta­vat tehokkaan ja joustavan data-analyysin Pyt­ho­nis­sa. Pandas DataFrame on kak­siu­lot­tei­nen tau­luk­ko­muo­toi­nen da­ta­ra­ken­ne, jossa on nu­me­roi­dut rivit ja nimetyt sarakkeet. Tämän rakenteen ansiosta data voidaan järjestää helposti ym­mär­ret­tä­vään ja kä­si­tel­tä­vään muotoon, sa­man­lai­sek­si kuin Excel- tai LibreOf­fice-kal­tai­sis­sa tau­luk­ko­las­ken­taoh­jel­mis­sa. Jokainen DataFrame-taulukon sarake voi sisältää erilaisia Python-tie­to­tyyp­pe­jä, mikä tar­koit­taa, että DataFrame-tau­luk­koon voidaan tallentaa he­te­ro­gee­ni­siä tietoja – esi­mer­kik­si nu­mee­ri­sia arvoja, merk­ki­jo­no­ja ja boo­le­nai­sia arvoja – yhteen tau­luk­koon.

Pandas-tie­to­ke­hys­ten rakenne

DataFrame-ke­hyk­ses­sä on kolme pää­kom­po­nent­tia: data, rivien indeksit ja sa­rak­kei­den nimet. Rivin indeksi (tai yk­sin­ker­tai­ses­ti indeksi) tunnistaa kunkin rivin yk­si­löl­li­ses­ti. Ole­tuk­se­na rivit in­dek­soi­daan nu­mee­ri­sil­la arvoilla, mutta nämä voidaan korvata merk­ki­jo­noil­la. On tärkeää huomata, että Pandas Da­taFra­mes -kehykset ovat nol­lain­dek­soi­tu­ja, mikä tar­koit­taa, että indeksit alkavat 0:sta.

Close

Pandas-tie­to­ke­hys­ten käyttö

Pandas Da­taFra­mes tarjoaa erilaisia tek­nii­koi­ta ja me­ne­tel­miä te­hok­kaa­seen tietojen kä­sit­te­lyyn, ana­ly­soin­tiin ja vi­sua­li­soin­tiin. Alla kerrotaan Pandas Da­taFra­me­sin avulla ta­pah­tu­van tietojen kä­sit­te­lyn kes­kei­sis­tä kä­sit­teis­tä ja me­ne­tel­mis­tä.

Kuinka luoda Pandas DataFrame

Jos olet jo tal­len­ta­nut haluamasi tiedot Python-luet­te­loon tai Python-sa­na­kir­jaan, voit helposti luoda niistä DataFrame-kehyksen. Siirrä vain olemassa oleva tie­to­ra­ken­ne DataFrame-kon­struk­to­riin käyt­tä­mäl­lä pandas.DataFrame([data]). Pandas tulkitsee tietosi sen mukaan, millaisen rakenteen olet antanut. Voit esi­mer­kik­si luoda Pandas Da­taFra­mes -kehyksen Python-luet­te­los­ta seu­raa­vas­ti:

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

Kuten yllä olevasta esi­mer­kis­tä voit nähdä, yk­sin­ker­tai­sil­la listoilla voit luoda vain DataFrame-tau­lu­koi­ta, joissa on yksi ainoa, nimetön sarake. Tästä syystä on suo­si­tel­ta­vaa luoda DataFrame-taulukot sa­na­kir­jois­ta, jotka si­säl­tä­vät listoja. Avaimet tulkitaan sa­rak­kei­den nimiksi ja listat niihin liit­ty­vik­si tiedoiksi. Seuraava esimerkki ha­vain­nol­lis­taa tätä:

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

Tällä me­ne­tel­mäl­lä DataFrame saa vä­lit­tö­mäs­ti halutun muodon ja halutut otsikot. Jos et kui­ten­kaan halua luottaa si­sään­ra­ken­net­tui­hin Python-tie­to­ra­ken­tei­siin, voit ladata tiedot myös ul­koi­ses­ta lähteestä, kuten CSV-tie­dos­tos­ta tai SQL- tie­to­kan­nas­ta. Kutsu vain sopiva Pandas-funktio:

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)

Yllä olevan esimerkin Da­taFra­mes csv ja sql si­säl­tä­vät nyt kaikki tiedot data.csv:sta ja SQL-tau­lu­kos­ta table. Kun luot DataFrame-kehyksen ul­koi­ses­ta lähteestä, voit määrittää li­sä­tie­to­ja, esi­mer­kik­si sen, pitäisikö nu­mee­ri­set indeksit si­säl­lyt­tää DataFrame-kehykseen vai ei. Li­sä­tie­to­ja näiden kahden toiminnon li­sä­ar­gu­men­teis­ta on Pandas DataFrame -do­ku­men­taa­tio­si­vul­la.

Kuinka näyttää tietoja Pandas Da­taFra­mes -so­vel­luk­ses­sa

Pandas Da­taFra­mes -so­vel­luk­sel­la voit näyttää paitsi koko taulukon myös yk­sit­täi­siä rivejä ja sa­rak­kei­ta. Voit valita tar­kas­tel­ta­vat rivit ja sarakkeet. Seuraava esimerkki ha­vain­nol­lis­taa, miten yk­sit­täi­siä tai useita rivejä ja sa­rak­kei­ta voidaan näyttää:

# 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']])

Esi­mer­kis­sä viittaus sa­rak­kee­seen tehdään käyt­tä­mäl­lä sen nimeä yk­sit­täi­sis­sä ha­ka­sul­keis­sa, samalla tavalla kuin Python-sa­na­kir­jois­sa viitataan arvoihin. Sen sijaan loc käytetään viit­taa­maan riveihin. loc avulla voit myös soveltaa loogisia ehtoja tietojen suo­dat­ta­mi­seen. Seuraava koo­di­loh­ko osoittaa, kuinka tu­los­te­taan vain ne rivit, joissa arvon “age” arvo on suurempi kuin 30:

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

Voit kuitenkin käyttää myös iloc va­li­tak­se­si rivejä ja sa­rak­kei­ta niiden sijainnin pe­rus­teel­la DataFrame-ke­hyk­ses­sä. Voit esi­mer­kik­si näyttää solun, joka on kol­man­nel­la rivillä ja nel­jän­nes­sä sa­rak­kees­sa:

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

Kuinka iteroida rivejä Pandas Da­taFra­mes -ke­hyk­sil­lä

Kun tietoja kä­si­tel­lään Pyt­ho­nis­sa, on usein tarpeen iteroida Pandas Da­taFra­mes -taulukon rivit, jotta sama operaatio voidaan soveltaa kaikkiin tietoihin. Pandas tarjoaa tähän tar­koi­tuk­seen kaksi me­ne­tel­mää: itertuples() ja iterrows(). Kum­mal­la­kin me­ne­tel­mäl­lä on omat etunsa ja haittansa suo­ri­tus­ky­vyn ja käyt­tä­jäys­tä­väl­li­syy­den suhteen.

iterrows() palauttaa indeksien ja sarjojen tuple-tyyppisen arvon jo­kai­sel­le DataFrame-taulukon riville. Sarja on Pandas- tai NumPy-tie­to­ra­ken­ne, joka muis­tut­taa Python-listaa, mutta tarjoaa paremman suo­ri­tus­ky­vyn. Sarjan yk­sit­täi­siin ele­ment­tei­hin pääsee käsiksi sarakkeen nimen avulla, mikä yk­sin­ker­tais­taa tietojen kä­sit­te­lyä.

Vaikka Pandas-sarjat ovat te­hok­kaam­pia kuin Python-luettelot, niillä on silti jonkin verran suo­ri­tus­ky­kyä hei­ken­tä­viä tekijöitä. Siksi itertuples() me­ne­tel­mää suo­si­tel­laan eri­tyi­ses­ti erittäin suurille DataFrame-tau­lu­koil­le. Toisin kuin iterrows(), itertuples() palauttaa koko rivin indeksin kanssa tupleina, jotka ovat suo­ri­tus­ky­kyi­sem­piä kuin sarjat. Tupleilla voit käyttää yk­sit­täi­siä ele­ment­te­jä pis­te­kir­joi­tuk­sel­la, samalla tavalla kuin objektin att­ri­buut­te­ja.

Toinen tärkeä ero sarjojen ja tuplejen välillä on se, että tupleja ei voi muuttaa. Jos siis haluat iteroida DataFrame-kehyksen käyt­tä­mäl­lä itertuples() ja muuttaa arvoja, sinun on vii­tat­ta­va DataFrame-kehykseen at ja tuple-indeksin avulla. Tämä att­ri­buut­ti toimii hyvin sa­man­kal­tai­ses­ti kuin loc. Seuraava esimerkki ha­vain­nol­lis­taa eroja iterrows() ja itertuples() välillä:

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