Modul Data Science - 3

Data

Visualization
Dengan Python
Disusun oleh:

Tim Digitalskillarea
Editor: Muh. Luthfi
dsarea.com
DATA VISUALIZATION
Pengenalan Matplotlib ............................................................... 2

Line Plot ................................................................................................. 9

Box Plot ............................................................................................... 25

Scatter Plot ...................................................................................... 34

Bar Plot ............................................................................................... 46

Area Plot ............................................................................................ 65

Pie Chart ........................................................................................... 76

Histogram ........................................................................................ 89

Heatmap .........................................................................................106

Word Cloud .................................................................................... 125

Waffle Chart .................................................................................. 142

Regression Plot ............................................................................158

 Pengenalan Matplotlib

Matplotlib adalah library Python yang digunakan untuk visualisasi data. Matplotlib dilengkapi
dengan scripting interface yang direpresentasikan dengan pyplot untuk memudahkan
dalam pembuatan grafik. Arsitektur matplotlib terdiri dari tiga layer utama, yaitu backend layer,
artist layer, dan scripting layer.

Kita dapat menggunakan matplotlib di banyak tools, seperti Jupyter Notebook, Google
Colab, dan lain-lain. Tetapi, kita perlu meng-install matplotlib terlebih dahulu sebelum
menggunakannya.

Figure dan Axes di Matplotlib

Figure adalah objek Matplotlib yang mengandung semua elemen dari sebuah grafik yang
ditampilkan, sedangkan Axes merupakan tempat dimana method untuk melakukan
plotting, seperti method untuk membuat dan memanipulasi garis axis, grid, label tick,
ataupun background.

Seperti dalam melukis, figure adalah sebuah kanvas, sedangkan Axes adalah gambarnya.
Sebuah figure biasanya mengandung satu Axes. Satu axes adalah satu plot (gambar).
Contohnya sebuah Figure terdiri dari 4 plot, berarti figure tersebut harus memiliki 4 axes.

2
Membuat plot sederhana

Sebelum membuat sebuah plot, kita harus mengimpor matplotlib.pyplot terlebih dahulu

1 import matplotlib.pyplot as plt

Kita dapat menggunakan alias untuk menginisialisasi matplotlib.pyplot sebagai plt agar
memudahkan kita dalam penulisan kode.

Kemudian dalam pembuatan plot terdapat dua cara, yaitu menggunakan cara
Explicit dan Implicit.

Cara Explicit

Pertama, kita akan menggunakan cara Explicit dengan membuat grafik sederhana dari dua
buah kumpulan bilangan yang didefinisikan di dalam dua buah list, yaitu list a dan list b.

1 a = [1, 3, 5, 7, 9]
2 b = [5, 3, 7, 4, 6]
3
4 # Membuat objek figure
5 fig = plt.figure()
6
7 # Membuat objek axes
8 ax = fig.add_subplot()
9
10 # Tambahkan data ke objek axes sebagai parameter
11 ax.plot(a, b)
12
13 # Menampilkan visualisasi data dengan function show()
14 plt.show()

3
Berdasarkan kode diatas, kita diharuskan membuat objek figure dan axes terlebih dahulu jika
menggunakan cara explicit. Penggunaanya memang sedikit rumit karena kita harus mengatur
berbagai macam komponen yang terdapat di dalam objek figure dan axes. Tetapi cara ini
direkomendasikan jika ingin membuat visualisasi data yang lebih kompleks.

Setelah itu, kita dapat menampilkan visualisasi data dengan memanggil method show().

Cara Implicit

Membuat visualisasi data dengan cara implicit menggunakan data yang sama seperti
sebelumnya.

1 a = [1, 3, 5, 7, 9]
2 b = [5, 3, 7, 4, 6]
3
4 # Membuat objek visual
5 plt.plot(a, b)
6
7 # Menampilkan visualisasi data dengan function show()
8 plt.show()

Berdasarkan kode diatas, penulisan kode terlihat lebih sederhana dalam membuat plot
dibandingkan dengan cara explicit.

4
Plotting multiple data dalam satu Axes
Kita dapat melakukan plotting lebih dari satu data dalam satu axes. Pada contoh ini, kita
menggunakan Numpy untuk men-generate bilangan. Perhatikan kode berikut.

1 # Plotting multiple data dalam satu Axes

2 import numpy as np
3
4 X = np.linspace(0, 40, 100)
5 y1 = np.cos(X*2)
6 y2 = np.cos(X)
7 y3 = np.sin(X/3)
8 y4 = np.sin(X)
9
10 fig, ax = plt.subplots(figsize=(10,6))
11
12 ax.plot(X, y1, color='red')
13 ax.plot(X, y2, color='green')
14 ax.plot(X, y3, color='blue')
15 ax.plot(X, y4, color='orange')
16
17 plt.show()

5
Mengatur style
Kita dapat mengatur style yang bisa digunakan pada Matplotlib. Namun kita perlu
mengetahuistyle apa saja yang tersedia menggunakan perintah kode di bawah ini.

1 # Cara mengetahui style yang tersedia di Matplotlib

2 print(plt.style.available)
'seaborn-bright', 'seaborn-colorblind', 'seaborn-dark', 'seaborn-dark-palette',

Sebagai contoh, kita dapat menggunakan style tableau-colorblind10 untuk data trigonometri
yang sebelumnya.

1 # Mengatur style menggunakan tableau-colorblind10

2 plt.style.use('tableau-colorblind10')
3 X = np.linspace(0, 40, 100)
4 y1 = np.cos(X*2)
5 y2 = np.cos(X)
6 y3 = np.sin(X/3)
7 fig, ax = plt.subplots(figsize=(10,6))
8 ax.plot(X, y1)
9 ax.plot(X, y2)
10 ax.plot(X, y3)
11 plt.show()

6
Selanjutnya menggunakan style ggplot.

1 # Mengatur style menggunakan ggplot

2
3 plt.style.use('ggplot')
4 X = np.linspace(0, 40, 100)
5 y1 = np.cos(X*2)
6 y2 = np.cos(X)
7 y3 = np.sin(X/3)
8
9 fig, ax = plt.subplots(figsize=(10,6))
10
11 ax.plot(X, y1)
12 ax.plot(X, y2)
13 ax.plot(X, y3)
14 plt.show()

Menyimpan gambar
Kita dapat menyimpan gambar menggunakan method savefig() dengan memberikan
parameternama file gambar yang ingin disimpan. Sebagai contoh, simpan hasil visualisasi
data sebelumnya dengan nama belajar_visualisasi.png

7
 1 plt.style.use('ggplot')
2 X = np.linspace(0, 40, 100)
3 y1 = np.cos(X*2)
4 y2 = np.cos(X)
5 y3 = np.sin(X/3)
6
7 fig, ax = plt.subplots(figsize=(10,6))
8
9 ax.plot(X, y1)
10 ax.plot(X, y2)
11 ax.plot(X, y3)
12
13 # Menyimpan gambar
14 fig.savefig('belajar_visualisasi.png')

Setelah itu, kita dapat mengeceknya di folder yang sama dengan file notebook ini.

8
 Line Plot
Dataset
Kita akan menggunakan dataset India Suicide Victims.
Pertama, import library yang akan digunakan seperti Pandas dan Matplotlib

1 import pandas as pd
2 import matplotlib.pyplot as plt

Setelah itu, me-load dataset menggunakan read_csv() dan memasukkannya ke variabel df.
Kemudian tampilkan beberapa data menggunakan method head()

1 df = pd.read_csv("/content/who_suicide_statistics.csv")
2 df.head(10)

country year sex age suicides_no population

0 Albania 1985 female 15-24 years NaN 277900.0

1 Albania 1985 female 25-34 years NaN 246800.0

2 Albania 1985 female 35-54 years NaN 267500.0

3 Albania 1985 female 5-14 years NaN 298300.0

4 Albania 1985 female 55-74 years NaN 138700.0

5 Albania 1985 female 75+ years NaN 34200.0

6 Albania 1985 male 15-24 years NaN 301400.0

7 Albania 1985 male 25-34 years NaN 264200.0

8 Albania 1985 male 35-54 years NaN 296700.0

9 Albania 1985 male 5-14 years NaN 325800.0

Kemudian cek info dari dataset tersebut.

1 df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 43776 entries, 0 to 43775
Data columns (total 6 columns):
# Column Non-Null Count Dtype

0 country 43776 non-null object

1 year 43776 non-null int64
2 sex 43776 non-null object

9
 3 age 43776 non-null object
4 suicides_no 41520 non-null float64
5 population 38316 non-null
float64dtypes: float64(2), int64(1),
object(3)
memory usage: 2.0+ MB

Berdasarkan info di atas, beberapa kolom mengandung bilangan integer kecuali kolom
'STATE/UT' dan 'CAUSE' bertipe object.

Visualisasi data dengan Line Plot

Line plot atau line chart adalah jenis plot dasar dalam visualisasi dasar yang menampilkan
informasi berupa rangkaian titik data yang terhubung dengan segmen garis lurus. Line plot
digunakan pada dataset yang memiliki nilai kontinu untuk melihat pergerakan data dari waktu
kewaktu.

Mari mencoba melakukan visualisasi data dengan line plot menggunakan satu data dan
beberapa data.

Single line

Sebagai contoh, kita akan menampilkan grafik jumlah orang yang melakukan bunuh diri setiap
tahunnya di dunia.

Kita akan melakukan grouping berdasarkan kolom 'Year' dan menampilkan jumlah total pada
kolom 'Grand Total' menggunakan agregasi sum

1 # Grouping data
2 df_tahun = df.groupby(['year'])[['suicides_no']].sum()
3 df_tahun

suicides_no

year

1979 92790.0

1980 153548.0

1981 178014.0

1982 182893.0

1983 122430.0

10
1984 124427.0

1985 197533.0

1986 189225.0

1987 186364.0

1988 181416.0

1989 186043.0

1990 205507.0

1991 204756.0

1992 219100.0

1993 229243.0

1994 240628.0

1995 245915.0

1996 250353.0

1997 244322.0

1998 253279.0

1999 259984.0

2000 259905.0

2001 255071.0

2002 260401.0

2003 260429.0

2004 245249.0

2005 238622.0

2006 237200.0

2007 237211.0

2008 239368.0

2009 247324.0
2010 242243.0
2011 239972.0
2012 234085.0
2013 229421.0
2014 227793.0

11
 2015 207908.0
2016 16483.0

Setelah melakukan grouping data, kita akan membuat line plot dengan method plot().

1 # Menghapus baris 2016

2
3 df_tahun = df_tahun.drop(2016, axis=0)

1 # Plotting dengan Pandas

2
3 df_tahun.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x7f72a9e534d0>

Selanjutnya menampilkan visualisasi data menggunakan Matplotlib dengan mendefinisikan

nilaix dan y terlebih dahulu. Untuk axis x akan diisi oleh indeks tot_suicides, sedangkan untuk
axis y akan ditempati oleh tot_suicides['Grand Total']. Namun, untuk mengantisipasi error
yang mungkin terjadi, sebaiknya ubah dulu menjadi list.

1 # Mendefinisikan nilai x dan y

2
3 x = list(df_tahun.index)
4 y = list(df_tahun['suicides_no'])

12
Kemudian buat plotnya dengan Matplotlib menggunakan cara implicit.

1 # Visualisasi data dengan Matplotlib

2
3 plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x7f72a9ded910>]

tot_suicides.index adalah sumbu x, sedangkan tot_suicides['Grand Total'] adalah sumbu y.

Multiple line

Sekarang kita akan mencoba mempraktekkan plotting beberapa data. Jadi nanti dalam satu
gambar ada beberapa garis yang mewakili masing-masing kategori.

Misalnya kita ingin menampilkan grafik data orang yang melakukan bunuh dari dari negara-
negara tertentu pada rentang tahun tertentu. Disini kita akan ambil negara Australia, Japan,
Republic of Korea, United Kingdom, dan United States of America. Sementara tahunnya, kita
akan ambil dari tahun 2006 hingga 2010.

Pertama, kita buat dua buah kondisi untuk memilih country dan year seperti di bawah ini.
Tanda |merupakan simbol or alias 'atau'.

1 countries = (df['country']=='Australia') | (df['country']=='Japan') | \

2 (df['country']=='Republic of Korea') | (df['country']=='United Kingdom')| \
3 (df['country']=='United States of America')
4
5 years = (df['year']==2006) | (df['year']==2007) | (df['year']==2008) | \
6 (df['year']==2009) | (df['year']==2010)

13
Setelah membuat kondisi, sekarang coba kita lihat dataframe yang di-filter dengan kondisi
tersebut. Misalnya kita akan menyimpan hasil filter tersebut ke dalam variabel df_filter.
Jangan lupa untuk me-reset indeks dari dataframe tersebut.

1 # Membuat dataframe yang di-filter dengan kondisi

2
3 df_filter = df[countries & years].reset_index(drop=True)
4 df_filter

Setelah mendapatkan dataframe yang dibutuhkan. Selanjutnya kita perlu mentransformasi

dataframe di atas menjadi bentuk pivot table menggunakan method pivot_table() dari
Python.

1 # Tranformasi menjadi pivot table

2 pivot_filter = df_choice.pivot_table(index='year',
3 columns='country',
4 values='suicides_no',
5 aggfunc='sum')
6 pivot_filter

14
Ada beberapa parameter yang kita gunakan pada kode di atas untuk membuat pivot table.

• index untuk menentukan fitur/kolom yang akan menjadi indeksnya,

• columns untuk menentukan fitur yang akan menjadi kolom,
• values untuk menentukan fitur yang akan dijadikan nilai dari dataframe, dan
• aggfunc adalah metode agregasi apa yang akan digunakan untuk memproses values.

Berdasarkan kode di atas, kolom year sebagai indeks, country sebagai kolom dan nilainya
adalah suicides_no dengan agregasi sum karena kita ingin mengetahui total jumlahnya.

Selanjutnya kita melakukan plotting.

1 # Plotting data
2
3 pivot_filter.plot(kind='line')

15
Sekarang kita sudah mendapatkan visualisasi yang kita butuhkan.
Namun kita juga dapat mengatur dan menambahkan beberapa komponen pada grafik dengan
menambahkan beberapa pengaturan.

Pengaturan dasar
Pada pembahasan berikutnya, kita akan membahas beberapa method Matplotlib dasar yang
digunakan untuk mengatur visualisasi data kita agar bisa dianalisis dengan baik.

Figure Size

Pertama, mengatur ukuran figure dengan parameter figsize yang dapat diberikan nilai berupa
tuple yang terdiri dari dua bilangan untuk mendefinisikan lebar dan tingginya.

1 plt.style.use('ggplot')
2
3 # Mengatur figure size
4 pivot_filter.plot(kind='line', figsize=(14, 6))
5 plt.show()

16
Title

Menambahkan title atau judul di visualisasi data kita dengan menggunakan method .title()

1 plt.style.use('ggplot')
2 pivot_filter.plot(kind='line', figsize=(14, 6))
3
4 # Mengatur judul grafik
5 plt.title('Statistik Bunuh Diri dari WHO\n', size=22)
6 plt.show()

17
Label

Memberikan label sebagai keterangan sumbu x dan y menggunakan method .xlabel() dan
.ylabel().

• .xlabel() untuk memberikan label pada sumbu x.

• .ylabel() untuk memberikan label pada sumbu y.

Kita juga dapat mengatur ukuran hurufnya dengan menambahkan parameter size.

1 plt.style.use('ggplot')
2 pivot_filter.plot(kind='line', figsize=(14, 6))
3
4 # Mengatur judul grafik
5 plt.title('Statistik Bunuh Diri dari WHO\n', size=22)
6
7 # Mengatur label pada sumbu x dan y
8
9 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
10 plt.xlabel('\nTahun', size=18)
11 plt.show()

Ticks

Mengatur ukuran ticks atau keteragan nilai dengan menggunakan .xticks() dan .yticks()
lalumemberikan parameter size.

18
 1 plt.style.use('ggplot')
2 pivot_filter.plot(kind='line', figsize=(14, 6))
3
4 # Mengatur judul grafik
5 plt.title('Statistik Bunuh Diri dari WHO\n', size=22)
6
7 # Mengatur label pada sumbu x dan y
8 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
9 plt.xlabel('\nTahun', size=18)
10
11 # Mengatur xticks dan yticks
12 plt.xticks(size=14)
13 plt.yticks(size=14)
14
15 plt.show()

Legend

Legend dapat kita atur ukurannya menggunakan .legend() seperti di bawah ini

19
 1 plt.style.use('ggplot')
2 pivot_filter.plot(kind='line', figsize=(14, 6))
3
4 # Mengatur judul grafik
5 plt.title('Statistik Bunuh Diri dari WHO\n', size=22)
6
7 # Mengatur label pada sumbu x dan y
8 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
9 plt.xlabel('\nTahun', size=18)
10
11 # Mengatur xticks dan yticks
12 plt.xticks(size=14)
13 plt.yticks(size=14)
14
15 # Mengatur legend
16 plt.legend(prop={'size': 12})
17 plt.show()

Line color

Mengatur line color dengan menambahkan parameter color atau disingkat dengan c.
Contohnyakita ingin warna garisnya orange, maka kita dapat menambahkan color =
'orange' atau c = 'orange'.

20
 1 plt.figure(figsize=(16, 8))
2
3 # Mengatur line color
4 plt.plot(x, y, color='orange')
5
6 # Mengatur judul grafik
7 plt.title('Statistik Bunuh Diri dari WHO Secara Global\n', size=22)
8
9 # Mengatur label pada sumbu x dan y
10 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
11 plt.xlabel('\nTahun', size=18)
12
13 # Mengatur xticks dan yticks
14 plt.xticks(size=14)
15 plt.yticks(size=14)
16
17 plt.show()

Line style

Mengatur jenis garis dengan parameter linestyle atau ls. Pada contoh kali ini kita ingin
menampilkan garis putus-putus dengan menambahakan linestyle = 'dashed'.

21
 1 plt.figure(figsize=(16, 8))
2
3 # Mengatur line style
4 plt.plot(x, y, linestyle='dashed')
5
6 # Mengatur judul grafik
7 plt.title('Statistik Bunuh Diri dari WHO Secara Global\n', size=22)
8
9 # Mengatur label pada sumbu x dan y
10 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
11 plt.xlabel('\nTahun', size=18)
12
13 # Mengatur xticks dan yticks
14 plt.xticks(size=14)
15 plt.yticks(size=14)
16
17 plt.show()

Line width

Mengatur Ketebalan garis dengan memberikan parameter linewidth atau lw yang bernilai
bilangan float

22
 1 plt.figure(figsize=(16, 8))
2
3 # Mengatur line width
4 plt.plot(x, y, linewidth='5')
5
6 # Mengatur judul grafik
7 plt.title('Statistik Bunuh Diri dari WHO Secara Global\n', size=22)
8
9 # Mengatur label pada sumbu x dan y
10 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
11 plt.xlabel('\nTahun', size=18)
12
13 # Mengatur xticks dan yticks
14 plt.xticks(size=14)
15 plt.yticks(size=14)
16
17 plt.show()

Marker

Menambahkan tanda pada setiap titik di line plot dengan parameter marker. Sebagai contoh
kita dapat menambahkan tanda titik untuk menandakan setiap kenaikan ditiap tahunnya.

23
 1 plt.figure(figsize=(16, 8))
