DEV Community: Danang Haris Setiawan

Exploratory Data Analysis with Python for Beginner

Danang Haris Setiawan — Wed, 15 Dec 2021 17:19:02 +0000

Pengenalan Library dalam Pyhton

Memanggil library di Python

import library_name as alias

example:
import numpy as np # memanggil library numpy sebagai np

Exploratory Data Analysis dengan Pandas - Part 1

Salah satu fungsi Pandas yaitu melakukan load data dari CSV atau Excel file. Syntax yang digunakan untuk melakukan operasi tersebut, yaitu:
```
import pandas as pd

# Membaca file CSV
variable_name = pd.read_csv("file_name.csv")

# Membaca file Excel
variable_name = pd.read_excel("file_name.xlsx")
```

Tugas Praktek 1

Mengimport dataset marketplace ABC Dari order.csv dan disimpan ke dalam dataframe Bernama order_df.

NOTE: dataset →https://storage.googleapis.com/dqlab-dataset/order.csv

import pandas as pd

order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")

Inspeksi struktur data frame

Setelah melakukan proses loading dataframe ke dalam Python. Hal selanjutnya sebelum memulai analisis tentunya mengerti struktur data set tersebut. Sehingga langkah selanjutnya dari pre - analisis biasanya dilakukan untuk:

Melihat struktur dataframe
Melihat preview data dari dataframe tersebut
Membuat summary data sederhana dari dataset.

Melihat struktur kolom dan baris dari data frame

Hal pertama dalam mengerti struktur dari data frame adalah informasi mengenai beberapa size dari data frame yang akan digunakan termasuk berapa jumlah kolom dan jumlah baris data frame tersebut.

untuk mengatasi hal tersebut bisa menggunakan fungsi berikut:

Mengembalikan tuple yang mewakili dimensi dataframe.

print([nama_dataframe].shape)

>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.shape
(2, 2)
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4],
...                    'col3': [5, 6]})
>>> df.shape
(2, 3)

[x] Tugas praktek 2

order dataframe dengan menuliskan sintax python untuk melihat struktur dari order_df dengan menggunakan fungsi shape

import pandas as pd

order_df = pd.read_csc("https://storage.googleapis.com/dqlab-dataset/order.csv")
print(order_df.shape)

Melihat preview data dari dataframe

Untuk mendapatkan gambaran dari konten dataframe tersebut. Kita dapat menggunakan fungsi head dan tail, dengan syntax:

head() ⇒ mengembalikan n baris pertama untuk objek berdasarkan posisi. Ini berguna untuk menguji dengan cepat apakah objek anda memiliki tipe data yang tepat di dalamnya. default 5 baris.

tail() ⇒ mengembalikan n baris terakhir dari objek berdasarkan posisi. Ini berguna untuk memverifikasi data dengan cepet, misalnya, setelah menyortir atau menambahkan baris. default 5 baris.

# Menampilkan konten teratas dari [nama_dataframe]
# untuk sejumlah bilangan bulat [jumlah_data]
print([name_dataframe].head(jumlah_data))

# Menampilkan konten terbawah dari [nama_dataframe]
# untuk sejumlah bilangan bulat [jumlah_baris]
print([name_dataframe].tail(jumlah_data))

[x] Tugas praktek 3

Cek bagaimana contoh data dari dataframe tersebut, dengan fungsi head() dengan limit 10 baris!

import pandas as pd

order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")
print(order_df.head(10))

Statistik Deskriptif dari DataFrame - part 1

Statistik deskriptif atau summary dalam Python - Pandas, dapat diperoleh dengan menggunakan fungsi describe(), yaitu:

ref: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.describe.html

print([name_dataframe].describe())

>>> data_df.describe()

data_df.describe()
CustomerID         Age  Annual Income (k$)  Spending Score (1-100)
count  200.000000  200.000000          200.000000              200.000000
mean   100.500000   38.850000           60.560000               50.200000
std     57.879185   13.969007           26.264721               25.823522
min      1.000000   18.000000           15.000000                1.000000
25%     50.750000   28.750000           41.500000               34.750000
50%    100.500000   36.000000           61.500000               50.000000
75%    150.250000   49.000000           78.000000               73.000000
max    200.000000   70.000000          137.000000               99.000000

Fungsi describe dapat memberikan informasi mengenai nilai rataan, standar deviasi dan IQR (interquartile range).

Ketentuan umum:

Secara umum fungsi describe() akan secara otomatis mengabaikan kolom category dan hanya memberikan summary statistik untuk kolom berjenis numerik.
Kita perlu menambahkan argument bernama include="all" untuk mendapatkan summary statistik atau statistik deskriptif dari kolom numerik dan karakter.

contoh:

print([name_dataframe].describe(include="all"))

