Levensthein Distance dalam bahasa C

Levenshtein Distance

Levenshtein Distance adalah sebuah metrik yang digunakan untuk mengukur jarak atau perbedaan antara dua string teks. Secara spesifik, metrik ini menghitung jumlah operasi minimum yang diperlukan untuk mengubah satu string menjadi string lainnya. Operasi ini meliputi penghapusan karakter, penyisipan karakter, atau penggantian karakter. Konsep ini sering digunakan dalam bidang seperti pengolahan bahasa alami, sistem pencarian, dan koreksi ejaan otomatis.

Levenshtein Distance menjadi relevan karena teks sering kali mengandung kesalahan ketik atau variasi dalam penulisan. Dalam konteks mesin pencari, misalnya, pengguna mungkin salah mengetikkan kata kunci, dan algoritma Levenshtein memungkinkan sistem untuk tetap menemukan hasil yang relevan. Selain itu, dalam aplikasi seperti deteksi plagiarisme atau analisis DNA, metrik ini membantu mengidentifikasi tingkat kemiripan antara dua data.

Levenshtein Distance digunakan oleh berbagai kalangan, mulai dari ilmuwan data, peneliti bioinformatika, hingga pengembang aplikasi. Di dunia bisnis, algoritma ini sering dimanfaatkan dalam sistem CRM untuk memastikan data pelanggan konsisten dan bebas dari duplikasi. Selain itu, dalam industri e-commerce, metrik ini membantu merekomendasikan produk yang mendekati preferensi pengguna meski ada kesalahan dalam pencarian.

Penggunaan Levenshtein Distance dapat ditemukan dalam berbagai situasi yang membutuhkan analisis kemiripan teks. Contohnya, saat seseorang mengetikkan “iphon” di mesin pencari, sistem menggunakan algoritma ini untuk menyarankan “iPhone” sebagai hasil pencarian. Teknologi ini juga diterapkan dalam pengolahan data medis untuk mencocokkan catatan pasien meskipun terdapat variasi dalam nama atau format data.

Levenshtein Distance bekerja dengan membandingkan setiap karakter dari dua string secara berurutan. Untuk setiap pasangan karakter yang berbeda, algoritma mencatat operasi yang dibutuhkan untuk menjadikannya sama. Hasil akhirnya adalah jumlah total operasi minimum yang diperlukan untuk menyelaraskan kedua string tersebut. Semakin kecil angkanya, semakin mirip kedua string.

Dengan memahami konsep Levenshtein Distance, Anda dapat mengimplementasikan pendekatan yang lebih cerdas dalam mengelola data teks. Metrik ini tidak hanya membantu meningkatkan akurasi dalam sistem pencarian tetapi juga mendukung analisis data yang lebih mendalam di berbagai domain. Terlebih lagi, pemahaman dasar ini menjadi landasan untuk mengeksplorasi algoritma kemiripan teks lainnya, seperti Jaro-Winkler atau Cosine Similarity.

Levenshtein Distance dihitung dengan membangun sebuah matriks yang merepresentasikan langkah-langkah untuk mengubah satu string menjadi string lain. Matriks ini membantu memvisualisasikan proses transformasi melalui operasi penyisipan, penghapusan, atau penggantian karakter.

Misalkan kita ingin menghitung jarak antara dua string:

  • String 1: “kucing”
  • String 2: “kuning”

Isi sel matriks dengan jumlah operasi minimum yang diperlukan untuk membuat string sejajar hingga titik tertentu. Operasi meliputi:

  1. Penyisipan (menambah karakter baru).
  2. Penghapusan (menghapus karakter).
  3. Penggantian (mengganti satu karakter dengan karakter lain).

Gunakan aturan:

  • Jika karakter sama, nilai diambil dari diagonal kiri-atas (tidak ada operasi tambahan).
  • Jika karakter berbeda, ambil nilai minimum dari tiga kemungkinan operasi lalu tambahkan 1.

Langkah pengisian:

  1. Mulai dari sel (1,1) di matriks.
  2. Bandingkan karakter string 1 dan string 2.
  3. Isi nilai berdasarkan aturan di atas.

Nilai di pojok kanan bawah matriks (sel [6,6]) adalah jarak Levenshtein Distance antara kedua string. Dalam kasus ini, nilai akhirnya adalah 1.

Levenshtein Similarity Score