2
3 # Mengatur marker
4 plt.plot(x, y, marker='o')
5
6 # Mengatur judul grafik
7 plt.title('Statistik Bunuh Diri dari WHO Secara Global\n', size=22)
8
9 # Mengatur label pada sumbu x dan y
10 plt.ylabel('Jumlah Korban Bunuh Diri\n', size=18)
11 plt.xlabel('\nTahun', size=18)
12
13 # Mengatur xticks dan yticks
14 plt.xticks(size=14)
15 plt.yticks(size=14)
16
17 plt.show()

24
 Box Plot
Dataset
Dataset yang digunakan adalah dataset India Suicide Victims yang berasal dari website
Kaggle. Mari kita load datasetnya.

1. import pandas as pd
2. import matplotlib.pyplot as plt
3. %matplotlib inline
4.
5. plt.style.use('seaborn')
6. df = pd.read_csv("/content/india_suicide_victims.csv")
7. df

Note: Hasil tangkapan layar

Visualisasi data dengan Box Plot

Box plot adalah jenis visualisasi data yang secara statistik merepresentasikan distribusi
data melalui lima dimensi utama, yaitu nilai minimum, kuartil 1, kuartil 2 (median), kuartil 3,
dan nilai maksimum. Box plot juga dapat digunakan untuk memeriksa keberadaan outlier
dalam dataset.
Sebelumnya, kita akan mempersiapkan datasetnya terlebih dahulu dengan melakukan
reshaping atau mengubah bentuk dataset menjadi bentuk pivot table dengan menggunakan
method pivot_table().
Kemudian, kita akan memberikan beberapa parameter seperti index, columns, values, dan
aggfunc di dalam method pivot_table().

25
Kita akan memberikan nilai pada parameter index yaitu kolom 'STATE/UT', nilai parameter
columns adalah kolom 'Year', nilai parameter values adalah 'Grand Total', dan nilai parameter
aggfunc adalah 'sum'.
1 # Reshaping data
2 # Set 'STATE/UT' sebagai indeks
3
4 df_pvt = df.pivot_table(index='STATE/UT', columns='Year',
5 values='Grand Total', aggfunc='sum')
6 df_pvt

Note: Hasil tangkapan layar

Selanjutnya, kita akan membuat visualisasi data.

Single Boxplot
Pertama, kita akan membuat list tahun terlebih dahulu yang nantinya berfungsi untuk
melakukan filter data, lalu kita akan membuat single box plot untuk data kota Delhi.

2007, 2008, 2009, 2010, 2011, 2012]

