Data wrangling adalah proses persiapan dan transformasi data mentah menjadi format yang lebih mudah dikelola dan dianalisis. Fungsinya sangat penting dalam pengolahan data karena membantu mengatasi masalah yang umumnya muncul dalam data mentah, seperti kehilangan nilai (missing values), format yang tidak konsisten, atau duplikasi data. Berikut adalah beberapa fungsi utama dari data wrangling dalam pengolahan data:

1. Pembersihan Data (Data Cleaning): Menghilangkan atau mengatasi masalah data yang tidak lengkap, tidak valid, atau tidak akurat. Contohnya adalah menghapus entri duplikat, menangani nilai yang hilang, atau mengubah format data yang tidak sesuai.

2. Penggabungan Data (Data Integration): Menggabungkan beberapa sumber data menjadi satu set data yang lebih besar. Ini dapat melibatkan penggabungan data dari berbagai sumber yang berbeda atau menggabungkan data yang tersebar dalam beberapa tabel atau file.

3. Transformasi Data (Data Transformation): Mengubah struktur atau format data agar sesuai dengan kebutuhan analisis. Ini bisa mencakup pengubahan tipe data, normalisasi data, atau penghitungan metrik baru berdasarkan data yang ada.

4. Pemilihan Data (Data Selection): Memilih subset data yang relevan untuk analisis tertentu. Ini membantu mengurangi kompleksitas dan meningkatkan efisiensi analisis.

5. Ekstraksi Fitur (Feature Extraction): Menciptakan fitur baru dari data mentah yang dapat meningkatkan kualitas analisis atau meningkatkan kinerja model pembelajaran mesin.

6. Validasi Data (Data Validation): Memverifikasi keakuratan dan konsistensi data setelah dilakukan transformasi atau pemrosesan. Ini penting untuk memastikan keandalan hasil analisis.

Data wrangling merupakan tahap awal dan kritis dalam proses pengolahan data, karena kualitas dan kebersihan data yang baik merupakan dasar untuk analisis yang akurat dan hasil yang dapat diandalkan.

Sebuah mantra umum di era modern adalah Data adalah Minyak Baru, yang berarti data sekarang merupakan sumber daya yang lebih berharga daripada minyak. Tetapi seperti minyak mentah tidak langsung menjadi bensin dan harus diproses untuk mendapatkan bensin dan produk lainnya, data juga harus diurus, dimanipulasi, atau dibersihkan dan disempurnakan untuk digunakan dalam ilmu data dan produk berbasis ilmu data. Ini dikenal sebagai wrangling. Sebagian besar ilmuwan data menghabiskan sebagian besar waktunya untuk melakukan data wrangling.

Data wrangling umumnya dilakukan pada tahap awal dari pipa garis data ilmu data/analytics. Setelah ilmuwan data mengidentifikasi sumber data yang berguna untuk memecahkan masalah bisnis yang ada (misalnya, penyimpanan basis data internal, internet, atau data sensor streaming seperti sensor seismik bawah air), mereka kemudian melanjutkan dengan mengekstrak, membersihkan, dan memformat data yang diperlukan dari sumber-sumber tersebut.

Secara umum, tugas data wrangling melibatkan langkah-langkah berikut:

1. Mengambil data mentah dari beberapa sumber (termasuk web dan tabel database)
2. Melakukan imputasi (menggantikan data yang hilang menggunakan berbagai teknik), memformat, dan mentransformasi - pada dasarnya membuatnya siap untuk digunakan dalam proses pemodelan (seperti pembelajaran mesin yang canggih)
3. Menangani kesalahan baca/tulis
4. Mendeteksi pencilan
5. Melakukan visualisasi cepat (plotting) dan analisis statistik dasar untuk menilai kualitas data yang diformat

Proses data wrangling melibatkan menemukan data yang sesuai yang diperlukan untuk analisis. Seringkali, analisis bersifat eksploratif, sehingga cakupannya tidak cukup. Anda sering perlu melakukan data wrangling untuk jenis analisis ini agar dapat memahami data Anda dengan lebih baik. Hal ini dapat mengarah pada analisis atau pembelajaran mesin yang lebih lanjut.

Data ini dapat berasal dari satu atau beberapa sumber, seperti tweet, laporan transaksi bank dalam basis data relasional, data sensor, dan sebagainya. Data ini perlu dibersihkan. Jika ada data yang hilang, kami akan menghapusnya atau menggantinya, dengan bantuan beberapa teknik. Jika ada pencilan, kita perlu mendeteksinya dan kemudian menanganinya dengan tepat. Jika data berasal dari beberapa sumber, kita harus menggabungkannya menggunakan operasi SQL (Structured Query Language) seperti JOIN.

Dalam situasi yang sangat jarang, data wrangling mungkin tidak diperlukan. Misalnya, jika data yang diperlukan untuk tugas pembelajaran mesin sudah disimpan dalam format yang dapat diterima dalam basis data internal, maka queri SQL sederhana mungkin sudah cukup untuk mengekstrak data ke dalam tabel, siap untuk diteruskan ke tahap pemodelan.

Selalu ada perdebatan mengenai apakah melakukan proses wrangling menggunakan alat enterprise atau bahasa pemrograman dan kerangka kerja terkaitnya. Ada banyak alat komersial tingkat enterprise untuk pemformatan data dan pra-pemrosesan yang tidak melibatkan banyak penulisan kode oleh pengguna. Beberapa contoh ini termasuk:

• Platform analisis data umum, seperti Microsoft Excel (dengan add-in)
• Paket penemuan statistik, seperti JMP (dari SAS)
• Platform pemodelan, seperti RapidMiner
• Platform analitik dari pemain niche yang fokus pada data wrangling, seperti Trifacta, Paxata, dan Alteryx

Namun, bahasa pemrograman seperti Python dan R memberikan lebih banyak fleksibilitas, kontrol, dan kekuatan dibandingkan dengan alat jadi tersebut. Hal ini juga menjelaskan popularitas mereka yang luar biasa di domain ilmu data:

