การสร้าง Pandas DataFrame: เจาะลึกการเริ่มต้นโครงสร้างข้อมูล

ยินดีต้อนรับสู่โลกแห่งการจัดการข้อมูลด้วย Python! หัวใจสำคัญของงานวิเคราะห์ข้อมูลเกือบทุกงานคือไลบรารี Pandas และหัวใจหลักของมันคือ DataFrame ลองนึกภาพ DataFrame เป็นเวอร์ชันที่ฉลาด ทรงพลัง และยืดหยุ่นของสเปรดชีตหรือตารางฐานข้อมูล ซึ่งอยู่ในสภาพแวดล้อม Python ของคุณ เป็นเครื่องมือหลักสำหรับการทำความสะอาด เปลี่ยนรูป วิเคราะห์ และแสดงภาพข้อมูล แต่ก่อนที่คุณจะสามารถทำการแปลงข้อมูลใดๆ ได้ คุณต้องเชี่ยวชาญศิลปะการสร้าง DataFrame ก่อน วิธีที่คุณเริ่มต้นโครงสร้างข้อมูลพื้นฐานนี้สามารถกำหนดเวทีสำหรับการวิเคราะห์ทั้งหมดของคุณได้

คู่มือฉบับสมบูรณ์นี้ออกแบบมาสำหรับผู้ชมทั่วโลกที่เป็นนักวิเคราะห์ข้อมูล นักวิทยาศาสตร์ และวิศวกรที่ต้องการเป็นและกำลังฝึกหัด เราจะสำรวจวิธีการที่พบบ่อยและมีประสิทธิภาพมากที่สุดสำหรับการสร้าง Pandas DataFrames จากรอยขีดข่วน ไม่ว่าข้อมูลของคุณจะอยู่ใน dictionary, list, NumPy array หรือรูปแบบอื่นๆ บทความนี้จะให้ความรู้และตัวอย่างที่เป็นประโยชน์แก่คุณในการเริ่มต้น DataFrames ของคุณด้วยความมั่นใจและมีประสิทธิภาพ มาสร้างรากฐานของเรากันเถอะ

Pandas DataFrame คืออะไร?

ก่อนที่เราจะเริ่มสร้าง มาทำความเข้าใจให้ชัดเจนว่าเรากำลังสร้างอะไร Pandas DataFrame เป็นโครงสร้างข้อมูลตารางสองมิติ ขนาดเปลี่ยนแปลงได้ และอาจเป็นแบบ heterogeneous มาแบ่งย่อยกัน:

• สองมิติ: มีแถวและคอลัมน์ เหมือนกับสเปรดชีต
• ขนาดเปลี่ยนแปลงได้: คุณสามารถเพิ่มหรือลบแถวและคอลัมน์ได้หลังจากที่สร้าง DataFrame แล้ว
• Heterogeneous: คอลัมน์สามารถมีประเภทข้อมูลที่แตกต่างกันได้ ตัวอย่างเช่น คอลัมน์หนึ่งสามารถมีตัวเลข (จำนวนเต็มหรือทศนิยม) อีกคอลัมน์หนึ่งสามารถมีข้อความ (สตริง) และคอลัมน์ที่สามสามารถมีวันที่หรือค่าบูลีน (จริง/เท็จ)

DataFrame มีส่วนประกอบหลักสามส่วน:

1. ข้อมูล: ค่าจริงที่อยู่ในโครงสร้าง จัดเรียงในแถวและคอลัมน์
2. Index: ป้ายกำกับสำหรับแถว หากคุณไม่ได้ระบุ index Pandas จะสร้างค่าเริ่มต้นโดยเริ่มจาก 0 Index เป็นวิธีที่มีประสิทธิภาพในการเข้าถึงและจัดเรียงข้อมูล
3. คอลัมน์: ป้ายกำกับสำหรับคอลัมน์ สิ่งเหล่านี้มีความสำคัญอย่างยิ่งสำหรับการเข้าถึงชุดข้อมูลเฉพาะภายใน DataFrame