[2001, 2002, 2003, 2004, 2005, 2006,

26
 1 # Membuat list Tahun
2
3 list_tahun = list(range(2001, 2013))
4 list_tahun

Selanjutnya melakukan filter data menggunakan loc dengan memberikan nilai ['DELHI
(UT)'] sebagai indeks yang akan dipilih dan list_tahun sebagai kolom yang dipilih.
Kita juga melakukan transpose() dataframe. Perhatikan kode di bawah ini.

1 # Lakukakan filter dan transpose dataframe

2
3 df_delhi = df_pvt.loc[['DELHI (UT)'], list_tahun].transpose()
4 df_delhi

Selanjutnya kita membuat box plot dengan memberikan parameter kind = 'box' untuk
menandakan bahwa yang ingin kita buat adalah box plot. Perhatikan kode di bawah ini.

1 # Membuat box Plot

2

27
 3 df_delhi.plot(kind='box', figsize=(10, 8))
4 plt.title('Grand Total Korban Bunuh Diri di Kota Delhi (UT) 2001-2012', size=16)
5 plt.ylabel('Jumlah Kasus Bunuh Diri\n', size=14)
6 plt.xticks(size=14)
7 plt.yticks(size=14)
8 plt.show()

Berdasarkan visualisasi di atas, kita dapat mengambil beberapa kesimpulan, di antaranya:

1. Nilai minimum dari kasus bunuh diri di kota Delhi dari tahun 2001 - 2012 kurang lebih
2500 kasus.
2. Nilai maksimum dari kasus bunuh diri di kota Delhi dari tahun 2001 - 2012 adalah
sekitar 4400 kasus.
3. Nilai median (kuartil 2) atau 50% dari kasus bunuh diri di kota Delhi dari tahun 2001 -
2012 adalah sekitar 3250 kasus.
Untuk melihat angka-angka sebenarnya, kita dapat menggunakan method describe()
seperti di bawah ini.

1 # Melihat statistik korban bunuh diri di Kota Delhi(UT)

2
3 df_delhi.describe()

28
Multiple Boxplot
Selanjutnya, kita akan mengamati beberapa kota di India dalam satu axes, misalnya kota
Delhi, Gujaratm dan Punjab.
Pertama kita harus mem-filter data menggunakan .loc dan memasukkannya ke dalam
variabel df_cities. Kemudian melakukan transpose() untuk data ini.

1 # Memfilter dan transpose dataframe

2
3 df_cities = df_pvt.loc[['DELHI (UT)', 'GUJARAT',
4 'PUNJAB'], list_tahun].transpose()
5 df_cities.head(10)

STATE/UT DELHI (UT) GUJARAT PUNJAB

Year

2001 3012 11793 1459

2002 2503 11380 1284

2003 2673 11282 1513

2004 2986 11826 1652

2005 2893 11838 1504

2006 3600 12423 1911

2007 3478 13721 2128

29
 2008 3087 15108 2196

2009 3412 15314 2145

2010 3629 15271 2341

Setelah itu, kita akan membuat visualisasi data pada dataframe df_cities.

1 # Visualisasi data dengan box plot

2
3 df_cities.plot(kind='box', figsize=(13, 8))
4 plt.title(Total Korban Bunuh Diri Kota Delhi (UT), Gujarat dan Punjab 2001-2012
5 plt.ylabel('Jumlah Kasus Bunuh Diri\n', size=14)
6 plt.xticks(size=14)
7 plt.yticks(size=14)
8 plt.show()

Sekarang kita lihat distribusi data detailnya menggunakan method describe.

1 # Melihat statistik korban bunuh diri di Kota Delhi(UT), Gujarat dan Punjab
2
3 df_cities.describe()

30
Horizontal Boxplot
Selain menampilkan boxplot secara default atau vertikal, kita dapat menampilkannya
secara horizontal dengan menambahkan parameter vert = False. Perhatikan kode di

1 # Menampilkan box plot secara horizontal

2
3 df_cities.plot(kind='box', figsize=(13, 8), vert=False)
4 plt.title(Total Korban Bunuh Diri Kota Delhi (UT), Gujarat dan Punjab 2001-2012
5
6 plt.ylabel('Jumlah Kasus Bunuh Diri\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

bawah ini.

31
Membuat Subplot
Kita juga dapat menampilkan beberapa plot di dalam satu figure menggunakan cara
explicit dengan membuat figure dan membaginya menjadi subplot yang masing-
masingnya mengandung sebuah plot.
Hal ini dilakukan agar lebih mudah untuk dibandingkan. Untuk memvisualisasikan
beberapa plot bersamaan, perhatikan kode di bawah ini.

• nrows adalah jumlah baris axes yang diinginkan

• ncols adalah jumlah kolom axes yang diinginkan
• plot_number adalah nomor plotnya, digunakan untuk mengidentifikasi subplot
tertentu. plot_number dimulai berurutan dari angka 1 sampai angka maksimumnya
adalah nrows * ncols.

32
Kemudian kita akan mencoba dengan membuat 2 plot yaitu box plot dan line plot
bersebelahan. Kita harus membuat figure yang terdiri dari 1 baris axes dan 2 kolom axes.
Perhatikan kode berikut.

1 # Membuat figure dan menambahkan subplot

2
3 fig = plt.figure()
4 ax0 = fig.add_subplot(1, 2, 1)
5 ax1 = fig.add_subplot(1, 2, 2)
6
7 # Subplot 1 menggunakan Box plot secara horizontal
8
9 df_cities.plot(kind='box', vert=False, figsize=(21, 8), ax=ax0)
10 ax0.set_title('Box Plot Grand Total Korban Bunuh Diri 2001-2012\n', size=16)
11 ax0.set_xlabel('Jumlah Kasus Bunuh Diri',size=14)
12 ax0.set_ylabel('Kota di India',size=14)
13
14 # Subplot 2 menggunakan Line plot
15
16 df_cities.plot(kind='line', figsize=(21, 8), ax=ax1)
17 ax1.set_title('Line Plot Grand Total Korban Bunuh Diri 2001 - 2012\n',size=16)
18 ax1.set_xlabel('Tahun',size=14)
19 ax1.set_ylabel('Jumlah Kasus Bunuh Diri\n',size=14)
20 plt.show()

Jika nrows, ncols, dan plot_number-nya kurang dari 10, kita dapat menuliskannya tanpa
dipisahkan koma. Jadi,

33
 Scatter Plot
Dataset
Dataset yang digunakan adalah dataset Austin Weather.

1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4 %matplotlib inline
5
6 df = pd.read_csv('/content/austin_weather.csv')
7 df.head()

Note: Hasil tangkapan layar

Setelah itu kita bisa melihat info dari dataset tersebut.

1 # Cek info dataset

2
3 df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1319 entries, 0 to 1318
Data columns (total 21 columns):
# Column Non-Null Count Dtype

1319 non-null object

0 Date
1 TempHighF 1319 non-null int64
2 TempAvgF 1319 non-null int64
3 TempLowF 1319 non-null int64
4 DewPointHighF 1319 non-null object
5 DewPointAvgF 1319 non-null object
6 DewPointLowF 1319 non-null object

34
7 HumidityHighPercent 1319 non-null object
8 HumidityAvgPercent 1319 non-null object
9 HumidityLowPercent 1319 non-null object
10 SeaLevelPressureHighInches 1319 non-null object
11 SeaLevelPressureAvgInches 1319 non-null object
12 SeaLevelPressureLowInches 1319 non-null object
13 VisibilityHighMiles 1319 non-null object
14 VisibilityAvgMiles 1319 non-null object
15 VisibilityLowMiles 1319 non-null object
16 WindHighMPH 1319 non-null object
17 WindAvgMPH 1319 non-null object
18 WindGustMPH 1319 non-null object
19 PrecipitationSumInches 1319 non-null object
20 Events 1319 non-null object
dtypes: int64(3),
object(18)memory usage:
216.5+ KB

Berdasarkan dataset di atas, hampir semua kolom bertipe numerik, namun pada dataset
tersebut masih bertipe 'object'. Jika kita cek dataframenya ada beberapa data yang
memiliki missing values yang berupa simbol -. Simbol tersebut terdeteksi sebagai
'object'.
Sekarang kita akan mengecek missing values yang berupa simbol '-' di setiap kolom.

1 # Mengecek keberadaan '-' di dataframe

2
3 df.isin(['-']).any()

Date False
TempHighF False
TempAvgF False
TempLowF False
DewPointHighF True
DewPointAvgF True
DewPointLowF True
HumidityHighPercent True
HumidityAvgPercent True
HumidityLowPercent
Tru
e SeaLevelPressureHighInches
Tru
e SeaLevelPressureAvgInche
Tru
e SeaLevelPressureLowInches
Tru
e VisibilityHighMiles
Tru

35
 e
VisibilityAvgMiles True
VisibilityLowMiles True
WindHighMPH True
WindAvgMPH True
WindGustMPH True
PrecipitationSumInches False
Events False
dtype: bool

Beberapa kolom dalam dataframe mengandung simbol '-'. Selanjutnya, kita akan
menangani missing values tersebut terlebih dahulu.
Pertama, me-replace simbol '-' dengan NaN, kemudian mengisi NaN dengan nilai yang
sama dengan cell sebelumnya (di atasnya) menggunakan method ffill.

1 # Replace dan fill missing values

2
3 df = df.replace('-', np.NaN).fillna(method='ffill')

Setelah itu kita ubah tipe datanya untuk empat kolom yang akan digunakan, yaitu
TempAvgF, DewPointAvgF, DewPointAvgF, dan WindAvgMPH.
Tipe data kolom TempAvgF sudah sesuai, sehingga kita akan mengubah kolom
DewPointAvgF, DewPointAvgF dan WindAvgMPH menjadi bertipe float.
1 # Mengubah tipe data
2
3 df['WindAvgMPH'] = df['WindAvgMPH'].astype('float')
4 df['HumidityAvgPercent'] = df['HumidityAvgPercent'].astype('float')
5 df['DewPointAvgF'] = df['DewPointAvgF'].astype('float')

Setelah menyiapkan data yang diperlukan, kita akan membuat visualisasi.

Visualisasi data dengan Scatter Plot

Scatter plot adalah jenis visualisasi data untuk menunjukkan hubungan antara dua
variabel. Scatter plot digunakan untuk melihat distribusi data dan bagaimana trend-nya.
Kita dapat membuat scatter plot dengan cara explicit dan implicit.
Sebagai contoh, kita akan membuat scatter plot untuk melihat hubungan antara kolom
TempAvgF dan HumidityAvgPercent.

36
 1 # Membuat scatter plot dengan cara implicit
2
3 plt.scatter(df['TempAvgF'], df['HumidityAvgPercent'])
4 plt.show()

Kemudian kita akan membuat menggunakan cara explicit seperti di bawah ini.
Kita dapat mengatur ukuran figure, label, serta menambahkan judul.
1 # Membuat scatter plot dengan cara explicit
2
3 fig, ax = plt.subplots()
4 ax.scatter(df['TempAvgF'], df['HumidityAvgPercent'])
5 plt.show()

37
 1 fig, ax = plt.subplots(figsize=(12,8))
2 ax.scatter(df['TempAvgF'],
3 df['HumidityAvgPercent'])
4 ax.set_title('Cuaca Austin', size=18)
5 ax.set_xlabel('Rata-rata Temperatur (F)',
6 size=14)ax.set_ylabel('Rata-rata Kelembapan %',
7 size=14)
plt.show()

Mengatur warna berdasarkan kategori

Dengan menggunakan scatter plot, kita dapat mengatur warna yang berbeda untuk
membedakan tiap kelompok data.
Sebagai contoh, kita ingin melihat hubungan antara kolom TempAvgF,
HumidityAvgPercent dan Events. Kita dapat meletakkan TempAvgF di sumbu X,
HumidityAvgPercent di sumbu Y, dan Events sebagai warnanya.
Kita akan mengecek terlebih dahulu nilai unik dari kolom Events seperti di bawah ini.

1 df['Events'].unique()

38
array(['Rain , Thunderstorm', ' ', 'Rain', 'Fog', 'Rain , Snow', 'Fog , Rain', 'Thunderstorm', 'Fog , Rain ,
Thunderstorm','Fog , Thunderstorm'], dtype=object)

Terdapat 9 kategori di kolom Events dimana salah satunya berupa string kosong. Kita
dapat mengganti string kosong tersebut menjadi None agar lebih mudah dipahami.

1 df['Events'] = df['Events'].replace(' ', 'None')

2 df['Events'].unique()

array(['Rain , Thunderstorm', 'None', 'Rain', 'Fog', 'Rain , Snow', 'Fog , Rain', 'Thunderstorm',
'Fog , Rain, Thunderstorm', 'Fog , Thunderstorm'], dtype=object)

Kemudian kita dapat menentukan warna yang akan merepresentasikan setiap kategori
tersebut dengan mendefinisikannya di dalam dictionary. Misalnya kita akan membuat
dictionary dengan nama colors.
1 colors = {'Rain , Thunderstorm':'red',
2 'None':'magenta',
3 'Fog':'grey',
4 'Rain':'yellow',
5 'Thunderstorm':'navy',
6 'Rain , Snow':'purple',
7 'Fog , Rain':'orange',
8 'Fog , Thunderstorm':'lime',
9 'Fog , Rain , Thunderstorm':'green'}

Saatnya kita membuat scatter plot dan menambahkan parameter c yang berisi nilai
berupa df['Event'].map(colors) untuk mapping warna berdasarkan kategori.

1 # Mengatur warna scatter plot berdasarkan kategori

2
3 fig, ax = plt.subplots(figsize=(14,9))
4 x = ax.scatter(df['TempAvgF'], df['HumidityAvgPercent'],
5 c=df['Events'].map(colors))
6
7 ax.set_title('Cuaca Austin', size=18)
8 ax.set_xlabel('Rata-rata Temperatur (F)', size=14)
9 ax.set_ylabel('Rata-rata Kelembapan %', size=14)
10
11 plt.show()

39
Menambahkan Legend
Kita dapat menambahkan legend dengan Matplotlib seperti di bawah ini.

1 # Mengatur warna scatter plot berdasarkan kategori

2 fig, ax = plt.subplots(figsize=(14,9))
3
4 # Mengelompokkan berdasarkan kolom Events
5 group = df.groupby('Events')
6
7 for name, category in group:
8 category.plot(ax=ax, kind='scatter', x='TempAvgF', y='HumidityAvgPercent',
9 c=colors[name], label=name)
10
11 ax.set_title('Cuaca Austin', size=18)
12 ax.set_xlabel('Rata-rata Temperatur (F)', size=14)
13 ax.set_ylabel('Rata-rata Kelembapan %', size=14)
14 plt.legend(fontsize=12) # Mengatur ukuran legend
15
16 plt.show()

40
Mengatur warna berdasarkan nilai kontinu
Selanjutnya, kita juga dapat mengatur warna berdasarkan kolom yang berisi nilai kontinu.
Sebagai contoh, kita akan membuat scatter plot dan mengatur kolom DewPointAvgF
sebagai warnanya.

Colormap
Kita dapat memberikan warna pada scatter plot berdasarkan kolom yang bernilai kontinu
menggunakan Colormap di Matplotlib dengan menambahkan variabel cmap.

41
Pada contoh kali ini kita akan menggunakan color map jenis viridis.

1 # Mengatur warna scatter plot dengan color map

2
3 fig, ax = plt.subplots(figsize=(12,8))
4 ax.scatter(df['TempAvgF'], df['HumidityAvgPercent'],
5 c=df['DewPointAvgF'],
cmap='viridis')6
7 ax.set_title('Cuaca Austin', size=18)
8 ax.set_xlabel('Rata-rata Temperatur (F)', size=14)
9 ax.set_ylabel('Rata-rata Kelembapan %', size=14)
10
11 plt.show()

Colorbar
Kita dapat menambahkan rentang nilai dari kolom yang di-set sebagai warna dengan
menambahkan method colorbar pada figure.

42
 1 fig, ax = plt.subplots(figsize=(14,8))
2 x = ax.scatter(df['TempAvgF'], df['HumidityAvgPercent'],
3 c=df['DewPointAvgF'], cmap='cool')
4
5 ax.set_title('Cuaca Austin', size=18)
6 ax.set_xlabel('Rata-rata Temperatur (F)', size=14)
7 ax.set_ylabel('Rata-rata Kelembapan %', size=14)
8 fig.colorbar(x) # Menambakan color bar
9
10 plt.show()

Bubble Plot
Bubble plot adalah salah satu variasi dari scatter plot yang menampilkan data tiga
dimensi (x, y, z). Data point pada scatter plot digantikan oleh bubble, dimana ukuran dari
bubble ditentukan oleh variabel ke tiga yaitu 'z' yang disebut sebagai bobotnya. Di
Matplotlib, Anda dapat menambahkan parameter s yang berarti scalar pada plot() atau
scatter().

43
Sebagai contoh, kita dapat memberikan nilai pada parameter s dengan nilai dari kolom
WindAvgMPH yang dikalikan 50.

1 # Membuat bubble plot

2
3 fig, ax = plt.subplots(figsize=(16,8))
4 x = ax.scatter(df['TempAvgF'], df['HumidityAvgPercent'],
5 c=df['DewPointAvgF'], cmap='Paired', s=df['WindAvgMPH']*50)
6
7 ax.set_title('Cuaca Austin', size=18)
8 ax.set_xlabel('Rata-rata Temperatur (F)', size=14)
9 ax.set_ylabel('Rata-rata Kelembapan %', size=14)
10
11 fig.colorbar(x)
12 plt.show()

Selain itu, kita dapat mengatur transparansi bubble dengan menambahkan parameter alpha
seperti contoh di bawah ini.

44
 1 # Membuat bubble plot dengan mengatur transparansi
2
3 fig, ax = plt.subplots(figsize=(16,8))
4 x = ax.scatter(df['TempAvgF'], df['HumidityAvgPercent'],
5 c=df['DewPointAvgF'],
6 cmap='Paired', s=df['WindAvgMPH']*50, alpha=0.6)
7
8 ax.set_title('Cuaca Austin', size=18)
9 ax.set_xlabel('Rata-rata Temperatur (F)', size=14)
10 ax.set_ylabel('Rata-rata Kelembapan %', size=14)
11
12 fig.colorbar(x)
13 plt.show()

45
 Bar Plot
Dataset
Dataset yang digunakan adalah dataset Automobile.

1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4 %matplotlib inline
3
4 plt.style.use('ggplot')
5
6 df = pd.read_csv('/content/Automobile.csv')
7 df.head()

Note: Hasil tangkapan layar

Berdasarkan dataframe df diatas, terdapat beberapa missing values berupa simbol tanda
tanya ?. Oleh karena itu, kita dapat menangani missing values tersebut dengan mengubah
simbol ? menjadi NaN.

1 df = df.replace('?', np.nan)

Selanjutnya, kita akan menangani missing values pada kolom price menggunakan
dropna(). Sementara itu, untuk menangani missing values pada kolom yang lain, kita dapat
mengisi nilai tertentu seperti di bawah ini. Penjelasan tentang missing values yang lebih
detail dapat Anda pelajari di modul data preparation, pada bab missing values.

46
 1 # Menghapus baris yang memiliki mising values pada kolom price
2 df.dropna(subset=['price'], axis=0, inplace=True)
3
4 # Me-reset indeks karena terdapat data yang terhapus
5 df.reset_index(drop=True, inplace=True)
6
7 # Mengganti missing values dengan 'four' untuk kolom num-of-doors
8 df['num-of-doors'].fillna('four', inplace=True)
9
10 # Mengganti missing values dengan nilai mean untuk tiap kolom lainnya
11 mean_norm = df['normalized-losses'].astype('float').mean(axis=0)
12 df['normalized-losses'].replace(np.nan, mean_norm, inplace=True)
13
14 mean_stroke = df['stroke'].astype('float').mean(axis=0)
15 df['stroke'].replace(np.nan, mean_stroke, inplace=True)
16
17 mean_bore = df['bore'].astype('float').mean(axis=0)
18 df['bore'].replace(np.nan, mean_bore, inplace=True)
19
20 mean_horse = df['horsepower'].astype('float').mean(axis=0)
21 df['horsepower'].replace(np.nan, mean_horse, inplace=True)
22
23 mean_peak = df['peak-rpm'].astype('float').mean(axis=0)
24 df['peak-rpm'].replace(np.nan, mean_norm, inplace=True)
25
26 df.head()

Note: Hasil tangkapan layar

47
Kemudian kita mengganti tipe datanya.
1 # Mengganti tipe datanya
2
3 df[['normalized-losses', 'horsepower']] = df[['normalized-losses',
4 'horsepower']].astype('int')
5
6 df[['bore', 'stroke', 'peak-rpm']] = df[['bore', 'stroke',
7 'peak-rpm']].astype('float')
8
9 df[['price']] = df[['price']].astype('float')

Setelah itu, kita dapat mengecek info dataframe df setelah penanganan missing values.

1 # Mengecek info dataframe

2 df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 201 entries, 0 to 200
Data columns (total 26 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 symboling 201 non-null int64
1 normalized-losses 201 non-null int64
2 make 201 non-null object
3 fuel-type 201 non-null object
4 aspiration 201 non-null object
5 num-of-doors 201 non-null object
6 body-style 201 non-null object
7 drive-wheels 201 non-null object
8 engine-location 201 non-null object
9 wheel-base 201 non-null float64
10 length 201 non-null float64
11 width 201 non-null float64
12 height 201 non-null float64
13 curb-weight 201 non-null int64
14 engine-type 201 non-null object
15 num-of-cylinders 201 non-null object
16 engine-size 201 non-null int64
17 fuel-system 201 non-null object
18 bore 201 non-null float64
19 stroke 201 non-null float64
20 compression-ratio 201 non-null float64
21 horsepower 201 non-null int64
22 peak-rpm 201 non-null float64
23 city-mpg 201 non-null int64
24 highway-mpg 201 non-null int64
25 price 201 non-null float64
dtypes: float64(9), int64(7), object(10)
memory usage: 41.0+ KB

48
Visualisasi data dengan Bar Plot
Pada pembahasan kali ini, kita akan menggunakan kolom make untuk melihat total jumlah
mobil dari masing-masing merek yang terdapat pada dataframe tersebut.
Untuk memperoleh jumlah mobil dari masing-masing merek, kita dapat menggunakan
method size() dengan mengelompokkannya berdasarkan kolom make. Setelah itu, kita
masukkan data tersebut menjadi sebuah dataframe baru, misalnya kita beri nama
dataframe tersebut dengan df_total.

1 # Membuat dataframe jumlah total data untuk tiap merek mobil

2
3 group_make = df.groupby('make').size()
4 df_total = pd.DataFrame(group_make).reset_index()
5 df_total = df_total.rename(columns={0: 'total'})
6
7 df_total

make total

0 alfa-romero 3

1 audi 6

2 bmw 8

3 chevrolet 3

4 dodge 9

5 honda 13

6 isuzu 2

7 jaguar 3

8 mazda 17

9 mercedes-benz 8

10 mercury 1

11 mitsubishi 13

12 nissan 18

13 peugot 11

14 plymouth 7

15 porsche 4

16 renault 2

49
 make total

17 saab 6

18 subaru 12

19 toyota 32

20 volkswagen 12

21 volvo 11
Setelah itu, kita akan membuat visualisasinya dengan bar plot seperti di bawah ini.

1 # Visualisasikan dengan bar plot

2
3 plt.figure(figsize=(14,6))
4 plt.bar(df_total['make'], df_total['total'])
5 plt.title('Jumlah Total dari Tiap Merek Mobil\n', size=18)
6 plt.xlabel('\nNama Merek Mobil', size=14)
7 plt.ylabel('Jumlah Total\n', size=14)
8 plt.xticks(size=14, rotation=90)
9 plt.yticks(size=14)
10
11 plt.show()

50
Dalam pembuatan bar plot, kita dapat menggunakan method bar() dari Matplotlib yang
diberi argumen berupa data yang akan dimasukkan ke sumbu x dan sumbu y. Berdasarkan
kode diatas, kita menetapkan df_total['make'] sebagai sumbu x, dan df_total['total'] sebagai
sumbu y.

Mengatur warna
Kita dapat mengatur warna pada bar dengan menambahkan parameter color dan
memberikan nama warna yang diinginkan sebagai nilai dari parameter tersebut. Selain
memberikan nama warna, kita juga dapat menggunakan kode warna hexagonal

1 # Mengatur warna bar

2
3 plt.figure(figsize=(14,6))
4 plt.bar(df_total['make'], df_total['total'], color='red')
5 plt.title('Jumlah Total dari Tiap Merek Mobil\n', size=18)
6 plt.xlabel('\nNama Merek Mobil', size=14)
7 plt.ylabel('Jumlah Total\n', size=14)
8 plt.xticks(size=14, rotation=90)
9 plt.yticks(size=14)
10
11 plt.show()

51
Mengatur width
Kita dapat mengatur width atau lebar dari bar dengan menambahkan parameter width
yang bernilai bilangan float antara 0 sampai 1. Sebagai contoh kita akan mengatur width
sebesar 0.9.

1 # Mengatur width bar

2
3 plt.figure(figsize=(14, 6))
4 plt.bar(df_total['make'], df_total['total'], width=0.7)
5 plt.title('Jumlah Total dari Tiap Merek Mobil\n', size=18)
6 plt.xlabel('\nNama Merek Mobil', size=14)
7 plt.ylabel('Jumlah Total\n', size=14)
8 plt.xticks(size=14, rotation=90)
9 plt.yticks(size=14)
10
11 plt.show()

52
Menambahkan label di ujung bar
Kita dapat menambahkan label di ujung bar dengan menggunakan cara explicit yaitu
dengan membuat figure dan axes. Perhatikan kode di bawah ini.

53
 1 fig, ax = plt.subplots(figsize=(14, 6))
2 plot_data = ax.bar(df_total['make'], df_total['total'], color='red', width=0.8)
3
4 for rect in plot_data:
5 height = rect.get_height()
6 ax.annotate('{}'.format(height),
7 xy=(rect.get_x() + rect.get_width() / 2, height),
8 xytext=(0, 2),
9 textcoords='offset points',
10 ha='center',
11 va='bottom',
12 fontsize=14
13 )
14 plt.title('Jumlah Total dari Tiap Merek Mobil\n', size=18)
15 plt.xlabel('\nNama Merek Mobil', size=14)
16 plt.ylabel('Jumlah Total\n', size=14)
17
18 plt.xticks(size=14, rotation=90)
19 plt.yticks(size=14)
20
21 plt.show()

Berdasarkan kode diatas, kita dapat menggunakan annotate() untuk menambahkan label
di atas masing-masing bar. kita dapat menggunakan annotate() yang diletakkan di dalam
perulangan for.

54
 • get_height() digunakan untuk mendapatkan tinggi dari bar.
• get_x() digunakan untuk mendapatkan kooordinat kiri dari bar.
• get_width() digunakan untuk mendapatkan lebar dari bar.
Parameter dari annotate()

• xy : Titik koordinat x,y atau titik dimana kita akan menuliskan label.
• xytext : Posisi penulisan label, default-nya adalah nilai xy.
• textcoords : Sistem koordinat, ada dua nilai yang dapat diberikan, yaitu offset points
atau offset pixels.
• ha : Horizontal Alignment
• va : Vertical Alignment
• fontsize : Ukuran huruf
Selain parameter yang kita gunakan di atas, terdapat beberapa parameter lain dari
annotate() yang mungkin berguna untuk penggunaan lainnya.

Error bars
Selanjutnya kita juga dapat menambahkan error bars di bar plot. Misalnya kita akan
membuat bar plot nilai rata-rata horsepower untuk masing-masing merek mobil. Namun,
kita juga ingin menambahkan error bar di setiap bar-nya yang berupa nilai standar
deviasinya.
Kemudian kita dapat melakukan pengelompokkan data berdasarkan kolom make yang
menghitung nilai mean dan std-nya. Lalu kita membuat 2 dataframe yaitu df_hp_mean dan
df_hp_std dan rename nama kolomnya untuk merepresentasikan data pada kolom
tersebut.
Setelah itu, kita harus membuat dataframe baru yang terdiri dari 3 kolom, yaitu merek
mobil, nilai mean untuk tiap horsepower, dan nilai std juga untuk tiap horsepower.

1 # Kelompokkan data berdasarkan kolom 'make'

2 horsepower_mean = df.groupby('make')['horsepower'].mean()
3 horsepower_std = df.groupby('make')['horsepower'].std()
4
5 # Membuat dataframe mean dan std dari kolom 'make'
6 df_hp_mean = pd.DataFrame(horsepower_mean).reset_index()
7 df_hp_std = pd.DataFrame(horsepower_std).reset_index()
8
9 # Mengubah nama kolom pada dataframe
10 df_hp_mean = df_hp_mean.rename(columns={'horsepower': 'horsepower-mean'})
11 df_hp_std = df_hp_std.rename(columns={'horsepower': 'horsepower-std'})

55
Selanjutnya kita dapat menggabungkan 2 dataframe baru menggunakan merge() lalu
disimpan ke dalam df_join seperti di bawah ini.

1 df_join = pd.merge(df_hp_mean, df_hp_std, on='make')

2 df_join

make horsepower-mean horsepower-std

0 alfa-romero 125.333333 24.826062

1 audi 114.500000 13.171940

2 bmw 138.875000 36.658414

3 chevrolet 62.666667 12.701706

4 dodge 86.333333 26.495283

5 honda 80.230769 12.742016

6 isuzu 84.000000 8.485281

7 jaguar 204.666667 49.652123

8 mazda 85.529412 20.230292

9 mercedes-benz 146.250000 27.164841

10 mercury 175.000000 NaN

11 mitsubishi 104.076923 29.061606

12 nissan 102.555556 45.945264

13 peugot 99.818182 14.020115

14 plymouth 86.714286 28.963853

15 porsche 191.000000 32.000000

16 renault 103.000000 0.000000

17 saab 126.666667 25.819889

18 subaru 86.250000 13.765074

19 toyota 92.781250 32.966977

20 volkswagen 81.083333 17.788956

21 volvo 128.000000 22.432120

56
Setelah menyiapkan data, saatnya kita membuat bar plot dengan menambahkan error bar.
Untuk menambahkan error bar, kita dapat menambahkan parameter yerr pada bar() seperti
di bawah ini.

1 # Membuat bar plot dengan error bar

2
3 plt.figure(figsize=(14, 6))
4 plt.bar(df_join['make'], df_join['horsepower-mean'], width=0.8,
5 yerr=df_join['horsepower-std'])
6
7 plt.title('Jumlah Total dari Tiap Merek Mobil', size=18)
8 plt.xlabel('\nNama Merek Mobil', size=14)
9 plt.ylabel('Rata-rata Horsepower\n', size=14)
10 plt.xticks(size=14, rotation=90)
11 plt.yticks(size=14)
12 plt.show()

Horizontal bar chart

57
Selain membuat bar chart secara vertikal, kita dapat membuat bar chart secara horizontal
menggunakan function barh(). Perhatikan kode di bawah ini.

1 # Membuat horizontal bar chart

2
3 plt.figure(figsize=(14,10))
4 plt.barh(df_total['make'], df_total['total'], color='steelblue')
5 plt.title('Jumlah Total dari Tiap Merek Mobil', size=18)
6 plt.xlabel('\nJumlah Total', size=14)
7 plt.ylabel('Nama Merek Mobil\n', size=14)
8 plt.xticks(size=14)
9 plt.yticks(size=12)
10 plt.show()

58
Seperti pada vertikal bar chart, kita juga dapat menambahkan label pada horizontal bar
chart dengan menggunakan annotate() seperti di bawah ini.

1 # Menambahkan label pada ujung bar

2
3 plt.figure(figsize=(14,10))
4 plot_data = plt.barh(df_total['make'], df_total['total'],
5 color='steelblue')
6 for index, value in enumerate(df_total['total']):
7 plt.annotate(value, xy=(value+0.1, index), fontsize=12)
8 plt.title('Jumlah Total dari Tiap Merek Mobil', size=18)
9 plt.xlabel('\nJumlah Total', size=14)
10 plt.ylabel('Nama Merek Mobil\n', size=14)
11 plt.xticks(size=14)
12 plt.yticks(size=12)
13 plt.show()

Grouped bar chart

59
Kita juga dapat menampilkan lebih dari satu bar dari beberapa kolom yang dikelompokkan
dengan membuat grouped bar chart. Sebagai contoh, kita akan menampilkan jumlah data
untuk masing-masing data pada kolom body-style yang dikelompokkan berdasarkan data
pada kolom fuel-type.
Pertama, kita harus membuat dataframe baru untuk menampung data yang kita
kelompokkan yaitu data body-style dan fuel-type lalu mengkalkulasi jumlahnya
menggunakan size(). kemudian, kita buat dataframe dari pengelompokkan tersebut.

1 # Membuat dataframe baru dari pengelompokkan kolom body-style dan fuel-type

2
3 body_fuel = df.groupby(['body-style', 'fuel-type']).size()
4 df_baru = pd.DataFrame(body_fuel).reset_index()
5 df_baru = df_baru.rename(columns={0: 'total'})
6 df_baru

body-style fuel-type total

0 convertible gas 6

1 hardtop diesel 1

2 hardtop gas 7

3 hatchback diesel 1

4 hatchback gas 67

5 sedan diesel 15

6 sedan gas 79

7 wagon diesel 3

Selanjutnya kita perlu membuat list yang berisi nilai unik dari kolom body-style yang akan
digunakan sebagai xticklabels nantinya.

1 df_body = list(df_baru['body-style'].unique())
2 df_body
['convertible', 'hardtop', 'hatchback', 'sedan', 'wagon']

Kemudian kita akan melakukan filter pada dataframe df_baru untuk data fuel-type =='gas'
lalu menyimpannya sebagai dataframe gas.

1 df_gas = df_baru[df_baru['fuel-type']=='gas'].sort_values(
2 by='body-style').reset_index(drop=True)
3 df_gas

60
 body-style fuel-type total
0 convertible gas 6

1 hardtop gas 7

2 hatchback gas 67

3 sedan gas 79

4 wagon gas 22

Selanjutnya kita perlu mem-filter dataframe df_baru dengan fuel-type == 'diesel' dengan
cara yang sama.

1 df_diesel = df_baru[df_baru['fuel-type']=='diesel'].sort_values(
2 by='body-style').reset_index(drop=True)
3 df_diesel

body-style fuel-type total

0 hardtop diesel 1

1 hatchback diesel 1

2 sedan diesel 15

3 wagon diesel 3

Setelah kita melihat hasil dari dataframe df_diesel, hanya ada 4 kategori body-style,
sementara yang kita tahu ada 5 kategori. Hal ini akan menjadi masalah karena perbedaan
dimensi. Kita perlu menambahkan data baru pada dataframe df_diesel yang menyatakan
bahwa body-style jenis convertible dengan fuel type diesel berjumlah 0. Perhatikan kode
berikut.
1 data_baru = {'body-style': 'convertible', 'fuel-type': 'diesel', 'total': 0}
2 df_diesel = df_diesel.append(data_baru, ignore_index=True).sort_values(
3 by='body-style').reset_index(drop=True)
4 df_diesel
body-style fuel-type total
0 convertible diesel 0

1 hardtop diesel 1

2 hatchback diesel 1

3 sedan diesel 15

4 wagon diesel 3

Setelah menyiapkan dataframe yang dibutuhkan, kita dapat membuat visualisasi data.

61
Dalam pembuaan grouped bar chart, kita mendefinisikan dua bar plot dalam satu axes
yang kita simpan dalam variabel, contohnya d1 dan d2. Kita juga perlu mendefinisikan
panjang dari sumbu x, dalam hal ini ada berapa label pada sumbu x yang kita simpan pada
variabel x. Selanjutnya kita harus mendefinisikan width-nya. Perhatikan kode berikut.

1 x = np.arange(len(df_body))
2 width = 0.4
3 labels = df_body
4 fig, ax = plt.subplots(figsize=(14, 6))
5 d1 = ax.bar(x - width/2, df_gas['total'], width, label='Gas')
6 d2 = ax.bar(x + width/2, df_diesel['total'], width, label='Diesel')
7 ax.set_title('Total dari Body Style dan Fuel type', size=18)
8 ax.set_ylabel('Total', size=14)
9 ax.set_xticks(x)
10 ax.set_xticklabels(labels, size=14)
11 ax.legend(fontsize=16)
12 plt.show()

Kemudian kita juga dapat menambahkan label di atas tiap bar dengan membuat sebuah
fungsi terpisah dari kode utama untuk menampilkan label. Untuk menggunakan fungsi
tersebut, kita dapat memanggilnya di kode utama.

62
 1 # Membuat fungsi untuk menampilkan label
2 def peaklabel(data):
3 for rect in data:
4 height = rect.get_height()
5 ax.annotate('{}'.format(height),
6 xy=(rect.get_x() + rect.get_width() / 2, height),
7 xytext=(0, 2),
8 textcoords='offset points',
9 ha='center',
10 va='bottom',
11 fontsize=14)

Setelah membuat fungsi untuk menampilkan label, buat kode seperti sebelumnya.
1 # Membuat grouped bar chart dengan label
2
3 x = np.arange(len(df_body))
4 width = 0.4
5 labels = df_body
6 fig, ax = plt.subplots(figsize=(14, 6))
7 d1 = ax.bar(x - width/2, df_gas['total'], width, label='Gas')
8 d2 = ax.bar(x + width/2, df_diesel['total'], width, label='Diesel')
9 ax.set_title('Total dari Body Style dan Fuel type', size=16)
10 ax.set_ylabel('Total', size=14)
11 ax.set_xticks(x)
12 ax.set_xticklabels(labels, size=14)
13 ax.legend(fontsize=16)
14 peaklabel(d1)
15 peaklabel(d2)
16 plt.show()

Stacked bar chart

63
Stacked bar chart adalah grouped bar chart yang ditampilkan secara bersusun ke atas.
Perhatikan kode berikut.

1 x = np.arange(len(df_body))
2 labels = df_body
3 fig, ax = plt.subplots(figsize=(12, 8))
4 d1 = ax.bar(x, df_gas['total'], label='Gas')
5 d2 = ax.bar(x, df_diesel['total'], label='Diesel', bottom=df_gas['total'])
6 ax.set_title('Total dari Body Style dan Fuel type', size=18)
7 ax.set_ylabel('Total', size=14)
8 ax.set_xticks(x)
9 ax.set_xticklabels(labels, size=14)
10 ax.legend(fontsize=16)
11 plt.show()

Seperti pada contoh diatas, ketika meletakkan bar d1 di bawah, kita tidak perlu
menambahkan parameter. Sementara untuk variabel d2, kita harus menambahkan
parameter bottom untuk mendefinisikan data yang berada di bawahnya.

64
 Area Plot
Dataset
Dataset yang digunakan adalah dataset Country Population dari tahun 1960 – 2016 yang
diambil dari website Kaggle.
Seperti sebelumnya kita import dulu library yang dibutuhkan seperti Pandas, Numpy, dan
Matplotlib. Kemudian kita load dataset tersebut.

1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4
5 plt.style.use('fivethirtyeight')
6 %matplotlib inline
7
8 df = pd.read_csv("/content/country_population.csv")
9 df.head()

Untuk memudahkan kita dapat mengatur Country Name menjadi indeks dengan bantuan
set_index().

1 # Set 'Country Name' menjadi indeks

2
3 df.set_index('Country Name', inplace=True)
4 df.head()

65
Pada pembahasan kali ini, kita akan membuat visualisasi data 5 negara dengan populasi
terbanyak dengan mencari tahu negara mana saja yang memiliki populasi terbanyak di
dunia saat ini. Kita akan mengasumsikan 5 negara dengan total populasi terbanyak adalah
China, India, United States, Indonesia, dan Pakistan.
Setelah mendapatkan daftar negara dengan populasi terbanyak, kita masukkan data
tersebut ke dalam list. Setelah itu, kita akan melakukan filter menggunakan loc seperti
kode di bawah ini.

1 # Membuat list negara top 5

2 countries = ['China', 'India', 'United States', 'Indonesia', 'Pakistan']
3
41 ## Memfilter dataframe
Membuat list tahun dan memasukkannya ke dalam variabel baru df_top5
52 df_top5 = df.loc[countries, :]
63 df_top5
years = list(map(str, range(1960, 2016)))
4 print(years)

Kemudian kita akan membuat list tahun dari 1960 - 2015 yang digunakan untuk memfilter
kolom.

66
Selanjutnya, kita akan melakukan filter dataframe df_top5 dengan hanya mengambil
kolom tahun, lalu melakukan transpose pada dataframe tersebut.

1 # Filter dan transpose dataframe df_top5

2
3 df_top5 = df_top5[years].transpose()
4 df_top5.head()

Country China India United States Indonesia Pakistan

Name
1960 667070000.0 449480608.0 180671000.0 87792515.0 44908293.0

1961 660330000.0 458494963.0 183691000.0 90138235.0 45984892.0

1962 665770000.0 467852537.0 186538000.0 92558005.0 47119361.0

1963 682335000.0 477527970.0 189242000.0 95055665.0 48309315.0

1964 698355000.0 487484535.0 191889000.0 97638029.0 49551904.0

Setelah menyiapkan dataframe, kita dapat membuat visualisasi dengan Area Plot.

Visualisasi data dengan Area Plot

Kita dapat membuat area plot menggunakan fungsi stackplot() dengan memberikan
beberapa argument seperti indeks dan kolom, serta parameter label untuk membuat
legend. Perhatikan kode berikut.

67
 1 # Membuat area plot dengan stackplot()
2
3 fig, ax = plt.subplots(figsize=(12, 8))
4 plt.stackplot(df_top5.index,
5 [df_top5['China'], df_top5['India'], df_top5['United States'],
6 df_top5['Indonesia'], df_top5['Pakistan']],
7 labels=['China', 'India', 'United States', 'Indonesia',
8 'Pakistan'])
9
10 plt.title('Top 5 World Population', size=18)
11 plt.xlabel('\nYear', size=14)
12 plt.ylabel('Total Population\n', size=14)
13 plt.xticks(rotation=90)
14 plt.yticks(size=14)
15 plt.legend(fontsize=14, loc='upper left')
16 plt.margins(0,0)
17 plt.show()

Selain itu, kita dapat membuat area plot menggunakan fungsi plot() dengan
menambahkan parameter kind = 'area' sebagai argumennya. Perhatikan kode berikut.

68
 1 # Membuat area plot menggunakan plot()
2
3 df_top5.plot(kind='area', figsize=(14,8))
4 plt.title('Top 5 World Population', size=18)
5 plt.xlabel('\nYear', size=14)
6 plt.ylabel('Total Population\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.legend(fontsize=14)
10 plt.show()

Mengatur warna
Kita dapat mengatur warna menggunakan parameter color seperti visualisasi data lainnya.

1 # Mengatur warna area plot

2
3 colors = ['magenta', 'purple', 'steelblue', 'green', 'lime']
4 df_top5.plot(kind='area', figsize=(14,8), color=colors)
5 plt.title('Top 5 World Population', size=18)
6 plt.xlabel('\nYear', size=14)
7 plt.ylabel('Total Population\n', size=14)
8 plt.xticks(size=14)
9 plt.yticks(size=14)
10 plt.legend(fontsize=14)
11 plt.show()

69
Selain itu, kita juga dapat menggunakan colormap atau cmap. Sebagai contoh, kita akan
menggunakan cmap = 'plasma'. Untuk melihat jenis colormap lainnya, dapat dilihat pada
website Matplotlib.

1 # Mengatur warna dengan cmap

2
3 df_top5.plot(kind='area', figsize=(14,8), cmap='plasma')
4 plt.title('Top 5 World Population', size=18)
5 plt.xlabel('\nYear', size=14)
6 plt.ylabel('Total Population\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.legend(fontsize=14)
10 plt.show()

70
Mengatur transparansi
Untuk mengatur transparansi area plot, kita bisa menambahkan parameter alpha. Sebagai
contoh, kita dapat memberikan nilai alpha = 0.5.

1 # Mengatur transparansi area plot

2
3 df_top5.plot(kind='area', figsize=(14,8), cmap='plasma', alpha=0.5)
4 plt.title('Top 5 World Population', size=18)
5 plt.xlabel('\nYear', size=14)
6 plt.ylabel('Total Population\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.legend(fontsize=14)
10 plt.show()

71
Unstacked Area Plot
Pada pembahasan sebelumnya, kita telah membuat stacked area plot untuk masing-
masing kategori menumpuk dengan data pertama berada di bawah.
Nah, untuk pembahasan kali ini kita akan membuat unstacked area plot dengan
menambahkan parameter stacked = False. Karena nilai default parameter = True akan
menampilkan data berbentuk stacked area plot atau data pertama berada di bawah.

1 # Membuat unstacked area plot

2
3 df_top5.plot(kind='area', figsize=(14,8), cmap='plasma',
4 alpha=0.5, stacked=False)
5
6 plt.title('Top 5 World Population', size=18)
7 plt.xlabel('\nYear', size=14)
8 plt.ylabel('Total Population\n', size=14)
9 plt.xticks(size=14)
10 plt.yticks(size=14)
11 plt.legend(fontsize=14)
12 plt.show()

72
100% Stacked Area Plot
Kali ini kita akan menampilkan area plot secara full area dengan membuat 100% stacked
area plot.
Dalam pembuatannya, kita perlu membagi dataframe terlebih dahulu. Kali ini kita akan
menggunakan method stackplot() untuk membuat area plot. Perhatikan kode berikut.

73
 1 # Membuat 100% stacked area plot
2
3 plt.figure(figsize=(14,8))
4 df_full = df_top5.divide(df_top5.sum(axis=1), axis=0)
5 plt.stackplot(df_full.index,
6 [df_full['China'], df_full['India'],
7 df_full['United States'], df_full['Indonesia'],
8 df_full['Pakistan']],
9
10 labels=['China', 'India', 'United States',
11 'Indonesia', 'Pakistan'],
12
13 alpha=0.8)
14 plt.title('Top 5 World Population', size=18)
15 plt.xlabel('\nYear', size=14)
16 plt.ylabel('Total Population\n', size=14)
17 plt.xticks(rotation=90)
18 plt.yticks(size=14)
19 plt.legend(fontsize=14)
20 plt.margins(0,0)
21 plt.show()

Selain menggunakan method stackplot(), Kita juga dapat menggunakan method plot()
seperti di bawah ini.

74
1 # Membuat 100% stacked area plot
2
3 df_full_top5 = df_top5.divide(df_top5.sum(axis=1), axis=0)
4 df_full_top5.plot(kind='area', figsize=(14,8), cmap='plasma', alpha=0.5)
5
6 plt.title('Top 5 World Population', size=18)
7 plt.xlabel('\nYear', size=14)
8 plt.ylabel('Total Population\n', size=14)
9 plt.xticks(size=14)
10 plt.yticks(size=14)
11 plt.legend(fontsize=14)
12
13 plt.show()

75
 Pie Chart
Dataset
Dataset yang digunakan adalah dataset refugess atau dataset yang menampilkan data
pengungsi di Amerika Serikat dari berbagai negara dari tahun 2006 hingga 2015.
Pada praktik kali ini, kita membutuhkan Pandas dan Matplotlib.

14 import pandas as pd
15 import numpy as np
16 import matplotlib.pyplot as plt
17 a
18 plt.style.use('fivethirtyeight')
19 df = pd.read_csv("/content/refugees.csv")
20 df

Selanjutnya, kita akan mengatur kolom Continent/Country of Nationality sebagai indeks

dengan set_index().

1 # Set 'Continent/Country of Nationality' sebagai indeks

2 df.set_index('Continent/Country of Nationality', inplace=True)

76
Pada praktik kali ini, kita akan menggunakan data pengungsi berdasarkan benua saja. Oleh
karena itu, kita akan melakukan filter dataframe df dengan mengambil 6 data teratas yang
merupakan data benua lalu menyimpannya ke dalam dataframe df_benua.

1 # Mengambil 6 baris teratas yang merupakan data benua

2 df_benua = df.head(6)
3 df_benua

Berdasarkan kode di atas, benua Oceania memiliki data yang memiliki nilai paling kecil dari
benua lainnya, ada baiknya kita perlu menghapus baris tersebut supaya memudahkan kita
untuk melihat perbandingan data di tiap benua.

1 # Menghapus baris 'Oceania'

2 df_benua = df_benua.drop(['Oceania'], axis=0)
3 df_benua

Kemudian cek informasi dataframe df_benua dengan info().

1 df_benua.info()

<class 'pandas.core.frame.DataFrame'>
Index: 5 entries, Africa to South America
Data columns (total 10 columns):
# Column Non-Null Count Dtype

77
--- ------ -------------- -----
0 2006 5 non-null object
1 2007 5 non-null object
2 2008 5 non-null object
3 2009 5 non-null object
4 2010 5 non-null object
5 2011 5 non-null object
6 2012 5 non-null object
7 2013 5 non-null object
8 2014 5 non-null object
9 2015 5 non-null object
dtypes: object(10)
memory usage: 440.0+ bytes

Pada hasil informasi dataframe df_benua diatas, semua kolom bertipe object yang berarti
string. Hal ini akan menjadi masalah ketika melakukan operasi numerik. Dapat kita lihat
pada dataframe tersebut penulisan angkanya dipisahkan oleh koma. Kita harus
menghilangkan tanda koma tersebut sebelum konversi tipe data dengan astype().

1 # Mengganti tanda koma dengan blank

2 for i in df_benua.columns:
3 df_benua[i] = df_benua[i].apply(str).str.replace(',', '').astype('int')

Perhatikan kode berikut.

Kita cek hasilnya.

1 df_benua

Selanjutnya kita cek menggunakan dtypes.

1 df_benua.dtypes

2006 int64

78
2007 int64
2008 int64
2009 int64
2010 int64
2011 int64
2012 int64
2013 int64
2014 int64
2015 int64
dtype: object

Setelah itu, kita dapat melakukan operasi numerik pada dataframe df_benua. Disini kita
akan membuat kolom baru, yaitu kolom Total untuk menampung jumlah total pengungsi
dari tahun 2006 sampai 2015.

1 df_benua['Total'] = df_benua.sum(axis=1)
2 df_benua

Visualisasi data dengan Pie Chart

Setelah menyiapkan data, kita akan membuat visualisasi data dengan pie chart
menggunakan plot() serta memberikan parameter kind = 'pie'. Perhatikan kode berikut.

79
 1 # Membuat visualisasi menggunakan pie chart
2
3 df_benua['Total'].plot(kind='pie',figsize=(6, 8),
4 autopct='%1.1f%%', # menambahkan persentase
5 startangle=90, # start angle 90 derajat
6 shadow=True # menambahkan shadow
7 )
8
9 plt.title('Data Pengungsi United States tahun 2006 - 2015')
10 plt.axis('equal') # mengatur rasio axis agar sama antara axis x dan y
11
12 plt.show()

Berdasarkan kode di atas, kita dapat menggunakan parameter selain parameter kind dan
figsize, parameter tersebut diantaranya:

• autopct untuk menambahkan angka persentase.

• startangle untuk mengatur sudut awal chart.
• shadow untuk memberikan kesan bayangan.

80
Menghapus label dan menggantinya dengan legend
Pada pembahasan kali ini kita akan mencoba menghapus label kategori atau nama benua
lalu memindahkannya ke dalam legend. Kita dapat menghapus label tersebut dengan
memberikan parameter labels = None di dalam method plot(). Kemudian kita simpan label
tersebut ke dalam legend. Kita juga dapat mengatur posisi legend dengan parameter loc
dan mengatur ukuran huruf menggunakan fontsize.
Perhatikan kode berikut.

1 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
2 autopct='%1.1f%%',
3 startangle=90,
4 shadow=True
5 labels=None
6 )
7 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18, y=1.12)
8 plt.axis('equal')
9
10 # menambahkan legend
11 plt.legend(labels=df_benua.index, loc='upper right', fontsize=14)
12 plt.show()

Mengatur posisi angka persentase

Selain menghapus label, kita dapat mengatur posisi angka presentase berada di luar pie
chart yang awalnya berada di dalam pie chart. Hal tersebut dapat dilakukan dengan
menambahkan parameter pctdistance yang memiliki nilai numerik berupa bilangan float.
Perhatikan kode berikut.

81
 1 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
2 autopct='%1.1f%%',
3 startangle=90,
4 shadow=True,
5 labels=None,
6 pctdistance=1.12
7 )
8
9 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18, y=1.12)
10 plt.axis('equal')
11
12 # menambahkan legend
13 plt.legend(labels=df_benua.index, loc='upper right', fontsize=14)
14 plt.show()

Mengatur warna

82
Seperti pada pembahasan pembuatan visualisasi sebelumnya, kita dapat mengatur warna
pada pie chart menggunakan parameter colors yang diberikan nilai berupa list nama atau
kode warna sesuai banyaknya data yang akan ditampilkan pada pie chart.

1 list_warna = ['indigo', 'purple', 'gold', 'darkgreen', 'crimson']

2 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
3 autopct='%1.1f%%',
4 startangle=90,
5 shadow=True
6 labels=None
7 pctdistance=1.12,
8 colors=list_warna # mengatur warna
9 )
10
11 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18, y=1.12)
12 plt.axis('equal')
13
14 # menambahkan legend
15 plt.legend(labels=df_benua.index, loc='upper right', fontsize=14)
16 plt.show()

83
Selain itu, kita juga dapat menggunakan colormap dengan memberikan parameter cmap
yang diberi nilai jenis colormap-nya. Contohnya kita memberikan parameter cmap =

1 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
2 autopct='%1.1f%%',
3 startangle=90,
4 shadow=True
5 labels=None
6 pctdistance=1.12,
7 cmap='coolwarm' # mengatur warna dengan colormap
8 )
9
10 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18, y=1.12)
11 plt.axis('equal')
12
13 # menambahkan legend
14 plt.legend(labels=df_benua.index, loc='upper right', fontsize=14)
15 plt.show()

'coolwarm'.

Menekankan irisan chart

Kita dapat menekankan atau menonjolkan irisan tertentu menggunakan parameter
explode yang diberikan nilai berupa list rasionya dalam bentuk bilangan float.
Pada contoh kali ini, kita akan menekankan 3 benua dengan angka persentase terkecil.
Kita harus membuat list berupa bilangan float dari banyaknya data yang akan ditampilkan.
Jika memberikan angka 0 berarti kita tidak menonjolkannya, sedangkan jika memberikan

84
nilai 0.1 dan seterusnya berarti irisan akan menonjol ke luar sesuai nilai rasio tersebut.
Perhatikan kode berikut.

1 list_warna = ['indigo', 'purple', 'gold', 'darkgreen', 'crimson']

2 explode_list = [0, 0, 0.1, 0.1, 0.1] # rasio untuk tiap benua
3
4 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
5 autopct='%1.1f%%',
6 startangle=90,
7 shadow=True,
8 labels=None,
9 pctdistance=1.12,
10 colors=list_warna,
11 explode=explode_list # menekankan irisan
12 )
13 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18, y=1.12)
14 plt.axis('equal')
15
16 # menambahkan legend
17 plt.legend(labels=df_benua.index, loc='upper right', fontsize=14)
18 plt.show()

Berdasarkan hasil visualisasi diatas, terdapat 3 irisan yang merupakan 3 benua dengan
persentase terkecil terlihat lebih menonjol ke luar lingkaran.

85
Selain itu, kita juga dapat menggeser seluruh bagian irisa dengan memberikan nilai selain
0 pada variabel explode_list.

1 list_warna = ['indigo', 'purple', 'gold', 'darkgreen', 'crimson']

2 explode_list = [0.1, 0.1, 0.2, 0.2, 0.2]
3
4 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
5 autopct='%1.1f%%',
6 startangle=90,
7 7shadow=True,
8 labels=None,
9 pctdistance=1.12,
10 colors=list_warna,
11 explode=explode_list # menekankan irisan
12 )
13 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18, y=1.12)
14 plt.axis('equal')
15
16 # menambahkan legend
17 plt.legend(labels=df_benua.index, loc='upper right', fontsize=14)
18 plt.show()

