Data Transform

Data Transform คืออะไร

Data Transformation คือ กระบวนการแปลงหรือปรับข้อมูลให้เหมาะสมสำหรับการวิเคราะห์เพิ่มเติมหรือการใช้งานอื่น ๆ โดยในหลายกรณี Data Transformation จะเกี่ยวข้องกับการรวมข้อมูลจากหลายแหล่งเข้าด้วยกันเพื่อให้ได้ภาพรวมของข้อมูลทั้งหมด ซึ่งอาจรวมถึงกระบวนการต่อไปนี้

Merging – การรวมข้อมูลจากสองหรือหลาย DataFrame เข้าด้วยกันบนฐานของคีย์ที่เกี่ยวข้อง เช่น การรวมข้อมูลของลูกค้าและรายการขาย โดยอิงจากรหัสลูกค้าหรือข้อมูลระบุตัวตนที่คล้ายกัน
Joining – คล้ายกับ Merging แต่การ Join มักจะระบุประเภทของการรวมมากขึ้น เช่น Inner Join, Left Join, Right Join ซึ่งจะกำหนดลักษณะการรวมว่าข้อมูลจาก DataFrame ใดที่ควรจะปรากฏหรือจะถูกกรองออก
Concatenating – การวางข้อมูลต่อกันในรูปแบบที่เรียงลำดับตามแนวนอนหรือแนวตั้ง เช่น การนำข้อมูลยอดขายของแต่ละปีมาต่อกันเพื่อให้ได้ยอดขายที่ครอบคลุมหลายปีใน DataFrame เดียว
Pivot – การจัดเรียงข้อมูลในรูปแบบใหม่โดยใช้ค่าเฉพาะเป็นการอ้างอิง เช่น เปลี่ยนข้อมูลในลักษณะรายการให้เป็นตาราง โดยหมุนหรือย้ายข้อมูลที่มีอยู่เพื่อให้ดูง่ายขึ้นหรือเพื่อใช้ในการวิเคราะห์เพิ่มเติม

การใช้ Data Transformation จะช่วยให้การทำงานกับข้อมูลที่หลากหลายเป็นไปอย่างมีประสิทธิภาพ ทำให้สามารถจัดการข้อมูลได้สะดวกและเตรียมพร้อมสำหรับการวิเคราะห์เชิงลึก

Merging

Merging คือกระบวนการรวมข้อมูลจากสอง DataFrame หรือมากกว่าที่มีข้อมูลที่เกี่ยวข้องกัน โดยอ้างอิงจากคีย์หรือคอลัมน์ที่มีค่าเดียวกัน เช่น รหัสลูกค้า หรือชื่อพนักงานที่ปรากฏใน DataFrame ทั้งสอง การ Merging จะช่วยในการรวบรวมข้อมูลที่อยู่ในแหล่งข้อมูลต่าง ๆ เข้าด้วยกันเพื่อให้สามารถวิเคราะห์ได้ง่ายขึ้น

ใน Python, การใช้ merge ของ pandas จะทำให้การรวม DataFrame เป็นเรื่องง่าย ตัวอย่างของการใช้งานมีดังนี้

import pandas as pd

# ตัวอย่าง DataFrame แรก
df1 = pd.DataFrame({
    'customer_id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'purchase': [100, 150, 200, 250]
})

# ตัวอย่าง DataFrame ที่สอง
df2 = pd.DataFrame({
    'customer_id': [1, 2, 3, 5],
    'location': ['Bangkok', 'Chiang Mai', 'Phuket', 'Pattaya'],
    'membership_level': ['Gold', 'Silver', 'Gold', 'Bronze']
})

# การ Merging DataFrame ทั้งสองโดยใช้คอลัมน์ 'customer_id' เป็นคีย์
merged_df = pd.merge(df1, df2, on='customer_id', how='inner')

print("Merged DataFrame:")
print(merged_df)

จาก code

df1 มีข้อมูลของลูกค้า เช่น customer_id, name, และ purchase
df2 มีข้อมูลสถานที่ (location) และระดับสมาชิก (membership_level) สำหรับลูกค้าใน customer_id
ใช้ pd.merge(df1, df2, on='customer_id', how='inner') เพื่อรวม DataFrame ทั้งสองโดยอ้างอิงจาก customer_id