การทำความเข้าใจโครงสร้างนี้เป็นกุญแจสำคัญในการทำความเข้าใจวิธีสร้างและจัดการ DataFrames อย่างมีประสิทธิภาพ

รากฐาน: การนำเข้า Pandas

สิ่งแรกที่ต้องทำ ในการใช้ Pandas คุณต้องนำเข้าไลบรารีลงในสคริปต์ Python หรือสมุดบันทึกของคุณ อนุสัญญาที่เป็นที่ยอมรับในระดับสากล ซึ่งปฏิบัติตามโดยผู้เชี่ยวชาญทั่วโลก คือการนำเข้าด้วยนามแฝง pd นามแฝงง่ายๆ นี้ทำให้โค้ดของคุณอ่านง่ายและกระชับยิ่งขึ้น

import pandas as pd
import numpy as np # มักใช้ควบคู่ไปกับ Pandas ดังนั้นเราจะนำเข้าด้วย

ด้วยบรรทัดเดียวนี้ คุณได้ปลดล็อกพลังทั้งหมดของไลบรารี Pandas แล้ว ตอนนี้ มาเข้าสู่ใจกลางของคู่มือนี้: การสร้าง DataFrames กัน

วิธีการสร้างหลัก: จากง่ายไปซับซ้อน

ตัวสร้าง pd.DataFrame() มีความสามารถรอบด้านอย่างเหลือเชื่อ สามารถรับอินพุตประเภทต่างๆ ได้มากมาย ตอนนี้เราจะสำรวจวิธีการที่จำเป็นที่สุด โดยย้ายจากกรณีที่พบบ่อยที่สุดไปจนถึงกรณีที่เฉพาะเจาะจงมากขึ้น

1. การสร้าง DataFrame จาก Dictionary ของ Lists หรือ Arrays

นี่เป็นวิธีการที่พบบ่อยและใช้งานง่ายที่สุดในการสร้าง DataFrame คุณเริ่มต้นด้วย Python dictionary ที่ keys จะกลายเป็นชื่อคอลัมน์ และ values จะเป็น lists (หรือ NumPy arrays หรือ Pandas Series) ที่มีข้อมูลสำหรับแต่ละคอลัมน์

วิธีการทำงาน: Pandas จับคู่แต่ละ dictionary key กับส่วนหัวของคอลัมน์ และแต่ละ list ของ values กับแถวของคอลัมน์นั้น ข้อกำหนดที่สำคัญที่นี่คือ lists ทั้งหมดต้องมีความยาวเท่ากัน เนื่องจากแต่ละ list แสดงถึงคอลัมน์ข้อมูลทั้งหมด

ตัวอย่าง:

มาสร้าง DataFrame ที่มีข้อมูลเกี่ยวกับเมืองต่างๆ ทั่วโลก

# ข้อมูลจัดระเบียบตามคอลัมน์ city_data = { 'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'], 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } # สร้าง DataFrame df_from_dict = pd.DataFrame(city_data) print(df_from_dict)

เอาท์พุต:

         City Country  Population_Millions  Is_Coastal
0       Tokyo   Japan                 37.3        True
1       Delhi   India                 32.0       False
2    Shanghai   China                 28.5        True
3   São Paulo  Brazil                 22.4       False
4      Mumbai   India                 20.9        True

ประเด็นสำคัญ: วิธีนี้เหมาะอย่างยิ่งเมื่อข้อมูลของคุณจัดระเบียบตามคุณสมบัติหรือหมวดหมู่ตามธรรมชาติ มีความชัดเจน อ่านง่าย และแปลโครงสร้างของ dictionary ของคุณเป็นรูปแบบตารางโดยตรง

2. การสร้าง DataFrame จาก List ของ Dictionaries

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

วิธีการทำงาน: Pandas วนซ้ำผ่าน list สำหรับแต่ละ dictionary จะสร้างแถวใหม่ keys ของ dictionary ใช้เพื่อกำหนดคอลัมน์ วิธีนี้มีความยืดหยุ่นอย่างเหลือเชื่อ เพราะหาก dictionary ไม่มี key Pandas จะเติมเซลล์นั้นในแถวที่เกี่ยวข้องโดยอัตโนมัติด้วย NaN (Not a Number) ซึ่งเป็นเครื่องหมายมาตรฐานสำหรับข้อมูลที่หายไปใน Pandas

