
Kali ini, kita akan mempelajari semua tentang pandas, pandas adalah suatu library di Python yang paling populer untuk analisis data.
Pandas adalah suatu library yang open source, menyediakan performance yang sangat baik, struktur data yang mudah digunakan dan alat analisis data untuk Python. Pandas akan menjadi langkah besar kamu dalam perjalanan mempelajari data science.
Untuk menggunakan pandas, kamu terlebih dahulu mesti menginstall nya di command prompt dengan mengetikan
pip install pandas

Tunggu sampai installasi selesai, ketika kamu hendak menginstall pandas, tidak hanya pandas yang akan di install, tapi juga beserta dependency nya, di gambar, ketika menginstall pandas kamu juga menginstall pytz dan numpy.
Objek Pandas : Series vs DataFrame
Series dan Dataframe ini adalah suatu objek tempat kita menyimpan data secara terstruktur. Perbedaan dari Series dan DataFrame ini terletak pada strukturnya dan juga attribute dan method-method yang mereka miliki, untuk perbedaan strukturnya adalah sebagai berikut :
- Series adalah objek 1 dimensi
- DataFrame adalah suatu objek 2 dimensi, mirip seperti tabel
Series
Series adalah suatu objek satu dimensi yang dapat menyimpan berbagai jenis tipe data seperti integer, string, dan lain sebagainya. tipe data dari objek series ini harus seragam. berikut contoh membuat list :
import pandas as pd
x = pd.Series([6,3,4,6])
print(x)
=============
0 6
1 3
2 4
3 6
dtype: int64
Series memiliki satu sumbu saja, dari contoh di atas sumbu tersebut berada baris baris, yaitu 0, 1, 2, 3. kita bisa mengubah sumbu tersebut dengan sebagai berikut :
# cara pertama
x.index = ['a', 'b', 'c', 'd']
print(x)
===========
a 6
b 3
c 4
d 6
dtype: int64
# cara kedua
x = pd.Series([6,3,4,6], index=['a', 'b', 'c', 'd'])
print(x)
===========
a 6
b 3
c 4
d 6
dtype: int64
# check tipe data
print(type(x))
================
pandas.core.series.Series
Perhatikan: jumlah index harus sama dengan jumlah data.
DataFrame
DataFrame adalah suatu objek 2 dimensi tempat menyimpan data dengan lebih terstruktur. dataframe memiliki 2 index, yaitu index baris dan index columns. Dalam satu column dataframe harus memiliki tipe data yang sama. tapi antar columnnya dataframe bisa memiliki jenis data yang berbeda. untuk lebih jelasnya perhatikan contoh berikut :
import pandas as pd
df = pd.DataFrame({'tipe_int': [50, 21], 'tipe_string': ['a', 'b']})
print(df)
==========
tipe_int tipe_string
0 50 a
1 21 b
# check tipe data
print(type(df))
==========
<class 'pandas.core.frame.DataFrame'>
Membaca Data dari File
Membaca data dari file adalah hal pertama yang dilakukan dalam suatu pekerjaan data science. maka hal ini sangat penting.
Ada beberapa tipe file yang biasa di gunakan untuk menyimpan data, seperti database, excel, csv. disini akan di jelaskan beberapa saja tentang cara membaca file dari berbagai sumber tersebut. akan di jelaskan 2 yaitu csv dan excel karena csv dan excel adalah sumber yang biasa di gunakan untuk menyimpan data karena kemudahannya. ok kita langsung saja.
Pandas menyediakan metode yang berbeda untuk membaca file dengan tipe berbeda. untuk membaca file bertipe csv pandas menggunakan suatu metode read_csv(), untuk membaca file bertipe excel pandas menggunkan suatu metode bernama read_excel. perhatikan contoh berikut :
# membaca dari csv
df_from_csv = pd.read_csv('jabar-corona-virus-case.csv')
# membaca data dari excel
df_from_excel = pd.read_excel('jabar-corona-virus-case.xlsx')
Untuk menggunakan method tersebut kita hanya perlu memasukan argument wajib, yaitu path dari file yang akan kita baca. lebih lanjutnya lagi pandas memiliki beberapa argumen optional, kalian bisa mecarinya dengan menggunakan metode help yang telah kalian pelajari sebelumnya
Pemeriksaan Sederhana Tentang Karakteristik Data
Pandas memiliki beberapa method untuk memahami gambaran besar karakteristik dari data kita. diantaranya adalah:
- head()
- tail()
- info()
- describe()
Metode head() secara default adalah untuk melihat 5 pertama data kita, sedangkan metode tail() secara default untuk melihat 5 data kita dari terakhir. kita bisa mengganti jumlah data yang akan di tampilkan dengan memberikan data integer sebagai argument terhadap metode tersebut. contohnya sebagai beriktu:


info() adalah suatu method untuk melakukan summary terhadap data yang memberikan informasi tentang tipe dari index data, tipe dari column data, non-null values pada setiap column dan jumlah memory yang digunakan. berikut adalah contohnya:

describe() adalah sutau metode yang menghasilkan kesimpulan deskriptif statistik dari data. kesimpulan deskriptif statistik yang dihasilkan adalah seperti central tendency, dispersi dan bentuk distributsi dari data. untuk mengetahui lebih dalam tentang deskriptik statistik silahkan baca artikel ini. berikut contoh penggunaan metode ini.

Indexing Series
Untuk melakukan indexing pada objek series, kita perlu menempatkan objek series tersebut sebagai dictionary dan sebagai array.
series as dictionary
seperti hanyal dictionary, kita bisa melakukan akses key maupun value terhadap objek series, seperti contoh:
import pandas as pd
obj_series = pd.Series([1,2,3,4], index=['a','b','c','d'])
obj_series
a 1
b 2
c 3
d 4
dtype: int64
#indexing key
obj_series.keys()
result:
Index(['a', 'b', 'c', 'd'], dtype='object')
#indexing value
obj_series.values
result:
array([1, 2, 3, 4])
#checking existing keys
'b' in obj_series
result:
True
series as array
# slicing dengan explicit index
obj_series['a':'c']
result:
a 1
b 2
c 3
dtype: int64
#slicing dengan implicit index
obj_series[:3]
result:
a 1
b 2
c 3
dtype: int64
indexing menggunakan .loc dan .iloc objek series
.loc indexing: indexing berdasarkan label objek series sedangkan .iloc indexing: indexing berdasarkan posisi objek series
#.loc indexing
obj_series.loc['a':'c']
result:
a 1
b 2
c 3
dtype: int64
#.iloc indexing
obj_series[:3]
result:
a 1
b 2
c 3
dtype: int64
Filtering objek series
obj_series[obj_series>2]
result:
c 3
d 4
dtype: int64
obj_series[['c','d']]
result:
c 3
d 4
dtype: int64
Indexing DataFrame
Akses DataFrame sering juga di kenal indexing atau Subset Selection. secara sederhana maknanya adalah kita memilih suatu data dari baris tertentu dan column tertentu. kita bisa saja memilih beberapa baris dan semua kolom dari data, semua baris dan beberapa column dari data, atau beberapa baris dan bebearpa column dari data.
Ada banyak cara-cara kita indexing suatu dataframe. diantranya adalah dengan menggunakan :
- dataframe[] : cara seperti ini dikenal sebagai index operator.
- dataframe.kolom : cara seperti ini dikenal dengan indexing menggunakan atribut
- dataframe.loc[]: operator yang menggunakan label untuk mengakses data, jika misalkan kamu melakukan dataframe.loc[‘jumlah’], berarti kamu hendak mengakses data yang mempunyai index jumlah
- dataframe.iloc[: operator yang menggunakan posisi index untuk mengakses data. jikalau kamu melakukan dataframe.iloc[2] berarti kamu hendak mengakses dataframe dengan index posisi 2
df_ramen = pd.read_csv('ramen-ratings.csv')
df_ramen.head()

# indexing operator as series
df_ramen['Brand']
result:
0 New Touch
1 Just Way
2 Nissin
3 Wei Lih
4 Ching's Secret
...
2575 Vifon
2576 Wai Wai
2577 Wai Wai
2578 Wai Wai
2579 Westbrae
Name: Brand, Length: 2580, dtype: object
#indexing operator as dataframe
df_ramen[['Brand']].head()
result:

# indexing using attribute
df_ramen.Brand
result:
0 New Touch
1 Just Way
2 Nissin
3 Wei Lih
4 Ching's Secret
...
2575 Vifon
2576 Wai Wai
2577 Wai Wai
2578 Wai Wai
2579 Westbrae
Name: Brand, Length: 2580, dtype: object
# indexing using .loc
df_ramen.loc[:, ['Country', 'Stars']].head()
result:

#indexing using .iloc
df_ramen.iloc[:, [4,5]].head()
result:

Filtering DataFrame with Boolean
Dapat dibilang kalau filtering dataframe dengan boolean is more human. karena kita mengakses suatu data berdasarkan logika dan dapat kita masukan ke dalam suatu statement, sebagai contoh, ‘Ambilkan data yang memiliki nilai luas lebih dari 50’. ketika mengubahnya kedalam suatu kode python ckup dengan menuliskan df>50. maka akan menghasillkan sua tu data Boolean Series berisi Ya (True) dan Tidak (False).
Filtering DataFrame dimulai dari pertanyaan
Pada tulisan ini saya akan memberikan beberapa contoh mengakses DataFrame dengan Filtering by Boolean. kita akan menggunakan suatu data tentang kejadian titanic. pertama kita import data kita.

Dari gambar dapat kita lihat bahwa data kita memiliki beberapa column seperti tentang status survived, tentang umur, tentang jenis kelamain, dan lain-lain. misalkan boss kita menyuruh kita untuk melakukan beberapa hal sebagai berikut :
1. Tunjukan kepada saya semua data orang-orang yang selamat!!
2. Tunjukan kepada saya semua data laki-laki yang selamat.
3. Tunjukan kepada saya semua data tentang perempuan yang tidak selamat di umur lebih dari 40 tahun atau kurang dari 20 tahun.
Hal pertama yang mesti kita lakukan untuk melakukan operasi yang bisa menjawab permintaan di atas adalah… kita membuat terlebih dahulu suatu Boolean Series. kemudian boolean series tersebut kita masukan kedalam dataframe kita. langsung saja akan saya perlihatkan dengan contoh. dimulai dari pertanyaan pertama.
1. Data orang-orang yang selamat
# boolean series orang orang yang selamat
survived = df.survived == 1
print(survived)
=================
0 True
1 True
2 False
3 False
4 False
...
1304 False
1305 False
1306 False
1307 False
1308 False
Name: survived, Length: 1309, dtype: bool
Sekarang kita masukan boolean series kita ke dalam dataframe kita.

2. Data laki-laki yang selamat
Seperti biasa kita buat terlebih dahulu boolean series nya, kali ini kita membuat 2 boolean series. yaitu boolean series orang yang selamat dan bolean series orang yang berjenis kelamin laki-laki. berikut caranya
# bolean series orang yang selamat
survived = df.survived == 1
# boolean series laki-laki
laki2 = df.sex = 'male'
# tampilkan data boolean series laki2
print(laki2)
=============
0 False
1 True
2 False
3 True
4 False
...
1304 False
1305 False
1306 True
1307 True
1308 True
Name: sex, Length: 1309, dtype: bool
Sekarang kita masukan 2 boolean series ini ke dalam dataframe kita, ada sedikit hal yang perlu kamu lakukan ketika ingin memfilter dataframe dengan lebih dari satu kondisi boolean series, pertama kamu harus memberikan kurung kepada setiap boolean series mu, kedua hubungkan kedua boolean series itu dengan logical operator seperti & (and), | (or), dan lain sebagainya. berikut caranya.
print(df[(survived) & (laki2)])

3. Data Perempuan yang tidak selamat dengan umur lebih dari 40 tahun atau kurang dari 20 tahun.
Coba perhatikan ada berapa boolean series yang perlu kita buat. disini ada 4 boolean series yang perlu kita buat, yaitu orang yang tidak selamat, orang yang berjnis kelamin perempuan, orang yang berumur lebih dari 40 tahun, dan orang yang kurang dari 20 tahun. jadi mari kita buat boolean series nya.
# orang yang tidak selamat
not_survived = df.survived == 0
# orang berjnis kelamin perempuan
perempuan = df.sex == 'female'
# orang yang berumur lebih dari 40 tahun
lebih_40 = df.age > 40
# orang yang berumur kurang dari 20 tahun
kurang_20 = df.age < 20
kemudian kita gabungkan boolean series ini dengan seperti ini :
df[(not_survived) & (perempuan) & (lebih_40 | kurang_20)]

Data Transformation
Data transformasi adalah mengubah format data kepada suatu format yang kita inginkan. didalam matematika dikenal dengan istilah mapping. dalam melakukan transformasi kita memerlukan terlebih dahulu suatu fungsi yang dapat memetakan bentuk data awal kita menjadi bentuk data akhir yang kita inginkan.


Pandas menyediakan berbagai method bawaan untuk melakukan transformasi terhadap data kita, beberapa diantaranya telah diperkenalkan pada hari pertama di minggu ke dua ini. misalnya describe(), method describe ini tidak lain memetakan data mentah kita menjadi suatu data hasil tentang deskriptif statistik.
Selain itu masih banyak lagi method2 bawaan yang di sediakan pandas untuk melakukan data transformasi seperti method mean(), dan lain sebagaiinya.
Kita juga bisa melakukan transformasi sesuai keinginan kita sendiri atau custom transformation. untuk melakukan custom transformation terlebih dahulu perlu membuat fungsi untuk melakukan mapping antara data awal hingga menjadi data yang di harapkan. berikut akan di periihatkan satu contoh transformasi data
kita kembali akan menggunakan data tentang titanic. misalkan kita ingin mengubah data kita, dimana kita ingin mengubah column age, semua nilainya di kurangi dengan nilai minimum dari kolumn tersebut. maka pertama kita definiskan fungsi tersebut.
def minus_minimum(x):
return x - x.min()
setelah kita mendefinisikan fungsinya. sekarang kita akan menggunakan method apply() dari pandas. method apply ini akan menerima suatu fungsi kemudian ‘meng-apply’ fungsi tersebut ke dalam setiap sumbu dari dataframe, secara default sumbu yang ‘apply’ adalah sumbu column. langsung saja kita perlihatkan. sebelum nykita lihat dulu data awal kita seperti apa.
print(df.age)
================
0 29.00
1 0.92
2 2.00
3 30.00
4 25.00
...
1304 14.50
1305 NaN
1306 26.50
1307 27.00
1308 29.00
Name: age, Length: 1309, dtype: float64
Dan nilai minumum dari column age adalah :
(df.age.min())
==============-
0.17
maka seharusnya apabila kita melakukan transformasi terhadap column age dengan fungsi ‘minus_minimum’, maka seharusnya semua nilai dari column age akan di kurangi dengan nilai minimumnya. kita buktikan
print(df[['age']].apply(minus_minimum))

Kalian lihat, hasilnya seperti yang kita harapkan, yaitu semua data dari column age dikurangi nilai minmumnya.
Reshaping Data
Dalam beberapa kasus kita perlu melakukan reshaping terhadap data untuk mengubah data yang ‘tidy’ menjadi data yang lebih relevan dan lebih optimal untuk di jadikan bahan analisis.
Ada beberapa teknik reshaping data di pandas, beberapa diantaranya yang akan dijelaskan dalam artikel ini adalah Pivoting dan Melting.
Pivoting Data

Pivoting adalah suatu pengubahan bentuk data dengan memutar data yang terletak di baris menjadi di column. coba perhatikan gambar di atas.
Kita juga dapat mengatakan pivoting tabel adalah melakukan perubahan pada bentuk data dari yang tadinya panjang menjadi lebar.
Ada beberapa metode untuk melakukan pivoting di pandas, yaitu pivot() dan pivot_table(), namun metode yang bagus adalah pivot_table(), oleh karena itu di artikel ini akan di tunjukan contoh melakukan perubahan bentuk data dengan metode pivot.
Untuk simplicity, kita akan menggunakan data buatan. misalkan kita mempunyai data seperti yang ada pada gambar diatas
import pandas as pd
data = {
'foo' : ['one']*3 + ['two']*3,
'bar' : ['A', 'B', 'C', 'A', 'B', 'C'],
'baz' : [1, 2, 3, 4, 5, 6],
'zoo' : ['x', 'y', 'z', 'q', 'w', 't']
}
df = pd.DataFrame(data)
print(df)
==================
foo bar baz zoo
0 one A 1 x
1 one B 2 y
2 one C 3 z
3 two A 4 q
4 two B 5 w
5 two C 6 t
kemudian kita akan melakukan pivoting tabel seperti yang ada di gambar, maka ada beberapa argument paling penting di dalam method pivot_tabel yang perlu kita perhatikan, diantaranya :
- values : Argumen ini mendefiniskan column mana dari dataframe yang asli yang akan di jadikan values yang ingin kita lihat di dalam hasil pivoting tabel kita.
- columns : Data dari column mana yang akan dijadikan column baru di dalam hasil pivoting dataframe kita.
- index : Data dari column mana yang akan dijadikan index di dalam hasil pivoting dataframe kita.
Jika kalian bingung memahami bahasa-bahasa diatas, maka kita langsung praktekan saja dan coba kalian perhatikan baik baik hasilnya.
# using pivot
pivot_df = pd.pivot(df, index='foo', columns='bar', values='baz')
print(pivot_df)
======================
bar A B C
foo
one 1 2 3
two 4 5 6
#using pivot_table
pivot_table_df= pd.pivot_table(df, index='foo', columns='bar', values='baz', aggfunc='sum')
print(pivot_table_df)
=======================
bar A B C
foo
one 1 2 3
two 4 5 6
Perbedaan antara pivot dan pivot_table terletak pada penggunaan fungsi agregasi. Dalam pivot, kita tidak bisa melakukan agregasi sedangkan pada pivot_table kita bisa mengaplikasikan fungsi agregasi.
Melting Data

Melting adalah ‘unpivoting’, melting mengubah suatu data dengan memutar dari yang tadinya berada di posisi column menjadi di posisi row.
Melting mengubah data yang tadinya lebar menjadi panjang.
Melting berguna ketika ada suatu kasus dimana terdapat satu atau lebih column yang merupakan identifier variable, dan columnn lain adalah measure variabel. Identifier variabel adalah suatu entitias yang melakukan identifikasi terhadap suatu variabel yang sedang di ukur.
Apabila kita memiliki suatu besaran yang nilainya selalu berubah, kemudian kita ingin mengamati perubahan itu, berarti kita sedang memperlakukan besaran itu sebagai measure variabel. dan kita perlu sesuatu yang mereferensikan perubahan tersebut. hal itu di sebut identifier variable.
contohnya nyatanya adalah apabila kita mengamati perubahan suhu setiap waktu. maka perubahan suhu adalah variabel yang di ukur, dan waktu adalah identifier variabel.
Sekarang kita akan mencoba mempraktekan teknik melting terhadap suatu dataframe :
# Membuat datafame sederhana
# importing pandas as pd
import pandas as pd
# membuat dataframe
df = pd.DataFrame({'Name': {0: 'John', 1: 'Bob', 2: 'Shiela'},
'Course': {0: 'Masters', 1: 'Graduate', 2: 'Graduate'},
'Age': {0: 27, 1: 23, 2: 21}})
df
=====================
Name Course Age
0 John Masters 27
1 Bob Graduate 23
2 Shiela Graduate 21
Dalam menggunakan method melt, ada beberapa argument yang penting untuk di perhatikan, diantaranya adalah :
- id_vars : columns mana yang akan dijadikan identifier variabel
- value_vars : columns yang akan menjadi value setelah kita melakukan ‘unpivot’ terhadap variabel, jika tidak di definisikan maka semua column selain id_vars akan dijadikan value_vars.
# Unpivot table
pd.melt(df, id_vars =['Name'], value_vars =['Course', 'Age'])
======================
Name variable value
0 John Course Masters
1 Bob Course Graduate
2 Shiela Course Graduate
3 John Age 27
4 Bob Age 23
5 Shiela Age 21
Grouping Data
Grouping adalah suatu teknik memisahkan data berdasarkan kriteria tertentu. untuk melakukan grouping di pandas kita menggunakan suatu method yang bernama groupby(). definisi abstraknya dari grouping adalah kita melakukan mapping suatu data terhadap suatu group.
ketika melakukan grouping ada beberapa proses yang terjadi secara berurutan, yaitu :
- Splitting : Memisahkan data kedalam suatu group berdasarkan kriteria tertentu.
- Applying : Melakukan suatu operasi terhadap sekumpulan data di group-group tersebut.
- Combining : Menggabungkan data menjadi suatu struktur baru
Langsung saja kita akan melihat bagaimana process split-apply-combine. kita akan menggunakan data sederhana untuk tujuan pembelajaran.
import numpy as np
import pandas as pd
df = pd.DataFrame([('bird', 'Falconiformes', 389.0),
('bird', 'Psittaciformes', 24.0),
('mammal', 'Carnivora', 80.2),
('mammal', 'Primates', np.nan),
('mammal', 'Carnivora', 58)],
index=['falcon', 'parrot', 'lion', 'monkey', 'leopard'],
columns=('class', 'order', 'max_speed'))
df

Mari kita praktikan method groupby terhadap data tersebut. misalkan kita group data tersebut berdasarkan class.
df.groupby('class')
====================
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000002054AEB2808>
Coba kalian perhatikan, pada tahap ini kita baru sampai pada process splitting berdasarkan kategori ‘class’. hasil dari groupby ini hanya sebuah objek GroupBy. objek groupby ini adalah representasi dari suatu hasil penggabungan data berdasarkan group class, namun tidak menghasilkan nilai apapun sebelum kita memberikan suatu operasi terhadap hasil dari setiap grouping tersebut. prosess melakukan operasi terhadap sekumpulan data yang telah di groupkan adalah process applying. kita bisa menggunakan berbagai jenis operasi terhadap objek groupby tersebut. ada operasi yang telah di sediakan sebagai operasi bawaan dari pandas seperti mean(), min(), max(), dan lain sebagainya. dapat pula menggunakan custom operasi tergantung apa yang kita inginkan. mari kita coba praktekan salah satu jenis operasi kepada objek groupby tersebut.
df.groupby('class').mean()
===========================
max_speed
class
bird 206.5
mammal 69.1
Coba kalian perhatikan. kita telah berhasil menggunakan groupby dan memberikan hasil. jenis operasi yang di apply terhadap setiap group adalah rata-rata. dan hasilnya di combine menjadi struktur data baru. dengan begini kita menhasilkan suatu hasil analisis sederhana yaitu bahwa binatang dengan class bird memiliki kecepatan maksimal rata-rata sebesar 206.5, dan bintang class mamalia sebesar 69.1
Merging Dataframe
Menggabungkan data adalah salah satu hal yang penting dalam suatu pekerjaan data analyst atau data science. karena dalam banyak kasus data selalu berada dri berbagai file dan sumber. Maka menguasai penggabungan data beserta logika-logika penggabungan data menjadi hal yang esensi untuk di kuasai.
Pandas menyediakan berbagai tool atau method yang memudahkan kita untuk melakukan penggabungan data dengan berbagai macam logik. method-method tersebut diantaranya seperti join(), merge(), concat(). kali ini kita kan mempelejari beberapa teknik tersebut.
Ada beberapa logika penggabungan data, diantaranya adalah :
- Inner Join
- Full Outer Join
- Left Outer Join
- Right Outer Join
- dll.

Penggabungan Baris dan Column dengan Metod concat()
Concat adalah salah satu metode untuk melakukan penggabungan data berdasarkan sumbu tertentu. langsung saja kita lihat.
misalkan kita mempunyai data seperti ini :
import pandas as pd
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D4', 'D5', 'D6', 'D7']},
index=[4, 5, 6, 7])
df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
'B': ['B8', 'B9', 'B10', 'B11'],
'C': ['C8', 'C9', 'C10', 'C11'],
'D': ['D8', 'D9', 'D10', 'D11']},
index=[8, 9, 10, 11])