Levenshtein Similarity Score adalah metrik yang digunakan untuk mengukur tingkat kemiripan antara dua string berdasarkan jarak Levenshtein (Levenshtein Distance). Setelah menghitung jarak Levenshtein, kita dapat menghitung similarity score dengan menggunakan rumus berikut:

  • Levenshtein Distance: Hasil perhitungan jarak Levenshtein.
  • Max Length: Panjang string yang lebih panjang antara kedua string.

Hasil dari Similarity Score berada dalam rentang 0 hingga 1:

  • 1: String benar-benar identik.
  • 0: String tidak memiliki kesamaan sama sekali.

Mari kita lanjutkan contoh sebelumnya dengan dua string:

  • String 1: “kucing”
  • String 2: “kuning”
  1. Levenshtein Distance:
    Dari matriks sebelumnya, jaraknya adalah 1.
  2. Panjang String Terpanjang (Max Length):
    Panjang kedua string sama, yaitu 6.
  3. Masukkan ke Rumus:

Similarity Score antara “kucing” dan “kuning” adalah 0.8333 atau sekitar 83.33%. Artinya, kedua string memiliki tingkat kemiripan sekitar 83%, yang menunjukkan bahwa mereka sangat mirip meskipun ada satu perbedaan karakter.

Similarity Score memberikan cara intuitif untuk memahami tingkat kemiripan antara dua string. Berbeda dengan Levenshtein Distance yang menunjukkan jumlah operasi, similarity score menyajikan hasil dalam bentuk persentase yang lebih mudah dipahami oleh pengguna non-teknis.

Contoh Implementasi pada bahasa pemrograman C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int min(int a, int b, int c) {
    int min = a;
    if (b < min) min = b;
    if (c < min) min = c;
    return min;
}

int max(int a,int b) {
    if (b > a) return b;
    return a;
}

void levenshtein_distance(char *s1, char *s2, int *distance, float *similarity) {
    int len1 = strlen(s1), len2 = strlen(s2);
    int matrix[len1 + 1][len2 + 1];
    float max_len = max(len1,len2);

    for (int i = 0; i <= len1; i++) {
        matrix[i][0] = i;
    }
    for (int j = 0; j <= len2; j++) {
        matrix[0][j] = j;
    }

    for (int i = 1; i <= len1; i++) {
        for (int j = 1; j <= len2; j++) {
            if (s1[i - 1] == s2[j - 1]) {
                matrix[i][j] = matrix[i - 1][j - 1];
            } else {
                matrix[i][j] = min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + 1);
            }
        }
    }

    *distance = matrix[len1][len2];
    *similarity = (max_len - matrix[len1][len2]) / max_len;
}

int main(int argc, char *argv[]) {
    char mode = '0';
    if (argc < 3 || argc > 4) {
        printf("Error: Program memerlukan dua [tiga] parameter \n");
	printf("radit-levenshtein kata1 kata2 [mode : 0: semua, 1: distance, 2: similarity] \n");
        return 1;
    }

    char *s1 = argv[1];
    char *s2 = argv[2];

    if (argc == 4) {
        if (strlen(argv[3]) != 1) {
            printf("Error: Parameter mode harus berupa 1 karakter\n");
            return 1;
        }
        mode = argv[3][0];
    }


    int distance = -1;
    float similarity = -1;
    levenshtein_distance(s1,s2,&distance,&similarity);

    if (mode == '0'){
		printf("%d %f\n",distance,similarity);
    }else if(mode == '1'){
		printf("%d\n",distance);
    }else if(mode == '2') {
		printf("%f\n",similarity);
    }

    return 0;
}

Map Reduce sederhana menggunakan Python

pada postingan sebelumnya, sudah dibahas terkait map reduce sederahana menggunakan PHP. kali ini akan dibahas jika menggunakan Python.

seperti biasa, akan dibuat 2 file python , yaitu map.py, dan reduce.py
untuk map.py akan menggunakan input data.csv yang akan menghasilkan intermediate.csv

sedangkan reduce.py membaca intermediate.csv dan menghasilkan result.csv

berikut map.py :

import csv
# map.py
data = []
with open('data.csv') as csv_file :
        csv_reader = csv.reader(csv_file,delimiter=',')
        line_count = 0
        for row in csv_reader :
                line_count = line_count + 1
                if line_count == 1 :
                        continue
                data.append([row[1],row[3]])

