Exploratory Data Analysis with Python for Beginner
Tags: python, datascience, analyst, beginners
Published: 2021-12-15 17:19:02


## Pengenalan Library dalam Pyhton

1. **Memanggil library di Python**
    
    ```python
    import library_name as alias
    
    example:
    import numpy as np # memanggil library numpy sebagai np
    ```
    
2. **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:
    
    ```python
    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](https://storage.googleapis.com/dqlab-dataset/order.csv)
        
```python
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:
    
1. Melihat struktur dataframe
2. Melihat preview data dari dataframe tersebut
3. 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.
            
```python
print([nama_dataframe].shape)
```
            
```bash
>>> 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
                
```python
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.
        
```python
# 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**!
            
```python
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](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.describe.html)
        
```python
print([name_dataframe].describe())
```

```bash
>>> 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,](https://en.wikipedia.org/wiki/Expected_value) [standar deviasi](https://id.wikipedia.org/wiki/Simpangan_baku) dan [IQR (interquartile range)](https://id.wikipedia.org/wiki/Jangkauan_interkuartil).
        
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:
            
```python
print([name_dataframe].describe(include="all"))
```
            
```bash
>>> 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()`.

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

```bash
>>> 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](https://en.wikipedia.org/wiki/Mean)
- median → [https://id.wikipedia.org/wiki/Median](https://id.wikipedia.org/wiki/Median)
- mode → [https://id.wikipedia.org/wiki/Modus_(statistika)](https://id.wikipedia.org/wiki/Modus_(statistika))
            
```python
print([nama_dataframe].loc[:, "nama_kolom"].mean())
print([nama_dataframe].loc[:, "nama_kolom"].median())
print([nama_dataframe].loc[:, "nama_kolom"].mode())
```
            
```bash
>>> 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](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

```python
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())

```
            

1. **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:
        
```python
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.**
        
```python
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:
        
```python
print([name_dataframe].loc[:, "nama_kolom"].std())
print([nama_dataframe].loc[:, "nama_kolom"].var())
```
        
Contoh:
        
```bash
>>> 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](https://storage.googleapis.com/dqlab-dataset/order.csv)
        
```python
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.
    
![3%201%20Exploratory%20Data%20Analysis%20with%20Python%20for%20Begi%20e4b182c396c34c00ad247083a0d0fe19/outlier.png](3%201%20Exploratory%20Data%20Analysis%20with%20Python%20for%20Begi%20e4b182c396c34c00ad247083a0d0fe19/outlier.png)
    
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:
    
```python
Q1 = nama_dataframe.quartile(0.25)
Q3 = nama_dataframe.quartile(0.75)
IQR = Q3 - Q1
print(IQR)
```
    
Contoh:
    
```bash
>>> 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.
    
```bash
>>> (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](https://storage.googleapis.com/dqlab-dataset/order.csv)
        
```bash
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
    
1. **Rename menggunakan nama kolom**
        
syntax:
        
```python
nama_dataframe.rename(columns={"column_name_before": "column_name_after"}, inplace=True)
```
        
contoh penggunaan:
        
```python
nilai_skor_df.rename(columns={"Age": "Umur"}, inplace=True)
        ```
        
2. **Rename menggunakan indeks kolom**
        
syntax:

```python
nama_dataframe.columns.values[no_of_column] = "column_name_after"
```
        
contoh penggunaan:
        
```python
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
        
```python
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!
    
![3%201%20Exploratory%20Data%20Analysis%20with%20Python%20for%20Begi%20e4b182c396c34c00ad247083a0d0fe19/contoh_df.png](3%201%20Exploratory%20Data%20Analysis%20with%20Python%20for%20Begi%20e4b182c396c34c00ad247083a0d0fe19/contoh_df.png)
    
Penggunaan groupby:

```bash
>>> 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:
    
```bash
>>> 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](https://storage.googleapis.com/dqlab-dataset/order.csv)
        
```python
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:
    
```python
nama_dataframe.sort_values(by="nama_kolom")
```
    
Contoh:
    
```bash
>>> 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:
    
```python
nama_dataframe.sort_value(by="nama_kolom", ascending=False)
```
    
Contoh:
    
```bash
>>> 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:
    
```python
nama_dataframe.sort_values(by=["nama_kolom1", "nama_kolom2"], ascending=[False, True])
```
    
Contoh penggunaan:
    
```bash
>>> 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](https://storage.googleapis.com/dqlab-dataset/order.csv)

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

```jsx
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()
```