Selain itu, karena volume, kecepatan, dan variasi (tiga V dari big data) data mengalami perubahan cepat, selalu merupakan ide bagus untuk mengembangkan dan memelihara sejumlah besar keahlian internal dalam data wrangling menggunakan kerangka kerja pemrograman fundamental sehingga sebuah organisasi tidak terikat pada keinginan dan kecenderungan dari platform enterprise tertentu untuk tugas dasar seperti data wrangling.

Beberapa keuntungan yang jelas dari menggunakan paradigma pemrograman open source dan gratis untuk data wrangling adalah sebagai berikut:

• Paradigma open source umum tidak memberikan batasan pada metode apa pun yang dapat Anda kembangkan untuk masalah tertentu yang sedang dihadapi.
• Ada ekosistem yang besar dari perpustakaan open source yang cepat, dioptimalkan, yang fokus pada analisis data.
• Ada juga dukungan yang berkembang untuk menghubungkan Python ke setiap jenis sumber data yang dapat dipikirkan.
• Ada antarmuka yang mudah untuk pengujian statistik dasar dan perpustakaan visualisasi cepat untuk memeriksa kualitas data.
• Dan ada antarmuka yang mulus dari output data wrangling dengan model machine learning yang canggih. Python adalah bahasa yang paling populer untuk pembelajaran mesin dan kecerdasan buatan saat ini. Mari kita lihat beberapa struktur data di Python.

Di Python, Anda tidak perlu mengimpor modul khusus untuk menggunakan Lists, Sets, Strings, Tuples, dan Dictionaries karena mereka merupakan bagian dari bahasa Python yang sudah disertakan secara bawaan. Anda dapat menggunakan struktur data ini langsung tanpa mengimpor modul apa pun.

Namun, jika Anda ingin menggunakan fungsi atau metode tambahan yang disediakan oleh modul tertentu, misalnya, jika Anda ingin melakukan operasi yang lebih kompleks atau memiliki kinerja yang dioptimalkan, Anda mungkin perlu mengimpor modul tambahan seperti collections atau numpy untuk beberapa operasi khusus.

Berikut adalah contoh penggunaan beberapa struktur data di Python tanpa mengimpor modul tambahan:

`### Lists my_list = [1, 2, 3, 4, 5]

my_set = {1, 2, 3, 4, 5}

my_string = "Hello, world!"

my_tuple = (1, 2, 3, 4, 5)

my_dict = {'a': 1, 'b': 2, 'c': 3} `

Kita akan memulai bab ini dengan membahas struktur data lanjutan. Awalnya, kita akan kembali ke daftar (lists). Kemudian, kita akan membuat sebuah tumpukan (stack) dan sebuah antrian (queue), menjelajahi pemeriksaan keanggotaan elemen ganda untuk memeriksa apakah data tersebut akurat, dan menambahkan sedikit pemrograman fungsional sebagai tambahan. Jangan khawatir jika semua ini terdengar menakutkan. Kita akan mengambil langkah demi langkah, dan Anda akan merasa percaya diri dalam menangani struktur data lanjutan setelah menyelesaikan bab ini. Sebelum kita melompat ke pembangunan struktur data, kita akan melihat beberapa metode untuk memanipulasinya.

Iterator dalam Python sangat berguna saat berurusan dengan data karena memungkinkan Anda untuk mengurai data satu unit pada satu waktu. Iterator bersifat stateful, yang berarti akan membantu untuk melacak status sebelumnya. Sebuah iterator adalah objek yang mengimplementasikan metode next—artinya sebuah iterator dapat mengulangi koleksi seperti daftar (lists), tuple, kamus (dictionaries), dan lainnya. Secara praktis, ini berarti bahwa setiap kali kita memanggil metode, itu memberikan elemen berikutnya dari koleksi; jika tidak ada elemen lebih lanjut dalam daftar, maka itu akan menimbulkan pengecualian StopIteration.

Dalam latihan ini, kita akan membuat daftar panjang (long list) yang berisi angka. Pertama, kita akan memeriksa memori yang digunakan oleh daftar yang dihasilkan. Kemudian, kita akan melihat bagaimana cara menggunakan modul iterator untuk mengurangi penggunaan memori, dan akhirnya, kita akan menggunakan iterator ini untuk mengulang daftar tersebut. Untuk melakukannya, mari kita ikuti langkah-langkah berikut:

1. Buka Jupyter Notebook baru dan buat daftar yang akan berisi 10000000 angka satu. Kemudian, simpan daftar ini dalam variabel yang disebut big_list_of_numbers: big_list_of_numbers = [1 for x in range (0, 10000000)] big_list_of_numbers menghasilkan output: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

2. Memeriksa ukuran variabel from sys import getsizeof getsizeof(big_list_of_numbers) output 81528056 Nilai yang ditunjukkan adalah 81528056 (dalam byte). Ini adalah sejumlah memori besar yang digunakan oleh daftar tersebut. Dan variabel big_list_of_numbers hanya tersedia setelah pemahaman daftar selesai. Ini juga dapat melampaui memori sistem yang tersedia jika Anda mencoba menggunakan angka yang terlalu besar.

3. Mari gunakan metode repeat() dari itertools untuk mendapatkan jumlah yang sama tetapi dengan penggunaan memori yang lebih sedikit:

from itertools import repeat small_list_of_numbers = repeat(1, times=10000000) getsizeof(small_list_of_numbers)

4. Lakukan perulangan di atas iterator yang baru dihasilkan: for i, x in enumerate(small_list_of_numbers): print(x) if i > 10: break

output: 1 1 1 1 1 1 1 1 1 1 1 1 1 Kami menggunakan fungsi enumerate sehingga mendapatkan penghitung perulangan, bersama dengan nilainya. Ini akan membantu dalam menghentikan perulangan begitu kami mencapai jumlah tertentu (10, misalnya).

Stacks adalah struktur data yang sangat berguna. Jika Anda sedikit mengerti tentang internal CPU dan bagaimana program dieksekusi, maka Anda akan tahu bahwa tumpukan hadir dalam banyak kasus seperti itu. Ini adalah daftar sederhana dengan satu batasan, Last In First Out (LIFO), yang berarti elemen yang masuk terakhir keluar pertama kali saat nilai dibaca dari tumpukan. Ilustrasi berikut akan menjelaskan hal ini sedikit lebih jelas:

Seperti yang Anda lihat, kami memiliki strategi LIFO untuk membaca nilai dari tumpukan. Kami akan mengimplementasikan tumpukan menggunakan daftar Python. Daftar Python memiliki metode yang disebut pop, yang melakukan operasi pop yang sama persis seperti yang dapat Anda lihat dalam ilustrasi sebelumnya. Pada dasarnya, fungsi pop akan mengambil sebuah elemen dari tumpukan, menggunakan aturan Last in First Out (LIFO). Kami akan menggunakan itu untuk mengimplementasikan tumpukan dalam latihan berikut

Dalam latihan ini, kita akan mengimplementasikan sebuah stack dalam Python. Pertama, kita akan membuat stack kosong dan menambahkan elemen-elemen baru ke dalamnya menggunakan metode append. Selanjutnya, kita akan mengeluarkan elemen dari stack menggunakan metode pop. Mari kita ikuti langkah-langkah berikut:

Dalam latihan ini, kita akan melanjutkan topik tentang tumpukan dari latihan sebelumnya. Kali ini, kita akan menerapkan fungsi append dan pop dengan membuat metode yang didefinisikan pengguna. Kita akan menerapkan sebuah tumpukan, dan kali ini dengan contoh penggunaan bisnis (mengambil Wikipedia sebagai sumber). Tujuan dari latihan ini ada dua. Pada beberapa langkah awal, kita akan mengekstrak dan menambahkan URL yang diambil dari sebuah halaman web ke dalam sebuah tumpukan, yang juga melibatkan metode string yang dibahas dalam bab terakhir. Pada beberapa langkah berikutnya, kita akan menggunakan fungsi stack_pop untuk mengulang tumpukan dan mencetaknya. Latihan ini akan menunjukkan kepada kita sebuah fitur halus dari Python dan bagaimana cara Python menangani variabel daftar yang dilewatkan ke fungsi. Mari ikuti langkah-langkah berikut:

1. Membuat 2 fungsi: stack_push dan stack_pop