>>> data_df.describe(include='all')
CustomerID   Genre         Age  Annual Income (k$)  Spending Score (1-100)
count   200.000000     200  200.000000          200.000000              200.000000
unique         NaN       2         NaN                 NaN                     NaN
top            NaN  Female         NaN                 NaN                     NaN
freq           NaN     112         NaN                 NaN                     NaN
mean    100.500000     NaN   38.850000           60.560000               50.200000
std      57.879185     NaN   13.969007           26.264721               25.823522
min       1.000000     NaN   18.000000           15.000000                1.000000
25%      50.750000     NaN   28.750000           41.500000               34.750000
50%     100.500000     NaN   36.000000           61.500000               50.000000
75%     150.250000     NaN   49.000000           78.000000               73.000000
max     200.000000     NaN   70.000000          137.000000               99.000000

Statistik Deskriptif dari DataFrame - part 2

Jika ingin mendapatkan summary dari kolom yang tidak benilai angka, maka dapat menambahkan command include=['object']pada describe().

print(nilai_skor_df.describe(include=['object']))

>>> data_df.describe(include=['object'])
Genre
count      200
unique       2
top     Female
freq       112

Statistik Deskriptif dari DataFrame - part 3

Selanjutnya, untuk mencari rataan dari suatu data dari dataframe, dapat menggunakan syntax [mean][https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.mean.html], [median][https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.median.html], dan [mode][https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.mode.html] dari Pandas.

wikipedia:

mean → https://en.wikipedia.org/wiki/Mean
median → https://id.wikipedia.org/wiki/Median
mode → https://id.wikipedia.org/wiki/Modus_(statistika)

print([nama_dataframe].loc[:, "nama_kolom"].mean())
print([nama_dataframe].loc[:, "nama_kolom"].median())
print([nama_dataframe].loc[:, "nama_kolom"].mode())

>>> data_df.loc[:, "Age"].mean()
38.85
>>> data_df.loc[:, "Age"].median()
36.0
>>> data_df.loc[:, "Age"].mode()
0    32
dtype: int64

[x] Tugas praktek 4

NOTE: dataset → https://storage.googleapis.com/dqlab-dataset/order.csv

summary bulanan dari segi kuantitas, harga, freight value, dan weight
Medain dari total pembelian konsumen per transaksi kolom price

import pandas as pd

order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")

# summary bulanan dari segi kuantitas, harga frright value, dan weight
print(order_df.describe())

# Median dari total pembelian konsumen per transaksi kolom price
print(order_df.loc[:, "price"].median())

Exploratory Data Analysis dengan Pandas - Part 2
Mengenal dan membuat distribusi data dengan Histogram

Histogram merupakan salah satu cara untuk mengidentifikasi sebaran distribusi dari data. Histogram adalah grafik yang berisi ringkasan dari sebaran (dispersi atau variasi) suatu data. Pada histogram, tidak ada jarak antara batang/bar dari grafik. Hal ini dikarenakan bahwa titik data kelas bisa muncul dimana saja didaerah cakupan grafik. Sedangkan ketinggian bar sesuai dengan frekuensi atau frekuensi relatif jumlah data di kelas. Semakin tinggi bar, semakin tinggi frekuensi data. Semakin rendah bar, semakin rendah frekuensi data.

syntax umum:

nama_dataframe[["nama_kolom"]].hist(
    bins=jumlah_bin,
    by=nama_kolom,
    alpha=nilai_alpha,
    figsize=tuple_ukuran_gambar
)

bins: jumlah bins dalam histogram yang akan digunakan. Jika tidak didefinisikan jumlahbins, maka fungsi akan secara default menentukan jumlah bins sebanya 10.
by: nama kolom di DataFrame untuk di groub by. (valuenya berupa nama column di dataframe tersebut)
alpha: nilai_alpha untuk menentukan opacity dari plot di histogram. (value berupa range 0.0 - 1.0, dimana semakin kecil akan semakin kecil opacitynya)
figsize: tuple_ukuran_gambar yang digunakan untuk menentukan ukuran dari plot histogram. Contoh: figsize=(10, 12)
[x] Tugas praktek 5

Buat histogram price dengan bins=10.

import pandas as pd
import matplotlib.pyplot as plt

order_df = pd.read_csv("order.csv")

order_df[['price']].hist(figsize=(4,5), bins=10, xlabelsize=8, ylabelsize=8)
plt.show()

Standar Deviasi dan Varians pada Pandas

Varians dan standar deviasi juga merupakan suatu ukuran dispersi atau variasi. Standar deviasi merupakan ukuran dispersi yang paling banyak dipakai. Hal ini mungkin karena standar deviasi merupakan suatu ukuran yang sama dengan satuan ukuran data asalnya. Sedangkan varians memiliki satuan kuadrat dari data asalnya (misalnya cm^2).

Syntaz dari standar deviasi dan varians pada Pandas:

print([name_dataframe].loc[:, "nama_kolom"].std())
print([nama_dataframe].loc[:, "nama_kolom"].var())