Donut Chart
Selanjutnya kita akan membuat donut chart yang memiliki lubang di tengah. Sebenarnya
dalam pembuatan donut chart tidak berbeda jauh dari pie chart. Kita juga masih
menggunakan parameter kind = 'pie'. Namun, yang membedakan adalah kita harus

86
membuat lubang di tengah pie tersebut menggunakan method Cirlce() dan menyimpannya
ke dalam sebuah variabel.
Kemudian, kita juga harus mendapatkan figure yang sedang aktif dengan method gcf()
serta axes yang sedang aktif dengan gca() lalu menambahkan variabel centre_cirlce ke
dalam axes tersebut dengan method add_artist().

1 # Visualisasi menggunakan donut chart

2 list_warna = ['indigo', 'purple', 'gold', 'darkgreen', 'crimson']
3
4 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
5 autopct='%1.1f%%',
6 startangle=90,
7 shadow=True,
8 labels=None,
9 pctdistance=1.12,
10 colors=list_warna,
11 )
12
13 #draw circle
14 centre_circle = plt.Circle((0,0), 0.7, fc='white')
15 fig = plt.gcf()
16 fig.gca().add_artist(centre_circle)

17 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18,

y=1.12)
18 plt.axis('equal')
19
20 # menambahkan legend
21 plt.legend(labels=df_benua.index, loc='upper right',
fontsize=14)
22 plt.show()

