ใช้ Python สำหรับการวิเคราะห์ข้อมูล: สร้างเวิร์กโฟลว์ที่ทำซ้ำได้

pandas dataframes ซึ่งได้รับการสนับสนุนโดย numpy และมองเห็นด้วย matplotlib หรือ seborn ให้เส้นทางโดยตรงจากระเบียนดิบไปยังข้อมูลเชิงลึกที่น่าเชื่อถือโดยไม่ต้องทำด้วยตนเอง วิธีการด้านล่างจัดลำดับความสำคัญของไปป์ไลน์เดียวที่ทำซ้ำได้คุณสามารถเรียกใช้ข้อมูลใหม่และแบ่งปันกับเพื่อนร่วมทีมได้อีกครั้ง

ข้อกำหนดเบื้องต้น

• Python 3.9+ ติดตั้งผ่าน Anaconda หรือ System Package Manager ของคุณ
• JupyterLab หรือ Jupyter Notebook สำหรับการวิเคราะห์ซ้ำ
• ห้องสมุด: แพนด้า, numpy, matplotlib, seborn, scikit-learn; บวกไดรเวอร์สำหรับแหล่งภายนอกใด ๆ ที่คุณใช้ (ตัวอย่างเช่น PYODBC หรือ PSYCOPG2)

วิธีที่ 1 - สร้างท่อส่งน้ำแพนด้าที่ทำซ้ำได้ (Jupyter)

ขั้นตอนที่ 1:สร้างและเปิดใช้งานสภาพแวดล้อม Python เฉพาะ

conda create -n data-pipeline python=3.11 -y
conda activate data-pipeline
# or with pip + venv:
python -m venv .venv
source .venv/bin/activate  # Windows: .venvScriptsactivate

ขั้นตอนที่ 2:ติดตั้งไลบรารีการวิเคราะห์หลัก

python -m pip install pandas numpy matplotlib seaborn scikit-learn pyarrow openpyxl lxml

ขั้นตอนที่ 3:เริ่ม JupyterLab หรือ Notebook และสร้างสมุดบันทึกใหม่

jupyter lab
# Run cells with 

Shift+Enterดำเนินการเซลล์ปัจจุบันและย้ายไปยังเซลล์ถัดไป

ขั้นตอนที่ 4:โหลด CSV ลงใน dataframe ที่มี dtypes อนุมาน

import pandas as pd

df = pd.read_csv("data.csv").convert_dtypes()
df.head()

ขั้นตอนที่ 5:กำหนดชื่อคอลัมน์มาตรฐานเป็น SNAKE_CASE สำหรับรหัสที่สอดคล้องกัน

df.columns = (
    df.columns
      .str.strip()
      .str.lower()
      .str.replace(r"[^0-9a-zA-Z]+", "_", regex=True)
      .str.replace(r"_+", "_", regex=True)
      .str.removesuffix("_")
)

ขั้นตอนที่ 6:ตรวจสอบประเภทและค่าที่ขาดหายไปเพื่อวางแผนการแก้ไข

df.info()
df.isna().sum()

ขั้นตอนที่ 7:แพตช์ที่รู้จักกันหายไปโดยไม่เขียนทับแถวที่ดี

# Example: fill specific cells by index using combine_first
patch = pd.DataFrame({"score_a": {42: 7.1}, "score_b": {42: 6.8}})
df = df.combine_first(patch)

ขั้นตอนที่ 8:ทำความสะอาดสายสกุลเงินและส่งไปยังตัวเลขในโซ่เดียว

df = df.assign(
    revenue_usd=lambda d: d["revenue_usd"]
        .astype("string")
        .str.replace(r"[$,]", "", regex=True)
        .astype("Float64"),
    budget_usd=lambda d: d["budget_usd"]
        .astype("string")
        .str.replace(r"[$,]", "", regex=True)
        .astype("Float64"),
)

ขั้นตอนที่ 9:แปลงข้อความระยะเวลาเช่น“ 130 นาที” เป็นนาทีจำนวนเต็ม

df = df.assign(
    duration_min=lambda d: d["duration_min"]
        .astype("string")
        .str.replace(" mins", "", regex=False)
        .astype("Int64")
)

ขั้นตอนที่ 10:แยกวิเคราะห์วันที่ที่มนุษย์อ่านได้ไปยังคอลัมน์วันหยุดที่เหมาะสม

แนะนำอ่าน:

df = df.assign(
    release_date=lambda d: pd.to_datetime(d["release_date"], format="%B, %Y")
)

ขั้นตอนที่ 11:ได้รับคุณสมบัติที่มีประโยชน์ (ตัวอย่างเช่นปีวางจำหน่าย) สำหรับการจัดกลุ่ม