Perhatikan, data yang kita punya sangatlah simple, kita mempunyai 3 data yang mempunyai nama column yang sama. apabila kita ingin menggabungkan baris data ini, kita bisa menggunakan suatu method concat(). pertama kita buat terlebih dahulu list dari data yang akan kita gabung, kemudian masukan list tersebut sebagai argument kedalam method concat(). seperti ini.
# list data yang akan di gabung
list_dataframe = [df1, df2, df3]
# gabungkan data dengan metode concat dari pandas
pd.concat(list_dataframe)
A | B | C | D | |
---|---|---|---|---|
0 | A0 | B0 | C0 | D0 |
1 | A1 | B1 | C1 | D1 |
2 | A2 | B2 | C2 | D2 |
3 | A3 | B3 | C3 | D3 |
4 | A4 | B4 | C4 | D4 |
5 | A5 | B5 | C5 | D5 |
6 | A6 | B6 | C6 | D6 |
7 | A7 | B7 | C7 | D7 |
8 | A8 | B8 | C8 | D8 |
9 | A9 | B9 | C9 | D9 |
10 | A10 | B10 | C10 | D10 |
11 | A11 | B11 | C11 | D11 |
Berikut hasilnya, hasil tersebut merupakan gabungan yang seperti ini :

Apabila kita ingin menggabungkan data tersebut berdasarkan column, kita mesti memberikan satu argument lagi kedalam method concat yaitu axis, dengan nilai 1. seperti ini
pd.concat(list_dataframe, axis=1)
A | B | C | D | A | B | C | D | A | B | C | D | |
---|---|---|---|---|---|---|---|---|---|---|---|---|
0 | A0 | B0 | C0 | D0 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN |
1 | A1 | B1 | C1 | D1 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN |
2 | A2 | B2 | C2 | D2 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN |
3 | A3 | B3 | C3 | D3 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN |
4 | NaN | NaN | NaN | NaN | A4 | B4 | C4 | D4 | NaN | NaN | NaN | NaN |
5 | NaN | NaN | NaN | NaN | A5 | B5 | C5 | D5 | NaN | NaN | NaN | NaN |
6 | NaN | NaN | NaN | NaN | A6 | B6 | C6 | D6 | NaN | NaN | NaN | NaN |
7 | NaN | NaN | NaN | NaN | A7 | B7 | C7 | D7 | NaN | NaN | NaN | NaN |
8 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN | A8 | B8 | C8 | D8 |
9 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN | A9 | B9 | C9 | D9 |
10 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN | A10 | B10 | C10 | D10 |
11 | NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN | A11 | B11 | C11 | D11 |
Coba kalian perhatikan, penggabungan ini adalah penggabungan sumbu column pada setiap dataframe, dan pada sumbu baris di lakukan penggabungan juga berdasarkan indeks. secara default logika penggabunganya adalah outer join. kita akan melihat beberapa logika penggabungan setelah ini.
Logika-Logika Penggabungan Dengan Metode merge
Full Outer Join