with open('intermediate.csv',mode='w') as csv_file :
        csv_writer = csv.writer(csv_file,delimiter=",",quotechar='"', quoting=csv.QUOTE_MINIMAL)
        for row in data :
                csv_writer.writerow(row)

berikut reduce.py : 

import csv
# reduce.py
jml = {}
with open('intermediate.csv') as file_csv :
        csv_reader = csv.reader(file_csv,delimiter = ',')
        for row in csv_reader :
                #print(row);
                if row[0] not in jml :
                        jml[row[0]] = 0
                jml[row[0]] = jml[row[0]] + int(row[1])

with open('result.csv',mode='w') as file_csv :
        csv_writer = csv.writer(file_csv,delimiter = ',', quotechar='"')
        for row in jml.items() :
                csv_writer.writerow([row[0],row[1]])

Langkah Awal Menggunakan Python Pandas DataFrame untuk Pengguna SQL

Kenapa dan untuk siapa ?

Pandas itu penting banget buat siapa pun yang mau mengelola data dengan cepat dan efisien di Python. Buat banyak orang yang biasa kerja dengan data, seperti data engineer atau data analyst, Pandas jadi solusi serbaguna yang bisa menangani banyak hal—mulai dari seleksi data, menggabungkan, sampai visualisasi, semua bisa dilakukan dengan sekali kode. Keunggulan lain, Pandas bisa baca data dari banyak format seperti file CSV, Excel, bahkan bisa langsung dari database. Jadi, kalau biasanya kita melakukan pekerjaan ini di SQL, sekarang bisa disederhanakan di Pandas.

Blog ini ditujukan untuk yang udah paham dasar-dasar SQL dan tertarik memulai analisis data pakai Pandas. Dengan dasar SQL, pasti lebih gampang paham cara kerja Pandas, karena konsepnya cukup mirip, sama-sama bekerja dengan data berbentuk tabel. Pandas malah lebih fleksibel dan sering kali lebih cepat buat hal-hal kompleks yang mungkin di SQL harus pakai query yang ribet. Intinya, kalau sudah biasa pakai SQL, belajar Pandas bakal lebih mulus dan bisa bikin banyak hal jadi lebih praktis.

Di blog ini, kita bakal bahas langkah-langkah sederhana buat mulai pakai Pandas, dengan perbandingan langsung sama SQL. Dari mulai baca data, pilih kolom, sampai menggabungkan tabel, semuanya dijelasin buat bikin pengalaman belajar Pandas ini jadi lancar. Jadi, buat siapa pun yang punya basic SQL dan mau explore cara baru buat kelola data, blog ini pas banget buat memulai.

Kerangka bekerja

Dalam Pandas, setiap DataFrame yang dibuat bisa dibayangkan seperti sebuah tabel di SQL, lengkap dengan baris dan kolom. Struktur DataFrame ini memudahkan kita dalam memvisualisasikan data, terutama bagi yang sudah terbiasa bekerja dengan tabel di SQL. Data dalam setiap kolom bisa terdiri dari berbagai tipe, seperti angka, teks, atau tanggal, yang membuat DataFrame menjadi format yang fleksibel untuk berbagai jenis analisis.

DataFrame tidak hanya tentang struktur, tetapi juga tentang kemampuannya dalam pemrosesan data dalam skala besar. Sama seperti pemrosesan batch dalam SQL, Pandas memungkinkan kita melakukan operasi pada banyak baris data sekaligus. Kita bisa melakukan pemilihan kolom tertentu, memfilter baris berdasarkan kondisi, hingga melakukan agregasi—semuanya dalam sekali pemanggilan kode. Hal ini membuat Pandas menjadi sangat efisien untuk mengelola data dalam jumlah besar tanpa harus melakukan manipulasi data per baris.

Dengan DataFrame, kita bisa menerapkan berbagai macam transformasi dan pembersihan data. Misalnya, mengisi nilai kosong, mengganti tipe data, atau menghitung kolom baru berdasarkan data yang ada. Semua proses ini bisa dilakukan dalam satu kerangka kerja, yang sangat membantu ketika bekerja dengan data secara batch. Pandas menyediakan pendekatan yang terstruktur, tapi tetap fleksibel, untuk setiap tahap pengelolaan data—dari membaca, membersihkan, hingga menyimpan data kembali dalam format yang diinginkan.

Membuat dataframe

1. Membuat DataFrame dari SQL Database