df = df.assign(release_year=lambda d: d["release_date"].dt.year.astype("Int64"))

ขั้นตอนที่ 12:แก้ไขการพิมพ์ผิดและหมวดหมู่ที่ไม่สอดคล้องกันสำหรับการจัดกลุ่มที่เชื่อถือได้

df = df.assign(
    lead_actor=lambda d: d["lead_actor"]
        .str.replace(r"^Shawn", "Sean", regex=True)
        .str.replace("MOORE", "Moore"),
    car_brand=lambda d: d["car_brand"].str.replace("Astin", "Aston"),
)

ขั้นตอนที่ 13:ระบุค่าผิดปกติที่ไม่น่าจะเป็นไปได้ด้วยสถิติที่รวดเร็ว

df[["duration_min", "martinis"]].describe()

ขั้นตอนที่ 14:แก้ไขค่าที่ไม่ดีที่ตรวจสอบแล้วสำหรับตัวเลขที่สมจริง

df = df.assign(
    duration_min=lambda d: d["duration_min"].replace({1200: 120}),
    martinis=lambda d: d["martinis"].replace({-6: 6})
)

ขั้นตอนที่ 15:ลบแถวที่ซ้ำกันและ Reindex สำหรับชุดข้อมูลที่สะอาด

df = df.drop_duplicates(ignore_index=True)

ขั้นตอนที่ 16:คงไว้ซึ่งชุดข้อมูลที่สะอาดสำหรับการวิเคราะห์ในอนาคต

# Parquet keeps types and compresses well
df.to_parquet("clean.parquet", index=False)
# CSV is broadly compatible
df.to_csv("clean.csv", index=False)

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

วิธีที่ 2 - ข้อมูลสอบถามโดยตรงจากฐานข้อมูลไปยังแพนด้า

ขั้นตอนที่ 1:ติดตั้ง DB Driver และ SQL Toolkit สำหรับเครื่องยนต์ของคุณ

# SQL Server example
python -m pip install pyodbc sqlalchemy
# PostgreSQL example
python -m pip install psycopg2-binary sqlalchemy

ขั้นตอนที่ 2:สร้างเอ็นจิ้น sqlalchemy ด้วยสตริงการเชื่อมต่อที่ปลอดภัย

from sqlalchemy import create_engine

# Example for SQL Server with ODBC Driver 17:
engine = create_engine(
    "mssql+pyodbc://username:password@SERVER/DB?driver=ODBC+Driver+17+for+SQL+Server",
    fast_executemany=True
)

ขั้นตอนที่ 3:ดึงข้อมูลตรงไปยังแพนด้าโดยไม่ส่งออก CSV

import pandas as pd

sql = "SELECT col_a, col_b, created_at FROM schema.table WHERE created_at >= '2024-01-01';"
df = pd.read_sql(sql, engine).convert_dtypes()

ขั้นตอนที่ 4:การสืบค้นพารามิเตอร์เพื่อหลีกเลี่ยงความเสี่ยงในการฉีด SQL

from sqlalchemy import text

stmt = text("SELECT * FROM sales WHERE region = :region AND dt >= :start")
df = pd.read_sql(stmt, engine, params={"region": "EMEA", "start": "2025-01-01"})

ขั้นตอนที่ 5:ปิดการเชื่อมต่อหลังการใช้งานหรือพึ่งพาผู้จัดการบริบท

engine.dispose()

วิธีการนี้จะช่วยลดการส่งออกด้วยตนเองสนับสนุนงานที่กำหนดเวลาและรักษาตรรกะของแหล่งที่มาของความจริงใน SQL ตามความเหมาะสม เหมาะอย่างยิ่งเมื่อข้อมูลของคุณอาศัยอยู่ในระบบเชิงสัมพันธ์ที่ใช้โดยเครื่องมือ BI

วิธีที่ 3 - อ่านจากไฟล์ทั่วไปและแหล่งข้อมูลเว็บ

ขั้นตอนที่ 1:โหลดไฟล์ Parquet สำหรับความเร็วและ dtypes ที่เก็บรักษาไว้

df = pd.read_parquet("data.parquet").convert_dtypes()

ขั้นตอนที่ 2:นำเข้าแผ่น Excel เมื่อทีมแบ่งปันไฟล์. xlsx

df = pd.read_excel("workbook.xlsx", sheet_name="Sheet1").convert_dtypes()

ขั้นตอนที่ 3:อ่านเอกสาร JSON ลงในตารางที่เป็นระเบียบ

df = pd.read_json("records.json").convert_dtypes()

ขั้นตอนที่ 4:ขูดตาราง HTML ง่าย ๆ เมื่อ API ไม่พร้อมใช้งาน