ผลลัพธ์

จะได้ DataFrame ที่รวมข้อมูลจาก df1 และ df2 โดยใช้ customer_id ซึ่งเป็นคีย์ร่วม ข้อมูลที่ไม่ตรงกันใน customer_id จะถูกตัดออกเพราะใช้ how='inner' ซึ่งจะรวมเฉพาะข้อมูลที่มีอยู่ในทั้งสอง DataFrame เท่านั้น

   customer_id     name  purchase    location membership_level
          1    Alice       100    Bangkok            Gold
          2      Bob       150 Chiang Mai          Silver
          3  Charlie       200     Phuket            Gold

ประเภทของการ Merge:

how='inner': รวมเฉพาะข้อมูลที่มีคีย์ร่วมกันในทั้งสอง DataFrame
how='left': รวมข้อมูลทั้งหมดจาก DataFrame แรกและเติมข้อมูลจาก DataFrame ที่สอง (ถ้าไม่มีข้อมูลตรงกัน จะเติมด้วย NaN)
how='right': รวมข้อมูลทั้งหมดจาก DataFrame ที่สองและเติมข้อมูลจาก DataFrame แรก
how='outer': รวมข้อมูลทั้งหมดจากทั้งสอง DataFrame

Joining

Joining คือการรวมข้อมูลจากสอง DataFrame หรือมากกว่าที่มีข้อมูลเกี่ยวข้องกัน โดยเชื่อมโยงคอลัมน์ที่เป็นคีย์หรือ index ร่วมกัน ซึ่งการ Join สามารถกำหนดเงื่อนไขในการรวมได้หลายรูปแบบ เช่น inner join, left join, right join, และ outer join เพื่อกำหนดว่าจะรวมเฉพาะข้อมูลที่ตรงกัน หรือรวมทั้งหมดแล้วเติมค่า NaN ในกรณีที่ไม่มีข้อมูลตรงกัน

ตัวอย่างการใช้ Joining ใน Python ด้วย pandas:

import pandas as pd

# ตัวอย่าง DataFrame แรก
df1 = pd.DataFrame({
    'customer_id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David']
})

# ตัวอย่าง DataFrame ที่สอง
df2 = pd.DataFrame({
    'customer_id': [1, 2, 3, 5],
    'location': ['Bangkok', 'Chiang Mai', 'Phuket', 'Pattaya']
})

# ตั้งค่าให้คอลัมน์ customer_id เป็น index เพื่อใช้ในการ join
df1.set_index('customer_id', inplace=True)
df2.set_index('customer_id', inplace=True)

# การ Joining DataFrame ทั้งสองโดยใช้ index 'customer_id'
joined_df = df1.join(df2, how='inner')  # ใช้ 'inner join' เป็นตัวอย่าง

print("Joined DataFrame:")
print(joined_df)

อธิบายจาก code

df1 มีข้อมูลของลูกค้า เช่น customer_id และ name
df2 มีข้อมูลสถานที่ (location) ของลูกค้า
ใช้ set_index ตั้งค่า customer_id เป็น index ของทั้งสอง DataFrame เพื่อใช้ในการ Join
ใช้ df1.join(df2, how='inner') เพื่อรวมข้อมูลเฉพาะลูกค้าที่มี customer_id ตรงกันในทั้งสอง DataFrame โดยกำหนด how='inner'

ผลลัพธ์

Joined DataFrame:
                name    location
customer_id                     
1              Alice     Bangkok
2                Bob  Chiang Mai
3            Charlie      Phuket

ประเภทของการ Join:

Inner Join (how='inner'): รวมเฉพาะข้อมูลที่มีคีย์ร่วมกันในทั้งสอง DataFrame
Left Join (how='left'): รวมข้อมูลทั้งหมดจาก DataFrame แรก และเติมข้อมูลจาก DataFrame ที่สอง (ถ้าไม่มีข้อมูลตรงกัน จะเติมด้วย NaN)
Right Join (how='right'): รวมข้อมูลทั้งหมดจาก DataFrame ที่สอง และเติมข้อมูลจาก DataFrame แรก
Outer Join (how='outer'): รวมข้อมูลทั้งหมดจากทั้งสอง DataFrame