ตัวอย่าง:

มาแสดงข้อมูลเมืองเดียวกัน แต่คราวนี้จัดโครงสร้างเป็น list ของ records

# ข้อมูลจัดระเบียบตามแถว (record) records_data = [ {'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True}, {'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False}, {'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5}, {'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False}, {'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # สังเกตโครงสร้างที่แตกต่างกัน ] # สร้าง DataFrame df_from_list_of_dicts = pd.DataFrame(records_data) print(df_from_list_of_dicts)

เอาท์พุต:

         City Country  Population_Millions  Is_Coastal Timezone
0       Tokyo   Japan                 37.3        True      NaN
1       Delhi   India                 32.0       False      NaN
2    Shanghai   China                 28.5         NaN      NaN
3   São Paulo  Brazil                 22.4       False      NaN
4       Cairo   Egypt                  NaN         NaN      EET

สังเกตว่า Pandas จัดการกับความไม่สอดคล้องกันได้อย่างสง่างาม ค่า 'Is_Coastal' สำหรับ Shanghai คือ NaN เนื่องจากหายไปจาก dictionary คอลัมน์ 'Timezone' ใหม่ถูกสร้างขึ้นสำหรับ Cairo โดยมี NaN สำหรับเมืองอื่นๆ ทั้งหมด ทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับการทำงานกับข้อมูลแบบกึ่งโครงสร้าง เช่น การตอบกลับ JSON จาก APIs

ประเด็นสำคัญ: ใช้วิธีนี้เมื่อข้อมูลของคุณมาเป็นชุดของ records หรือ observations มีความทนทานในการจัดการข้อมูลที่หายไปและการเปลี่ยนแปลงในโครงสร้าง record

3. การสร้าง DataFrame จาก NumPy Array

สำหรับผู้ที่ทำงานด้านการคำนวณทางวิทยาศาสตร์ การเรียนรู้ของเครื่อง หรือสาขาใดๆ ที่เกี่ยวข้องกับการดำเนินการทางตัวเลขอย่างหนัก ข้อมูลมักจะมาจาก NumPy arrays Pandas สร้างขึ้นบน NumPy ทำให้การรวมกันระหว่างทั้งสองราบรื่นและมีประสิทธิภาพสูง

วิธีการทำงาน: คุณส่ง 2D NumPy array ไปยังตัวสร้าง pd.DataFrame() โดยค่าเริ่มต้น Pandas จะสร้าง indexes และคอลัมน์ที่อิงตามจำนวนเต็ม อย่างไรก็ตาม คุณสามารถ (และควร) ระบุป้ายกำกับที่มีความหมายโดยใช้พารามิเตอร์ index และ columns

ตัวอย่าง:

มาสร้าง DataFrame จาก 5x4 NumPy array ที่สร้างขึ้นแบบสุ่ม ซึ่งแสดงถึงการอ่านเซ็นเซอร์เมื่อเวลาผ่านไป

# สร้าง 5x4 NumPy array ด้วยข้อมูลสุ่ม data_np = np.random.rand(5, 4) # กำหนดป้ายกำกับคอลัมน์และ index columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D'] index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04']) # สร้าง DataFrame df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns) print(df_from_numpy)

เอาท์พุต (ตัวเลขสุ่มของคุณจะแตกต่างกัน):

                           Sensor_A  Sensor_B  Sensor_C  Sensor_D
2023-10-27 10:00:00  0.123456  0.987654  0.555555  0.111111
2023-10-27 10:01:00  0.234567  0.876543  0.666666  0.222222
2023-10-27 10:02:00  0.345678  0.765432  0.777777  0.333333
2023-10-27 10:03:00  0.456789  0.654321  0.888888  0.444444
2023-10-27 10:04:00  0.567890  0.543210  0.999999  0.555555

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