Contoh:

>>> shop_df.loc[:, "Annual Income (k$)"].std()
26.264721165271244
>>> shop_df.loc[:, "Annual Income (k$)"].var()
689.8355778894472

[x] Tugas praktek 6

Tampilkan data persebaran dari product_weight_gram!

NOTE: data → https://storage.googleapis.com/dqlab-dataset/order.csv

import pandas as pd
order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")

# Standar variasi kolom product_weight_gram
order_df.loc[:, "product_weight_gram"].std()

# Varians kolom product_weight_gram
order_df.loc[:, "product_weight_gram"].var()

Menemukan Outliers Menggunakan Pandas

Outliers merupakan data observasi yang muncul dengan nilai-nilai ekstrim. Yang dimaksud dengan nilai-nilai ekstrim dalam observasi adalah nilai yang jauh atau beda sama sekali dengan sebagian besar nilai lain dalam kelompoknya.

Pada umumnya, outliers dapat ditentukan dengan metric IQR (interquartile range).

Rumus dasar dari IQR: Q3 - Q1. Dan data suatu observasi dapat dikatakan outliers jika memenuhi kedua syarat dibawah ini:

data < Q1 - 1.5 * IQR
data > Q3 + 1.5 * IQR

Syntax python:

Q1 = nama_dataframe.quartile(0.25)
Q3 = nama_dataframe.quartile(0.75)
IQR = Q3 - Q1
print(IQR)

Contoh:

>>> Q1 = shopping_df[["Annual Income (k$)"]].quantile(0.25)
>>> Q3 = shopping_df[["Annual Income (k$)"]].quantile(0.75)
>>> IQR = Q3 - Q1
>>> IQR
Annual Income (k$)    36.5
dtype: float64

jika sudah memiliki skor IQR, selanjutnya menentukan Outliers. Kode di bawah in akan memberikan output dengan beberapa nilai True atau False. Titik data di mana terdapat False yang berarti nilai-nilai ini valid sendagkan True menunjukkan adanya Ourtliers.

>>> (shopping_df < (Q1 - 1.5 * IQR)) | (shopping_df > (Q3 + 1.5 * IQR))

<stdin>:1: FutureWarning: Automatic reindexing on DataFrame vs Series comparisons is deprecated and will raise ValueError in a future version.  Do `left, right = left.align(right, axis=1, copy=False)` before e.g. `left == right`
<stdin>:1: FutureWarning: Automatic reindexing on DataFrame vs Series comparisons is deprecated and will raise ValueError in a future version.  Do `left, right = left.align(right, axis=1, copy=False)` before e.g. `left == right`

Age  Annual Income (k$)  CustomerID  Genre  Spending Score (1-100)
0    False               False       False  False                   False
1    False               False       False  False                   False
2    False               False       False  False                   False
3    False               False       False  False                   False
4    False               False       False  False                   False
..     ...                 ...         ...    ...                     ...
195  False               False       False  False                   False
196  False               False       False  False                   False
197  False               False       False  False                   False
198  False                True       False  False                   False
199  False                True       False  False                   False

[x] Tugas Praktek 7

Menentukan batas IQR untuk menentukan outliers pada kolom product_weight_gram!

NOTE: data → https://storage.googleapis.com/dqlab-dataset/order.csv

import pandas as pd
order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")
# Hitung quartile 1
Q1 = order_df[["product_weight_gram"]].quantile(0.25)
# Hitung quartile 3
Q3 = order_df[["product_weight_gram"]].quantile(0.75)
# Hitung inter quartile range dan cetak ke console
IQR = Q3 - Q1
print(IQR)

Rename Kolom Data Frame

Mengganti nama kolom pada Pandas dapat dilakukan dengan 2 cara:

1. Menggunakan nama kolom
2. Menggunakan indeks kolom

Rename menggunakan nama kolom

syntax:

nama_dataframe.rename(columns={"column_name_before": "column_name_after"}, inplace=True)

contoh penggunaan:

nilai_skor_df.rename(columns={"Age": "Umur"}, inplace=True)
        ```
{% endraw %}


2. **Rename menggunakan indeks kolom**

syntax:
{% raw %}


```python
nama_dataframe.columns.values[no_of_column] = "column_name_after"

contoh penggunaan:

nilai_skor_df.columns.values[0] = "Umur"

[x] Tugas praktek 8

Cobalah untuk mengubah kolom freight_value menjadi shipping_cost dalam data frame order_df, dengan menggunakan fungsi rename().

DataFrame = https://storage.googleapis.com/dqlab-dataset/order.csv

import pandas as pd
order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")
# Ganti nama kolom freight_value menjadi shipping_cost
order_df.rename(columns={"freight_value": "shipping_cost"}, inplace=True)
print(order_df)

.groupby menggunakan Pandas