Jika kita sudah memiliki data di database SQL, Pandas memungkinkan kita untuk mengimpor data langsung dari database tersebut. Pertama, kita perlu koneksi ke database, lalu menjalankan query SQL menggunakan Pandas untuk mengimpor data ke dalam DataFrame.

import pandas as pd
import sqlite3

conn = sqlite3.connect('nama_database.db')  # ganti dengan nama database Anda
query = "SELECT * FROM nama_tabel"  # tuliskan query SQL sesuai kebutuhan
df = pd.read_sql_query(query, conn)
conn.close()

Dengan cara ini, data dari tabel SQL langsung disimpan dalam DataFrame df yang bisa langsung kita olah.

2.Membuat DataFrame dari File CSV

File CSV (Comma-Separated Values) adalah format umum untuk data tabular. Pandas menyediakan fungsi read_csv untuk memuat data dari file CSV ke dalam DataFrame.

df = pd.read_csv('data.csv')  # ganti dengan path file CSV

Dengan satu baris kode ini, Pandas membaca data CSV dan mengonversinya menjadi DataFrame, lengkap dengan kolom dan baris yang siap diolah.

3.Membuat DataFrame dari File Excel

Untuk data dalam format Excel, Pandas juga menyediakan cara mudah mengimpornya. Pastikan Anda sudah menginstal pustaka openpyxl atau xlrd (tergantung versi Excel Anda).

df = pd.read_excel('data.xlsx', sheet_name='Sheet1')  # ganti dengan path file Excel dan nama sheet jika perlu

Data dari sheet Excel yang dipilih akan dimuat ke dalam DataFrame df dengan struktur tabel yang sama.

4.Membuat DataFrame dari List dan Tuple

Jika kita hanya memiliki data sederhana dalam bentuk list atau tuple, kita bisa mengonversinya menjadi DataFrame secara manual. Misalnya, kita memiliki list dengan beberapa data dan ingin membuat DataFrame darinya.

data = [
    ('Ali', 25, 'Engineer'),
    ('Budi', 30, 'Data Scientist'),
    ('Citra', 28, 'Analyst')
]
df = pd.DataFrame(data, columns=['Nama', 'Usia', 'Profesi'])

Dalam contoh ini, kita membuat DataFrame dari list of tuples dengan menentukan kolomnya (Nama, Usia, dan Profesi).

5.Membuat DataFrame dari Dictionary

Pandas juga mendukung pembuatan DataFrame dari dictionary. Dictionary di mana setiap kunci adalah nama kolom, dan nilai-nilainya adalah data kolom tersebut.

data = {
    'Nama': ['Ali', 'Budi', 'Citra'],
    'Usia': [25, 30, 28],
    'Profesi': ['Engineer', 'Data Scientist', 'Analyst']
}
df = pd.DataFrame(data)

Dengan cara ini, kita mendapatkan DataFrame df dengan tiga kolom (Nama, Usia, dan Profesi) langsung dari dictionary.

Projection

Projection di SQL adalah proses memilih satu atau beberapa kolom tertentu dari tabel, tanpa harus mengambil seluruh data. Projection berguna untuk menyaring kolom agar hanya mengambil yang relevan saja.

SELECT nama, usia FROM karyawan;

Di Pandas, projection dilakukan dengan memilih kolom tertentu dari DataFrame menggunakan daftar kolom. Cara ini serupa dengan SQL karena kita hanya mengambil kolom yang kita inginkan dan mengabaikan sisanya.

import pandas as pd

# Misal kita punya DataFrame `df` dengan data karyawan
df = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra'],
    'usia': [25, 30, 28],
    'profesi': ['Engineer', 'Data Scientist', 'Analyst']
})

# Memilih hanya kolom 'nama' dan 'usia'
df_projection = df[['nama', 'usia']]

Filtering

Di SQL, kita bisa melakukan filtering dengan beberapa kondisi menggunakan operator AND dan OR, serta IN dan NOT IN. Kita juga bisa menggunakan tanda kurung untuk mengelompokkan kondisi agar urutan evaluasi kondisi lebih jelas.

SELECT * 
FROM karyawan 
WHERE (usia > 25 AND profesi = 'Data Scientist') 
   OR (usia < 30 AND nama IN ('Ali', 'Citra'));

Query ini akan mengembalikan baris yang memenuhi kondisi:

  1. Usia lebih dari 25 dan profesi adalah ‘Data Scientist’, atau
  2. Usia kurang dari 30 dan nama karyawan ada di dalam daftar ('Ali', 'Citra').