87
Selain itu, kita juga dapat mengatur radius lingkarannya dengan mengganti nilai radius-nya
menjadi 0.5 yang sebelumnya bernilai 0,7.

1 # Visualisasi menggunakan donut chart

2 list_warna = ['indigo', 'purple', 'gold', 'darkgreen', 'crimson']
3
4 df_benua['Total'].plot(kind='pie',figsize=(12, 6),
5 autopct='%1.1f%%',
6 startangle=90,
7 shadow=True,
8 labels=None,
9 pctdistance=1.12,
10 colors=list_warna,
11 )
12
13 # mengatur radius lingkarannya
14 centre_circle = plt.Circle((0,0), 0.5, fc='white')
15 fig = plt.gcf()
16 fig.gca().add_artist(centre_circle)

17 plt.title('Data Pengungsi United States tahun 2006 - 2015', size=18,

y=1.12)
18 plt.axis('equal')
19
20 # menambahkan legend
21 plt.legend(labels=df_benua.index, loc='upper right',
fontsize=14)
22 plt.show()

88
 Histogram
Dataset
Dataset yang digunakan adalah dataset diabetes, yang berisi kumpulan data yang terkena
penyakit diabetes. Dataset diambil dari website Kaggle.
Kita dapat melihat dataset tersebut seperti kode di bawah ini.
1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4 import scipy.stats
5
6 %matplotlib inline
7 plt.style.use('fivethirtyeight')
8
9 df = pd.read_csv("/content/diabetes.csv")
10 df.head(10)

Visualisasi data dengan Histogram

Histogram adalah jenis visualisasi data untuk menunjukkan distribusi frekuensi dari
dataset numerik. Sumbu X adalah bin dari data point, sedangkan sumbu Y adalah frekuensi
atau banyaknya data point pada setiap bin. Kita dapat mengatur ukuran bin agar
distribusinya mudah untuk dianalisa. Namun nilai default akan membagi menjadi 10 bin.

89
Mendapatkan rentang bin dan frekuensinya dengan Numpy
Sebelumnya, kita dapat mengecek rentang bin dan masing-masing frekuensinya
menggunakan method dari Numpy yaitu histogram(). Sebagai contoh, kita akan melihat
distribusi frekuensi dari kolom Age.

1 # Mendapatkan rentang bin dan frekuensinya

2
3 count, bin_edges = np.histogram(df['Age'])
4
5 print(count) # menampilkan jumlah frekuensi tiap bin
6 print(bin_edges) # rentang bin, default = 10
[300 157 92 86 52 34 26 16 4 1]
[21. 27. 33. 39. 45. 51. 57. 63. 69. 75. 81.]
Berdasarkan kode diatas, np.histogram akan mengembalikan dua nilai, oleh karena itu kita
harus mendefinisikan dua variabel untuk menyimpan hasilnya, misalnya variabel count dan
bin_edges. Kemudian kita dapat melihat hasil rentang bin dan frekuensinya.
Lebih lanjut, jika kita tidak mendefinisikan jumlah bin, parameter bins akan terisi oleh nilai
default yaitu 10 bin. Namun, kita dapat mengatur parameter bins dan memberikan nilai
berupa integer sesuai dengan kebutuhan seperti di bawah ini.

1 # Mendapatkan rentang bin dan frekuensinya dengan mendefinisikan jumlah bin

2
3 count, bin_edges = np.histogram(df['Age'], bins=15)
4
5 print(count) # menampilkan jumlah frekuensi tiap bin
6 print(bin_edges) # rentang bin

[219 148 90 57 60 61 39 29 18 20 11 11 4 0 1]
[21. 25. 29. 33. 37. 41. 45. 49. 53. 57. 61. 65. 69. 73. 77. 81.]

Kita dapat mengatur parameter bins = 15 sehingga Python akan membaginya menjadi 15
bin.
Plotting Histogram dengan Matplotlib
Kita dapat melakukan plotting histogtam menggunakan du acara, yaitu dengan method
hist() dari Matplotlib atau method plot() dari Pandas dengan mendefinisikan kind = 'hist'.
Pertama kita akan mencoba untuk membuat Histogram dengan method hist().
Perhatikan kode di bawah ini.

90
 1 # Membuat histogram dengan hist()
2
3 plt.figure(figsize=(8,6))
4 plt.hist(df['Age']) # Membuat histogram
5 plt.title("Histogram of Indians Diabetes Patients Ages\n", size=16)
6 plt.ylabel('Number of Patients\n', size=14)
7 plt.xlabel('\nAges', size=14)
8 plt.show()

Selanjutnya kita akan menggunakan method plot() seperti di bawah ini.

1 # Membuat histogram dengan plot()

2
3 df['Age'].plot(kind='hist', figsize=(8, 6))
4 plt.title("Histogram of Indians Diabetes Patients Ages\n",
size=16)5 plt.ylabel('Number of Patients\n', size=14)
6 plt.xlabel('\nAges', size=14)
7 plt.show()

91
Mengatur jumlah bin
Kita dapat mengatur jumlah bin sesuai dengan kebutuhan analisa kita sendiri
menggunakan parameter bins. Sebagai contoh, kita akan menvisualisasikan histogram
dari kolom Age dengan 16 bin.
1 # Membuat histogram dengan hist() dan mengatur jumlah bin
2
3 plt.figure(figsize=(8,6))
4 plt.hist(df['Age'], bins=16) # Membuat histogram
5 plt.title("Histogram of Indians Diabetes Patients Ages\n", size=16)
6 plt.ylabel('Number of Patients\n', size=14)
7 plt.xlabel('\nAges', size=14)
8 plt.show()

92
Selanjutnya kita akan menggunakan method plot() seperti di bawah ini.

1 # Membuat histogram dengan 16 bin

2
3 df['Age'].plot(kind='hist', figsize=(8, 6), bins=16)

93
Mengatur xticks
Kita dapat mengatur label xticks tersebut dengan parameter xticks. Hal ini digunakan
untuk menempatkan label xticks pada batasan tiap bin. Pada contoh di bawah ini, kita
mengatur nilai xticks = bin_edges.

1 # Mengatur label xticks

2
3 count, bin_edges = np.histogram(df['Age'])
4 df['Age'].plot(kind='hist', figsize=(8, 6), xticks=bin_edges)
5 plt.title("Histogram of Indians Diabetes Patients Ages\n", size=16)
6 plt.ylabel('Number of Patients\n', size=14)
7 plt.xlabel('\nAges', size=14)
8 plt.show()

94
Apabila ingin mengisi nilai pada parameter bins, pada np.histogram() harus didefinisikan
dahulu bins-nya. Begitu pun saat visualisasi data dengan plot() atau hist() jumlah bin-nya.
Perhatikan kode di bawah ini.

1 # Mengatur bin dan label xticks

2
3 count, bin_edges = np.histogram(df['Age'], bins=16)
4 df['Age'].plot(kind='hist', figsize=(10, 7), bins=16, xticks=bin_edges)
5 plt.title("Histogram of Indians Diabetes Patients Ages\n", size=16)
6 plt.ylabel('Number of Patients\n', size=14)
7 plt.xlabel('\nAges', size=14)
8 plt.show()

95
Menambahkan 'best fit' line
Selain itu, kita dapat menambahkan 'best fit' line dengan bantuan library spipy.stats untuk
menampilkan distribusi data. Perhatikan kode berikut.

1 # Menambahkan 'best fit' line pada histogram

2
3 plt.figure(figsize=(10,7))
4 n, bins, pathes = plt.hist(df['Age'], 20, density=True)
5 mu, sigma = scipy.stats.norm.fit(df['Age'])
6 best_fit_line = scipy.stats.norm.pdf(bins, mu, sigma)
7 plt.plot(bins, best_fit_line)
8 plt.show()

96
Berdasarkan contoh di atas, scipy.stats.norm.fit() digunakan untuk fitting distribusi normal
ke histogram. Sementara itu, scipy.stats.norm.pdf() digunakan untuk menghitung
probability density function-nya. Setelah itu, kita plotkan sebagai line plot.
Kemudian, kita juga dapat mengubah warna dan jenis garisnya.

1 # Mengubah warna dan jenis garis distribusi normal

2
3 plt.figure(figsize=(10,7))
4 n, bins, pathes = plt.hist(df['Age'], 20, density=True, alpha=0.5)
5 mu, sigma = scipy.stats.norm.fit(df['Age'])
6 best_fit_line = scipy.stats.norm.pdf(bins, mu, sigma)
7 plt.plot(bins, best_fit_line, '--', color='gold')
8 plt.show()

97
Multiple Histogram dalam satu plot
Selain membuat satu histogram, kita dapat membuat lebih dari satu histogram ke dalam
satu plot yang sama. Caranya adalah menuliskan nama-nama kolomnya seperti di bawah

1 # Membuat multiple histogram dalam satu plot

2
3 count, bin_edges = np.histogram(df[['BloodPressure', 'BMI']])
4 df[['BloodPressure', 'BMI']].plot(kind='hist', figsize=(10, 7),
5 xticks=bin_edges)
6
7 plt.title("Histogram of Indians Diabetes Patients BloodPressure & BMI\n")
8 plt.ylabel('Number of Patients\n')
9 plt.xlabel('\nBloodPressure & BMI')
10 plt.legend(['BloodPressure : Blood Pressure', 'BMI : Body Mass Index'],
11 fontsize=14)
12
13 plt.show()

ini.

98
Setelah kita amati, dua histogram tersebut saling tumpang tindih. Permasalahan tersebut
dapat kita atasi dengan mengatur transparansinya untuk melihat batas dari masing-
masing histogram.
Mengatur transparansi dan warna
Kita dapat mengatur transparansi menggunakan parameter alpha. Selain itu, kita dapat
mengatur warna sesuai kebutuhan menggunakan parameter color. Perhatikan kode
1 # Mengatur transparansi dan warna
2
3 count, bin_edges = np.histogram(df[['BloodPressure', 'BMI']])
4 df[['BloodPressure', 'BMI']].plot(kind='hist', figsize=(10, 7),
5 xticks=bin_edges, alpha=0.6,
6 color=['gold', 'yellowgreen'])
7
8 plt.title("Histogram of Indian Diabetes Patients' BloodPressure & BMI")
9 plt.ylabel('Number of Patients')
10 plt.xlabel('BloodPressure & BMI')
11 plt.legend(['BloodPressure: Blood Pressure', 'BMI : Body Mass Index'],
12 fontsize=14)
13
14 plt.show()
berikut.
15

99
Menyesuaikan min dan max label x-axis
Kita dapat menyesuaikan jarak dari nilai minimum histogram atau nilai bin terkecil dan
jarak nilai maksimum histogram atau nilai bin terbesar dengan menyesuaikan min dan
max label x-axis.
Setelah mendefinisikan jarak, kita simpan ke dalam variabel xmin dan xmax. kemudian,
kita perlu menambahkan parameter xlim untuk mengaplikasikan jarak yang sudah diatur
tersebut. Perhatikan kode berikut.

100
 1 # Menyesuaikan min dan max label xticks
2
3 count, bin_edges = np.histogram(df[['BloodPressure', 'BMI']])
4
5 #mengatur ruas kosong antara ujung figure kiri dan bin terkecil
6 xmin = bin_edges[0] - 0.2
7
8 #mengatur ruas kosong antara ujung figure kanan dan bin terbesar
9 xmax = bin_edges[-1] + 0.2
10 df[['BloodPressure', 'BMI']].plot(kind='hist',
11 figsize=(10, 7),
12 xticks=bin_edges,
13 alpha=0.6,
14 color=['gold', 'yellowgreen'],
15 xlim=(xmin, xmax))# menambahkan parameter xlim
16
17 plt.title("Histogram of Indian Diabetes Patients' BloodPressure & BMI")
18 plt.ylabel('Number of Patients')
19 plt.xlabel('BloodPressure & BMI')
20 plt.legend(['BloodPressure : Blood Pressure', 'BMI : Body Mass Index'],
21 fontsize=14)
22 plt.show()

Sekarang kita telah menghilangkan ruas kosong antara ujung figure dengan bin terkecil
dan terbesarnya.

101
Stacked histogram
Selain membuat transparansi antara 2 histogram, kita dapat membuat histogram yang
bersusun atau stacked histogram dengan menambahkan parameter stacked = True.
Perhatikan kode berikut.

1 # Membuat stacked histogram

2 count, bin_edges = np.histogram(df[['BloodPressure', 'BMI']])
3
4 #mengatur ruas kosong antara ujung figure kiri dan bin terkecil
5 xmin = bin_edges[0] - 0.2
6
7 #mengatur ruas kosong antara ujung figure kanan dan bin terbesar
8 xmax = bin_edges[-1] + 0.2
9 df[['BloodPressure', 'BMI']].plot(kind='hist',
10 figsize=(10, 7),
11 xticks=bin_edges,
12 color=['gold', 'yellowgreen'],
13 xlim=(xmin, xmax),
14 stacked=True)
15
16 plt.title("Histogram of Indian Diabetes Patients' BloodPressure & BMI")
17 plt.ylabel('Number of Patients')
18 plt.xlabel('BloodPressure & BMI')
19 plt.legend(['BloodPressure : Blood Pressure', 'BMI : Body Mass Index'],
20 fontsize=14)
21 plt.show()

102
Subplots
Selanjutnya kita akan mempraktikkan cara membuat subplots. Pada pembahasan kali ini
kita akan membuat subplots yang terdiri dari beberapa histogram dari berbagai kolom di
dataframe df. Perhatikan kode berikut.

1 # Membuat subplot
2 fig, ax = plt.subplots(ncols=2, nrows=4, figsize=(18, 17))
3
4 # Menambahkan subplot dengan indexing
5 ax0 = fig.add_subplot(ax[0,0])
6 ax1 = fig.add_subplot(ax[0,1])
7 ax2 = fig.add_subplot(ax[1,0])
8 ax3 = fig.add_subplot(ax[1,1])
9 ax4 = fig.add_subplot(ax[2,0])
10 ax5 = fig.add_subplot(ax[2,1])
11 ax6 = fig.add_subplot(ax[3,0])
12 ax7 = fig.add_subplot(ax[3,1])
13
14 # Subplot ax[0,0]: Pregnancies
15 df['Pregnancies'].plot(kind='hist', ax=ax0)
16 ax0.set_title("Histogram of Indian Diabetes Patients' Pregnancies")

103
17 ax0.set_ylabel('Number of Patients')
18 ax0.set_xlabel('Pregnancies')
19
20 # Subplot ax[0,1]: Glucose
21 df['Glucose'].plot(kind='hist', ax=ax1)
22 ax1.set_title("Histogram of Indian Diabetes Patients' Glucose")
23 ax1.set_ylabel('Number of Patients')
24 ax1.set_xlabel('Glucose')
25
26 # Subplot ax[1,0]: SkinThickness
27 df['SkinThickness'].plot(kind='hist', ax=ax2)
28 ax2.set_title("Histogram of Indian Diabetes Patients' SkinThickness")
29 ax2.set_ylabel('Number of Patients')
30 ax2.set_xlabel('SkinThickness')
31
32 # Subplot ax[1,1]: BloodPressure
33 df['BloodPressure'].plot(kind='hist', ax=ax3)
34 ax3.set_title("Histogram of Indian Diabetes Patients' BloodPressure")
35 ax3.set_ylabel('Number of Patients')
36 ax3.set_xlabel('Blood Pressure')
37
38 # Subplot ax[2,0]: Insulin
39 df['Insulin'].plot(kind='hist', ax=ax4)
40 ax4.set_title("Histogram of Indian Diabetes Patients' Insulin")
41 ax4.set_ylabel('Number of Patients')
42 ax4.set_xlabel('Insulin')
43
44 # Subplot ax[2,1]: BMI
45 df['BMI'].plot(kind='hist', ax=ax5)
46 ax5.set_title("Histogram of Indian Liver Patients' BMI (Body Mass Index)")
47 ax5.set_ylabel('Number of Patients')
48 ax5.set_xlabel('Body Mass Index (BMI)')
49
50 # Subplot ax[3,0]: DiabetesPedigreeFunction
51 df['DiabetesPedigreeFunction'].plot(kind='hist', ax=ax6)
52 ax6.set_title("Histogram of Indian Liver Patients' DiabetesPedigreeFunction ")
53 ax6.set_ylabel('Number of Patients')
54 ax6.set_xlabel('DiabetesPedigreeFunction')
55
56 # Subplot ax[3,1]: Age
57 df['Age'].plot(kind='hist', ax=ax7)
58 ax7.set_title("Histogram of Indian Liver Patients' Age")
59 ax7.set_ylabel('Number of Patients')
60 ax7.set_xlabel('Age')

104
 61
62 plt.subplots_adjust(wspace=0.4, hspace=0.6)
63 plt.show()

Note : Hasil tangkapan layar

Kita dapat membuat subplots dengan plt.subplots() yang diberikan argumen berupa:

• ncols : jumlah kolom yang diinginkan.

• nrows : jumlah baris yang diinginkan.
• figsize : ukuran figure.
Kemudian, kita tambahkan subplots pada figure tersebut dengan fig.add_subplot() yang
diberikan argumen berupa posisi tiap axes.
Berdasarkan pada hasil visualisasi di atas, kita telah membuat subplots yang terdiri dari 8
plot dengan 4 baris dan 2 kolom. Selanjutnya, kita buat plotnya pada masing-masing
subplot. Kemudian kita dapat mengatur jarak antar subplot dengan method
subplots_adjust() dan menambahkan parameter wspace untuk mengatur lebar kanan-kiri,
serta hspace untuk mengatur tinggi atas-bawah.

105
 Heatmap
Dataset
Dataset yang digunakan adalah dataset Automobile yang berasal dari website Kaggle.
1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4 import seaborn as sns
5 %matplotlib inline
6
7 df = pd.read_csv('/content/Automobile.csv')
8 df.head()

Note : Hasil tangkapan layar, data terlalu banyak

Berdasarkan dataframe df diatas, terdapat beberapa missing values berupa simbol tanda
tanya ?. Oleh karena itu, kita dapat menangani missing values tersebut dengan mengubah
simbol ? menjadi NaN.