ความแตกต่างระหว่าง merge กับ join

หลายคนอ่านถึงตรงนี้ อาจจะสงสัยว่า ในเมื่อผลลัพธ์เหมือนกัน แล้ว merge กับ join นั้นมีความแตกต่างกันอย่างไร ?

merge และ join ใน pandas เป็นฟังก์ชันที่ใช้สำหรับรวมข้อมูลใน DataFrame โดยมีหลักการทำงานที่คล้ายกัน แต่มีความแตกต่างในด้านการใช้งานและข้อจำกัดในบางกรณี ดังนี้

การอ้างอิงคีย์สำหรับการรวมข้อมูล:
- merge: สามารถรวมข้อมูลโดยอ้างอิงจากคอลัมน์หรือ index ได้ จึงมีความยืดหยุ่นในการกำหนดคีย์มากกว่า สามารถใช้ on, left_on, และ right_on เพื่อระบุคีย์เฉพาะในแต่ละ DataFrame ได้
- join: จะรวมข้อมูลโดยอ้างอิงจาก index เป็นหลัก ดังนั้นการใช้ join จะเหมาะสมในกรณีที่ข้อมูลมีการตั้งค่า index พร้อมแล้ว
โครงสร้างและความยืดหยุ่นในการรวมข้อมูล:
- merge: ใช้ได้ทั้งกับคอลัมน์และ index ที่เป็นคีย์ ทำให้รองรับการรวมข้อมูลที่มีโครงสร้างซับซ้อน เช่น การรวมที่มีหลายคีย์
- join: ถูกออกแบบมาให้ใช้งานง่ายและรวดเร็วในกรณีที่ต้องการรวมข้อมูลตาม index เท่านั้น โดยมีข้อจำกัดว่าควรใช้กับ index เป็นหลัก
การอ่านและความกระชับของโค้ด:
- join: โค้ดที่ใช้ join จะกระชับและอ่านง่ายกว่าเมื่อใช้กับ DataFrame ที่มี index ตรงกัน
- merge: การใช้ merge อาจต้องกำหนดพารามิเตอร์เพิ่มเติม เช่น left_on, right_on เพื่อระบุคีย์ในบางกรณี แต่จะให้การควบคุมที่มากกว่า

ตัวอย่างการใช้งานและความแตกต่าง

ตัวอย่างที่ 1: ใช้ merge เมื่อรวมโดยอิงจากคอลัมน์

import pandas as pd

# DataFrame แรก
df1 = pd.DataFrame({
    'customer_id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David']
})

# DataFrame ที่สอง
df2 = pd.DataFrame({
    'customer_id': [1, 2, 3, 5],
    'purchase': [100, 150, 200, 250]
})

# การใช้ merge โดยระบุ customer_id เป็นคีย์
merged_df = pd.merge(df1, df2, on='customer_id', how='inner')

print("Merged DataFrame using merge with column 'customer_id':")
print(merged_df)

ผลลัพธ์: merge จะรวมข้อมูลโดยอิงจากคอลัมน์ customer_id ซึ่งเป็นคีย์ที่กำหนดใน DataFrame ทั้งสอง

   customer_id     name  purchase
          1    Alice       100
          2      Bob       150
          3  Charlie       200

ตัวอย่างที่ 2: ใช้ join เมื่อรวมโดยอิงจาก index

# ตั้งค่า customer_id เป็น index สำหรับทั้งสอง DataFrame
df1.set_index('customer_id', inplace=True)
df2.set_index('customer_id', inplace=True)

# การใช้ join โดยอิงจาก index
joined_df = df1.join(df2, how='inner')

print("Joined DataFrame using join with index 'customer_id':")
print(joined_df)

ผลลัพธ์: join จะรวมข้อมูลโดยอิงจาก index ของ DataFrame ทั้งสอง ซึ่งให้ผลลัพธ์เหมือน merge ในตัวอย่างนี้

             name  purchase
customer_id                
1           Alice       100
2             Bob       150
3         Charlie       200

ตัวอย่างที่ 3: ใช้ merge กับคอลัมน์ที่ต่างกันใน DataFrame ทั้งสอง