Di Pandas, kita bisa melakukan filtering kompleks dengan menggunakan operator & untuk AND, | untuk OR, serta isin() untuk IN dan ~ untuk NOT IN. Jangan lupa, setiap kondisi dalam filter kompleks perlu dikelilingi tanda kurung () untuk memastikan urutan evaluasi yang benar.

import pandas as pd

# DataFrame contoh
df = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'profesi': ['Engineer', 'Data Scientist', 'Analyst', 'Manager']
})

# Filter: (usia > 25 dan profesi 'Data Scientist') atau (usia < 30 dan nama dalam ['Ali', 'Citra'])
df_filtered = df[((df['usia'] > 25) & (df['profesi'] == 'Data Scientist')) |
                 ((df['usia'] < 30) & (df['nama'].isin(['Ali', 'Citra'])))]

Kode di atas menghasilkan DataFrame df_filtered yang hanya berisi baris yang memenuhi kondisi yang sama dengan query SQL.

Sorting

Di SQL, sorting dilakukan menggunakan klausa ORDER BY, di mana kita bisa menentukan kolom mana yang akan digunakan untuk mengurutkan data, serta arah pengurutan (ascending atau descending).

SELECT * FROM karyawan ORDER BY usia DESC, nama ASC;

Query ini akan mengurutkan data di tabel karyawan berdasarkan kolom usia secara descending (dari yang terbesar ke terkecil), dan jika ada kesamaan pada usia, akan diurutkan lagi berdasarkan nama secara ascending (dari A ke Z).

Di Pandas, sorting dilakukan menggunakan metode sort_values(). Kita bisa menentukan kolom mana yang akan digunakan sebagai acuan pengurutan, serta arah pengurutan dengan argumen ascending.

import pandas as pd

# DataFrame contoh
df = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'profesi': ['Engineer', 'Data Scientist', 'Analyst', 'Manager']
})

# Mengurutkan berdasarkan kolom 'usia' descending, dan 'nama' ascending
df_sorted = df.sort_values(by=['usia', 'nama'], ascending=[False, True])

Kode di atas akan menghasilkan DataFrame df_sorted, di mana data diurutkan berdasarkan kolom usia secara descending dan nama secara ascending, mirip dengan hasil query SQL di atas.

Grouping

Di SQL, kita menggunakan GROUP BY untuk mengelompokkan data, dan HAVING untuk memfilter hasil dari pengelompokan tersebut. HAVING memungkinkan kita menyaring berdasarkan hasil agregat (misalnya, COUNT, SUM, AVG).

SELECT profesi, AVG(usia) AS rata_usia
FROM karyawan
GROUP BY profesi
HAVING AVG(usia) > 25;

Query ini mengelompokkan data pada tabel karyawan berdasarkan kolom profesi, lalu menghitung rata-rata usia untuk setiap grup. Hanya grup di mana rata-rata usia lebih besar dari 25 yang akan ditampilkan

Di Pandas, kita bisa melakukan grouping menggunakan groupby() dan kemudian menerapkan agregasi dengan metode seperti .mean(), .sum(), dan sebagainya. Setelah pengelompokan, kita bisa menggunakan metode chaining atau filtering langsung pada DataFrame hasil agregasi.

import pandas as pd

# DataFrame contoh
df = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'profesi': ['Engineer', 'Data Scientist', 'Analyst', 'Manager']
})

# Mengelompokkan berdasarkan 'profesi' dan menghitung rata-rata 'usia'
# Memfilter hasil agar hanya rata-rata usia > 25 yang ditampilkan
df_grouped = df.groupby('profesi')['usia'].mean().reset_index()
df_filtered = df_grouped[df_grouped['usia'] > 25]

Dalam contoh ini, df_grouped adalah DataFrame yang berisi rata-rata usia untuk setiap profesi, dan df_filtered adalah hasil penyaringan di mana hanya grup dengan rata-rata usia lebih besar dari 25 yang disertakan.

Di SQL, HAVING digunakan untuk menyaring hasil agregat, sedangkan di Pandas, kita bisa melakukan filtering setelah agregasi dengan cara chaining atau menyaring pada DataFrame hasil grouping.

INNER Join

Di SQL, kita menggunakan klausa JOIN ... ON untuk melakukan inner join antara dua tabel. ON menentukan kolom yang menjadi acuan untuk penggabungan.