1 # mengganti nilai missing values '?' dengan NaN

2 df = df.replace('?', np.nan)
3 df.head()

106
Note : Hasil tangkapan layar, data terlalu banyak

Selanjutnya, kita akan menangani missing values pada kolom price menggunakan
dropna(). Sementara itu, untuk menangani missing values pada kolom yang lain, kita dapat
mengisi nilai tertentu seperti di bawah ini. Penjelasan tentang missing values yang lebih
detail dapat Anda pelajari di modul data preparation, pada bab missing values.

1 # Menghilangkan baris yang mengandung mising values di kolom price

2 df.dropna(subset=['price'], axis=0, inplace=True)
3
4 # Me-reset indeks karena ada data yang terhapus
5 df.reset_index(drop=True, inplace=True)
6
7 # Mengganti nilai missing values dengan 'four' pada kolom num-of-doors
8 df['num-of-doors'].fillna('four', inplace=True)
9
10 # Mengganti nilai missing values dengan nilai mean untuk tiap kolom lainnya
11 rata_norm = df['normalized-losses'].astype('float').mean(axis=0)
12 df['normalized-losses'].replace(np.nan, rata_norm, inplace=True)
13 rata_stroke = df['stroke'].astype('float').mean(axis=0)
14 df['stroke'].replace(np.nan, rata_stroke, inplace=True)
15 rata_bore = df['bore'].astype('float').mean(axis=0)
16 df['bore'].replace(np.nan, rata_bore, inplace=True)
17 rata_horse = df['horsepower'].astype('float').mean(axis=0)
18 df['horsepower'].replace(np.nan, rata_horse, inplace=True)
19 rata_peak = df['peak-rpm'].astype('float').mean(axis=0)
20 df['peak-rpm'].replace(np.nan, rata_norm, inplace=True)
21 df.head()

107
Note : Hasil tangkapan layar, data terlalu banyak

Kemudian kita ganti tipe datanya.

1 # Mengganti tipe datanya

2 df[['bore', 'stroke', 'peak-rpm']] = df[['bore', 'stroke',
3 'peak-rpm']].astype('float')
4
5 df[['normalized-losses', 'horsepower']] = df[['normalized-losses',
6 'horsepower']].astype('int')
7
8 df[['price']] = df[['price']].astype('float')

Setelah penanganan missing values, kita cek info dataframe di atas.

1 df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 201 entries, 0 to 200
Data columns (total 26 columns):
# Column Non-Null Count Dtype

0 symboling 201 non-null object

1 normalized-losses 201 non-null int64
2 make 201 non-null object
3 fuel-type 201 non-null object
4 aspiration 201 non-null object
5 num-of-doors 201 non-null object
6 body-style 201 non-null object
7 drive-wheels 201 non-null object
8 engine-location 201 non-null object
9 wheel-base 201 non-null object
10 length 201 non-null object

108
 11 width 201 non-null object
12 height 201 non-null object
13 curb-weight 201 non-null object
14 engine-type 201 non-null object
15 num-of-cylinders 201 non-null object
16 engine-size 201 non-null object
17 fuel-system 201 non-null object
18 bore 201 non-null float64
19 stroke 201 non-null float64
20 compression-ratio 201 non-null object
21 horsepower 201 non-null int64
22 peak-rpm 201 non-null float64
23 city-mpg 201 non-null object
24 highway-mpg 201 non-null object
25 price 201 non-null float64
dtypes: float64(4), int64(2),
object(20)memory usage: 41.0+ KB

Membuat Heatmap dengan Seaborn

Heatmap adalah salah satu jenis visualisasi data yang memetakan kolom-kolom pada
dataframe ke dalam axis X dan Y sebagai kotak-kotak berwarna. Dalam pembuatannya,
Heatmap lebih mudah dibuat menggunakan library Seaborn karena memiliki method
tersendiri, yaitu heatmap() untuk men-generate-nya.
Seaborn sendiri merupakan salah satu library visualisasi data sama seperti Matplotlib.
Perbedaannya terdapat di fungsionalitas. Matplotlib digunakan untuk membuat pola-pola
dasar, sedangkan Seaborn bisa digunakan untuk membuat variasi pola visualisasi.
Hal pertama yang harus dilakukan sebelum membuat heatmap dengan Seaborn, kita harus
menyiapkan dahulu dataframenya. Kali ini kita akan melakukan reshaping terhadap
dataframe df menggunakan pivot_table().
Kita akan menjadikan kolom drive-wheels sebagai indeks, kolom body-style sebagai
kolom, dan kolom price sebagai nilai. Untuk aggregate function menggunakan nilai mean.
Hasil akhir yang akan tampil adalah rata-rata atau mean dari harganya.

1 # Melakukan reshaping dataframe menggunakan function pivot_table()

2 df_pivot = df.pivot_table(index='drive-wheels', columns='body-style',
3 values='price', aggfunc='mean')
4 df_pivot

body-style convertible hardtop hatchback sedan wagon

drive-wheels
4wd NaN NaN 7603.000000 12647.333333 9095.750000

fwd 11595.0 8249.000000 8396.387755 9811.800000 9997.333333

109
 rwd 23949.6 24202.714286 14337.777778 21711.833333 16994.222222

Setelah membuat pivot table, saatnya kita membuat heatmap menggunakan method
heatmap() dari Seaborn. Perhatikan kode berikut.

1 # Visualisasikan menggunakan heatmap

2 sns.heatmap(df_pivot)

<matplotlib.axes._subplots.AxesSubplot at 0x7f7c171fc3d0>

Berdasarkan hasil visualisasi diatas, terdapat dua kotak di sebelah kiri atas yang tidak
terbentuk yang berwarna putih karena memang nilai tersebut adalah NaN.
Kemudian kita juga dapat mengatur ukuran figure maupun label menggunakan Matplotlib.

110
 1 # Mengatur plot menggunakan Matplotlib
2 plt.figure(figsize=(12,7)) # Mengatur ukuran figure
3
4 # Visualisasikan menggunakan heatmap
5 sns.heatmap(df_pivot)
6 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
7 size=16)
8 plt.xlabel('\nBody Style', size=14)
9 plt.ylabel('Drive Wheels\n', size=14)
10 plt.xticks(size=14)
11 plt.yticks(size=14)
12 plt.show()

Menambahkan teks label

Saatnya untuk kita menambahkan teks pada kotak-kotak tersebut dengan menambahkan
argumen annot = True pada heatmap(). Teks disini maksudnya nilai yang ada pada
dataframe, dalam hal ini nilai rata-ratanya.
Kemudian kita bisa mengatur jumlah angka di belakang koma dengan menambahkan
argumen fmt='.2f' yang berarti kita hanya ingin menampilkan 2 angka di belakang koma
decimal.

111
 1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f') # Membuat heatmap dengan teks
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

Menambahkan grid lines

Kemudian kita juga bisa menambahkan grid lines atau garis di antara kotak-kotak tersebut
dengan menambahkan parameter linewidth. Lalu kita dapat mengatur warna garisnya
dengan menambahakan parameter linecolor. Perhatikan kode di bawah ini

112
 1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f', linewidths=3.5, linecolor='pink')
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

Menghapus label axis X atau Y

Apabila kita ingin menghilangkan label axis X pada heatmap, kita dapat menambahkan
argumen xticklabels = False pada heatmap(). Penggunaannya seperti pada contoh di
bawah ini.

113
 1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f', xticklabels=False)
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

Kemudian, kita dapat mengatur yticklabels = False jika ingin menghilangkan label axis Y.
Selain menghapus label secara keseluruhan, kita juga dapat mengatur untuk kelipatan
berapa label axis X atau Y yang ingin dimunculkan. Pada contoh berikut ini, kita akan
mengatur xticklabels=2 maka label axis X yang muncul akan lompat satu angka.

114
 1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f', xticklabels=2)
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9
10 plt.show()

Menghilangkan colorbar
Menghilangkan colorbar dengan menambahkan argumen cbar = False pada heatmap().

115
 1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f', cbar=False)
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

Mengatur warna
Anda dapat mengatur warna pada heatmap dengan menambahkan parameter cmap yang
berisi nama colorbar pada heatmap(). Sebagai contoh, kita menggunakan cmap =
'plasma'.

1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f', cbar=False)
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

116
Contoh lainnya, kita bisa memberikan warna cmap = 'Blues'.

1 plt.figure(figsize=(12,7))
2 sns.heatmap(df_pivot, annot=True, fmt='.2f', cmap='Blues')
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n', size=14)
7 plt.xticks(size=14)
8 plt.yticks(size=14)
9
10 plt.show()

117
Melihat korelasi antarkolom dengan Heatmap
Selain membuat visualisasi, kita dapat mengetahui korelasi antar kolom numerik pada
dataframe menggunakan heatmap dengan bantuan method corr(). Perhatikan kode
berikut.
1 plt.figure(figsize=(12,7))
2 sns.heatmap(df.corr(), annot=True, fmt='.2f', cmap='Blues')
3 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive
Wheels\n',4 size=16)
5 plt.xlabel('\nBody Style', size=14)
6 plt.ylabel('Drive Wheels\n',
size=14)7 plt.xticks(size=14)
8 plt.yticks(size=14)
9 plt.show()

118
Membuat Heatmap dengan Matplotlib
Selain menggunakan Seaborn, Anda juga dapat membuat heatmap dengan Matplotlib.
Untuk praktik kali ini, kita akan menggunakan dataframe df_pivot seperti pada contoh di
atas.
Sebelumnya, mari kita lihat lagi dataframe df_pivot.
1 df_pivot()

body-style convertible hardtop hatchback sedan wagon

drive-wheels
4wd NaN NaN 7603.000000 12647.333333 9095.750000

fwd 11595.0 8249.000000 8396.387755 9811.800000 9997.333333

rwd 23949.6 24202.714286 14337.777778 21711.833333 16994.222222

119
Dalam membuat heatmap menggunakan Matplotlib, kita dapat menggunakan method
imshow(). Perhatikan contoh kode di bawah ini.

1 plt.figure(figsize=(12,7))
2
3 # Visualisasikan heatmap dengan function imshow()
4 plt.imshow(df_pivot, cmap='Reds')
5 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
6 size=16)
7
8 plt.colorbar() # Tampilkan colorbar
9 plt.xlabel('\nBody Style', size=14)
10 plt.ylabel('Drive Wheels\n', size=14)
11
12 #Tampilkan xticklabel
13 plt.xticks(range(len(df_pivot.columns)),df_pivot.columns, size=14)
14
15 #Tampilkan yticklabel
16 plt.yticks(range(len(df_pivot.index)),df_pivot.index, size=14)
17
18 plt.show()

Seperti pada pembahasan sebelumnya, kita dapat melihat korelasi kolom numerik pada
dataframe df dengan Matplotlib.

120
 1 plt.figure(figsize=(12,7))
2
3 # Visualisasikan heatmap dengan function imshow()
4 plt.imshow(df.corr(), cmap='Purples')
5 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
6 size=16)
7
8 plt.colorbar()
9 plt.xlabel('\nBody Style', size=14)
10 plt.ylabel('Drive Wheels\n', size=14)
11 plt.xticks(range(len(df.corr().columns)),df.corr().columns, size=14, rotation=90)
12 plt.yticks(range(len(df.corr().index)),df.corr().index, size=14)
13 plt.show()

Selain menggunakan method imshow(), kita juga dapat menggunakan method pcolor()
untuk membuat heatmap di Matplotlib.

121
 1 plt.figure(figsize=(12,7))
2
3 # Visualisasikan heatmap dengan function pcolor()
4 plt.pcolor(df_pivot, cmap='Reds')
5 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
6 size=16)
7
8 plt.colorbar()
9 plt.xlabel('\nBody Style', size=14)
10 plt.ylabel('Drive Wheels\n', size=14)
11 plt.xticks(np.arange(0.5, len(df_pivot.columns), 1), df_pivot.columns, size=14)
12 plt.yticks(np.arange(0.5, len(df_pivot.index), 1), df_pivot.index, size=14)
13 plt.show()

Menambahkan label
Menambahkan label pada heatmap menggunakan Matplotlib agak rumit. Pada
pembahasan kali ini, kita akan memisahkan blok kode untuk menampilkan label di
heatmap dengan membuat fungsi tersendiri yang nantinya dipanggil pada blok kode
utama. Perhatikan kode di bawah ini

122
 1 def tampil_nilai(pc, fmt="%.2f", **kw):
2 pc.update_scalarmappable()
3 ax = pc.axes
4 for p, color, value in zip(pc.get_paths(), pc.get_facecolors(),
5 pc.get_array()):
6
7 x, y = p.vertices[:-2, :].mean(0)
8 if np.all(color[:3] > 0.5):
9 color = (0.0, 0.0, 0.0)
10 else:
11 color = (1.0, 1.0, 1.0)
12 ax.text(x, y, fmt % value, ha="center", va="center",
13 color=color, **kw)

Setelah membuat fungsi, kita buat blok kode utama untuk menampilkan heatmap dengan
Matplotlib dan memanggil fungsi tampil_nilai. Perhatikan kode berikut.

1 fig, ax = plt.subplots(figsize=(12,7))
2
3 # Visualisasikan heatmap dengan function pcolor()
4 heatmap = ax.pcolor(df_pivot, cmap='Reds')
5 fig.colorbar(heatmap) # Tampilkan colorbar
6 tampil_nilai(heatmap) # Tampilkan teks/label/values
7
8 plt.title('Harga Rata-rata Mobil Berdasarkan Body Style dan Drive Wheels\n',
9 size=16)
10
11 plt.xlabel('\nBody Style', size=14)
12 plt.ylabel('Drive Wheels\n', size=14)
13 plt.xticks(np.arange(0.5, len(df_pivot.columns), 1), df_pivot.columns, size=14)
14 plt.yticks(np.arange(0.5, len(df_pivot.index), 1), df_pivot.index, size=14)
15 plt.show()

123
Berdasarkan hasil visualisasi di atas, akan lebih mudah untuk membuat heatmap dengan
Seaborn dibandingkan menggunakan Matplotlib. Jika menggunakan Seaborn, kita bisa
memberikan parameter annot = True. Jika menggunakan Matplotlib, kita perlu membuat
fungsi untuk menampilkan label.

124
 Word Cloud
Word Cloud digunakan untuk melihat kata-kata yang paling sering muncul di sebuah data
teks seperti artikel, buku, dan lain sebagainya. Sederhananya, semakin banyak suatu kata
digunakan maka semakin besar ukuran kata tersebut pada Word Cloud.
Pada pembahasan kali ini, kita akan import terlebih dahulu beberapa library yang akan
digunakan untuk visualisasi menggunakan Word Cloud. Library stopwords akan kita
gunakan untuk mem-filter kata-kata yang kurang penting pada string.

1 import nltk
2 import matplotlib.pyplot as plt
3 import numpy as np
4 import pandas as pd
5 from wordcloud import WordCloud
6 from nltk.corpus import stopwords

Data teks
Untuk data teks, kita akan menggunakan novel Little Dorrit yang berasal dari website
Kaggle.
Langkah pertama kita harus membuka file tersebut dan membacanya. Setelah itu, kita
akan memasukkannya ke dalam sebuah variabel.
Anda dapat melihat isi dari teks tersebut dengan print.

1 # Membuka file dan memasukkannya ke dalam variabel novel_alice

2 novel_Little_Dorrit = open('/content/Little Dorrit.txt', 'r',
encoding='utf8').read()
4
5 # Menampilkan teks novel_Little_Dorrit
6 print(novel_Little_Dorrit)

125
Note : Hasil tangkapan layar karena data terlalu banyak

Kita dapat mengunduh package stopwords terlebih dahulu agar bisa mengikuti praktik
hingga selesai.

1 nltk.download('stopwords')

[nltk_data] Downloading package stopwords to /root/nltk_data...

[nltk_data] Package stopwords is already up-to-date!
True

Setelah itu, kita harus mendefinisikan stopwords dari package wordcloud yang telah kita
import sebelumnya. Stopwords yang tersedia di Python adalah versi bahasa inggris. Selain
itu, kita harus mendefinisikannya sendiri.
Sekarang kita tampilkan stopwords.

{"hadn't", 'what', 'or', "you'll", 'very', 'o', 'haven', 'over', 'where',

'why', 've', 'aren', 'needn', 'can', 'to', 'doing', 'an', 'these',
'should', 'd', 'just', 'you', 'itself', 'shan', 'that', 'when', 'being',

126
 1 # Mendefinisikan stopwords
2 stop_words = set(stopwords.words('english'))
3 print(stop_words)
'ma', 'from', 'having', 'on', "aren't", 'her', 'doesn', "it's", 'couldn',
'those', 'so', 'most', 'below', 'it', 'all', 'mustn', 'down', 'than',
'each', 'a', 'in', 'y', 'further', 'their', 's', 'through', 'they', 'ain',
'off', "doesn't", "didn't", 'once', "mightn't", 'own', "wouldn't", 'she',
'he', 'them', "weren't", "you're", 'again', 'then', 'are', 'theirs',
'themselves', 'because', "shouldn't", 'during', 'had', "isn't", 'weren',
'any', "needn't", 'more', 'of', 'between', 'and', 'about', 'did', 'but',
"you'd", 'its', 'some', 'won', 'be', 'who', 'yourselves', "should've",
'out', 'how', 'the', 'before', 'few', 'both', "wasn't", 'does', 'we',
"that'll", "shan't", "she's", 'me', 'ours', 'if', "don't", 'didn',
"mustn't", 'only', 'our', "hasn't", 't', "haven't", 'been', 'i',
'himself', 'wasn', 'such', 'has', 'nor', 'do', 'while', 'shouldn',
'here', 'same', 'wouldn', 'hers', 'as', 'other', 'don', 'not', 'into',
'no', 'up', 'm', 'mightn', 'this', "you've", 'until', 'have', 'which',
'with', 'now', 'for', 'ourselves', 'yours', 'herself', 'after', 'him',
'hasn', 'whom', 'hadn', 'above', 'myself', 'yourself', 'by', 'your',
'were', 'under', 'his', 'is', "won't", 'was', 'my', 'at', 'am', 'too',
'there', 'isn', 'will', 'against', 'll', 're', "couldn't"}
Setelah menyiapkan data yang dibutuhkan, saatnya kita membuat visualisasi
menggunakan Word Cloud.

Visualisasi teks dengan Word Cloud

Hal pertama yang harus kita lakukan adalah membuat objek WordCloud dan men-
generate-nya dengan method generate(). Perhatikan kode berikut.

1 # Membuat objek word cloud

2 wordcloud_Little_Dorrit = WordCloud(
3 background_color='white',
4 max_words=10000,
5 stopwords=stop_words
6 )
7 # Generate word cloud
8 wordcloud_Little_Dorrit.generate(novel_Little_Dorrit)

<wordcloud.wordcloud.WordCloud at 0x7fd72c721210>

127
Berdasarkan kode diatas, terdapat beberapa argumen yang dapat kita berikan pada objek
word cloud, diantaranya :

• background_color untuk mengatur warna latar belakang. Pada contoh di atas, kita
mendefinisikan warna putih (white) sebagai warna latarnya.
• max_words untuk mendefinisikan jumlah kata yang akan diambil. Pada contoh di
atas, hanya 10000 kata pertama dari novel_alice yang akan digunakan untuk
membuat word cloud.
• stopwords untuk mem-filter kata-kata tertentu agar tidak muncul pada hasil
visualisasi.
Setelah itu, kita dapat menampilkan objek word cloud tersebut menggunakan method
imshow() dari Matplotlib.
1 # Menampilkan word cloud
2 plt.imshow(wordcloud_Little_Dorrit, interpolation='bilinear')
3 plt.axis('off')
4 plt.show()