ในบางกรณีที่คีย์ในแต่ละ DataFrame ไม่ได้มีชื่อเหมือนกัน เราสามารถใช้ merge เพื่อระบุคอลัมน์คีย์ที่แตกต่างกันระหว่างสอง DataFrame

# DataFrame ที่มีคอลัมน์ชื่อแตกต่างกัน
df1 = pd.DataFrame({
    'customer_id_1': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David']
})

df2 = pd.DataFrame({
    'customer_id_2': [1, 2, 3, 5],
    'purchase': [100, 150, 200, 250]
})

# ใช้ merge โดยระบุคอลัมน์ที่แตกต่างกันใน DataFrame ทั้งสอง
merged_df = pd.merge(df1, df2, left_on='customer_id_1', right_on='customer_id_2', how='inner')

print("Merged DataFrame using merge with different columns 'customer_id_1' and 'customer_id_2':")
print(merged_df)

ผลลัพธ์: สามารถใช้ merge เพื่อรวมข้อมูลจากคอลัมน์ที่มีชื่อแตกต่างกันได้โดยการระบุ left_on และ right_on

   customer_id_1     name  customer_id_2  purchase
            1    Alice              1       100
            2      Bob              2       150
            3  Charlie              3       200

ดังนั้น หากเราจะสรุปคือ

ใช้ merge เมื่อ:
- ต้องการรวมข้อมูลโดยอิงจากคอลัมน์ที่เป็นคีย์
- ต้องการรวมข้อมูลที่มีคีย์หลายตัว หรือคีย์ที่มีชื่อแตกต่างกันในแต่ละ DataFrame
- ต้องการความยืดหยุ่นสูงในการกำหนดคีย์การรวม
ใช้ join เมื่อ:
- ต้องการรวมข้อมูลโดยอิงจาก index ที่มีอยู่แล้ว
- ต้องการโค้ดที่อ่านง่ายและกระชับ

แต่เอาจริง จากประสบการณ์ส่วนตัว merge นั้น สามารถเป็นได้ทั้ง merge และ join โดยเราสามารถใช้ merge ให้ได้ผลลัพธ์เหมือนกับการรวมโดยอิงจาก index ได้ โดยใช้พารามิเตอร์ left_index=True และ right_index=True เพื่อบอกให้ pandas ใช้ index ของทั้งสอง DataFrame ในการรวมข้อมูล

เช่น ตัวอย่างนี้จะแสดงวิธีการใช้ merge โดยอิงจาก index เพื่อให้ได้ผลลัพธ์ที่เหมือนกับ join ในตัวอย่างที่ 1

import pandas as pd

# DataFrame แรก ตั้งค่า customer_id เป็น index
df1 = pd.DataFrame({
    'customer_id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David']
}).set_index('customer_id')

# DataFrame ที่สอง ตั้งค่า customer_id เป็น index
df2 = pd.DataFrame({
    'customer_id': [1, 2, 3, 5],
    'purchase': [100, 150, 200, 250]
}).set_index('customer_id')

# ใช้ merge โดยใช้ index ของทั้งสอง DataFrame
merged_df = pd.merge(df1, df2, left_index=True, right_index=True, how='inner')

print("Merged DataFrame using merge with index:")
print(merged_df)

ผลลัพธ์: การใช้ merge โดยอิงจาก index ของทั้งสอง DataFrame จะให้ผลลัพธ์เดียวกับการใช้ join เช่นกัน

Reference เพิ่มเติม: https://stackoverflow.com/questions/22676081/what-is-the-difference-between-join-and-merge-in-pandas

Concatenating datasets

Concatenating datasets คือการต่อหรือรวมข้อมูลจากหลาย DataFrame เข้าด้วยกัน โดยไม่จำเป็นต้องมีคีย์หรือ index ร่วมกันเสมอไป การ Concatenate จะทำการวางข้อมูลต่อกันตามแนวตั้งหรือแนวนอน ขึ้นอยู่กับการกำหนด ซึ่งจะช่วยให้การจัดการข้อมูลที่อยู่แยกกันหลายส่วนเป็นไปได้ง่ายขึ้น เช่น การรวมข้อมูลรายเดือนจากหลาย DataFrame ให้เป็นหนึ่ง DataFrame เดียว