- Full Outer Join menghasilkan gabungan index bari dari setiap data yang di gabung.
- Full Outer Join menggabungan pula column yang berbeda
- Memberikan nilai null untuk nilai column yang tidak di miliki oleh suatu index tertentu.
Misalkan kita mempunyai data seperti ini :
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K4', 'K5'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
print('data pertama')
print(=========)
print(left)
print('data kedua')
print(=========)
print(right)
data pertama ========= key A B 0 K0 A0 B0 1 K1 A1 B1 2 K2 A2 B2 3 K3 A3 B3 data kedua ========= key C D 0 K0 C0 D0 1 K1 C1 D1 2 K4 C2 D2 3 K5 C3 D3
Kita akan menggabungkan data ini denga menggunakan method merge() dari pandas. dalam penggabungan kita kan gunakan column key dari data kita sebagai variabel identifier dari data kita, atau sebagai column key/referensi.
- Untuk melakukan penggabungan dengan menggunakan column key sebagai referensi penggabungan, maka kita akan memberikan argument on dengan nilai ‘key’
- untuk melakukan penggabungan outer join kita akan memberikan argument how dengan nilai ‘outer’
# gabungkan data dengan logika outer join
pd.merge(left, right, on='key', how='outer')
key | A | B | C | D | |
---|---|---|---|---|---|
0 | K0 | A0 | B0 | C0 | D0 |
1 | K1 | A1 | B1 | C1 | D1 |
2 | K2 | A2 | B2 | NaN | NaN |
3 | K3 | A3 | B3 | NaN | NaN |
4 | K4 | NaN | NaN | C2 | D2 |
5 | K5 | NaN | NaN | C3 | D3 |
Inner Join