Kegunaan .groupby adalah mencari summary dari data frame dengan menggunakan aggregate dari kolom tertentu.

contoh penggunaan:

Diberikan dataset bernama df seperti gambar di bawah ini!

Penggunaan groupby:

>>> shopping_data["Age"].groupby([shopping_data["Genre"]]).mean()
Genre
Female    38.098214
Male      39.806818
Name: Age, dtype: float64

Penjelasan: Komputasi di atas menggunakan kolom "Genre" sebagai aggregate dan kemudian menghitung mean dari kolom "Age" pada tiap-tiap aggregate tersebut.

Contoh lainnya:

>>> order_df["freight_value"].groupby([order_df["product_category_name"], order_df["order_status"]]).sum()
product_category_name  order_status
    automotive             canceled          2212000
                           delivered       640559000
                           invoiced          2909000
                           processing        4152000
                           shipped           9012000
    beauty                 canceled          4089000
                           delivered       626722000
                           invoiced          3132000
                           processing        3016000
                           shipped           7613000
                           unavailable        186000
    electronics            approved            10000
                           canceled          3993000
                           delivered       638651000
                           invoiced          3823000
                           processing        3462000
                           shipped           8280000
                           unavailable        194000
    fashion                canceled          3582000
                           delivered       635846000
                           invoiced          3951000
                           processing        3434000
                           shipped           7192000
                           unavailable         53000
    gadget                 approved            53000
                           canceled          3294000
                           delivered       634502000
                           invoiced          1787000
                           processing        4236000
                           shipped           6386000
    sports                 canceled          3634000
                           delivered       633185000
                           invoiced          2652000
                           processing        3396000
                           shipped           6758000
                           unavailable        207000
    toys                   canceled          3381000
                           delivered       645547000
                           invoiced          3584000
                           processing        3518000
                           shipped           6627000
    utilities              approved            39000
                           canceled          2537000
                           delivered       633463000
                           invoiced          1494000
                           processing        3544000
                           shipped           6068000
Name: freight_value, dtype: int64

Penjelasan: Komputasi di atas menggunakan kolom 'product_category_name', dan 'order_status' sebagai aggregate dan kemudian menggunakan menghitung sum dari kolom "freight_value" pada tiap-tiap aggregate tersebut.

[x] Tugas praktek 9

Cobalah untuk mencari rata rata dari price per payment_type dari dataset order_df!

NOTE: dataset → https://storage.googleapis.com/dqlab-dataset/order.csv

import pandas as pd

order_df = pd.read_csv("[https://storage.googleapis.com/dqlab-dataset/order.csv](https://storage.googleapis.com/dqlab-dataset/order.csv)")

rata_rata = order_df["price"].groupby(order_df["payment_type"]).mean()
print(rata_rata)

Sorting Menggunakan Pandas

Sorting adalah sebuah metode mengurutkan data berdasarkan syarat kolom tertentu, dan biasanya digunakan untuk melihat nilai maximum dan minimum dari dataset. Library Pandas sendiri menyediakan fungsi sorting sebagai fundamental dari exploratory data analysis.

Syntax untuk operasi sorting pada Pandas:

nama_dataframe.sort_values(by="nama_kolom")

Contoh:

>>> shopping_data.sort_values(by="Age")
         CustomerID   Genre  Age  Annual Income (k$)  Spending Score (1-100)
    114         115  Female   18                  65                      48
    91           92    Male   18                  59                      41
    65           66    Male   18                  48                      59
    33           34    Male   18                  33                      92
    0             1    Male   19                  15                      39
    ..          ...     ...  ...                 ...                     ...
    90           91  Female   68                  59                      55
    108         109    Male   68                  63                      43
    57           58    Male   69                  44                      46
    70           71    Male   70                  49                      55
    60           61    Male   70                  46                      56

Fungsi tersebut akan secara default mengurutkan secara ascending (dimulai dari nilai terkecil). Untuk dapat mengurutkan secara descending (dimulai dari nilai terbesar). dapat menggunakan properti tambahan:

nama_dataframe.sort_value(by="nama_kolom", ascending=False)

Contoh:

>>> shopping_data.sort_values(by="Age", ascending=False)
         CustomerID   Genre  Age  Annual Income (k$)  Spending Score (1-100)
    70           71    Male   70                  49                      55
    60           61    Male   70                  46                      56
    57           58    Male   69                  44                      46
    90           91  Female   68                  59                      55
    67           68  Female   68                  48                      48
    ..          ...     ...  ...                 ...                     ...
    0             1    Male   19                  15                      39
    33           34    Male   18                  33                      92
    65           66    Male   18                  48                      59
    91           92    Male   18                  59                      41
    114         115  Female   18                  65                      48

Fungsi sorting di Pandas juga dapat dilakukan menggunakan lebih dari satu kolom sebagai syarat. Contohnya pada skenario dibawah, akan mencoba mengaplikasikan fungsi Sorting menggunakan Age dan Score sekaligus:

Syntax:

nama_dataframe.sort_values(by=["nama_kolom1", "nama_kolom2"], ascending=[False, True])

Contoh penggunaan:

>>> shopping_data.sort_values(by=["Age", "Spending Score (1-100)"], ascending=[False, True])
         CustomerID   Genre  Age  Annual Income (k$)  Spending Score (1-100)
    70           71    Male   70                  49                      55
    60           61    Male   70                  46                      56
    57           58    Male   69                  44                      46
    108         109    Male   68                  63                      43
    67           68  Female   68                  48                      48
    ..          ...     ...  ...                 ...                     ...
    68           69    Male   19                  48                      59
    91           92    Male   18                  59                      41
    114         115  Female   18                  65                      48
    65           66    Male   18                  48                      59
    33           34    Male   18                  33                      92

[200 rows x 5 columns]

[x] Tugas Praktek 10

Cari berapa harga maximum pembelian customer di dataset order_df.

NOTE: dataset → https://storage.googleapis.com/dqlab-dataset/order.csv

import pandas as pd
order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")
# Hitung harga maksimum pembelian customer
sort_harga = order_df.groupby(by="price", ascending=False)
print(sort_harga)

[x] Tugas Proyek Mini

Mengolah beberapa data penjualan dari dataset order.csv?

Median price yang dibayar customer dari masing-masing metode pembayaran.
Tentukan metode pembayaran yang memiliki basket size (rataan median price) terbesar.
Ubah freight_value menjadi shipping_cost dan cari shipping_cost termahal dari data penjualan tersebut menggunakan sort.
Untuk product_category_name, berapa rata-rata weight produk tersebut dan standar deviasi mana yang terkecil dari weight tersebut,
Buat histogram quantity penjualan dari dataset tersebut untuk melihat persebaran quantity penjualan tersebut dengan bins = 5 dan figsize= (4,5)

import pandas as pd
import matplotlib.pyplot as plt

order_df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/order.csv")

# Median price yang dibayar customer dari masing-masing metode pembayaran. 
median_price = order_df["price"].groupby(order_df["payment_type"]).median()
print(median_price)

# Ubah freight_value menjadi shipping_cost dan cari shipping_cost 
# termahal dari data penjualan tersebut menggunakan sort.
order_df.rename(columns={"freight_value": "shipping_cost"}, inplace=True)
sort_value = order_df.sort_values(by="shipping_cost", ascending=0)
print(sort_value)

# Untuk product_category_name, berapa  rata-rata weight produk tersebut 
# dan standar deviasi mana yang terkecil dari weight tersebut, 
mean_value = order_df["product_weight_gram"].groupby(order_df["product_category_name"]).mean()
print(mean_value.sort_values())
std_value = order_df["product_weight_gram"].groupby(order_df["product_category_name"]).std()
print(std_value.sort_values())

# Buat histogram quantity penjualan dari dataset tersebutuntuk melihat persebaran quantity 
# penjualan tersebut dengan bins = 5 dan figsize= (4,5)
order_df[["quantity"]].hist(figsize=(4, 5), bins=5)
plt.show()

Tipe Data Abstract - Day 01

Danang Haris Setiawan — Sun, 24 Oct 2021 16:33:13 +0000

Theory 1

Sebagai developer, kami sering diberi tugas dalam istilah non-teknis, dan terserah kami untuk mencari tahu bagaimana sebenarnya mengimplementasikan ide ke tingkat yang lebih tinggi. Bagaimana kita memilih alat apa yang akan digunakan untuk melakukan tugas ini? Biasanya, tugas yang ada memiliki persyaratan tertentu, jadi kami menjelajahi dokumentasi bahasa favorit kami (atau sebagai alternatif hanya mencari di Google dan memilih hasil StackOverflow pertama, hhehehe... Just Kidding!!) dan memilih sesuatu yang memiliki fungsi yang memenuhi persyaratan untuk tugas kami.

Sebagai contoh, katakanlah kita ingin menyimpan nilai dari banyak siswa di sebuah kelas dengan cara kita dapat query struktur data dengan nama siswa dan mengembalikan nilai siswa tersebut. Jelas, kasus ini bisa diselesaikan dengan jenis struktur data "map", yang memetakan "keys" (nama siswa) ke "values" (nilai). Jika kami tidak terlalu khawatir tentang kinerja, kami tidak perlu peduli tentang bagaimana struktur data menjalankan tugas-tugas ini: kami hanya peduli bahwa itu menyelesaikan pekerjaan.

Apa yang kami jelaskan, suatu model untuk tipe data di mana tipe data ditentukan oleh perilakunya dari sudut pandang pengguna data (yakni, dengan fungsi apa yang diklaim pengguna perlu dimiliki) adalah Tipe Data Abstrak ( ADT).