2. Analisislah string sehingga kita dapat mendorong URL ke dalam tumpukan satu per satu saat kita menemui mereka, dan kemudian gunakan loop for untuk mengeluarkan mereka satu per satu. Mari ambil baris pertama dari artikel Wikipedia (https://en.wikipedia.org/wiki/Data_mining) tentang ilmu data:

Ilmu data adalah bidang lintas disiplin yang menggunakan metode ilmiah, proses, algoritma, dan sistem untuk mengekstraksi pengetahuan [https://en.wikipedia.org/wiki/Knowledge] dan wawasan dari data [https://en.wikipedia.org/wiki/Data] dalam berbagai bentuk, baik yang terstruktur maupun tidak terstruktur, mirip dengan penambangan data [https://en.wikipedia.org/wiki/Data_mining].

len(wikipedia_datascience) wd_list = wikipedia_datascience.split() wd_list len(wd_list)

3. Gunakan sebuah loop for untuk membaca setiap kata dan periksa apakah itu merupakan URL. Untuk melakukannya, kita akan menggunakan metode startswith dari string, dan jika itu adalah URL, maka kita akan memasukkannya ke dalam stack: for word in wd_list: if word.startswith("[https://"): url_stack = stack_push(url_stack, word[1:-1]) print(word[1:-1]) output: print(url_stack)

4. Jika Anda memiliki fungsi stack_popz yang dapat digunakan untuk mengeluarkan elemen dari tumpukan (stack), Anda dapat menggunakan loop untuk mengeluarkan dan mencetak URL satu per satu.

Membuat fungsi dengan lambda expression, berbeda dengan def. Bahkan, lambda expression memiliki kelebihan yang tidak dimiliki def. Harapannya, nanti kamu akan bisa paham cara membuat fungsi dengan lambda expression serta dapat menggunakannya dalam program.

Lambda expression di Python adalah sebuah ekspresi untuk membuat fungsi. Lambda sendiri berasal dari teori kalkulus, yakni Lambda Calculus yang dikenalkan oleh Alonzo Church di tahun 1930. Berkat lambda, kita bisa membuat fungsi tanpa nama atau dikenal juga dengan anonymous function.

Misalkan kita punya fungsi penjumlahan kuadrat seperti ini:

def suqare_sum(x,y): return x**2 + y**2 Nah, dengan lambda.. kita tidak perlu menggunakan def dan return, bahkan kita juga tidak perlu menuliskan namanya. lambda x,y : x**2 + y**2

Ini adalah format untuk membuat fungsi lambda:

Fungsi lambda di Python Lambda bisa memiliki lebih dari satu argumen atau parameter, tapi hanya bisa memiliki satu ekspresi atau isi. Eksekusi function: (lambda x,y: x**2 + y**2)(4,6) atau hasil = (lambda x,y: x**2 + y**2)(4,6)

Perhatikan persamaan berikut:

Lakukan eksekusi pada function tersebut. Hint: gunakan package math.

Selain tumpukan (stacks), jenis struktur data tingkat tinggi lain yang menarik bagi kita adalah antrian (queues). Antrian mirip dengan tumpukan, yang berarti Anda terus menambahkan elemen satu per satu. Dengan antrian, pembacaan elemen mengikuti strategi Pertama Masuk Pertama Keluar (First in First Out, FIFO). Perhatikan diagram berikut untuk memahaminya lebih baik:

Antrian adalah struktur data yang sangat penting. Kita bisa membayangkan sebuah skenario pada desain sistem produsen-konsumen. Saat melakukan data wrangling, Anda sering kali akan menemui masalah di mana Anda harus memproses file yang sangat besar. Salah satu cara untuk menangani masalah ini adalah dengan membagi isi file menjadi bagian-bagian kecil dan kemudian memasukkannya ke dalam sebuah antrian sambil membuat proses pekerja kecil yang didedikasikan, untuk membaca dari antrian dan memproses satu bagian kecil setiap kali. Ini adalah desain yang sangat kuat, dan Anda bahkan dapat menggunakannya secara efisien untuk merancang pipa data wrangling multi-node yang besar.

Array NumPy adalah mirip dengan daftar (List) tetapi berbeda dalam beberapa hal. Dalam kehidupan seorang ilmuwan data, membaca dan memanipulasi array adalah hal yang sangat penting, dan juga merupakan tugas yang paling sering dihadapi. Array ini bisa berupa daftar satu dimensi, tabel multi-dimensi, atau matriks yang penuh dengan angka dan dapat digunakan untuk berbagai perhitungan matematika. Sebuah array bisa diisi dengan bilangan bulat, bilangan pecahan, Booleans, string, atau bahkan tipe-tipe campuran. Namun, dalam kebanyakan kasus, tipe data numerik mendominasi. Beberapa skenario contoh di mana Anda akan perlu menangani array numerik adalah sebagai berikut:

• Untuk membaca daftar nomor telepon dan kode pos dan mengekstrak pola tertentu
• Untuk membuat matriks dengan angka acak untuk menjalankan simulasi Monte Carlo pada proses statistik
• Untuk menyesuaikan dan menormalkan tabel angka penjualan, dengan banyak data keuangan dan transaksional
• Untuk membuat tabel kecil dari statistik deskriptif kunci (misalnya, rata-rata, median, rentang min/maks, varians, dan rentang kuartil) dari tabel data mentah besar
• Untuk membaca dan menganalisis data deret waktu dalam array satu dimensi setiap hari, seperti harga saham sebuah organisasi selama setahun atau data suhu harian dari stasiun cuaca

Singkatnya, array dan tabel data numerik ada di mana-mana. Sebagai seorang profesional pengelolaan data, pentingnya kemampuan untuk membaca dan memproses array numerik tidak bisa diabaikan. Sangat umum untuk bekerja dengan data dan perlu memodifikasinya dengan fungsi matematika. Dalam hal ini, array NumPy adalah objek paling penting dalam Python yang perlu Anda ketahui.

NumPy dan SciPy adalah modul tambahan sumber terbuka untuk Python yang menyediakan rutinitas matematika dan numerik umum dalam fungsi-fungsi yang telah dikompilasi sebelumnya dan cepat. Selama bertahun-tahun, ini telah berkembang menjadi perpustakaan yang sangat matang yang menyediakan fungsionalitas yang memenuhi, atau mungkin melebihi, apa yang terkait dengan perangkat lunak komersial umum seperti Matlab atau Mathematica. Salah satu keuntungan utama dari modul NumPy adalah bahwa ia dapat digunakan untuk menangani atau membuat array satu dimensi atau multi-dimensi. Struktur/data kelas lanjutan ini adalah inti dari paket NumPy dan berfungsi sebagai blok bangunan dasar dari konsep yang lebih canggih, seperti perpustakaan pandas dan khususnya, DataFrame pandas, yang akan kita bahas segera dalam bab ini. Array NumPy berbeda dengan daftar Python umum karena daftar Python dapat dianggap sebagai array sederhana. Array NumPy dibangun untuk operasi vektor matematika yang tervektorisasi yang memproses banyak data numerik dengan hanya satu baris kode. Banyak fungsi matematika bawaan dalam array NumPy ditulis dalam bahasa rendah seperti C atau Fortran dan telah dikompilasi sebelumnya untuk eksekusi yang sangat cepat. Catatan Array NumPy adalah struktur data yang dioptimalkan untuk analisis numerik, dan itulah mengapa mereka sangat penting bagi ilmuwan data.

conda install numpy

Atau

pip install numpy

Membuat Array Multi-Dimensi

Untuk membuat array multi-dimensi menggunakan NumPy, kita dapat menggunakan fungsi numpy.array() dengan menyediakan nested list yang mewakili array multidimensi tersebut. Misalnya, untuk membuat array 2D, kita dapat memberikan nested list dua dimensi seperti ini:

import numpy as np

# Membuat array 2D
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Array 2D:")
print(array_2d)

Output:

Array 2D:
[[1 2 3]
 [4 5 6]]

Untuk membuat array 3D, kita dapat menyediakan nested list tiga dimensi:

# Membuat array 3D
array_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("Array 3D:")
print(array_3d)

Output:

Array 3D:
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

NumPy menyediakan berbagai fungsi dan metode untuk melakukan operasi hitung pada array multidimensi. Berikut adalah beberapa contoh operasi umum:

1. Penjumlahan atau Pengurangan:

   import numpy as np
   
   # Membuat dua array 2D
   array1 = np.array([[1, 2], [3, 4]])
   array2 = np.array([[5, 6], [7, 8]])
   
   # Penjumlahan dua array
   hasil_penjumlahan = array1 + array2
   print("Penjumlahan array:")
   print(hasil_penjumlahan)
   
   # Pengurangan dua array
   hasil_pengurangan = array1 - array2
   print("\nPengurangan array:")
   print(hasil_pengurangan)

2. Perkalian atau Pembagian:

   # Membuat array 2D
   array = np.array([[1, 2], [3, 4]])
   
   # Perkalian dengan skalar
   hasil_perkalian_skalar = array * 2
   print("Perkalian dengan skalar:")
   print(hasil_perkalian_skalar)
   
   # Pembagian dengan skalar
   hasil_pembagian_skalar = array / 2
   print("\nPembagian dengan skalar:")
   print(hasil_pembagian_skalar)

3. Operasi Perkalian Dot (Dot Product):

   # Membuat dua array 2D
   array1 = np.array([[1, 2], [3, 4]])
   array2 = np.array([[5, 6], [7, 8]])
   
   # Perkalian dot (dot product) dua array
   hasil_dot_product = np.dot(array1, array2)
   print("Hasil perkalian dot:")
   print(hasil_dot_product)

4. Operasi Transpose:

   # Transpose array
   array_transpose = np.transpose(array)
   print("Transpose array:")
   print(array_transpose)

5. Fungsi Matematika Universal (Universal Functions): NumPy memiliki fungsi matematika universal (ufunc) seperti np.sin(), np.cos(), np.exp(), dan lainnya yang dapat diterapkan pada array multidimensi.

Dalam NumPy, terdapat beberapa fungsi bawaan yang memungkinkan kita untuk membuat matriks dan vektor dengan nilai tertentu, seperti nol, satu, nilai acak, matriks identitas, dan vektor tertentu. Berikut adalah penjelasan singkat tentang setiap fungsi:

1. zeros: Fungsi np.zeros digunakan untuk membuat array dengan semua elemen bernilai nol.

   import numpy as np
   
   # Membuat matriks 3x3 dengan semua elemen nol
   zeros_matrix = np.zeros((3, 3))
   print("Matriks dengan semua elemen nol:")
   print(zeros_matrix)

2. ones: Fungsi np.ones digunakan untuk membuat array dengan semua elemen bernilai satu.

   # Membuat matriks 2x4 dengan semua elemen satu
   ones_matrix = np.ones((2, 4))
   print("\nMatriks dengan semua elemen satu:")
   print(ones_matrix)

3. random: Fungsi np.random.rand digunakan untuk membuat array dengan elemen-elemen acak antara 0 dan 1.

   # Membuat matriks 2x3 dengan elemen-elemen acak antara 0 dan 1
   random_matrix = np.random.rand(2, 3)
   print("\nMatriks dengan elemen acak:")
   print(random_matrix)

4. identity: Fungsi np.identity digunakan untuk membuat matriks identitas dengan ukuran tertentu.

   # Membuat matriks identitas 4x4
   identity_matrix = np.identity(4)
   print("\nMatriks identitas:")
   print(identity_matrix)

5. arange: Fungsi np.arange digunakan untuk membuat vektor dengan urutan nilai tertentu.

   # Membuat vektor dengan nilai dari 0 hingga 9
   range_vector = np.arange(10)
   print("\nVektor dengan nilai dari 0 hingga 9:")
   print(range_vector)

Di NumPy, terdapat sejumlah fungsi penting untuk melakukan pengelolaan dan manipulasi array. Berikut adalah beberapa fungsi penting:

Fungsi reshape digunakan untuk mengubah bentuk (shape) dari array tanpa mengubah datanya. Ini sering digunakan untuk mengubah array menjadi dimensi yang diinginkan.

import numpy as np

# Membuat array 1D dengan 12 elemen
arr = np.arange(12)
print("Array awal:")
print(arr)

# Mengubah array menjadi matriks 3x4
reshaped_arr = arr.reshape(3, 4)
print("\nArray yang telah direshape:")
print(reshaped_arr)

Fungsi ravel digunakan untuk meratakan (flatten) array multi-dimensi menjadi array 1 dimensi.

# Meratakan matriks kembali menjadi array 1 dimensi
flattened_arr = reshaped_arr.ravel()
print("\nArray yang telah diratakan:")
print(flattened_arr)

Fungsi min dan max digunakan untuk mencari nilai minimum dan maksimum dalam array. Fungsi sort digunakan untuk mengurutkan elemen-elemen array.

# Mencari nilai minimum, maksimum, dan mengurutkan array
print("\nNilai minimum:", arr.min())
print("Nilai maksimum:", arr.max())

# Mengurutkan array secara ascending
arr_sorted = np.sort(arr)
print("Array yang telah diurutkan:")
print(arr_sorted)

NumPy mendukung indeks dan slicing seperti pada list Python, tetapi dengan lebih banyak kemampuan untuk menangani array multi-dimensi.

# Mengakses elemen array dengan indeks dan slicing
print("\nElemen pertama:", arr[0])
print("Slicing dari indeks 2 hingga 5:", arr[2:6])
print("Elemen terakhir:", arr[-1])

# Slicing array 2D
print("\nElemen pada baris pertama, kolom kedua:", reshaped_arr[0, 1])
print("Slicing baris kedua:", reshaped_arr[1, :])

Dengan fungsi-fungsi ini, kita dapat dengan mudah melakukan operasi-operasi dasar pada array NumPy.

Dalam NumPy, ada beberapa fungsi penting yang digunakan untuk melakukan manipulasi dan pengelolaan array. Berikut adalah beberapa di antaranya:

Fungsi reshape digunakan untuk mengubah bentuk (shape) dari array tanpa mengubah datanya. Ini berguna untuk mengubah array ke dimensi yang diinginkan.

import numpy as np

# Membuat array 1D dengan 12 elemen
arr = np.arange(12)
print("Array awal:")
print(arr)

# Mengubah array menjadi matriks 3x4
reshaped_arr = arr.reshape(3, 4)
print("\nArray yang telah direshape:")
print(reshaped_arr)

Fungsi ravel digunakan untuk meratakan (flatten) array multi-dimensi menjadi array 1 dimensi.

# Meratakan matriks kembali menjadi array 1 dimensi
flattened_arr = reshaped_arr.ravel()
print("\nArray yang telah diratakan:")
print(flattened_arr)

Fungsi min dan max digunakan untuk mencari nilai minimum dan maksimum dalam array. Fungsi sort digunakan untuk mengurutkan elemen-elemen array.

# Mencari nilai minimum, maksimum, dan mengurutkan array
print("\nNilai minimum:", arr.min())
print("Nilai maksimum:", arr.max())

# Mengurutkan array secara ascending
arr_sorted = np.sort(arr)
print("Array yang telah diurutkan:")
print(arr_sorted)

NumPy mendukung indeks dan slicing seperti pada list Python, tetapi dengan lebih banyak kemampuan untuk menangani array multi-dimensi.

# Mengakses elemen array dengan indeks dan slicing
print("\nElemen pertama:", arr[0])
print("Slicing dari indeks 2 hingga 5:", arr[2:6])
print("Elemen terakhir:", arr[-1])

# Slicing array 2D
print("\nElemen pada baris pertama, kolom kedua:", reshaped_arr[0, 1])
print("Slicing baris kedua:", reshaped_arr[1, :])

Operasi pada array multi-dimensi sangat penting dalam pengolahan data. NumPy menyediakan berbagai fungsi untuk melakukan operasi pada array multi-dimensi. Berikut adalah beberapa operasi yang sering digunakan:

NumPy memungkinkan untuk melakukan operasi aritmatika antara array dengan array lainnya, atau array dengan skalar.

import numpy as np

# Membuat dua array multi-dimensi
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# Penambahan
print("Penambahan:")
print(arr1 + arr2)

# Pengurangan
print("\nPengurangan:")
print(arr1 - arr2)

# Perkalian
print("\nPerkalian:")
print(arr1 * arr2)

# Pembagian
print("\nPembagian:")
print(arr1 / arr2)

# Operasi dengan skalar
print("\nOperasi dengan skalar:")
print(arr1 + 2)

NumPy juga menyediakan fungsi untuk melakukan operasi statistik pada array multi-dimensi, seperti menghitung rata-rata, standar deviasi, dan lainnya.

# Menghitung rata-rata
print("Rata-rata arr1:", np.mean(arr1))

# Menghitung standar deviasi
print("Standar deviasi arr2:", np.std(arr2))

# Menghitung nilai maksimum
print("Nilai maksimum arr1:", np.max(arr1))

# Menghitung nilai minimum
print("Nilai minimum arr2:", np.min(arr2))

NumPy juga menyediakan berbagai fungsi matematika yang dapat diterapkan pada array, seperti sin, cos, log, dll.

# Sinus
print("Sinus arr1:")
print(np.sin(arr1))

# Logaritma natural
print("\nLogaritma natural arr2:")
print(np.log(arr2))

Stacking array adalah proses menggabungkan beberapa array menjadi satu array tunggal. NumPy menyediakan fungsi np.stack() untuk melakukan stacking array.

Berikut adalah contoh penggunaan stacking array dengan NumPy:

import numpy as np

# Membuat dua array
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# Melakukan stacking secara vertikal (menambahkan array sebagai baris baru)
vertical_stack = np.stack((arr1, arr2))
print("Stacking secara vertikal:")
print(vertical_stack)

# Melakukan stacking secara horizontal (menambahkan array sebagai kolom baru)
horizontal_stack = np.stack((arr1, arr2), axis=1)
print("\nStacking secara horizontal:")
print(horizontal_stack)

Output:

Stacking secara vertikal:
[[1 2 3]
 [4 5 6]]

Stacking secara horizontal:
[[1 4]
 [2 5]
 [3 6]]

Dalam contoh di atas, np.stack() digunakan untuk melakukan stacking secara vertikal dan horizontal. Dengan menentukan parameter axis, kita dapat mengatur arah stacking yang diinginkan. Perhatikan bahwa semua array yang akan di-stacking harus memiliki dimensi yang sama.

#PANDAS

Pandas adalah paket Python yang menyediakan struktur data yang cepat, fleksibel, dan ekspresif yang dirancang untuk membuat bekerja dengan data yang terkait atau berlabel menjadi mudah dan intuitif. Tujuannya adalah menjadi blok bangunan tingkat tinggi yang mendasar untuk melakukan analisis data praktis di dunia nyata dengan menggunakan Python. Selain itu, tujuannya lebih luas untuk menjadi alat analisis/manipulasi data sumber terbuka yang paling kuat dan fleksibel yang tersedia dalam bahasa apa pun.

Dua struktur data utama dari pandas adalah Series (satu dimensi) dan DataFrames (dua dimensi) dan keduanya menangani sebagian besar kasus penggunaan yang tipikal. pandas dibangun di atas NumPy dan dimaksudkan untuk terintegrasi dengan baik dalam lingkungan komputasi ilmiah dengan banyak pustaka pihak ketiga lainnya.

Mari kita lihat beberapa latihan untuk memahami teknik pengelolaan data menggunakan Library pandas.

conda install pandas

Atau

pip install pandas

import numpy as np

# 1. Create a pandas series with numerical data
labels = ['a', 'b', 'c']
my_data = [10, 20, 30]
array_1 = np.array(my_data)
d = {'a': 10, 'b': 20, 'c': 30}

import pandas as pd

print("\nHolding numerical data\n", '-' * 25, sep='')
print(pd.Series(array_1))

# 2. Create a pandas series with labels
print("\nHolding text labels\n", '-' * 20, sep='')
print(pd.Series(labels))

# 3. Create a pandas series with functions
print("\nHolding functions\n", '-' * 20, sep='')
print(pd.Series(data=[sum, print, len]))

# 4. Create a pandas series with a dictionary
print("\nHolding objects from a dictionary\n", '-' * 40, sep='')
print(pd.Series(data=[d.keys, d.items, d.values]))

Output

Holding numerical data
-------------------------
0    10
1    20
2    30
dtype: int64

Holding text labels
--------------------
0    a
1    b
2    c
dtype: object

Holding functions
--------------------
0      <built-in function sum>
1    <built-in function print>
2      <built-in function len>
dtype: object

Holding objects from a dictionary
----------------------------------------
0    <built-in method keys of dict object at 0x7fb8...
1    <built-in method items of dict object at 0x7fb...
2    <built-in method values of dict object at 0x7f...
dtype: object

import pandas as pd

# Creating a pandas series from a list
my_list = [10, 20, 30, 40, 50]
series_from_list = pd.Series(my_list)
print("Series from list:")
print(series_from_list)

# Creating a pandas series from a numpy array
import numpy as np
my_array = np.array([10, 20, 30, 40, 50])
series_from_array = pd.Series(my_array)
print("\nSeries from numpy array:")
print(series_from_array)

# Creating a pandas series with custom index
custom_index = ['a', 'b', 'c', 'd', 'e']
series_with_custom_index = pd.Series(my_list, index=custom_index)
print("\nSeries with custom index:")
print(series_with_custom_index)

# Creating a pandas series from a dictionary
my_dict = {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}
series_from_dict = pd.Series(my_dict)
print("\nSeries from dictionary:")
print(series_from_dict)

Output:

Series from list:
0    10
1    20
2    30
3    40
4    50
dtype: int64

Series from numpy array:
0    10
1    20
2    30
3    40
4    50
dtype: int32

Series with custom index:
a    10
b    20
c    30
d    40
e    50
dtype: int64

Series from dictionary:
a    10
b    20
c    30
d    40
e    50
dtype: int64

import numpy as np
import pandas as pd

labels = ['a','b','c']
my_data = [10,20,30]

array_1 = np.array(my_data)
d = {'a':10,'b':20,'c':30}

print ("\nHolding numerical data\n",'-'*25, sep='')
print(pd.Series(array_1))

print ("\nHolding text labels\n",'-'*20, sep='')
print(pd.Series(labels))

print ("\nHolding functions\n",'-'*20, sep='')
print(pd.Series(data=[sum,print,len]))

print ("\nHolding objects from a dictionary\n",'-'*40, sep='')
print(pd.Series(data=[d.keys, d.items, d.values]))

output

import numpy as np
import pandas as pd

labels = ['a','b','c']
my_data = [10,20,30]

array_1 = np.array(my_data)
d = {'a':10,'b':20,'c':30}

print ("\nHolding numerical data\n",'-'*25, sep='')
print(pd.Series(array_1))

print ("\nHolding text labels\n",'-'*20, sep='')
print(pd.Series(labels))

print ("\nHolding functions\n",'-'*20, sep='')
print(pd.Series(data=[sum,print,len]))

print ("\nHolding objects from a dictionary\n",'-'*40, sep='')
print(pd.Series(data=[d.keys, d.items, d.values]))

Holding numerical data
-------------------------
0    10
1    20
2    30
dtype: int64

Holding text labels
--------------------
0    a
1    b
2    c
dtype: object

Holding functions
--------------------
0      <built-in function sum>
1    <built-in function print>
2      <built-in function len>
dtype: object

Holding objects from a dictionary
----------------------------------------
0    <built-in method keys of dict object at 0x0000...
1    <built-in method items of dict object at 0x000...
2    <built-in method values of dict object at 0x00...
dtype: object

import pandas as pd

# Creating a DataFrame from a dictionary
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 35, 21, 42],
        'Gender': ['Male', 'Female', 'Male', 'Female']}