Inner join ini akan menggabungkan data antara nilai key/referensi yang beririsan.
Kita akan mencoba melakukan inner join dengan data yang sama pada outer join, Untuk melakukan inner join dengan metode merge(), kurang lebih sama seperti yang di lakukan pada outer join, kita hanya perlu mengubah argument argument how menjadi inner.
pd.merge(left, right, on='key', how='inner')
key | A | B | C | D | |
---|---|---|---|---|---|
0 | K0 | A 0 | B0 | C0 | D0 |
1 | K1 | A1 | B1 | C1 | D1 |
Coba perhatikan, bahwa data yang di gabungkan adalah data yang mempunyai nilai key beririsan.
Left Join

Left Outer Join menghasilkan seluruh data dari data yang kiri ditambah data kanan yang memiliki nilai key yang sama dengan data dari kiri.
Kita akan mencoba melakukan left outer join dengan data yang sama pada outer join, untuk melakukan left outer join kita hanya perlu memberikan nilai ‘left’ kepada argument how.
pd.merge(left, right, on='key', how='left')
key | A | B | C | D | |
---|---|---|---|---|---|
0 | K0 | A0 | B0 | C0 | D0 |
1 | K1 | A1 | B1 | C1 | D1 |
2 | K2 | A2 | B2 | NaN | NaN |
3 | K3 | A3 | B3 | NaN | NaN |
Right Join
Right outer join ini hanya kebalikan dari left outer join.
Untuk melakukan operasi penggabungan right outer join dengan metode merge, kita hanya perlu memberikan nilai ‘right’ pada argument how.
pd.merge(left, right, on='key', how='right')
key | A | B | C | D | |
---|---|---|---|---|---|
0 | K0 | A0 | B0 | C0 | D0 |
1 | K1 | A1 | B1 | C1 | D1 |
2 | K4 | NaN | NaN | C2 | D2 |
3 | K5 | NaN | NaN | C3 | D3 |