Theory 2

Kami baru saja memperkenalkan istilah, "tipe data abstrak", tetapi artikel ini tentang "struktur data", jadi apa bedanya? Kedua istilah ini terdengar sangat mirip, tetapi sebenarnya memiliki implikasi yang sangat berbeda. Seperti yang saya sebutkan, Tipe Data Abstrak didefinisikan oleh fungsi apa yang harus dapat dilakukan, tetapi sama sekali tidak tergantung pada bagaimana sebenarnya melakukan fungsi-fungsi tersebut (yaitu, tidak spesifik untuk implementasi). Di sisi lain, Struktur Data adalah representasi data yang konkret: terdiri dari semua mur dan baut, bagaimana data direpresentasikan (bagaimana mereka disimpan dalam memori, algoritma untuk melakukan berbagai operasi, dll.).

Misalnya, katakanlah seorang pengguna ingin kita mendesain wadah "set" yang berisi bilangan bulat. Pengguna memutuskan bahwa wadah ini harus memiliki fungsi berikut:

Fungsi "insert" yang akan mengembalikan True setelah penyisipan elemen baru, atau False jika elemen sudah ada.
Fungsi "find" yang akan mengembalikan True jika ada elemen, jika tidak False.
Fungsi "union" yang akan menambahkan semua elemen dari "set" lain ke dalam "set" ini.

Pengguna telah berhasil menjelaskan fungsionalitas apa yang akan dimiliki wadah "set", tanpa detail spesifik implementasi apa pun (yakni, bagaimana ketiga fungsi yang dijelaskan akan bekerja). Akibatnya, wadah "set" ini adalah Tipe Data Abstrak. Sekarang terserah kita, para developer, untuk mencari cara yang benar untuk mengimplementasikan Tipe Data Abstrak ini.

Bisakah kita mengetahui kompleksitas waktu dari salah satu dari tiga fungsi yang dijelaskan dalam wadah "set" di atas? Sayangnya tidak ada! Tipe Data Abstrak hanya menjelaskan fungsionalitas, bukan implementasi, kompleksitas waktu dari fungsi-fungsi ini sepenuhnya tergantung pada bagaimana programmer memilih untuk mengimplementasikan "set" (yakni, Struktur Data apa yang kami pilih untuk digunakan untuk mendukung wadah ini).

Theory 3

Singkatnya, Tipe Data Abstrak hanya menjelaskan serangkaian fitur, dan berdasarkan fitur yang ingin kita miliki, kita perlu memilih Struktur Data yang sesuai untuk digunakan sebagai tulang punggung untuk mengimplementasikan ADT.

Misalnya, bagaimana jika pengguna ingin ADT menyimpan daftar lagu? Saat kita mendengarkan musik, apakah kita selalu ingin mengulang lagu sesuai urutan kemunculannya? Biasanya, kami suka memiliki kemampuan untuk memilih lagu tertentu, yang dapat muncul di suatu tempat di tengah daftar lagu. Akibatnya, mungkin masuk akal bagi kami, para pemrogram, untuk menggunakan struktur berbasis array untuk mengimplementasikan ADT ini karena memiliki akses acak terbukti bermanfaat. Namun, kami dapat menggunakan Linked List untuk mengimplementasikan ADT ini sebagai gantinya! Fungsionalitasnya akan tetap benar, tetapi mungkin tidak secepat menggunakan struktur berbasis array.

Pada bagian selanjutnya, kita akan membahas beberapa Tipe Data Abstrak yang mendasar dan akan membahas pendekatan berbeda yang dapat kita gunakan untuk mengimplementasikannya (serta trade-off dari setiap pendekatan).

Cara Beralih Versi Python Di Ubuntu

Danang Haris Setiawan — Wed, 03 Mar 2021 07:10:29 +0000

Cara beralih alternatif versi Python langkah demi langkah

Langkah pertama adalah memeriksa versi python apa yang tersedia di sistem Ubuntu Anda. Untuk melakukannya, jalankan perintah berikut:

 $ ls /usr/bin/python*

/usr/bin/python2  /usr/bin/python2.7  /usr/bin/python3  /usr/bin/python3.7  /usr/bin/python3.7m  /usr/bin/python3.8  /usr/bin/python3-futurize  /usr/bin/python3m  /usr/bin/python3-pasteurize

Selanjutnya, periksa apakah Anda sudah memiliki beberapa alternatif python yang dikonfigurasi. Untuk melakukannya, jalankan:

$ sudo update-alternatives --list python

update-alternatives: error: no alternatives for python
    Saat ini sistem tidak memiliki alternatif python yang dikonfigurasi.

Pada langkah ini kita akan mengatur dua alternatif Python, yaitu alternatif Python2 dan Python3. Jalankan perintah berikut:

$ sudo update-alternatives --install /usr/bin/python python /usr/bin/python2 1