df = pd.DataFrame(data)
print("DataFrame created from dictionary:")
print(df)

# Creating a DataFrame from a list of lists with column labels
data = [[10, 'A', True],
        [20, 'B', False],
        [30, 'C', True]]
columns = ['Number', 'Letter', 'Is_True']
df = pd.DataFrame(data, columns=columns)
print("\nDataFrame created from list of lists:")
print(df)

# Creating a DataFrame from a list of dictionaries
data = [{'Name': 'John', 'Age': 28, 'Gender': 'Male'},
        {'Name': 'Anna', 'Age': 35, 'Gender': 'Female'},
        {'Name': 'Peter', 'Age': 21, 'Gender': 'Male'},
        {'Name': 'Linda', 'Age': 42, 'Gender': 'Female'}]
df = pd.DataFrame(data)
print("\nDataFrame created from list of dictionaries:")
print(df)

Output:

DataFrame created from dictionary:
    Name  Age  Gender
0   John   28    Male
1   Anna   35  Female
2  Peter   21    Male
3  Linda   42  Female

DataFrame created from list of lists:
   Number Letter  Is_True
0      10      A     True
1      20      B    False
2      30      C     True

DataFrame created from list of dictionaries:
    Name  Age  Gender
0   John   28    Male
1   Anna   35  Female
2  Peter   21    Male
3  Linda   42  Female