Mengatur ukuran figure

Pada visualisasi sebelumnya, word cloud yang terbentuk berukuran kecil. Kita dapat
mengatur ukuran figure dengan method set_figwidth() dan set_figheight().

128
 1 fig = plt.figure()
2 fig.set_figwidth(14) # mengatur width
3 fig.set_figheight(10) # mengatur height
4
5 # menampilkan word cloud
6 plt.imshow(wordcloud_Little_Dorrit, interpolation='bilinear')
7 plt.axis('off')
8 plt.show()

Selain itu, kita dapat menggunakan figsize seperti di bawah ini.

1 fig = plt.figure(figsize=(14, 10))

2
3 # menampilkan word cloud
4 plt.imshow(wordcloud_Little_Dorrit, interpolation='bilinear')
5 plt.axis('off')
6 plt.show()

129
Menghapus kata pada Word Cloud
Kita dapat menghapus kata yang dianggap kurang penting dengan menambahkan kata
tersebut ke dalam stopwords agar tidak diikutsertakan dalam pembuatan word cloud.
Pada contoh kali ini, kita akan menghapus kata 'said' dengan menambahkan kata tersebut
pada stopwords.

1 # menambahkan 'said' pada stopwords

2 stop_words.add('said')
3
4 # men-generate ulang word cloud
5 wordcloud_Little_Dorrit.generate(novel_Little_Dorrit)
6
7 # menampilkan word cloud
8 fig = plt.figure()
9 fig.set_figwidth(14)
10 fig.set_figheight(10)
11 plt.imshow(wordcloud_Little_Dorrit, interpolation='bilinear')
12 plt.axis('off')
13 plt.show()

130
Selain menambahkan kata secara manual, kita dapat menambahkan beberapa kata pada
stopwords menggunakan for looping seperti di bawah ini.

1 # membuat list stopwords

2 add_stopword = ['people', 'Mr', 'head']
3
4 # menambahkan add_stopword pada stopwords
5 for i in add_stopword:
6 stop_words.add(i)
7
8 # men-generate ulang word cloud
9 wordcloud_Little_Dorrit.generate(novel_Little_Dorrit)
10
11 # menampilkan word cloud
12 fig = plt.figure()
13 fig.set_figwidth(14)
14 fig.set_figheight(10)
15 plt.imshow(wordcloud_Little_Dorrit, interpolation='bilinear')
16 plt.axis('off')
17 plt.show()

131
Visualisasi data pada dataframe dengan Word Cloud

Selain menggunakan data teks, kita dapat memakai dataframe untuk membuat visualisasi
menggunakan word cloud. Caranya kita dapat membuat data tersebut menjadi string.
Pada praktik kali ini, kita menggunakan dataset populasi penduduk di setiap negara di
dunia, lalu menampilkan nama-nama negara dalam bentuk word cloud berdasarkan pada
jumlah populasinya. Semakin banyak populasinya, maka nama negara tersebut akan
semakin besar di word cloud.
Pertama, kita load datasetnya terlebih dahulu.

1 # Load dataset
2 df = pd.read_csv("/content/world_population.csv")
3 df.head()

Note : Hasil tangkapan layar

132
Kita dapat melakukan reshaping dengan mengatur kolom Country/Other sebagai indeks
menggunakan method set_index().

1 df.set_index("Country/Other", inplace=True)
2 df.head()

Note : Hasil tangkapan layar

Mengubah data pada dataframe menjadi string

Langkah pertama adalah mengubah data pada dataframe menjadi string. Pada contoh kali
ini, kita akan menjadikan nama-nama negara sebagai string dengan masing-masing
negara memiliki jumlah tertentu. Perhatikan kode berikut.

1 # Membuat string dari indeks dataframe

2 word_string = '' # Mendefinisikan string kosong
3
4 # Perhitungan untuk menentukan jumlah untuk tiap negara
5 for country in df.index.values:
6 repeat_num_times = int(df.loc[country, 'World Share']*100)
7 word_string = word_string + ((country + ' ') * repeat_num_times)
8
9 # display the generated text
10 word_string

Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan

Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan Afghanistan
Afghanistan Afghanistan Albania Albania Albania Albania Algeria Algeria
Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria
Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria
Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria
Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria
Algeria Algeria Algeria Algeria Algeria Algeria Algeria Algeria

133
Berdasarkan kode di atas, kita menentukan jumlah kata untuk tiap negara yang tercetak
dengan mengalikan kolom World Share dengan 100
Setelah kita mempunyai string-nya, selanjutnya adalah membuat objek word cloud lalu
men-generate-nya, kemudian menampilkannya dengan Matplotlib seperti di bawah ini.

1 # Membuat word cloud

2 wordcloud_country = WordCloud(background_color='black',
3 collocations=False,
4 colormap='viridis',
5 width=600,
6 height=330)
7 wordcloud_country.generate(word_string)
8 plt.figure(figsize=(16,12))
9 plt.imshow(wordcloud_country, interpolation='bilinear')
10 plt.axis('off')
11 plt.show()

Ada beberapa parameter yang baru kita gunakan, di antaranya:

• collocations : kita atur dengan nilai False agar kemunculan nama negara tidak
double.
• colormap : untuk mengatur warna teks pada word cloud.
• width : untuk mengatur lebar (horizontal) word cloud.

134
 • height : untuk mengatur tinggi (vertikal) word cloud.

Membuat Word Cloud dari frekuensi kata

Langkah berikutnya dalam membuat word cloud dari dataframe adalah dari frekuensi
setiap kata. Pada praktik kali ini, kita membuat 2 list dengan jumlah elemen yang sama,
dimana satu list berfungsi untuk menampung nama negara dan satu list lagi untuk
menampung jumlah frekuensi. Untuk mendapatkan frekuensi, kita akan menggunakan
perhitungan hasil kali antara kolom World Share dengan 100.

1 # Membuat list_country dan list_freq

2
3 list_country = [] # Mendefinisikan list kosong untuk menampung nama negara
4 list_freq = [] # Mendefinisikan list kosong untuk menampung frekuensi
5
6 for country in df.index.values:
7 frequency = int(df.loc[country, 'World Share']*100)
8 list_country.append(country) # Menambahkan nama negara ke list_country
9 list_freq.append(frequency) # Menambahkan frekuensi ke list_freq

Kemudian, buat sebuah dictionary untuk menampung 2 list tersebut.

1 # Membuat dictionary
2 d = dict(zip(list_country, list_freq))
3 print(d)
{'Afghanistan': 50, 'Albania': 4, 'Algeria': 56, 'Angola': 42, 'Antigua and Barbuda': 0,
'Argentina': 57, 'Armenia': 4, 'Aruba': 0, 'Australia': 33, 'Austria': 12, 'Azerbaijan':
13, 'Bahamas': 1, 'Bahrain': 2, 'Bangladesh': 211, 'Barbados': 0, 'Belarus': 12,
'Belgium': 15, 'Belize': 1, 'Benin': 16, 'Bhutan': 1, 'Bolivia': 15, 'Bosnia and
Herzegovina': 4, 'Botswana': 3, 'Brazil': 273, 'Brunei': 1, 'Bulgaria': 9, 'Burkina Faso':
27, 'Burundi': 15, 'Cabo Verde': 1, 'Cambodia': 21, 'Cameroon': 34, 'Canada': 48, 'Central
African Republic': 6, 'Chad': 21, 'Channel Islands': 0, 'Chile': 25, 'China': 1847,
'Colombia': 65, 'Comoros': 1, 'Congo': 7, 'Costa Rica': 7, 'Croatia': 5, 'Cuba': 15,
'Curaçao': 0, 'Cyprus': 2, 'Czech Republic (Czechia)': 14, "Côte d'Ivoire": 34, 'DR
Congo': 114, 'Denmark': 7, 'Djibouti': 1, 'Dominican Republic': 14, 'Ecuador': 23,
'Egypt': 131, 'El Salvador': 8, 'Equatorial Guinea': 2, 'Eritrea': 5, 'Estonia': 2,
'Eswatini': 1, 'Ethiopia': 147, 'Fiji': 1, 'Finland': 7, 'France': 84, 'French Guiana':
0, 'French Polynesia': 0, 'Gabon': 3, 'Gambia': 3, 'Georgia': 5, 'Germany': 107, 'Ghana':
40, 'Greece': 13, 'Grenada': 0, 'Guadeloupe': 1, 'Guam': 0, 'Guatemala': 23, 'Guinea':
17, 'Guinea-Bissau': 3, 'Guyana': 1, 'Haiti': 15, 'Honduras': 13, 'Hong Kong': 10,
'Hungary': 12, 'Iceland': 0, 'India': 1770, 'Indonesia': 351, 'Iran': 108, 'Iraq': 52,
'Ireland': 6, 'Israel': 11, 'Italy': 78, 'Jamaica': 4, 'Japan': 162, 'Jordan': 13,
'Kazakhstan': 24, 'Kenya': 69, 'Kiribati': 0, 'Kuwait': 5, 'Kyrgyzstan': 8, 'Laos': 9,
'Latvia': 2, 'Lebanon': 9, 'Lesotho': 3, 'Liberia': 6, 'Libya': 9, 'Lithuania': 3,
'Luxembourg': 1, 'Macao': 1, 'Madagascar': 36, 'Malawi': 25, 'Malaysia': 42, 'Maldives':
1, 'Mali': 26, 'Malta': 1, 'Martinique': 0, 'Mauritania': 6, 'Mauritius': 2, 'Mayotte':
0, 'Mexico': 165, 'Micronesia': 1, 'Moldova': 5, 'Mongolia': 4, 'Montenegro': 1,
'Morocco': 47, 'Mozambique': 40, 'Myanmar': 70, 'Namibia': 3, 'Nepal': 37, 'Netherlands':
22, 'New Caledonia': 0, 'New Zealand': 6, 'Nicaragua': 8, 'Niger': 31, 'Nigeria': 264,
'North Korea': 33, 'North Macedonia': 3, 'Norway': 7, 'Oman': 7, 'Pakistan': 283,
'Panama': 6, 'Papua New Guinea': 11, 'Paraguay': 9, 'Peru': 42, 'Philippines': 141,
'Poland': 49, 'Portugal': 13, 'Puerto Rico': 4, 'Qatar': 4, 'Romania': 25, 'Russia': 187,

135
'Rwanda': 17, 'Réunion': 1, 'Saint Lucia': 0, 'Samoa': 0, 'Sao Tome & Principe': 0, 'Saudi
Arabia': 45, 'Senegal': 21, 'Serbia': 11, 'Seychelles': 0, 'Sierra Leone': 10,
'Singapore': 8, 'Slovakia': 7, 'Slovenia': 3, 'Solomon Islands': 1, 'Somalia': 20, 'South
Africa': 76, 'South Korea': 66, 'South Sudan': 14, 'Spain': 60, 'Sri Lanka': 27, 'St.
Vincent & Grenadines': 0, 'State of Palestine': 7, 'Sudan': 56, 'Suriname': 1, 'Sweden':
13, 'Switzerland': 11, 'Syria': 22, 'Taiwan': 31, 'Tajikistan': 12, 'Tanzania': 77,
'Thailand': 90, 'Timor-Leste': 2, 'Togo': 11, 'Tonga': 0, 'Trinidad and Tobago': 2,
'Tunisia': 15, 'Turkey': 108, 'Turkmenistan': 8, 'U.S. Virgin Islands': 0, 'Uganda': 59,
'Ukraine': 56, 'United Arab Emirates': 13, 'United Kingdom': 87, 'United States': 425,
'Uruguay': 4, 'Uzbekistan': 43, 'Vanuatu': 0, 'Venezuela': 36, 'Vietnam': 125, 'Western
Sahara': 1, 'Yemen': 38, 'Zambia': 24, 'Zimbabwe': 19}

Selanjutnya, kita akan membuat objek word cloud dan men-generate-nya menggunakan
method generate_from_frequencies().

1 # Membuat objek word cloud

2 wordcloud_country = WordCloud(background_color='purple',
3 collocations=False,
4 colormap='Paired',
5 width=600,
6 height=330)
7
8 # Generate word cloud from frequencies
9 wordcloud_country.generate_from_frequencies(d)
10 plt.figure(figsize=(16,12))
11 plt.imshow(wordcloud_country, interpolation='bilinear')
12 plt.axis('off')
13 plt.show()

136
Menambahkan kolom 'frequency' pada dataframe
Kita juga dapat melakukan cara lain yaitu dengan menambahkan kolom baru yang berisi
frekuensinya.
Sebagai contoh, kita buat kolom baru yaitu Frequency for Word Cloud yang berisi hasil kali
dari kolom World Share dan 100.
1 # Membuat kolom baru 'Frequency for Word Cloud'
2 df['Frequency for Word Cloud'] = df['World Share'] * 100
3 df.head()

Note Hasil tangkapan layar

Kita dapat mengikuti cara yang sama seperti sebelumnya dengan membuat dictionary dari
df.index.values dan df['Frequency for Word Cloud'] lalu men-generate word cloud dengan
generate_from_frequencies() dengan memasukkan argumen berupa dictionary tersebut.

1 d = dict(zip(df.index.values, df['Frequency for Word Cloud']))

2
3 # Create the word cloud
4 wordcloud_country = WordCloud(background_color='maroon',
5 collocations=False,
6 colormap='coolwarm',
7 width=600,
8 height=330)
9
10 # Generate word cloud from frequencies
11 wordcloud_country.generate_from_frequencies(d)
12
13 plt.figure(figsize=(16,12))
14 plt.imshow(wordcloud_country, interpolation='bilinear')
15 plt.axis('off')
16 plt.show()

137
Word Cloud pada berbagai bentuk objek

Selanjutnya kita akan membuat word cloud pada gambar tertentu yang menjadi mask-nya.
Oleh karena itu, kita harus meng-import Image dari package PIL. Sebagai contoh, kita akan
menggunakan gambar twitter_mask.png yang didapat dari website Kaggle.

1 from PIL import Image

2
3 # Menyimpan mask pada variabel alice_mask
4 doraemon_mask = np.array(Image.open('/content/twitter_mask.jpg'))

Setelah itu, kita tampilkan gambar atau mask tersebut dengan imshow().

1 # Menampilkan gambar mask

2
3 fig = plt.figure()
4 fig.set_figwidth(6)
5 fig.set_figheight(10)
6
7 plt.imshow(doraemon_mask, cmap=plt.cm.gray, interpolation='bilinear')
8 plt.axis('off')
9 plt.show()

138
Selanjutnya kita akan membuat visualisasi word cloud menggunakan gambar atau mask
di atas dengan menambah parameter mask yang diberi nilai nama variabel dari mask-nya.

1 # Membuat objek word cloud

2 wordcloud_Little_Dorrit = WordCloud(background_color='white',
3 max_words=2000,
4 mask=doraemon_mask,
5 stopwords=stop_words)
6
7 # Generate word cloud
8 wordcloud_Little_Dorrit.generate(novel_Little_Dorrit)
9
10 # Menampilkan word cloud
11 fig = plt.figure()
12 fig.set_figwidth(10)
13 fig.set_figheight(14
)
14 plt.imshow(wordcloud_Little_Dorrit,
interpolation='bilinear')
15 plt.axis('off')
16 plt.show()
17

139
Lebih lanjut, kita akan mencoba menerapkan untuk nama-nama negara dengan
menggunakan gambar peta dunia.

1 # Menyimpan mask pada variabel world_mask

2 world_mask = np.array(Image.open('/content/worldmap.png'))
3
4 fig = plt.figure()
5 fig.set_figwidth(14)
6 fig.set_figheight(10)
7
8 plt.imshow(world_mask, cmap=plt.cm.gray, interpolation='bilinear')
9 plt.axis('off')
10 plt.show()

Seperti pada cara sebelumnya, kita membuat dictionary, kemudian objek word cloud, lalu
men-generate-nya dengan generate_from_frequencies().

140
1 d = dict(zip(df.index.values, df['Frequency for Word Cloud']))
2
3 # Membuat objek word cloud dan men-generate-nya
4 wordcloud_country = WordCloud(background_color='white',
5 collocations=False,
6 colormap='winter',
7 mask=world_mask).generate_from_frequencies(d)
8
9 # Menampilkan word cloud
10 fig = plt.figure()
11 fig.set_figwidth(18)
12 fig.set_figheight(14)
13
14 plt.imshow(wordcloud_country)
15 plt.axis('off')
16 plt.show()

141
 Waffle Chart
Waffle Chart adalah sebuah visualisasi data yang umumnya berbentuk persegi dan
biasanya terdiri dari kotak-kotak kecil yang disusun dalam tata letak tertentu. Kotak diberi
warna sesuai dengan proporsi masing-masing kategori. Dinamakan waffle chart karena
memang bentuknya menyerupai jenis makanan waffle.
Disini kita akan belajar membuat waffle chart menggunakan bahasa pemrograman Python.
Sebelumnya kita import terlebih dahulu library yang dibutuhkan seperti Pandas, Numpy, dan
tentunya Matplotlib.

1 import pandas as pdimport numpy as np

2 import matplotlib.pyplot as plt
3 # Diperlukan untuk membuat Waffle Charts
4 import matplotlib.patches as mpatches

Dataset
Dataset yang digunakan adalah dataset populasi penduduk dunia berdasarkan negara pada
tahun 2022 yang bisa diunduh di website Kaggle.
Pertama, kita load dataset terlebih dahulu lalu disimpan pada variabel df.

1 df = pd.read_csv("/content/2022_population.csv")
2 df.head(10)

Setelah itu, kita akan menjadikan kolom country sebagai indeks.

142
 1 # Mengganti tanda koma dengan blank
2 df['2022_last_updated'] = df['2022_last_updated'].apply(
3 str).str.replace(',', '').astype('int')
4
5 df['2020_population'] = df['2020_population'].apply(
6 str).str.replace(',', '').astype('int')
7
8 df

Selanjutnya kita bisa melihat 10 data teratas dari dataframe df setelah perubahan indeks.

1 df.set_index('country', inplace=True)
2 df.head(10)

143
Pada praktik kali ini kita akan membuat waffle chart untuk 5 negara dengan populasi
terbanyak. Setelah itu, kita membuat dataframe baru untuk menampung 5 data teratas dari
dataframe df dan disimpan pada variabel df_top5.

1 # Mengambil 5 data teratas

2 df_top5 = df.head(5)
3 df_top5

Waffle Chart dengan Matplotlib

Pembahasan kali ini kita akan membuat waffle chart menggunakan Matplotlib terlebih
dahulu. Terdapat langkah-langkah dalam membuat waffle chart dengan Matplotlib,
diantaranya:
1. Menentukan proporsi dari masing-masing kategori dengan membagi nilai dari tiap
kategori tersebut dengan total nilai dari keseluruhan kategori.
2. Mendefinisikan keseluruhan ukuran waffle chart.
3. Menggunakan proporsi dari tiap kategori untuk menentukan jumlah kotak yang
mewakili tiap kategori.
4. Membuat matriks yang menyerupai waffle chart dan mengisinya.
5. Memetakan matriks waffle chart ke dalam bentuk visual

Langkah 1 - Menentukan proporsi dari masing-masing kategori.

1 # Menghitung proporsi dari tiap kategori

2 total = sum(df_top5['2022_last_updated'])
3 kategori_proporsi = [(float(value) / total) for value in
4 df_top5['2022_last_updated']]
5
6 # Menampilkan proporsi tiap kategori (negara)
7 for i, proporsi in enumerate(kategori_proporsi):
8 print (df_top5.index.values[i] + ': ' + str(proporsi))

China: 0.39197871008966856
India: 0.38014333408112233

144
United States: 0.09055125487572167
Indonesia: 0.07542737385728603
Pakistan: 0.06189932709620145

Setelah mendapatkan proporsi dari masing-masing kategori atau dari tiap negara, kita
harus menentukan ukuran waffle chart.
Langkah 2 - Mendefinisikan keseluruhan ukuran waffle chart.

1 lebar = 45 # lebar chart

2 tinggi = 15 # tinggi chart
3 jml_tot_kotak = lebar * tinggi # jumlah total kotak persegi
4 print ('Total jumlah kotak : ', jml_tot_kotak)

Total jumlah kotak : 675

Langkah 3 - Menggunakan proporsi dari tiap kategori untuk menentukan jumlah kotak yang
mewakili tiap kategori.

1 # Menghitung jumlah blok persegi untuk tiap kategori/negara

2 jmlKotak_per_kategori = [round(proporsi * jml_tot_kotak) for proporsi in
3 kategori_proporsi
4
5 # Menampilkan jumlah blok persegi per kategori/negara
6 for i, kotak in enumerate(jmlKotak_per_kategori):
7 print (df_top5.index.values[i] + ': ' + str(kotak))

China: 265
India: 257
United States: 61
Indonesia: 51
Pakistan: 42

145
Langkah 4 - Membuat matriks yang menyerupai waffle chart dan mengisinya.

1 # Menginisialisasi waffle chart sebagai matriks kosong

2 waffle_chart = np.zeros((tinggi, lebar))
3
4 # Menentukan indeks awal untuk perulangan waffle chart
5 index_kategori = 0
6 index_kotak = 0
7
8 # Mengisi waffle chart
9 for col in range(lebar):
10 for row in range(tinggi):
11 index_kotak += 1
12
13 # Jika jumlah blok persegi yang terisi untuk kategori yang sedang
14 # diproses sama dengan blok persegi yang dialokasikan..
15 if index_kotak > sum(jmlKotak_per_kategori[0:index_kategori]):
16
17 # ...lanjutkan proses ke kategori selanjutnya
18 index_kategori += 1
19
20 waffle_chart[row, col] = index_kategori

Selanjutnya mari kita tampilkan array waffle_chart yang terbentuk.

1 # Tampikan array menggunakan waffle

2 chartwaffle_chart

array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],

146
 [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 3., 3., 3., 3., 3., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5., 5.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5., 5.]])