$ sudo update-alternatives --install /usr/bin/python python  /usr/bin/python3 2

Konfirmasikan bahwa kedua alternatif siap digunakan:

$ sudo update-alternatives --list python

/usr/bin/python2
/usr/bin/python3

Ubah ke versi alternatif python. Misalnya untuk mengubah ke Python 2 jalankan perintah berikut:

$ sudo update-alternatives --config python

There are 2 choices for the alternative python (providing /usr/bin/python).

  Selection    Path              Priority   Status
------------------------------------------------------------
* 0            /usr/bin/python3   2         auto mode
  1            /usr/bin/python2   1         manual mode
  2            /usr/bin/python3   2         manual mode

Press  to keep the current choice[*], or type selection number: 1

Masukkan nomor pilihan. Dalam hal ini untuk beralih ke Python versi 2 kami memasukkan 1 nomor pilihan.

Periksa versi python Anda:

$ python -V

Python 2.7.17

NB: Untuk beralih ke alternatif Python 3, ulangi Langkah 5 dan masukkan nomor pilihan yang sesuai dengan versi python yang Anda inginkan.

Port Scanner Dengan Python

Danang Haris Setiawan — Sat, 24 Oct 2020 15:54:06 +0000

Port Scanners biasanya digunakan untuk Penetration Testing dan Information Gathering. Pada dasarnya, hal itu adalah mencari port terbuka di host karena ada satu dari dua alasan. Pertama untuk memastikan server aman atau yang kedua untuk mengeksploitasi server orang lain. Port yang tidak perlu dibuka berarti port tersebut sudah terbuka dan memiliki kerentanan dan disertai dengan kurangnya keamanan.

Oleh karena itu, sangat masuk akal untuk memindai porta jaringan Anda sendiri untuk menemukan potensi celah keamanan. Untuk melakukannya, kita dapat menggunakan perangkat lunak yang populer dan powerfull seperti Nmap. Namun dalam tutorial ini, kita akan membuat kode untuk memindai port dengan Python. Keuntungan yang kita dapat adalah kita dapat menyesuaikannya sesuai keinginan dan kita bisa belajar sesuatu tentang pemrograman. Kita memilih Python sebagai bahasa karena sederhana, modern, dan sangat powerfull.

Sebelum kita mulai, Anda perlu tahu bahwa pemindaian port jaringan orang lain tanpa izin mereka adalah kejahatan. Pindai hanya jaringan Anda sendiri atau jaringan yang diizinkan. Atau, Anda dapat menggunakan scanme.nmap.org untuk bereksperimen. Saya tidak bertanggung jawab atas penyalahgunaan informasi.

Dasar-Dasar

Mari kita lihat dulu fungsionalitas dasar pemindai port. Pemindai port mencoba menyambung ke Alamat IP pada port tertentu. Biasanya, ketika kita menjelajahi web, kita terhubung ke server melalui port 80 (HTTP) atau port 443 (HTTPS). Tetapi ada juga banyak port penting lainnya seperti 21 (FTP), 22 (SSH), 25 (SMTP) dan banyak lagi. Faktanya, ada lebih dari 130.000 port yang 1.023 distandarisasi dan 48.128 dicadangkan. Jadi, saat kita membuat pemindai port, lebih baik kita membuatnya seefesien mungkin dan fokus pada port-port penting.

Sekarang, pertama-tama kita akan melihat cara paling sederhana untuk memindai port dengan Python.