Untuk melihat sebagian dari DataFrame di Pandas, Anda dapat menggunakan metode head() dan tail() untuk menampilkan beberapa baris pertama atau beberapa baris terakhir, secara berturut-turut. Selain itu, Anda dapat menggunakan slicing atau metode iloc[] untuk melihat baris dan kolom tertentu. Berikut cara melakukannya:

import pandas as pd

# Membuat DataFrame contoh
data = {
    'Nama': ['John', 'Anna', 'Peter', 'Linda', 'Tom'],
    'Usia': [28, 35, 45, 30, 42],
    'Kota': ['New York', 'Paris', 'London', 'Berlin', 'Tokyo']
}
df = pd.DataFrame(data)

# Melihat 3 baris pertama menggunakan head()
print("Tiga baris pertama:")
print(df.head(3))

# Melihat 2 baris terakhir menggunakan tail()
print("\nDua baris terakhir:")
print(df.tail(2))

# Melihat baris dan kolom tertentu menggunakan iloc[]
print("\nBaris dan kolom tertentu:")
print(df.iloc[1:4, 0:2])  # Baris 2 hingga 4, Kolom 1 hingga 2

Keluaran:

Tiga baris pertama:
    Nama  Usia      Kota
0   John    28  New York
1   Anna    35     Paris
2  Peter    45    London