การ Concatenate ใน pandas สามารถใช้คำสั่ง pd.concat() ซึ่งจะทำให้การรวม DataFrame ทำได้ทั้งในแนวตั้ง (axis=0) และแนวนอน (axis=1)

ตัวอย่างการใช้ Concatenate

ตัวอย่างที่ 1: การต่อข้อมูลในแนวตั้ง (ต่อแถวตามปกติ)

import pandas as pd

# DataFrame แรก
df1 = pd.DataFrame({
    'customer_id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie']
})

# DataFrame ที่สอง
df2 = pd.DataFrame({
    'customer_id': [4, 5, 6],
    'name': ['David', 'Eve', 'Frank']
})

# Concatenate DataFrame ทั้งสองในแนวตั้ง (default คือ axis=0)
concatenated_df = pd.concat([df1, df2])

print("Concatenated DataFrame (vertical):")
print(concatenated_df)

ผลลัพธ์: การ Concatenate ในแนวตั้งจะรวมข้อมูลของทั้งสอง DataFrame ให้เรียงต่อกัน

   customer_id     name
          1    Alice
          2      Bob
          3  Charlie
          4    David
          5      Eve
          6    Frank

ตัวอย่างที่ 2: การต่อข้อมูลในแนวนอน (ต่อ column จาก 2 dataframe)

หากต้องการ Concatenate ในแนวนอน (ตาม axis=1) สามารถทำได้โดยการตั้ง axis=1 เพื่อวางข้อมูลตามแนวนอน

import pandas as pd

# DataFrame แรก
df1 = pd.DataFrame({
    'customer_id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie']
})

# DataFrame เพิ่มเติมสำหรับการ Concatenate แนวนอน
df3 = pd.DataFrame({
    'purchase': [100, 150, 200]
})

# Concatenate DataFrame แนวนอน
concatenated_df_horizontal = pd.concat([df1, df3], axis=1)

print("Concatenated DataFrame (horizontal):")
print(concatenated_df_horizontal)

ผลลัพธ์: การ Concatenate ในแนวนอนจะวางข้อมูลจากแต่ละ DataFrame ต่อกันตามแนวนอน

   customer_id     name  purchase
          1    Alice       100
          2      Bob       150
          3  Charlie       200

ดังนั้น

การ Concatenate ในแนวตั้ง (Vertical Concatenation): pd.concat([df1, df2], axis=0) (ค่า default คือ axis=0) เหมาะสำหรับการต่อข้อมูลที่มีโครงสร้างคอลัมน์เหมือนกัน เพื่อให้ข้อมูลเรียงต่อกันในแนวตั้ง
การ Concatenate ในแนวนอน (Horizontal Concatenation): pd.concat([df1, df3], axis=1) ใช้สำหรับการรวมข้อมูลที่อาจจะมีโครงสร้างคอลัมน์ต่างกัน และต้องการต่อข้อมูลในแนวนอน

Pivot

Pivot ใน pandas คือการปรับเปลี่ยนรูปแบบของข้อมูลจากลักษณะแถวให้กลายเป็นตาราง (หรือ Pivot Table) โดยการนำค่าในคอลัมน์ใดคอลัมน์หนึ่งมาเป็นตัวกำหนดชื่อคอลัมน์ใหม่ ซึ่งช่วยให้การดูข้อมูลและการวิเคราะห์ทำได้สะดวกมากขึ้น

โดยทั่วไป pivot จะช่วยให้สามารถจัดกลุ่มข้อมูลได้ดีขึ้น เหมาะสำหรับการสร้างรายงานสรุปเชิงวิเคราะห์หรือเปรียบเทียบข้อมูล

ตัวอย่างการใช้ Pivot ใน Python

import pandas as pd

# ตัวอย่าง DataFrame
data = {
    'date': ['2024-01-01', '2024-01-01', '2024-01-02', '2024-01-02'],
    'product': ['A', 'B', 'A', 'B'],
    'sales': [100, 150, 200, 250]
}

df = pd.DataFrame(data)

print("Original DataFrame:")
print(df)

ผลลัพธ์ของ DataFrame เริ่มต้น:

         date product  sales