ประเด็นสำคัญ: นี่เป็นวิธีที่มีประสิทธิภาพด้านหน่วยความจำมากที่สุดในการสร้าง DataFrame จากข้อมูลตัวเลขที่เป็นเนื้อเดียวกัน เป็นตัวเลือกมาตรฐานเมื่อเชื่อมต่อกับไลบรารี เช่น NumPy, Scikit-learn หรือ TensorFlow

4. การสร้าง DataFrame จาก List ของ Lists

วิธีนี้มีความคล้ายคลึงในด้านแนวคิดกับการสร้างจาก NumPy array แต่ใช้ Python lists มาตรฐาน เป็นวิธีที่ตรงไปตรงมาในการแปลงข้อมูลตารางที่จัดเก็บในรูปแบบ list ที่ซ้อนกัน

วิธีการทำงาน: คุณระบุ list โดยที่แต่ละ inner list แสดงถึงแถวของข้อมูล เช่นเดียวกับ NumPy arrays ขอแนะนำอย่างยิ่งให้ระบุชื่อคอลัมน์ผ่านพารามิเตอร์ columns เพื่อความชัดเจน

ตัวอย่าง:

# ข้อมูลเป็น list ของแถว product_data = [ ['P001', 'Laptop', 1200.00, 'Electronics'], ['P002', 'Mouse', 25.50, 'Electronics'], ['P003', 'Desk Chair', 150.75, 'Furniture'], ['P004', 'Keyboard', 75.00, 'Electronics'] ] # กำหนดชื่อคอลัมน์ column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category'] # สร้าง DataFrame df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names) print(df_from_list_of_lists)

เอาท์พุต:

  ProductID ProductName  Price_USD     Category
0      P001      Laptop    1200.00  Electronics
1      P002       Mouse      25.50  Electronics
2      P003  Desk Chair     150.75    Furniture
3      P004    Keyboard      75.00  Electronics

ประเด็นสำคัญ: นี่เป็นวิธีที่ง่ายและมีประสิทธิภาพเมื่อข้อมูลของคุณถูกจัดโครงสร้างเป็น list ของแถวอยู่แล้ว เช่น เมื่ออ่านจากรูปแบบไฟล์ที่ไม่มี headers

การเริ่มต้นขั้นสูง: การปรับแต่ง DataFrame ของคุณ

นอกเหนือจากการให้ข้อมูลดิบแล้ว ตัวสร้าง pd.DataFrame() ยังมีพารามิเตอร์หลายอย่างเพื่อควบคุมโครงสร้างและคุณสมบัติของ DataFrame ใหม่ของคุณตั้งแต่ตอนที่สร้าง

การระบุ Index

เราได้เห็นพารามิเตอร์ `index` ในการดำเนินการแล้ว Index เป็นส่วนสำคัญของ DataFrame โดยให้ป้ายกำกับสำหรับแถวที่ใช้สำหรับการค้นหาอย่างรวดเร็ว การจัดเรียงข้อมูล และอื่นๆ แม้ว่า Pandas จะมี numeric index เริ่มต้น (0, 1, 2, ...) การตั้งค่า index ที่มีความหมายสามารถทำให้ข้อมูลของคุณใช้งานได้ง่ายขึ้นมาก

ตัวอย่าง: มาใช้ dictionary ของตัวอย่าง lists ของเราซ้ำ แต่ตั้งค่าคอลัมน์ `City` เป็น index เมื่อสร้าง