Dua baris terakhir:
    Nama  Usia    Kota
3  Linda    30  Berlin
4    Tom    42   Tokyo

Baris dan kolom tertentu:
    Nama  Usia
1   Anna    35
2  Peter    45
3  Linda    30

Untuk mengindeks dan memotong kolom dalam DataFrame Pandas, Anda dapat menggunakan nama kolom atau posisi indeks kolom. Berikut adalah beberapa cara untuk melakukannya:

1. Menggunakan Nama Kolom:

import pandas as pd

# Membuat DataFrame contoh
data = {
    'Nama': ['John', 'Anna', 'Peter', 'Linda', 'Tom'],
    'Usia': [28, 35, 45, 30, 42],
    'Kota': ['New York', 'Paris', 'London', 'Berlin', 'Tokyo']
}
df = pd.DataFrame(data)

# Mengakses satu kolom dengan nama
nama_kolom = df['Nama']
print(nama_kolom)

2. Menggunakan Slicing untuk Memilih Beberapa Kolom:

# Memilih beberapa kolom menggunakan slicing
beberapa_kolom = df[['Nama', 'Usia']]
print(beberapa_kolom)

3. Menggunakan Metode .loc[] untuk Mengindeks Berdasarkan Nama Kolom:

# Mengindeks berdasarkan nama kolom menggunakan .loc[]
nama_kota = df.loc[:, 'Kota']
print(nama_kota)

4. Menggunakan Metode .iloc[] untuk Mengindeks Berdasarkan Posisi Indeks Kolom:

# Mengindeks berdasarkan posisi indeks kolom menggunakan .iloc[]
usia = df.iloc[:, 1]
print(usia)

5. Menggunakan Operator Slicing : untuk Memilih Sebagian Kolom:

# Memilih sebagian kolom menggunakan operator slicing
sebagian_kolom = df.loc[:, 'Usia':'Kota']
print(sebagian_kolom)

Untuk mengindeks dan memotong baris dalam DataFrame Pandas, Anda dapat menggunakan metode .loc[] dan .iloc[]. Berikut adalah beberapa cara untuk melakukannya:

1. Menggunakan .loc[] untuk Mengindeks Berdasarkan Label Baris:

import pandas as pd

# Membuat DataFrame contoh
data = {
    'Nama': ['John', 'Anna', 'Peter', 'Linda', 'Tom'],
    'Usia': [28, 35, 45, 30, 42],
    'Kota': ['New York', 'Paris', 'London', 'Berlin', 'Tokyo']
}
df = pd.DataFrame(data, index=['A', 'B', 'C', 'D', 'E'])

# Mengindeks baris menggunakan label
baris_A = df.loc['A']
print(baris_A)

2. Menggunakan .iloc[] untuk Mengindeks Berdasarkan Posisi Indeks Baris:

# Mengindeks berdasarkan posisi indeks baris menggunakan .iloc[]
baris_keempat = df.iloc[3]
print(baris_keempat)

3. Menggunakan Operator Slicing : untuk Memotong Beberapa Baris:

# Memotong beberapa baris menggunakan operator slicing
baris_2_4 = df.iloc[1:4]
print(baris_2_4)

4. Memilih Baris Berdasarkan Kondisi Logis:

# Memilih baris berdasarkan kondisi logis
baris_usia_lebih_dari_30 = df[df['Usia'] > 30]
print(baris_usia_lebih_dari_30)

Untuk membuat dan menghapus kolom atau baris pada DataFrame Pandas, Anda dapat menggunakan metode .drop() untuk menghapus baris atau kolom, dan metode .insert() untuk menambahkan kolom baru. Berikut contohnya:

1. Membuat Kolom Baru:

import pandas as pd

# Membuat DataFrame contoh
data = {
    'Nama': ['John', 'Anna', 'Peter', 'Linda', 'Tom'],
    'Usia': [28, 35, 45, 30, 42],
    'Kota': ['New York', 'Paris', 'London', 'Berlin', 'Tokyo']
}
df = pd.DataFrame(data)

# Membuat kolom baru
df['Pekerjaan'] = ['Engineer', 'Doctor', 'Teacher', 'Artist', 'Manager']

print(df)

2. Menghapus Kolom:

# Menghapus kolom 'Usia'
df = df.drop(columns=['Usia'])

print(df)

3. Membuat Baris Baru:

# Membuat baris baru dengan data baru
new_row = pd.DataFrame({'Nama': ['Alice'], 'Pekerjaan': ['Lawyer'], 'Kota': ['Los Angeles']})

# Menambahkan baris baru ke DataFrame
df = pd.concat([df, new_row], ignore_index=True)

print(df)

4. Menghapus Baris:

# Menghapus baris dengan indeks tertentu (misalnya baris ke-2)
df = df.drop(index=1)

print(df)

Pandas menyediakan fungsi matematika dan statistika yang dapat diaplikasikan pada kolom seperti fungsi-fungsi statistika deskritif berikut:

# Menghitung jumlah elemen dalam kolom pada dataframe
df[‘dataframe_column'].count()
# Menghitung rata-rata dalam suatu kolom pada dataframe
df[‘dataframe_column'].mean()
# Menghitung standar deviasi pada kolom dataframe
df[‘dataframe_column'].std()
# Mencari nilai minimum pada kolom dataframe
df[‘dataframe_column'].min()
# Menghitung kuantil 1 (Q1) pada kolom dataframe
df[‘dataframe_column'].quantile(q=0.25)
# Menghitung kuantil 2 (Q2) pada kolom dataframe
df[‘dataframe_column'].quantile(q=0.50)
# Menghitung kuantil 3 (Q3) pada kolom dataframe
df[‘dataframe_column'].quantile(q=0.75)
# Mencari nilai maximum pada kolom dataframe
df['dataframe_column'].max()
# Menghitung rangkuman statistika deskrptif pada suatu kolo dataframe 
df[‘dataframe_column'].describe()

Contoh memebaca file format csv ke dalam DataFrame:

import pandas as pd

# Membaca file CSV
df = pd.read_csv('nama_file.csv')

# Menampilkan DataFrame
print(df)

Kita juga bisa menggunakan membaca file csv berdasarkan pemisahnya (delimiter):

import pandas as pd

# Membaca file CSV dengan menentukan pemisah titik koma
df = pd.read_csv('nama_file.csv', sep=';')

# Menampilkan DataFrame
print(df)

Pastikan untuk menyesuaikan lokasi file 'ex1.csv' sesuai dengan struktur direktori pada komputer Anda.

Selain formaat csv Python memiliki banyak perpustakaan untuk membaca dan menulis data dalam format text lainnya seperti, HTML dan XML. Contohnya adalah lxml, Beautiful Soup, dan html5lib. Meskipun lxml umumnya lebih cepat, perpustakaan lainnya dapat lebih baik menangani file HTML atau XML yang cacat.

Pandas memiliki fungsi bawaan, read_html, yang menggunakan perpustakaan seperti lxml dan Beautiful Soup untuk secara otomatis mengurai tabel dari file HTML menjadi objek DataFrame. Contohnya mengunduh file HTML dari lembaga pemerintah FDIC Amerika Serikat yang menunjukkan kegagalan bank. Pertama, Anda harus menginstal beberapa perpustakaan tambahan yang digunakan oleh read_html:

conda install lxml
pip install beautifulsoup4 html5lib

Jika Anda tidak menggunakan conda, kemungkinan besar pip install lxml juga akan berfungsi.

Fungsi pandas.read_html memiliki beberapa opsi, tetapi secara default mencari dan mencoba mengurai semua data tabel yang terkandung dalam tag

import pandas as pd

# Membaca HTML dan menguraikannya ke dalam DataFrame
tables = pd.read_html('contoh_file.html')

# Mengetahui jumlah tabel yang dihasilkan
jumlah_tabel = len(tables)
print(jumlah_tabel)

# Mengakses DataFrame pertama dari hasil pembacaan
failures = tables[0]

# Menampilkan beberapa baris pertama dari DataFrame
print(failures.head())

Pastikan untuk menyesuaikan lokasi file 'contoh_file.html' sesuai dengan struktur direktori (diletakkan satu folder dengan file codingan) pada komputer Anda.