Langkah 5 - Memetakan matriks waffle chart ke dalam bentuk visual.

Di Matplotlib, kita menggunakan method matshow() untuk menampilkan waffle chart

1 # Membuat objek figure

2 fig = plt.figure()
3
4 # Menampilkan waffle chart menggunakan matshow()
5 colormap = plt.cm.coolwarm
6 plt.matshow(waffle_chart, cmap=colormap)
7 plt.colorbar()

147
Setelah menampilkan waffle chart, selanjutnya kita akan mempercantik tampilannya
dengan menerapkan beberapa pengaturan seperti menambahkan grid lines dan
menambahkan legend.

Menambahkan grid lines

Menambahkan grid lines pada waffle chart, kita harus mendapatkan axes saat ini atau yang
sedang kita kerjakan untuk membuat waffle chart tersebut dengan menggunakan method
gca() (get current axes). Kemudian pada axes tersebut kita atur minor ticks-nya, baru
setelah itu kita tambahkan gridlines berdasarkan minor ticks.

1 fig = plt.figure()
2
3 # Menampilkan waffle chart menggunakan matshow()
4 colormap = plt.cm.coolwarm
5 plt.matshow(waffle_chart, cmap=colormap)
6 plt.colorbar()
7
8 # Mendapatkan axes dengan gca() (get current axes)
9 ax = plt.gca()
10
11 # Mengatur minor ticks
12 ax.set_xticks(np.arange(-.5, (lebar), 1), minor=True)
13 ax.set_yticks(np.arange(-.5, (tinggi), 1), minor=True)
14
15 # Menambah gridlines berdasarkan minor ticks
16 ax.grid(which='minor', color='w', linestyle='-', linewidth=2)
17 plt.xticks([])
18 plt.yticks([])
19 plt.show()

148
Menambahkan legend
Kita dapat menambahkan legend dengan menghitung jumlah kumulatif dari kategori
individu untuk menyesuaikan skema warna antara chart dan legend. Setelah itu, kita dapat
membuat legend dan menambahkannya ke chart. Perhatikan kode berikut.

1 fig = plt.figure()
2
3 # Menampilkan waffle chart menggunakan matshow()
4 colormap = plt.cm.coolwarm
5 plt.matshow(waffle_chart, cmap=colormap)
6 plt.colorbar()
7
8 # Mendapatkan axes dengan gca() (get current axes)
9 ax = plt.gca()
10
11 # Mengatur minor ticks
12 ax.set_xticks(np.arange(-.5, (lebar), 1), minor=True)
13 ax.set_yticks(np.arange(-.5, (tinggi), 1), minor=True)
14
15 # Menambahkan gridlines berdasarkan minor ticks
16 ax.grid(which='minor', color='w', linestyle='-', linewidth=2)
17 plt.xticks([])
18 plt.yticks([])
19
20 # Menghitung jumlah kumulatif kategori individu untuk menyesuaikan skema
21 # warna antara chart dan legend
22 values_cumsum = np.cumsum(df_top5['2022_last_updated'])
23 total_values = values_cumsum[len(values_cumsum) - 1]
24
25 # Membuat legend
26 legend_handles = []
27 for i, kategori in enumerate(df_top5.index.values):
28 label_str = kategori + ' (' + str(df_top5['2022_last_updated'][i]) + ')'
29 color_val = colormap(float(values_cumsum[i])/total_values)
30 legend_handles.append(mpatches.Patch(color=color_val, label=label_str))
31
32 # Menambahkan legend ke chart
33 plt.legend(handles=legend_handles,
34 loc='lower center',
35 ncol=len(df_top5.index.values),
36 bbox_to_anchor=(0., -0.3, 1, .1)
37 )
38
39 plt.show()

149
<Figure size 432x288 with 0 Axes>

Seperti yang telah kita lihat, membuat waffle chart menggunakan Matplotlib terbilang rumit.
Selain menggunakan Matplotlib, kita juga bisa menggunakan package khusus untuk
membuat waffle chart, yaitu PyWaffle. Pembahasan selanjutnya akan dibahas mengenai
package tersebut.

Waffle Chart dengan PyWaffle

PyWaffle adalah package Python yang digunakan untuk membuat waffle chart yang
penggunaanya cukup mudah, seperti kemudahan dalam men-generate- waffle chart serta
melakukan modifikasi-modifikasi untuk memperindah tampilan sesuai yang kita inginkan.
Sebelumnya, pastikan kita telah mengunduh package PyWaffle di file notebook kita.
Selanjutnya, dari package PyWaffle kita import Waffle.

1 !pip install pywaffle

Setelah menginstall pywaffle, kita import Waffle.

1 from pywaffle import Waffle

Selanjutnya, kita mendefinisikan FigureClass = Waffle untuk membuat visualisasi data jenis
waffle chart seperti di bawah ini.

150
 1 # Membuat waffle chart dengan PyWaffle
2 fig = plt.figure(
3 FigureClass=Waffle,
4 rows=15,
5 columns=45,
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0.15, 0.4)}
10 )

Dari kode di atas, kita harus menentukan:

• rows : Jumlah baris yang diinginkan.

• columns : Jumlah kolom yang diinginkan.
• values : Nilai dari waffle chart, dalam hal ini nilainya adalah tiles_per_category yang
sudah kita buat sebelumnya.
• labels : Label yang akan ditampilkan pada legend, dalam hal ini adalah nama negara
yang merupakan indeks dari df_top5.
• figsize : Ukuran figure.
• legend : Untuk menampilkan legend, dimana bbox_to_anchor adalah untuk mengatur
posisinya.

Mengatur legend dan warna

Posisi default legend akan ditampilkan seperti visualisasi di atas. Kita dapat mengatur
legend menjadi berbentuk memanjang dengan mendefinisikan ncol. Selain itu kita juga
dapat mengatur ukuran huruf dengan fontsize dan lokasinya dengan loc. Perhatikan kode
berikut.

151
 1 fig = plt.figure(
2 FigureClass=Waffle,
3 rows=15,
4 columns=45,
5 cmap_name='Paired',
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0, -0.2),
10 'loc': 'lower left',
11 'ncol': len(df_top5.index.values),
12 'fontsize': 14}
13 )

Menambahkan judul
Menambahkan judul dengan mendefinisikan title. Perhatikan kode berikut.

152
 1 fig = plt.figure(
2 FigureClass=Waffle,
3 rows=15,
4 columns=45,
5 cmap_name='Paired',
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0, -0.2),
10 'loc': 'lower left',
11 'ncol': len(df_top5.index.values),
12 'fontsize': 14},
13 title={'label': "Data 5 Negara dengan Populasi Manusia Terbanyak di Dunia\n",
14 'loc': 'center',
15 'fontdict': {'fontsize': 20}}
16 )

Mengatur jarak blok

Kita dapat mengatur jarak antar blok dengan menambahkan parameter berikut:

• interval_ratio_x : Untuk mengatur jarak antar kotak di sumbu X, atau jarak kanan dan
kirinya.
• interval_ratio_y : Untuk mengatur jarak antar kotak di sumbu Y, atau jarak atas dan
bawahnya.

153
 1 fig = plt.figure(
2 FigureClass=Waffle,
3 rows=15,
4 columns=45,
5 cmap_name='Paired',
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0, -0.2),
10 'loc': 'lower left',
11 'ncol': len(df_top5.index.values),
12 'fontsize': 14},
13 title={'label': "Data 5 Negara dengan Populasi Manusia Terbanyak di Dunia\n",
14 'loc': 'center',
15 'fontdict': {'fontsize': 20}},
16 interval_ratio_x=1,
17 interval_ratio_y=0.5
18 )

Mengganti blok persegi dengan karakter dan icon

Selain menampilkan blok atau kotak-kotak, kita dapat menggantinya dengan karakter atau
icon seperti bentuk bulat, bintang, matahari, bulan, dan sebagainya.
Sebagai contoh, kita memberikan parameter icons = 'star' untuk mengganti kotak dengan
icon bintang.

154
 1 fig = plt.figure(
2 FigureClass=Waffle,
3 rows=15,
4 columns=45,
5 cmap_name='Paired',
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0, -0.2),
10 'loc': 'lower left',
11 'ncol': len(df_top5.index.values),
12 'fontsize': 14},
13 title={'label': "Data 5 Negara dengan Populasi Manusia Terbanyak di Dunia\n",
14 'loc': 'center',
15 'fontdict': {'fontsize': 20}},
16 icons='star',
17 font_size=14
18 )

Apabila kita ingin menggunakan icon untuk tiap kategori adalah bentuk yang berbeda, maka
kita harus mendefinisikannya dalam bentuk list. Kemudian, kita dapat menambahkan
parameter icon_legend = True agar legend menampilkan icon yang sesuai untuk tiap
kategori. Perhatikan kode di bawah ini.

155
 1 fig = plt.figure(
2 FigureClass=Waffle,
3 rows=15,
4 columns=45,
5 cmap_name='Paired',
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0, -0.2),
10 'loc': 'lower left',
11 'ncol': len(df_top5.index.values),
12 'fontsize': 14},
13 title={'label': "Data 5 Negara dengan Populasi Manusia Terbanyak di Dunia\n",
14 'loc': 'center',
15 'fontdict': {'fontsize': 20}},
16 icons=['star', 'sun', 'cloud-showers-heavy', 'snowflake', 'moon'],
17 icon_size=14,
18 icon_legend=True
19 )

Vertical Waffle Chart

Selain menampilkan secara horizontal atau menyamping, kita dapat menampilkan waffle
chart dalam bentuk vertikal dengan menambahkan parameter vertical = True. Perhatikan
kode berikut.

156
1 fig = plt.figure(
2 FigureClass=Waffle,
3 rows=15,
4 columns=45,
5 cmap_name='Paired',
6 values=jmlKotak_per_kategori,
7 labels=list(df_top5.index.values),
8 figsize=(12, 8),
9 legend={'bbox_to_anchor': (0, -0.2),
10 'loc': 'lower left',
11 'ncol': len(df_top5.index.values),
12 'fontsize': 14},
13 title={'label': "Data 5 Negara dengan Populasi Manusia Terbanyak di Dunia\n",
14 'loc': 'center',
15 'fontdict': {'fontsize': 20}},
16 icons='star',
17 icon_size=15,
18 icon_legend=True,
19 vertical=True
20 )

157
 Regression Plot
Dataset
Pada pembahasan kali ini, kita menggunakan dataset korban bunuh diri di negara India yang
dapat diunduh di website Kaggle.
Setelah melakukan load dataset menggunakan read_csv(), kita dapat menyimpannya ke
dalam variabel df.

1 import pandas as pd
2 import numpy as numpy
3 import seaborn as sns
4 import matplotlib.pyplot as plt
5 %matplotlib inline
6
7 df = pd.read_csv("/content/india_suicide_victims.csv")
8 df.head(10)

Selanjutnya kita bisa mengetahui informasi dari dataset.

1 df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6840 entries, 0 to 6839
Data columns (total 16 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 STATE/UT 6840 non-null object
1 Year 6840 non-null int64
2 CAUSE 6840 non-null object
3 Male upto 14 years 6840 non-null int64
4 Male 15-29 years 6840 non-null int64
5 Male 30-44 years 6840 non-null int64
6 Male 45-59 years 6840 non-null int64
7 Male 60 years and above 6840 non-null int64
8 Total Male 6840 non-null int64
9 Female upto 14 years 6840 non-null int64
10 Female 15-29 years 6840 non-null int64
11 Female 30-44 years 6840 non-null int64
12 Female 45-59 years 6840 non-null int64
13 Female 60 years and above 6840 non-null int64
14 Total Female 6840 non-null int64
15 Grand Total 6840 non-null int64
dtypes: int64(14), object(2)
memory usage: 855.1+ KB

Berdasarkan informasi di atas, kolom Grand Total dan Year sudah bertipe integer atau int64.
Kita akan menggunakan kedua kolom tersebut.

158
Sebelumnya, kita akan melakukan grouping berdasarkan kolom Year dan menampilkan
jumlah total orang yang melakukan bunuh diri dari kolom Grand Total menggunakan
agregasi sum.

1 # Grouping data
2 df_group = df.groupby(['Year'])[['Grand Total']].sum()
3 df_group

Grand Total
Year
2001 819795
2002 836010
2003 838407
2004 855804
2005 856005
2006 894756
2007 933711
2008 946230
2009 960807
2010 1019313
2011 1015659
2012 908076
Setelah mendapatkan data yang diperlukan, kita dapat membuat visualisasi data dengan
Regression Plot.

Visualisasi data dengan Regression Plot

Visualisasi data dengan regression plot bisa menggunakan library Seaborn.
Seaborn adalah sebuah library Python yang menyediakan high-level interface untuk
membuat grafik statistik yang menarik. Kita dapat membuat regression plot menggunakan
method regplot().
Penggunaan regplot(), kita dapat memberikan 3 argumen pada regplot(), diantaranya:

• x : Untuk mendefinisikan data yang akan ditampilkan pada sumbu X.

• y : Untuk mendefinisikan data yang akan ditampilkan pada sumbu Y.
• data : Untuk mendefinisikan dataframe yang digunakan.

159
Perhatikan kode berikut.

1 ax = sns.regplot(x=df_group.index.values, y='Grand Total', data=df_group)

Mengatur warna
Mengatur warna dengan menambahkan parameter color seperti di bawah ini.

1 # Mengatur warna pada regression plot

2 ax = sns.regplot(x=df_group.index.values, y='Grand Total', data=df_group,
3 color='purple')

160
Mengatur ukuran figure
Kita dapat mengatur ukuran figure menggunakan Matplotlib karena Seaborn bekerja
berdasarkan Matplotlib. Perhatikan kode berikut.

1 # Mengatur ukuran figure

2 plt.figure(figsize=(15, 10))
3 ax = sns.regplot(x=df_group.index.values, y='Grand Total', data=df_group,
4 color='orange')

Mengganti jenis titik (marker)

Apabila ingin mengganti bentuk marker, kita dapat menggantinya dengan menambahkan
parameter marker. Lihat kode di bawah ini.

1 # Mengatur jenis marker

2
3 plt.figure(figsize=(15, 10))
4 ax = sns.regplot(x=df_group.index.values, y='Grand Total', data=df_group,
5 color='navy', marker='+')

161
Mengubah ukuran marker
Selain mengganti bentuk martker, kita bisa mengatur ukuran marker dengan memberikan
parameter scatter_kws yang diberikan nilai berupa dictionary. Key 's' untuk mengatur
ukuran marker, untuk nilai berupa integer sebagai ukurannya. Perhatikan kode berikut.

1 # Mengubah ukuran marker

2
3 plt.figure(figsize=(15, 10))
4 ax = sns.regplot(x=df_group.index.values,
5 y='Grand Total',
6 data=df_group,
7 color='darkgreen',
8 marker='+',
9 scatter_kws={'s': 200})
10 plt.show()

162
Mengatur ukuran huruf
Mengatur ukuran huruf pada ticks, label, ataupun judul plot dengan menggunakan method
set() dari Seaborn dan memberikan argumen berupa parameter font_scale.

1 plt.figure(figsize=(15, 10))
2
3 sns.set(font_scale=1.5) # Mengatur ukuran huruf
4 ax = sns.regplot(x=df_group.index.values, y='Grand Total', data=df_group,
5 color='green', marker='+', scatter_kws={'s': 200})
6
7 ax.set(xlabel='\nTahun', ylabel="Jumlah Kasus Bunuh Diri\n")
8 ax.set_title("Jumlah Kasus Bunuh Diri Per Tahun\n")
9
10 plt.show()

163
Mengatur background menjadi berwarna putih
Warna default background adalah abu-abu. Kita bisa mengubah warna background tersebut
menjadi putih dengan menambahkan kode sns.set_style('ticks') seperti di bawah ini.

1 plt.figure(figsize=(15, 10))
2 sns.set(font_scale=1.5)
3
4 sns.set_style('ticks') # mengubah background menjadi berwarna putih
5 ax = sns.regplot(x=df_group.index.values,
6 y='Grand Total',
7 data=df_group,
8 color='darkgreen',
9 marker='+',
10 scatter_kws={'s': 200})
11
12 ax.set(xlabel='\nTahun', ylabel="Jumlah Kasus Bunuh Diri\n")
13 ax.set_title("Jumlah Kasus Bunuh Diri Per Tahun\n")
14
15 plt.show()

164
Menambahkan gridlines
Menambahkan gridlines pada regression plot dengan menambahkan kode
sns.set_style('whitegrid').

1 plt.figure(figsize=(15, 10))
2 sns.set(font_scale=1.5)
3
4 sns.set_style('whitegrid') # menambahkan gridlines
5 ax = sns.regplot(x=df_group.index.values,
6 y='Grand Total',
7 data=df_group,
8 color='darkgreen',
9 marker='+',
10 scatter_kws={'s': 200})
11
12 ax.set(xlabel='\nTahun', ylabel="Jumlah Kasus Bunuh Diri\n")
13 ax.set_title("Jumlah Kasus Bunuh Diri Per Tahun\n")
14
15 plt.show()

165
166