SELECT karyawan.nama, karyawan.usia, departemen.nama_departemen
FROM karyawan
INNER JOIN departemen ON karyawan.departemen_id = departemen.id;

Query ini menggabungkan tabel karyawan dan departemen berdasarkan kolom departemen_id di karyawan dan id di departemen. Hanya baris yang memiliki nilai yang cocok di kedua tabel yang akan disertakan dalam hasil.

Di Pandas, kita menggunakan fungsi merge() untuk melakukan inner join antara dua DataFrame. Parameter on menentukan kolom yang digunakan untuk join, dan how='inner' menentukan bahwa jenis join yang dilakukan adalah inner join.

import pandas as pd

# DataFrame contoh
df_karyawan = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'departemen_id': [1, 2, 1, 3]
})

df_departemen = pd.DataFrame({
    'id': [1, 2, 3],
    'nama_departemen': ['Engineering', 'Data Science', 'Management']
})

# Inner join berdasarkan kolom 'departemen_id' dan 'id'
df_joined = pd.merge(df_karyawan, df_departemen, left_on='departemen_id', right_on='id', how='inner')

Kode di atas menggabungkan DataFrame df_karyawan dan df_departemen dengan inner join menggunakan departemen_id di df_karyawan dan id di df_departemen. Hasil df_joined hanya akan berisi baris di mana departemen_id dan id memiliki nilai yang sama.

Kedua cara ini menghasilkan output yang sama, yaitu menggabungkan dua tabel atau DataFrame berdasarkan kolom yang memiliki nilai sama, hanya dengan sedikit perbedaan sintaksis.

LEFT OUTER Join

Left join mengembalikan semua baris dari tabel kiri dan hanya baris yang cocok dari tabel kanan. Jika tidak ada kecocokan, kolom dari tabel kanan akan diisi NULL.

SELECT karyawan.nama, karyawan.usia, departemen.nama_departemen
FROM karyawan
LEFT JOIN departemen ON karyawan.departemen_id = departemen.id;

Query ini menggabungkan tabel karyawan dengan tabel departemen menggunakan left join, menampilkan semua data dari karyawan dan hanya data yang cocok dari departemen. Jika tidak ada kecocokan, kolom nama_departemen akan bernilai NULL.

Di Pandas, left join dilakukan dengan merge() dan parameter how='left'. Ini menggabungkan dua DataFrame, mempertahankan semua baris dari DataFrame kiri.

import pandas as pd

# DataFrame contoh
df_karyawan = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'departemen_id': [1, 2, 1, 3]
})

df_departemen = pd.DataFrame({
    'id': [1, 2, 3],
    'nama_departemen': ['Engineering', 'Data Science', 'Management']
})

# Left join berdasarkan kolom 'departemen_id' dan 'id'
df_left_join = pd.merge(df_karyawan, df_departemen, left_on='departemen_id', right_on='id', how='left')

Kode ini menggabungkan df_karyawan dengan df_departemen menggunakan left join, mempertahankan semua baris dari df_karyawan dan hanya menambahkan data yang cocok dari df_departemen.

CROSS Join

Di SQL, cross join menggabungkan setiap baris di tabel pertama dengan setiap baris di tabel kedua tanpa syarat pencocokan tertentu. Hasilnya adalah semua kombinasi baris dari kedua tabel.

SELECT karyawan.nama, karyawan.usia, departemen.nama_departemen
FROM karyawan
CROSS JOIN departemen;

Query ini akan menghasilkan semua kemungkinan pasangan baris dari tabel karyawan dan tabel departemen. Jika karyawan memiliki 4 baris dan departemen memiliki 3 baris, hasilnya akan memiliki 4 * 3 = 12 baris.

Di Pandas, cross join dapat dilakukan dengan mengatur merge() untuk menghasilkan semua kombinasi dari dua DataFrame. Salah satu cara termudah adalah dengan menambahkan kolom tambahan sebagai kunci yang sama, melakukan join di atasnya, lalu menghapus kolom tambahan ini.

import pandas as pd

# DataFrame contoh
df_karyawan = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22]
})

df_departemen = pd.DataFrame({
    'nama_departemen': ['Engineering', 'Data Science', 'Management']
})

# Menambahkan kolom kunci sementara
df_karyawan['key'] = 1
df_departemen['key'] = 1

# Cross join
df_cross_join = pd.merge(df_karyawan, df_departemen, on='key').drop('key', axis=1)