2024-01-01       A    100
2024-01-01       B    150
2024-01-02       A    200
2024-01-02       B    250

ซึ่งการ Pivot Data นั้นใน pandas สามารถทำได้ด้วยคำสั่ง .pivot

คำสั่ง .pivot ใน pandas ใช้สำหรับการเปลี่ยนแปลงรูปแบบข้อมูลใน DataFrame จากข้อมูลที่อยู่ในรูปแบบ "long" (มีหลายแถวที่มีค่าที่ซ้ำกันในคอลัมน์หนึ่ง ๆ) ไปเป็นรูปแบบ "wide" (โดยแปลงค่าในคอลัมน์ให้กลายเป็นหัวของคอลัมน์ใหม่) ซึ่งช่วยให้การอ่านและการวิเคราะห์ข้อมูลง่ายขึ้น โดยเฉพาะในกรณีที่ต้องการดูข้อมูลแบบสรุปจากหลายๆ มิติ

โดยคำสั่ง .pivot มีรูปแบบดังนี้

DataFrame.pivot(index=None, columns=None, values=None)

index: ระบุคอลัมน์ที่จะใช้เป็นแถวใน DataFrame ที่แปลงแล้ว (เช่น วันที่, ชื่อคน)
columns: ระบุคอลัมน์ที่จะใช้เป็นคอลัมน์ใหม่ (เช่น ประเภทสินค้า, ประเภทข้อมูล)
values: ระบุคอลัมน์ที่จะใช้เป็นค่าใน DataFrame ใหม่ (เช่น ยอดขาย, จำนวน)

สำหรับในตัวอย่างนี้ เราจะเปลี่ยน date เป็นแถว (index) และ product เป็นคอลัมน์ โดยให้ค่าสำหรับแต่ละคอลัมน์ใหม่ (A, B) เป็นยอดขาย (sales)

# การใช้ pivot โดยกำหนด index เป็น 'date', columns เป็น 'product', values เป็น 'sales'
pivot_df = df.pivot(index='date', columns='product', values='sales')

print("Pivoted DataFrame:")
print(pivot_df)

คำอธิบาย code

index='date': กำหนดให้ date เป็น index ของ DataFrame
columns='product': กำหนดให้ค่าของคอลัมน์ product เป็นชื่อคอลัมน์ใหม่
values='sales': กำหนดให้ค่าของแต่ละช่องในตารางเป็นยอดขาย (sales)

ผลลัพธ์ของ Pivoted DataFrame

product          A    B
date                    
2024-01-01     100  150
2024-01-02     200  250

Reshaping Data

การ Reshaping data คือการปรับเปลี่ยนโครงสร้างของข้อมูลใน DataFrame เพื่อให้เหมาะสมกับการวิเคราะห์ การจัดการข้อมูล หรือการสร้างรายงาน การ Reshape ข้อมูลใน pandas สามารถทำได้หลายวิธี เช่น การใช้ pivot เพื่อเปลี่ยนจากรูปแบบแถวเป็นตาราง (ที่เราพึ่งพูดถึงเมื่อกี้) และการใช้ melt เพื่อเปลี่ยนข้อมูลจากรูปแบบกว้าง (wide) เป็นรูปแบบยาว (long)

เรามาลองดูตัวอย่างการ Reshaping แบบ 2 วิธีเทียบกัน

ตัวอย่าง 1: Reshaping Data with melt

melt จะช่วยในการเปลี่ยนข้อมูลจากรูปแบบกว้าง (wide) เป็นรูปแบบยาว (long) เหมาะสำหรับการจัดข้อมูลให้อยู่ในรูปแบบที่เหมาะสมกับการวิเคราะห์เพิ่มเติม

import pandas as pd

# DataFrame แบบกว้าง
df = pd.DataFrame({
    'date': ['2024-01-01', '2024-01-02', '2024-01-03'],
    'A_sales': [100, 150, 130],
    'B_sales': [200, 250, 220]
})

print("Original Wide DataFrame:")
print(df)

ผลลัพธ์ DataFrame แบบกว้าง

         date  A_sales  B_sales
2024-01-01      100      200
2024-01-02      150      250
2024-01-03      130      220

ใช้ melt เพื่อเปลี่ยนเป็นรูปแบบยาว