city_data = { 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'] # สร้าง DataFrame ด้วย custom index df_with_index = pd.DataFrame(city_data, index=city_names) print(df_with_index)

เอาท์พุต:

          Country  Population_Millions  Is_Coastal
Tokyo       Japan                 37.3        True
Delhi       India                 32.0       False
Shanghai    China                 28.5        True
São Paulo  Brazil                 22.4       False
Mumbai      India                 20.9        True

ตอนนี้ คุณสามารถเข้าถึงข้อมูลแถวโดยใช้ป้ายกำกับที่มีความหมายเหล่านี้ได้ ตัวอย่างเช่น ด้วย df_with_index.loc['Tokyo']

การควบคุมประเภทข้อมูล (`dtype`)

Pandas ค่อนข้างดีในการอนุมานประเภทข้อมูล (เช่น การจดจำตัวเลข ข้อความ และค่าบูลีน) อย่างไรก็ตาม บางครั้งคุณต้องบังคับใช้ประเภทข้อมูลเฉพาะสำหรับคอลัมน์เพื่อให้แน่ใจว่ามีประสิทธิภาพด้านหน่วยความจำหรือเปิดใช้งานการดำเนินการเฉพาะ พารามิเตอร์ `dtype` ช่วยให้คุณควบคุมสิ่งนี้ได้

ตัวอย่าง: ลองจินตนาการว่าเรามี Product IDs ที่ดูเหมือนตัวเลข แต่ควรได้รับการปฏิบัติเหมือนเป็นข้อความ (สตริง)

data = { 'ProductID': [101, 102, 103], 'Stock': [50, 75, 0] } # สร้าง DataFrame ในขณะที่ระบุ dtype สำหรับ 'ProductID' df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'}) print(df_types.dtypes)

เอาท์พุต:

ProductID    object
Stock         int32
dtype: object

สังเกตว่า `str` ใน Pandas แสดงเป็น `object` โดยการตั้งค่า `dtype` อย่างชัดเจน เราป้องกันไม่ให้ Pandas ปฏิบัติ `ProductID` เป็นตัวเลข ซึ่งอาจนำไปสู่การคำนวณที่ไม่ถูกต้องหรือปัญหาการจัดเรียงในภายหลัง การใช้ประเภทจำนวนเต็มที่เฉพาะเจาะจงมากขึ้น เช่น `int32` แทนที่จะเป็น `int64` เริ่มต้น ยังสามารถประหยัดหน่วยความจำได้อย่างมากด้วยชุดข้อมูลขนาดใหญ่

สถานการณ์เชิงปฏิบัติและแนวทางปฏิบัติที่ดีที่สุด

การเลือกวิธีการสร้างที่ถูกต้องขึ้นอยู่กับรูปแบบดั้งเดิมของข้อมูลของคุณ นี่คือคู่มือการตัดสินใจง่ายๆ:

• ข้อมูลของคุณอยู่ในคอลัมน์ (เช่น หนึ่ง list ต่อคุณสมบัติ)? ใช้ dictionary ของ lists เป็นสิ่งที่เหมาะสมโดยธรรมชาติ
• ข้อมูลของคุณเป็นชุดของ records (เช่น จาก JSON API)? ใช้ list ของ dictionaries มีความเป็นเลิศในการจัดการกับฟิลด์ที่หายไปหรือพิเศษใน records
• ข้อมูลของคุณเป็นตัวเลขและอยู่ใน grid (เช่น จากการคำนวณทางวิทยาศาสตร์)? ใช้ NumPy array เป็นตัวเลือกที่มีประสิทธิภาพมากที่สุดสำหรับกรณีการใช้งานนี้
• ข้อมูลของคุณอยู่ในรูปแบบตารางแบบแถวต่อแถวอย่างง่ายโดยไม่มี headers? ใช้ list ของ lists และระบุชื่อคอลัมน์แยกกัน

ข้อผิดพลาดทั่วไปที่ควรหลีกเลี่ยง

1. ความยาวไม่เท่ากันใน Dictionary ของ Lists: นี่เป็นข้อผิดพลาดทั่วไป เมื่อสร้าง DataFrame จาก dictionary ของ lists แต่ละ list ต้องมีจำนวนองค์ประกอบที่แน่นอนเท่ากัน หากไม่เป็นเช่นนั้น Pandas จะส่ง `ValueError` ตรวจสอบให้แน่ใจเสมอว่าข้อมูลคอลัมน์ของคุณมีความยาวเท่ากันก่อนสร้าง
2. ละเว้น Index: การพึ่งพา index ที่อิงตาม 0 เริ่มต้นนั้นใช้ได้ดีในหลายกรณี แต่ถ้าข้อมูลของคุณมีตัวระบุตามธรรมชาติ (เช่น Product ID, User ID หรือ Timestamp ที่เฉพาะเจาะจง) การตั้งค่าเป็น index ตั้งแต่เริ่มต้นสามารถลดความซับซ้อนของโค้ดของคุณได้ในภายหลัง
3. ลืมประเภทข้อมูล: การปล่อยให้ Pandas อนุมานประเภทข้อมูลได้ผลดีในเวลาส่วนใหญ่ แต่สำหรับชุดข้อมูลขนาดใหญ่หรือคอลัมน์ที่มีประเภทผสม ประสิทธิภาพอาจลดลง ควรใช้ `dtype` อย่างแข็งขันสำหรับคอลัมน์ที่ต้องได้รับการปฏิบัติเหมือนเป็นหมวดหมู่ สตริง หรือประเภทตัวเลขที่เฉพาะเจาะจงเพื่อประหยัดหน่วยความจำและป้องกันข้อผิดพลาด

นอกเหนือจากการเริ่มต้น: การสร้าง DataFrames จากไฟล์

แม้ว่าคู่มือนี้จะเน้นที่การสร้าง DataFrames จาก Python objects ในหน่วยความจำ แต่สิ่งสำคัญคือต้องรู้ว่าในสถานการณ์จริงส่วนใหญ่ ข้อมูลของคุณจะมาจากไฟล์ภายนอก Pandas มีชุดฟังก์ชัน reader ที่ปรับให้เหมาะสมอย่างมากเพื่อจุดประสงค์นี้ รวมถึง:

• pd.read_csv(): สำหรับไฟล์ค่าที่คั่นด้วยเครื่องหมายจุลภาค ซึ่งเป็นตัวหลักของการนำเข้าข้อมูล
• pd.read_excel(): สำหรับการอ่านข้อมูลจากสเปรดชีต Microsoft Excel
• pd.read_json(): สำหรับการอ่านข้อมูลจากไฟล์หรือสตริง JSON
• pd.read_sql(): สำหรับการอ่านผลลัพธ์ของการสืบค้นฐานข้อมูลลงใน DataFrame โดยตรง
• pd.read_parquet(): สำหรับการอ่านจากรูปแบบไฟล์ Parquet ที่มีประสิทธิภาพและเน้นคอลัมน์

ฟังก์ชันเหล่านี้เป็นขั้นตอนเชิงตรรกะถัดไปในการเดินทางของ Pandas ของคุณ การเชี่ยวชาญจะช่วยให้คุณสามารถนำเข้าข้อมูลจากแหล่งใดก็ได้ลงในโครงสร้าง DataFrame ที่มีประสิทธิภาพ

บทสรุป: รากฐานของคุณสำหรับการเรียนรู้ข้อมูล

Pandas DataFrame เป็นโครงสร้างข้อมูลส่วนกลางสำหรับงานข้อมูลที่สำคัญใดๆ ใน Python ดังที่เราได้เห็น Pandas นำเสนอชุดเครื่องมือที่ยืดหยุ่นและใช้งานง่ายสำหรับการเริ่มต้นโครงสร้างเหล่านี้จากรูปแบบที่หลากหลาย โดยการทำความเข้าใจวิธีสร้าง DataFrame จาก dictionaries, lists และ NumPy arrays คุณได้สร้างรากฐานที่มั่นคงสำหรับโครงการวิเคราะห์ข้อมูลของคุณ

สิ่งสำคัญคือการเลือกวิธีการที่ตรงกับโครงสร้างเดิมของข้อมูลของคุณมากที่สุด ไม่เพียงแต่ทำให้โค้ดของคุณสะอาดและอ่านง่ายขึ้นเท่านั้น แต่ยังมีประสิทธิภาพมากขึ้นอีกด้วย จากที่นี่ คุณพร้อมที่จะไปยังงานที่น่าตื่นเต้นในการทำความสะอาด สำรวจ เปลี่ยนรูป และแสดงภาพข้อมูล มีความสุขกับการเขียนโค้ด!