Käytä Pythonia tietojen analysointiin: Rakenna toistettava työnkulku

Panda-datakehykset, joita tukee Numpy ja visualisoitu matplotlibilla tai Seabornilla, antavat sinulle suoran polun raa'ista tietueista luotettaviin oivalluksiin ilman manuaalisia, virheen alttiita vaiheita. Alla oleva lähestymistapa priorisoi yhden, toistettavan putkilinjan, jonka voit käyttää uudelleen uusia tietoja ja jakaa joukkuetovereiden kanssa.

Edellytykset

• Python 3.9+ asennettuna Anacondan tai System Package Manager -sovelluksen kautta.
• Jupyterlab tai Jupyter -muistikirja iteratiivista analyysiä varten.
• Kirjastot: pandas, numphy, matplotlib, meren syntynyt, scikit-oppiminen; Plus -ohjaimet käyttämillesi ulkoisille lähteille (esimerkiksi PYODBC tai PsyCOPG2).

Menetelmä 1 - Rakenna toistettava Panda -putkilinja (Jupyter)

Vaihe 1:Luo ja aktivoi omistettu python -ympäristö.

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

Vaihe 2:Asenna ydinanalyysikirjastot.

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

Vaihe 3:Käynnistä JUPYTERLAB tai muistikirja ja luo uusi muistikirja.

jupyter lab
# Run cells with 

Shift+EnterSuorita nykyinen solu ja siirtyy seuraavaan.

Vaihe 4:Lataa CSV data -kehyksessä, jossa dtypit on päätetty.

import pandas as pd

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

Vaihe 5:Standardoi sarakkeet Snake_Case -sovellukseen johdonmukaisen koodin varalta.

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

Vaihe 6:Tarkasta tyypit ja puuttuvat arvot suunnitelmien korjaamiseksi.

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

Vaihe 7:Patch tunnetut puuttuvat arvot korvaamatta hyviä rivejä.

# 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)

Vaihe 8:Puhdista valuuttakielet ja valettu numeeriksi yhdessä ketjussa.

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"),
)

Vaihe 9:Muunna kestoteksti, kuten “130 minuuttia” kokonaislukuiksi.

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

Vaihe 10:Jäsentä ihmisen luettavissa olevat päivämäärät oikeaan DateTime-sarakkeeseen.

Ehdotettu lukeminen:Evoto AI: Muuta työnkulku AI-moottorilla editoinnilla

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

Vaihe 11:Johda hyödyllisiä ominaisuuksia (esimerkiksi julkaisuvuosi) ryhmittelyyn.

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

Vaihe 12:Korjaa kirjoitusvirheet ja epäjohdonmukaiset luokat luotettavalle ryhmittelylle.

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"),
)

Vaihe 13:Tunnista epätodennäköiset poikkeavuudet, joilla on nopeat tilastot.

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

Vaihe 14:Oikea tarkistettu huonot arvot realistisiin numeroihin.

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

Vaihe 15:Poista päällekkäiset rivit ja reindex puhtaalle tietojoukolle.

df = df.drop_duplicates(ignore_index=True)

Vaihe 16:Pysy puhdistettuun tietojoukkoon tulevaa analyysiä varten.

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

Miksi tämä menetelmä ensin: Yksi, ketjutettu putkilinja vähentää manuaalisia vaiheita, estää piilotetut Excel -muokkaukset ja antaa joukkuetoveriensa tuottaa tuloksia pyynnöstä. Se myös skaalaa paremmin kuin laskentataulukoita, kun tietojoukko kasvaa muutaman sadan tuhannen rivin yli.

Menetelmä 2 - Kyselytiedot suoraan tietokannasta pandaiksi

Vaihe 1:Asenna DB -ohjain ja SQL -työkalupakki moottorillesi.

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

Vaihe 2:Luo sqlalchemy -moottori, jossa on suojattu yhteysmerkkijono.

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
)

Vaihe 3:Vedä tietoa suoraan pandaan viemättä CSV: tä.

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

Vaihe 4:Parametrize -kyselyt SQL -injektioriskien välttämiseksi.

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"})

Vaihe 5:Sulje yhteydet käytön jälkeen tai luota asiayhteyshenkilöihin.

engine.dispose()

Tämä lähestymistapa eliminoi manuaalisen viennin, tukee aikataulun mukaisia ​​työpaikkoja ja pitää totuuden lähteen logiikan SQL: ssä tarvittaessa. Se on ihanteellinen, kun tietosi elävät jo BI -työkalujen käyttämissä relaatiojärjestelmissä.

Menetelmä 3 - Lue yhteisistä tiedosto- ja verkkolähteistä

Vaihe 1:Lataa sarake -parkettitiedostot nopeuden ja säilyneiden DTYP: ien varalta.

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

Vaihe 2:Tuo Excel -arkit, kun joukkueet jakavat .xlsx -tiedostoja.

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

Vaihe 3:Lue JSON -asiakirjat siisteisiin taulukoihin.

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

Vaihe 4:Raaputa yksinkertaisia ​​HTML -taulukoita, kun sovellusliittymä ei ole käytettävissä.

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

Vinkki: mieluummin parquet välitallennusta varten, koska se puristaa ja säilyttää tyypit; Jos sinun on jaettava työkaluilla, joilla ei ole parkettitukea, vienti CSV: n varaosana.

Menetelmä 4 - Analysoi, visualisoi ja malli

Vaihe 1:Laske nopea kuvailevat tilastot alueille ja poikkeavuuksille.

df.describe(numeric_only=True)

Vaihe 2:Luo sirontakaavio korrelaation arvioimiseksi kahden mittarin välillä.

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

Vaihe 3:Asenna yksinkertainen lineaarinen regressio ja piirrä parhaiten sopiva viiva.

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

Vaihe 4:Tarkasta jakaumat binned -määrillä nähdäksesi tyypilliset alueet.

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

Vaihe 5:Ryhmä ja aggregaatti segmenttien vertaamiseksi.

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

Tonttien lukeminen: Näkyvä ylöspäin suuntautuva trendi sirontaan osoittaa positiivisen suhteen, kun taas pilvi, jolla ei ole kaltevuutta, viittaa vähän tai ei lainkaan lineaarista suhdetta. Käytä R²: n määrittämiseen, kuinka hyvin regressioviiva selittää tietojen varianssin.

Operatiiviset vinkit ja varoitukset

• Automatisoi toistuva työ pitämällä kaikki yhdessä muistikirjassa tai komentosarjassa ja suorittamalla se aikataulussa valitsemasi orkesterin kanssa.
• Käytä menetelmä ketjuttamista (esimerkiksidf.assign(...).drop_duplicates(...)) pitää koodin luettavissa ja välttää vahingossa tapahtuva välivaihtelu.
• Mieluummin kirjoitettuja kokonaislukuja (Int64) ja kelluu (Float64) matematiikasta; Jouset eivät tiivistä tai keskimäärin oikein.
• Validoi jokaisessa vaiheessadf.info()-df.head(), ja pisteiden tarkistaminen virheiden saamiseksi aikaisin.
• Kun tietojoukot ylittävät Excel -mukavuusrajat, pandat lataavat tyypillisesti, suodattimia ja ryhmiä miljoonia rivejä nopeammin ja vähemmän kaatumisia.

Keskitämällä työsi yhdellä pandaputkella, leikkaat kiireiset työt, nopeuta toistuvia ajoja ja helpotat tuloksia tarkistamisen ja uudelleenkäytön uudelleen. Lisää suora SQL lukee, kun se on saatavana, ja pidä parkettivalot siirtääksesi tietoja työnkulun läpi nopeasti.