def portscan(port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((target, port))
        return True
    except:
        return False

Dalam contoh ini, kita membuat soket biasa yang mencoba menyambung ke target menggunakan port tertentu. Jika berhasil, kita mengembalikan nilai True. Jika ada pengecualian atau kesalahan, kita mengembalikan False. Kemudian kita mencetak hasilnya untuk masing-masing port.

Ya, tentu saja, kita juga dapat mengotomatiskannya dengan membuat loop-for yang memindai semua port standar.

for port in range(1, 1024):
    result = portscan(port)
    if(result):
        print("Port {} is open!".format(port))
    else:
        print("Port {} is closed!".format(port))

Sebenarnya, ini aplikasi pemindai port sudah jadi. Tapi masih ada masalah. Saat Anda menjalankannya, Anda akan melihat bahwa ini sangat lambat, karena memindai port satu demi satu. Hal itu bisa sempurnakan dengan Multithreading. Jadi, mari kita masuk ke kodenya.

Siapkan Port

Kita perlu mengimport beberapa paket untuk mempermudah pekerjaan, untuk itu mari kita lakukan.

from queue import Queue
import socket
import threading

Socket akan digunakan untuk mengkoneksikan ke host di port tertentu.
Threading akan memungkinkan kita menjalankan beberapa fungsi pemindaian secara bersamaan.
Queue adalah struktur data yang akan membantu kita mengelola akses beberapa thread pada satu resource, yang dalam kasus ini adalah nomor port. Karena thread kita berjalan secara bersamaan saat memindai port, kita menggunakan queue untuk memastikan bahwa setiap port hanya dipindai satu kali.
Kemudian, kita juga akan membuat tiga variabel global yang nantinya akan kita gunakan di berbagai fungsi:

target = "103.131.51.4"
queue = Queue()
open_ports = []

Target memiliki nilai yang berupa IP-Address atau domain dari host yang coba kita pindai.
queque untuk sekarang kita kosongkan, nanti kita akan mengisinya dengan port yang ingin kita pindai.
Dan yang tak kalah pentingnya kita memiliki daftar kosong, yang akan menyimpan nomor port terbuka.
Mari kita mulai dengan mengimplementasikan fungsi portscan, seperti contoh di atas.

def portscan(port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((target, port))
        return True
    except:
        return False

Di sini Anda dapat melihat blok try-except, di mana kita mencoba untuk terhubung ke target pada port tertentu. Jika berhasil akan mengembalikan True, yang berarti port tersebut terbuka. Jika tidak, code di atas akan mengembalikan False, yang berarti ada kesalahan dan kita asumsikan bahwa port ditutup.

Sekarang, sebelum kita masuk ke threading, kita perlu menentukan port yang ingin kita pindai. Untuk itu, kita akan mendefinisikan fungsi lain yang disebut get_ports .

def get_ports(mode):
    if mode == 1:
        for port in range(1, 1024):
            queue.put(port)
    elif mode == 2:
        for port in range(1, 49152):
            queue.put(port)
    elif mode == 3:
        ports = [20, 21, 22, 23, 25, 53, 80, 110, 443]
        for port in ports:
            queue.put(port)
    elif mode == 4:
        ports = input("Enter your ports (spreate by blank):")
        ports = ports.split()
        ports = list(map(int, ports))
        for port in ports:
            queue.put(port)

Dalam fungsi ini kita menetapkan empat mode. Mode pertama memindai 1023 port standar. Mode kedua kita menambahkan 48.128 port yang dicadangkan. Dan di mode ketiga kita fokuskan pada beberapa port terpenting. Terakhir, mode keempat memberi kita kemungkinan untuk memilih port kita secara manual. Kemudian kita menambahkan semua port tersebut ke queue.

Mohon diperhatikan, ketika kita memasukan port di mode empat, nilai atau port yang kita inputkan berupa string. Oleh karena itu, kita perlu memetakan fungsi typecasting dari tipe data integer ke setiap elemen list untuk menggunakannya.

Multithreading

Hal berikutnya yang perlu kita lakukan adalah mendefinisikan fungsi pemindai. Fungsi yang akan bertanggung jawab untuk mendapatkan nomor port dari queue, memindai dan mencetak hasilnya.

def pemindai():
    while not queue.empty():
        port = queue.get()
        if portscan(port):
            print("Port {} is open!".format(port))
            open_ports.append(port)
        else:
            print("Port {} is closed!".format(port))

Kode di atas cukup sederhana. Selama queue tidak kosong, kita mendapatkan elemen berikutnya dan memindainya. Jika port terbuka, kita mencetaknya begitupun dengan port yang ditutup. Tapi ketika kita mendapatkan port yang terbuka kita akan mendambahkanya ke daftar open_ports.

Catatan: Kita sangat menyarankan untuk tidak mencetak informasi saat port ditutup, karena informasi ini tidak berguna dan membuat keluaran kita membingungkan.

Okey, sekarang kita bisa mengimplementasikan fungsionalitasnya, kita akan menulis fungsi utama yang membuat, memulai, dan mengelola thread.

def run_scanner(threads, mode):
    get_ports(mode)
    thread_list = []

    for t in range(threads):
        thread = threading.Thread(target=pemindai)
        thread_list.append(thread)

    for thread in thread_list:
        thread.start()

    for thread in thread_list:
        thread.join()

    print("Open ports are:", open_ports)

Dalam fungsi ini, kita memiliki dua parameter. Yang pertama untuk jumlah thread yang ingin kita mulai dan yang kedua adalah mode. Kita akan memuat port tergantung pada mode yang kita pilih dan kita juga membuat daftar kosong baru untuk menyimpan thread. Kemudian, kita menentukan jumlah thread yang diinginkan, menetapkan fungsi pemindai dan menambahkannya ke list. Setelah itu, kita dapat memulainya dan melihat apakah kode kita berfungsi.

run_scanner(100, 1)

Dengan menjalankan kode di atas, kode tersebut akan memindai semua port standar. Untuk itu, kita menggunakan seratus thread. yang berarti kita memindai sekitar seratus port per detik. Anda dapat meningkatkan jumlah itu jika Anda mau. Maksimal kecepatanyang bisa saya lakukan dengan komputer saya adalah sekitar 800 pemindaian port per detik.