Dalam kode di atas, key adalah kolom sementara yang sama pada kedua DataFrame untuk memungkinkan merge() menghasilkan produk Cartesian. Setelah join, kita menghapus kolom key untuk mendapatkan hasil cross join yang bersih.

INSERT Data

Di SQL, INSERT INTO digunakan untuk menambahkan baris baru ke dalam tabel.

INSERT INTO karyawan (nama, usia, departemen_id)
VALUES ('Eko', 27, 2);

Query ini akan menambahkan satu baris baru dengan nama Eko, usia 27, dan departemen_id 2 ke tabel karyawan. Jika Anda ingin menambahkan beberapa baris sekaligus, SQL juga mendukung multiple insert.

INSERT INTO karyawan (nama, usia, departemen_id)
VALUES 
    ('Farah', 32, 1),
    ('Gilang', 29, 3),
    ('Hana', 24, 2);

Di Pandas, menambahkan data ke DataFrame dapat dilakukan dengan metode append() atau pd.concat().

Menambahkan Satu Baris dengan append()

import pandas as pd

# DataFrame contoh
df_karyawan = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra'],
    'usia': [25, 30, 28],
    'departemen_id': [1, 2, 1]
})

# Menambahkan satu baris baru
df_karyawan = df_karyawan.append({'nama': 'Eko', 'usia': 27, 'departemen_id': 2}, ignore_index=True)

Kode di atas akan menambahkan satu baris baru dengan nama Eko, usia 27, dan departemen_id 2 ke DataFrame df_karyawan.

Menambahkan Beberapa Baris dengan pd.concat()

Jika ingin menambahkan beberapa baris sekaligus, kita bisa membuat DataFrame baru berisi data tambahan, lalu menggabungkannya menggunakan pd.concat().

# Data baru untuk ditambahkan
df_new = pd.DataFrame({
    'nama': ['Farah', 'Gilang', 'Hana'],
    'usia': [32, 29, 24],
    'departemen_id': [1, 3, 2]
})

# Menambahkan beberapa baris ke DataFrame utama
df_karyawan = pd.concat([df_karyawan, df_new], ignore_index=True)

UPDATE Data

Di SQL, UPDATE digunakan untuk mengubah data yang ada di tabel, dengan klausa WHERE untuk menetapkan baris yang akan diperbarui.

UPDATE karyawan
SET usia = 26
WHERE nama = 'Ali';

Query ini akan memperbarui kolom usia menjadi 26 pada baris di mana nama adalah 'Ali'.

Kita juga bisa mengubah beberapa kolom sekaligus:

UPDATE karyawan
SET usia = 31, departemen_id = 2
WHERE nama = 'Budi';

Ini akan mengubah usia menjadi 31 dan departemen_id menjadi 2 untuk karyawan bernama Budi.

Di Pandas, kita dapat memperbarui data di DataFrame dengan menggunakan seleksi baris dan kolom menggunakan kondisi loc[].

Update Satu Kolom Berdasarkan Kondisi

import pandas as pd

# DataFrame contoh
df_karyawan = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'departemen_id': [1, 2, 1, 3]
})

# Mengupdate usia Ali menjadi 26
df_karyawan.loc[df_karyawan['nama'] == 'Ali', 'usia'] = 26

Kode ini memperbarui kolom usia menjadi 26 pada baris di mana nama adalah 'Ali'.

Update Beberapa Kolom Berdasarkan Kondisi

Kita juga bisa mengubah beberapa kolom sekaligus:

# Mengupdate usia dan departemen_id untuk Budi
df_karyawan.loc[df_karyawan['nama'] == 'Budi', ['usia', 'departemen_id']] = [31, 2]

Kode ini memperbarui kolom usia menjadi 31 dan departemen_id menjadi 2 untuk Budi.

Pada SQL, kita menggunakan UPDATE ... SET ... WHERE untuk memperbarui data, sementara di Pandas, kita menggunakan loc[] untuk memilih dan memperbarui baris berdasarkan kondisi tertentu.

DELETE Data

Di SQL, DELETE digunakan untuk menghapus baris dari tabel berdasarkan kondisi tertentu. Klausa WHERE digunakan untuk menentukan baris yang akan dihapus.

DELETE FROM karyawan
WHERE nama = 'Ali';