tables = pd.read_html("https://example.com/tables-page")
df = tables[0].convert_dtypes()

เคล็ดลับ: ชอบ Parquet สำหรับที่เก็บข้อมูลระดับกลางเพราะมันบีบอัดและรักษาประเภท; หากคุณต้องแบ่งปันกับเครื่องมือที่ขาดการสนับสนุน Parquet ให้ส่งออก CSV เป็นทางเสีย

วิธีที่ 4 - วิเคราะห์แสดงภาพและโมเดล

ขั้นตอนที่ 1:คำนวณสถิติเชิงพรรณนาอย่างรวดเร็วเพื่อดูช่วงและความผิดปกติ

df.describe(numeric_only=True)

ขั้นตอนที่ 2:สร้างพล็อตกระจายเพื่อประเมินความสัมพันธ์ระหว่างสองตัวชี้วัด

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.scatter(df["metric_x"], df["metric_y"], alpha=0.7)
ax.set_title("Metric Y vs Metric X")
ax.set_xlabel("Metric X")
ax.set_ylabel("Metric Y")
plt.show()

ขั้นตอนที่ 3:พอดีกับการถดถอยเชิงเส้นอย่างง่ายและพล็อตเส้นที่ดีที่สุด

from sklearn.linear_model import LinearRegression
import numpy as np

X = df[["metric_x"]].to_numpy()
y = df["metric_y"].to_numpy()
model = LinearRegression().fit(X, y)
r2 = model.score(X, y)
y_pred = model.predict(X)

fig, ax = plt.subplots()
ax.scatter(X, y, alpha=0.7)
ax.plot(X, y_pred, color="red")
ax.set_title(f"Linear Fit (R²={r2:.2f})")
ax.set_xlabel("Metric X")
ax.set_ylabel("Metric Y")
plt.show()

ขั้นตอนที่ 4:ตรวจสอบการแจกแจงด้วยจำนวนเงินที่ถูกต้องเพื่อดูช่วงทั่วไป

counts = df["duration_min"].value_counts(bins=7).sort_index()
ax = counts.plot.bar(, xlabel="Minutes (bins)", ylabel="Count")
plt.show()

ขั้นตอนที่ 5:กลุ่มและรวมเพื่อเปรียบเทียบกลุ่ม

(df.groupby("release_year")["revenue_usd"]
   .agg(["count", "mean", "sum"])
   .sort_index())

การอ่านพล็อต: แนวโน้มที่มองเห็นได้ในการกระจายแสดงถึงความสัมพันธ์เชิงบวกในขณะที่คลาวด์ที่ไม่มีความลาดชันแสดงความสัมพันธ์เชิงเส้นเพียงเล็กน้อยถึงไม่มีเลย ใช้R²เพื่อหาปริมาณว่าเส้นการถดถอยอธิบายความแปรปรวนในข้อมูลได้ดีเพียงใด

เคล็ดลับการปฏิบัติงานและข้อควรระวัง

• ทำงานที่เกิดขึ้นเป็นประจำโดยอัตโนมัติโดยเก็บทุกอย่างไว้ในสมุดบันทึกหรือสคริปต์เดียวและเรียกใช้ตามกำหนดเวลาด้วยเครื่องเลือกที่คุณเลือก
• ใช้วิธีการผูกมัด (ตัวอย่างเช่นdf.assign(...).drop_duplicates(...)) เพื่อให้รหัสอ่านได้และเพื่อหลีกเลี่ยงการแก้ไขขั้นกลางโดยไม่ตั้งใจ
• ชอบจำนวนเต็มพิมพ์ (Int64) และลอย (Float64) สำหรับคณิตศาสตร์; สตริงจะไม่รวมหรือเฉลี่ยอย่างถูกต้อง
• ตรวจสอบในแต่ละขั้นตอนด้วยdf.info()-df.head()และตรวจสอบจุดที่จะจับข้อผิดพลาด แต่เนิ่นๆ
• เมื่อชุดข้อมูลเกินขีด จำกัด ของ Excel Comfort โดยทั่วไปแล้วแพนด้าจะโหลดตัวกรองและกลุ่มหลายล้านแถวเร็วขึ้นและมีปัญหาน้อยลง

ด้วยการจัดงานของคุณในท่อแพนด้าเดียวคุณจะตัดงานยุ่งเร่งความเร็วการวิ่งซ้ำและทำให้ผลลัพธ์ง่ายขึ้นในการตรวจสอบและนำกลับมาใช้ใหม่ เพิ่มการอ่าน SQL โดยตรงเมื่อพร้อมใช้งานและให้ Parquet Snapshots ย้ายข้อมูลผ่านเวิร์กโฟลว์ของคุณอย่างรวดเร็ว