# ใช้ melt เพื่อเปลี่ยนจากรูปแบบ wide เป็น long
melted_df = pd.melt(df, id_vars=['date'], var_name='product', value_name='sales')

print("Melted DataFrame (Long Format):")
print(melted_df)

อธิบาย code

id_vars=['date'] ระบุคอลัมน์ที่ต้องการคงไว้ (date ในกรณีนี้)
var_name='product' กำหนดชื่อคอลัมน์ใหม่สำหรับชื่อของคอลัมน์ที่ถูก melt (ในที่นี้คือ A_sales และ B_sales)
value_name='sales' กำหนดชื่อคอลัมน์สำหรับค่าในคอลัมน์เดิม

ผลลัพธ์ DataFrame แบบยาว

         date  product  sales
2024-01-01  A_sales    100
2024-01-02  A_sales    150
2024-01-03  A_sales    130
2024-01-01  B_sales    200
2024-01-02  B_sales    250
2024-01-03  B_sales    220

ตัวอย่าง 2: Reshaping Data with pivot

pivot จะช่วยในการเปลี่ยนข้อมูลจากรูปแบบยาว (long) กลับไปเป็นรูปแบบกว้าง (wide) โดยใช้คอลัมน์หนึ่งเป็น index และคอลัมน์อื่นเป็นคอลัมน์ใหม่ในตาราง

# DataFrame แบบยาว (ที่ได้จากการ melt ข้างต้น)
melted_df = pd.DataFrame({
    'date': ['2024-01-01', '2024-01-01', '2024-01-02', '2024-01-02', '2024-01-03', '2024-01-03'],
    'product': ['A_sales', 'B_sales', 'A_sales', 'B_sales', 'A_sales', 'B_sales'],
    'sales': [100, 200, 150, 250, 130, 220]
})

print("Original Long DataFrame:")
print(melted_df)

ผลลัพธ์ DataFrame แบบยาว

         date  product  sales
2024-01-01  A_sales    100
2024-01-01  B_sales    200
2024-01-02  A_sales    150
2024-01-02  B_sales    250
2024-01-03  A_sales    130
2024-01-03  B_sales    220

ใช้ pivot เพื่อเปลี่ยนเป็นรูปแบบกว้าง

# ใช้ pivot เพื่อเปลี่ยนจาก long format เป็น wide format
pivoted_df = melted_df.pivot(index='date', columns='product', values='sales')

print("Pivoted DataFrame (Wide Format):")
print(pivoted_df)

คำอธิบาย code

index='date' กำหนดให้ date เป็น index ของ DataFrame
columns='product' กำหนดให้ค่าใน product เป็นคอลัมน์ใหม่
values='sales' กำหนดให้คอลัมน์ sales เป็นค่าของแต่ละช่องในตาราง

ผลลัพธ์ DataFrame แบบกว้าง:

product     A_sales  B_sales
date                      
2024-01-01      100      200
2024-01-02      150      250
2024-01-03      130      220

ซึ่งถ้าเราลองดูเชิงผลลัพธ์มาเทียบกันจริงๆ melt กับ pivot คือการทำงานแบบกลับกันนั่นเอง !

pivot ใช้ในการเปลี่ยนข้อมูลจากรูปแบบยาว (long format) ไปเป็นรูปแบบกว้าง (wide format) โดยสร้างคอลัมน์ใหม่จากค่าของคอลัมน์ที่กำหนด
melt ใช้ในการเปลี่ยนข้อมูลจากรูปแบบกว้าง (wide format) ไปเป็นรูปแบบยาว (long format) โดยนำคอลัมน์หลาย ๆ คอลัมน์มารวมกันเป็นคอลัมน์เดียว

ดังนั้น หากเราทำโจทย์ไหน และต้องมี Reshape data ให้นึกถึง keyword ว่าเราจะเปลี่ยน long เป็น wide หรือ wide เป็น long จะช่วยทำให้เราหยิบคำสั่งมาใช้งานได้ง่ายขึ้นเช่นกัน

Data Transform คืออะไร​

Merging​

Joining​

ความแตกต่างระหว่าง merge กับ join​

Concatenating datasets​

Pivot​

Reshaping Data​