Query ini akan menghapus baris di mana nama adalah 'Ali'. Jika WHERE dihilangkan, semua baris dalam tabel akan terhapus (perlu berhati-hati dengan penggunaan ini).

DELETE FROM karyawan;

Di Pandas, menghapus baris dapat dilakukan dengan menggunakan metode drop() atau dengan menggunakan filter kondisi.

Menghapus Baris Berdasarkan Kondisi.

import pandas as pd

# DataFrame contoh
df_karyawan = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'departemen_id': [1, 2, 1, 3]
})

# Menghapus baris di mana nama adalah 'Ali'
df_karyawan = df_karyawan[df_karyawan['nama'] != 'Ali']

Kode ini akan menghapus semua baris di mana nama adalah 'Ali' dengan menyaring baris yang tidak cocok dengan kondisi.

Menghapus Baris dengan drop() Berdasarkan Index

Jika kita ingin menghapus baris berdasarkan indeksnya, kita bisa menggunakan drop().

# Menghapus baris dengan indeks 0
df_karyawan = df_karyawan.drop(0)

Ini akan menghapus baris pertama dari DataFrame (index 0), tanpa mempertimbangkan nilai kolom tertentu.

Pada SQL, DELETE ... WHERE digunakan untuk menghapus data, sementara di Pandas, kita dapat menghapus baris dengan kondisi menggunakan filter atau drop() jika berdasarkan indeks.

Menyimpan dataframe

1. Menyimpan ke CSV

CSV adalah format teks sederhana yang populer untuk menyimpan data berbentuk tabel.

import pandas as pd

# DataFrame contoh
df = pd.DataFrame({
    'nama': ['Ali', 'Budi', 'Citra', 'Dina'],
    'usia': [25, 30, 28, 22],
    'departemen_id': [1, 2, 1, 3]
})

# Menyimpan DataFrame ke file CSV
df.to_csv('data_karyawan.csv', index=False)

Kode di atas akan menyimpan DataFrame df ke dalam file data_karyawan.csv tanpa menyimpan indeks baris.

2. Menyimpan ke Excel

Pandas mendukung penyimpanan DataFrame ke format Excel, baik format .xls (Excel lama) maupun .xlsx (Excel baru).

# Menyimpan DataFrame ke file Excel
df.to_excel('data_karyawan.xlsx', index=False)

Ini akan menyimpan DataFrame ke dalam file data_karyawan.xlsx tanpa indeks baris.

3. Menyimpan ke SQL

DataFrame bisa disimpan ke database SQL menggunakan fungsi to_sql(). Untuk ini, Anda perlu koneksi database (misalnya SQLite atau MySQL).

from sqlalchemy import create_engine

# Membuat koneksi ke database SQLite (atau bisa diganti dengan MySQL)
engine = create_engine('sqlite:///karyawan.db')

# Menyimpan DataFrame ke tabel SQL
df.to_sql('karyawan', con=engine, index=False, if_exists='replace')

Ini akan menyimpan DataFrame ke tabel karyawan di dalam database SQLite karyawan.db. Parameter if_exists='replace' akan menimpa tabel jika sudah ada.

4. Menyimpan ke Parquet

Parquet adalah format kolom yang efisien dan populer di ekosistem big data. Format ini sangat cocok untuk penyimpanan besar karena kompresinya yang tinggi.

# Menyimpan DataFrame ke file Parquet
df.to_parquet('data_karyawan.parquet')

Kode ini akan menyimpan DataFrame ke file data_karyawan.parquet dengan kompresi bawaan, yang cocok untuk analisis big data.

5. Menyimpan ke Format JSON

JSON sering digunakan untuk pertukaran data antar aplikasi karena kompatibel dengan banyak sistem.

# Menyimpan DataFrame ke file JSON
df.to_json('data_karyawan.json', orient='records')

Ini akan menyimpan DataFrame sebagai array JSON dengan orient='records' untuk menyimpan data dalam bentuk array objek JSON.

6. Menyimpan ke HDF5

HDF5 adalah format biner yang efisien untuk menyimpan data besar dan kompleks dalam format yang dapat diakses cepat.

# Menyimpan DataFrame ke file HDF5
df.to_hdf('data_karyawan.h5', key='karyawan', mode='w')

Kode ini akan menyimpan DataFrame dalam file HDF5 data_karyawan.h5 di bawah key karyawan.

semoga membantu kalian para sql ers yang mau gak mau harus masuk ke pandas 😀

happy coding 😀