در این فصل چه یاد میگیری#
یک جدولِ ثابت را در پنج قالب مینویسیم و حجم و زمانِ خواندنش را اندازه میگیریم. parquet حدودِ یکچهارمِ csv جا میگیرد و jsonl بزرگتر از csv درمیآید.
ولی نتیجهٔ اصلیِ فصل عدد نیست: csv سه ستون از چهار ستونی که میسنجیم را بیصدا خراب میکند. کدِ شعبهٔ 099 برمیگردد 99، ستونِ زمان برمیگردد رشته، و امتیازِ صحیح برمیگردد اعشاری. هیچ خطایی داده نمیشود — و همان کد دفعهٔ بعد روی همان فایل نتیجهٔ دیگری میدهد.

آخر این فصل میتوانی:
- حجم و زمانِ خواندنِ یک جدول را در قالبهای مختلف اندازه بگیری
- تفاوتِ ذخیرهٔ سطری و ستونی را با یک آزمایش نشان بدهی
- بگویی هر قالب چه چیزی از تایپها را نگه میدارد و چه چیزی را دور میریزد
- برای هر جای مسیر قالبِ درست را انتخاب کنی و دلیلش را با عدد بگویی
قبل از شروع#
از فصل ۱: پیکرهٔ خام و اینکه هر مرحله فایلی میسازد که مرحلهٔ بعد میخوانَد. قالبِ آن فایل یک تصمیمِ مهندسی است، نه یک عادت.
از سرنخ ترمِ ۲: pandas، read_csv و dtype.
💡 نکته:
pyarrowدر Colab از قبل نصب است، پسto_parquetبدونِ نصبِ چیزی کار میکند. اگر روی ماشینِ خودت اجرا میکنی و نبود،pip install pyarrowلازم میشود.
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوتبوک روی CPU | کمتر از یک دقیقه |
| GPU | لازم نیست |
۱. اول جدولی با تایپِ درست بساز#
هر مقایسهای بیمعناست اگر خودِ جدول از اول خراب باشد. پس csv خام را کاملاً بهصورتِ رشته میخوانیم و بعد هر ستون را دستی به تایپِ درستش میبریم.
import pandas as pd
RAW = WORK / "raw" / "tickets.csv"
FMT = WORK / "formats"
FMT.mkdir(exist_ok=True)
raw = pd.read_csv(RAW, dtype=str, keep_default_na=False) # هیچ حدسی نزن
df = raw.drop_duplicates().reset_index(drop=True)
df["created_at"] = pd.to_datetime(df["created_at"])
df["escalated"] = df["escalated"].astype("int8")
df["handling_minutes"] = df["handling_minutes"].astype("int32")
df["rating"] = pd.to_numeric(df["rating"], errors="coerce").astype("Int8")
# branch_code عمداً رشته میماند: «007» با «7» یکی نیست
print("ردیف:", len(df), "· ستون:", len(df.columns))
print("branch_code ردیفِ اول:", df["branch_code"].iloc[0],
"· نوعِ مقدار:", type(df["branch_code"].iloc[0]).__name__)
ردیف: 1200 · ستون: 10
branch_code ردیفِ اول: 099 · نوعِ مقدار: str
dtype=str یعنی «حدس نزن»، و keep_default_na=False یعنی «رشتهٔ خالی را با NaN عوض نکن». این دو با هم تنها راهِ خواندنِ یک csv بدونِ از دست دادنِ اطلاعاتاند. بعدش هر تبدیل را خودمان و آگاهانه انجام میدهیم.
Int8 با I بزرگ یک تایپِ عددیِ خالیپذیر است: هم عددِ صحیح نگه میدارد و هم «مقدار ندارد». int8 معمولی نمیتواند، و به همین دلیل pandas وقتی خودش حدس میزند ستونی با خانهٔ خالی را اعشاری میکند.
۲. یک جدول، پنج فایل#
PATHS = {
"csv": FMT / "t.csv",
"csv.gz": FMT / "t.csv.gz",
"jsonl": FMT / "t.jsonl",
"parquet": FMT / "t.parquet",
"parquet+zstd": FMT / "t.zstd.parquet",
}
df.to_csv(PATHS["csv"], index=False, encoding="utf-8")
df.to_csv(PATHS["csv.gz"], index=False, encoding="utf-8", compression="gzip")
df.to_json(PATHS["jsonl"], orient="records", lines=True,
force_ascii=False, date_format="iso")
df.to_parquet(PATHS["parquet"], index=False, compression="snappy")
df.to_parquet(PATHS["parquet+zstd"], index=False, compression="zstd")
base = PATHS["csv"].stat().st_size
print(f"{'قالب':<14}{'کیلوبایت':>10}{'نسبت به csv':>14}")
for name, p in PATHS.items():
size = p.stat().st_size
print(f"{name:<14}{size / 1024:>10.1f}{base / size:>14.2f}")
قالب کیلوبایت نسبت به csv
csv 246.3 1.00
csv.gz 33.9 7.26
jsonl 410.7 0.60
parquet 65.9 3.74
parquet+zstd 45.3 5.44
سه چیز در این جدول هست و هر سه ارزشِ توضیح دارند.
اول، jsonl از csv بزرگتر است. چون نامِ هر ستون در هر ردیف دوباره نوشته میشود. با ۱۲۰۰ ردیف و ده ستون، دوازده هزار بار نامِ ستونها روی دیسک تکرار شده است.
دوم، csv.gz از parquet هم کوچکتر شد. فشردهسازیِ عمومی روی متنِ تکراری خیلی خوب کار میکند و متنِ تیکتهای ما پر از عبارتهای تکراری است. پس «parquet همیشه کوچکتر است» غلط است — و اگر فقط دنبالِ حجم باشی، csv.gz گزینهٔ کاملاً معقولی است.
سوم، zstd روی همان parquet حجم را باز هم کم کرد. الگوریتمِ فشردهسازی یک انتخابِ جداست، نه بخشی از قالب.
⚠️ مواظب باش: حجمِ
parquetبه نسخهٔ کتابخانهای که آن را مینویسد وابسته است، پس عددهای تو با کتاب کمی فرق میکنند. نتیجهگیریِ فصل به اختلافِ نسبی تکیه دارد، نه به عددِ مطلق — و آن اختلاف روی هر نسخهای همین شکلی است.
۳. زمانِ خواندن#
import time
def fastest(fn, n=5):
"""کمترین زمان از چند اجرا — کمتر از میانگین تحتِ تأثیرِ نویزِ سیستم است."""
best = None
for _ in range(n):
t0 = time.perf_counter()
fn()
dt = time.perf_counter() - t0
best = dt if best is None else min(best, dt)
return best
READERS = {
"csv": lambda: pd.read_csv(PATHS["csv"]),
"csv.gz": lambda: pd.read_csv(PATHS["csv.gz"]),
"jsonl": lambda: pd.read_json(PATHS["jsonl"], lines=True),
"parquet": lambda: pd.read_parquet(PATHS["parquet"]),
}
print(f"{'قالب':<10}{'خواندنِ کلِ جدول':>22}")
for name, fn in READERS.items():
print(f"{name:<10}{fastest(fn) * 1000:>18.1f} ms")
قالب خواندنِ کلِ جدول
csv 8.6 ms
csv.gz 8.9 ms
jsonl 15.2 ms
parquet 3.1 ms
parquet حدودِ سه برابر سریعتر خوانده شد، و csv.gz با اینکه هفت برابر کوچکتر است، سریعتر از csv نبود.
دلیلش این است که خواندنِ csv کارِ سنگینی است: هر عدد بهصورتِ متن روی دیسک است و باید تجزیه شود. باز کردنِ فشردهسازی کارِ ارزانی است در مقایسه با همان تجزیه، پس فایلِ کوچکترْ زمانِ کمتری نمیآورد. parquet اعداد را بهشکلِ دودویی نگه میدارد و تجزیهای در کار نیست.
۴. ستونی یعنی چه#
فرقِ اصلیِ parquet این است که داده را ستونبهستون روی دیسک میچیند، نه ردیفبهردیف. حالا فقط یک ستون بخواه.
def one_col_csv():
return pd.read_csv(PATHS["csv"], usecols=["escalated"])
def one_col_parquet():
return pd.read_parquet(PATHS["parquet"], columns=["escalated"])
t_csv = fastest(one_col_csv)
t_pq = fastest(one_col_parquet)
print(f"یک ستون از csv : {t_csv * 1000:>6.1f} ms")
print(f"یک ستون از parquet : {t_pq * 1000:>6.1f} ms")
print("نسبت :", round(t_csv / t_pq, 1))
یک ستون از csv : 5.9 ms
یک ستون از parquet : 2.3 ms
نسبت : 2.6
usecols در csv هم کمک کرد — از ۸٫۶ به ۵٫۹ — ولی نتوانست به parquet برسد.
چرا؟ چون در یک فایلِ سطری، مقادیرِ یک ستون در کلِ فایل پخشاند. برای برداشتنِ ستونِ دهم باید نُه ستونِ دیگر را هم از دیسک بخوانی و رد کنی؛ فقط از تبدیلشان به مقدارِ پایتون فرار کردهای. در فایلِ ستونی، آن ستون یک قطعهٔ پیوسته است و بقیه اصلاً لمس نمیشوند.
روی ۱۲۰۰ ردیف این تفاوت ناچیز است. روی جدولی با صد ستون که فقط سهتایش را میخواهی، همین تفاوت مرزِ بینِ ثانیه و دقیقه است.
۵. حالا چیزی که csv بیصدا خراب میکند#
back = {
"csv": pd.read_csv(PATHS["csv"]),
"jsonl": pd.read_json(PATHS["jsonl"], lines=True),
"parquet": pd.read_parquet(PATHS["parquet"]),
}
def kind(frame, col):
return type(frame[col].iloc[0]).__name__
print(f"{'ستون':<16}{'قبل':>12}{'csv':>12}{'jsonl':>12}{'parquet':>12}")
for col in ("branch_code", "created_at", "rating", "escalated"):
line = f"{col:<16}{kind(df, col):>12}"
for name in ("csv", "jsonl", "parquet"):
line += f"{kind(back[name], col):>12}"
print(line)
print("branch_code ردیفِ اول — خام:", df["branch_code"].iloc[0],
"· بعد از csv:", back["csv"]["branch_code"].iloc[0])
ستون قبل csv jsonl parquet
branch_code str int64 int64 str
created_at Timestamp str Timestamp Timestamp
rating int8 float64 float64 int8
escalated int8 int64 int64 int8
branch_code ردیفِ اول — خام: 099 · بعد از csv: 99
از این چهار ستون، سهتا از csv سالم بیرون نیامدند، و هیچکدام خطا ندادند. escalated فقط عرضِ نوعش عوض شد و مقدارش همان ماند. این چهارتا نمونهاند: بقیهٔ ستونهای جدول را اینجا نسنجیدهایم.
branch_codeرشته بود و عدد برگشت. کدِ شعبهٔ099شد99و صفرِ ابتدایی برای همیشه رفت. اگر این کد را با جدولِ دیگریjoinکنی، هیچ ردیفی نمیخورد و ساعتها دنبالِ باگ میگردی.created_atزمان بود و رشته برگشت. تا وقتیto_datetimeرا دوباره صدا نزنی، مرتبسازیات الفبایی است نه زمانی.ratingعددِ صحیحِ خالیپذیر بود و اعشاری برگشت، چونcsvجای «خالی» فقط رشتهٔ خالی دارد وpandasبرای نگهداشتنِ آن مجبور است بهfloatبرود.
علتِ ریشهای یکی است: csv تایپ ندارد. هر چیزی که در آن مینویسی متن است، و هر بار که میخوانی، یک نفر باید حدس بزند. اینجا آن یک نفرْ pandas است و حدسش معقول ولی غلط است.
parquet هر چهار ستون را دستنخورده پس داد، چون تایپ را کنارِ داده نگه میدارد. jsonl وسطِ این دو ایستاد: زمان را نگه داشت (چون بهشکلِ متنِ استاندارد نوشته شد) ولی 099 را باز هم عدد خواند.
✅ چک کن: ستونِ
created_atرا در فایلِt.csvبا یک ویرایشگر باز کن. مقدارها آنجا هستند و کاملاً خوانا. مسئله این نیست که داده گم شده؛ مسئله این است که «این ستون زمان است» گم شده. فرقِ داده و فراداده دقیقاً همینجاست.
۶. و چیزی که parquet قبول نمیکند#
parquet سختگیر است: هر ستون یک تایپ دارد و تمام. حالا عمداً ستونی میسازیم که نصفه تمیز شده — بعضی خانههایش عدد است و بعضی متن.
half_clean = df.copy()
half_clean["rating_raw"] = [int(v) if pd.notna(v) else "نامشخص" for v in df["rating"]]
try:
half_clean.to_parquet(FMT / "broken.parquet", index=False)
except Exception as e:
print(type(e).__name__)
print(str(e).split("\n")[0][1:69])
ArrowInvalid
"Could not convert 'نامشخص' with type str: tried to convert to int64
🔧 اگر کار نکرد: این خطا درست است و باید بیفتد.
parquetدارد میگوید ستونت دو تایپ دارد و او فقط یکی را میتواند بنویسد. راهِ حل، آرام کردنِparquetنیست؛ تصمیم گرفتن دربارهٔ ستون است: یا «نامشخص» را به «مقدار ندارد» تبدیل کن و ستون راInt8بگذار، یا کلِ ستون را رشته کن و بپذیر که دیگر عدد نیست. همین سختگیری بزرگترین مزیتِparquetاست: ستونِ دوتایپه درcsvبیصدا ذخیره میشود و سه مرحله بعد بهشکلِ یک خطای عجیب بیرون میزند.
۷. پس چرا هنوز jsonl لازم داری#
row = df.iloc[[0]]
before_j = PATHS["jsonl"].stat().st_size
with open(PATHS["jsonl"], "a", encoding="utf-8") as fh:
fh.write(row.to_json(orient="records", lines=True,
force_ascii=False, date_format="iso"))
after_j = PATHS["jsonl"].stat().st_size
pd.concat([df, row], ignore_index=True).to_parquet(PATHS["parquet"], index=False)
after_p = PATHS["parquet"].stat().st_size
print("یک ردیف به jsonl : نوشتنِ", after_j - before_j, "بایت")
print("یک ردیف به parquet : بازنویسیِ", after_p, "بایت")
print("نسبت :", round(after_p / (after_j - before_j)))
یک ردیف به jsonl : نوشتنِ 290 بایت
یک ردیف به parquet : بازنویسیِ 67530 بایت
نسبت : 233
برای افزودنِ یک ردیف، jsonl ۲۹۰ بایت نوشت و parquet کلِ فایل را از نو ساخت.
parquet ستونی است، پس هر ردیفِ تازه به همهٔ قطعههای ستونی دست میزند. عملاً «افزودن» ندارد؛ فقط «نوشتنِ دوباره» دارد. jsonl در عوض یک خط است پشتِ خطِ قبلی، و همینطور هم خوانده میشود — خطبهخط، بدونِ اینکه لازم باشد کلِ فایل در حافظه جا شود.
پس اینها رقیبِ هم نیستند؛ برای دو جای مسیرند. jsonl قالبِ ورودِ داده است: چیزی که همین الان میرسد. parquet قالبِ دادهٔ تثبیتشده است: چیزی که بارها خوانده میشود و کم عوض میشود. الگوی رایج همین است: با jsonl جمع کن، دورهای به parquet تبدیل کن.
📏 اندازه بگیر: با چه چیزی مقایسه شد؟ پنج قالب روی یک جدولِ کاملاً یکسان — بدونِ این، مقایسهٔ حجم بیمعنا بود. روی کدام داده؟ همان ۱۲۰۰ ردیفِ ترم، که متنِ فارسیِ تکراری دارد؛ روی دادهٔ عددیِ محض نسبتها فرق میکنند. با چند
seed؟ زمانها بهترین از پنج اجرااند نه یک اجرا، چون یک اندازهگیریِ تکیِ زمان تقریباً همیشه نویز است.
۸. انتخاب#
| قالب | کِی | چه چیزی را از دست میدهی |
|---|---|---|
csv |
تبادل با آدمها و ابزارهایی که فقط همین را میخوانند | تایپ، بهکل |
csv.gz |
آرشیوِ ارزان وقتی خواندنش نادر است | تایپ، و امکانِ خواندنِ تکهای |
jsonl |
دادهٔ در حالِ ورود، سیاهه، رویداد | ستونی نیست؛ حجمِ زیاد |
parquet |
دادهٔ تثبیتشدهای که بارها خوانده میشود | افزودنِ ارزان؛ خوانا نبودن با چشم |
sqlite |
وقتی به پرسوجو و شرط و join نیاز داری |
یک فایلِ واحد با قفل، برای موازیسازیِ سنگین مناسب نیست |
و یک قاعدهٔ ساده که بیشترِ تصمیمها را میگیرد: هر جا داده از مسیرِ تو خارج میشود و به دستِ آدم میرسد، csv؛ هر جا داده داخلِ مسیرِ تو از مرحلهای به مرحلهای میرود، parquet.
🤖 از دستیارت بپرس: «در
parquetمفهومِrow groupچیست و چطور باعث میشود بشود بخشی از فایل را بدونِ خواندنِ کلِ آن فیلتر کرد؟» بعد این را هم بپرس: «اگر جدولِ من ۱۰ گیگابایت باشد و فقط ردیفهای یک ماهِ خاص را بخواهم،partitionچه کمکی میکند و چه هزینهای دارد؟» — جوابش توضیح میدهد چرا مسیرهای دادهٔ بزرگ فایلها را در پوشههایی به نامِ تاریخ میچینند.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| row-oriented | رو-اورینتد | چیدنِ داده ردیفبهردیف روی دیسک |
| column-oriented | کالمن-اورینتد | چیدنِ داده ستونبهستون روی دیسک |
| parquet | پارکِت | قالبِ ستونیِ دودویی با تایپِ ذخیرهشده |
| jsonl | جیسون-اِل | هر خط یک شیءِ JSON کامل |
| schema | اسکیما | تعریفِ ستونها و تایپشان، جدا از خودِ داده |
| nullable type | نالاِیبل تایپ | تایپی که «مقدار ندارد» را هم نگه میدارد |
| round-trip | راند-تریپ | نوشتن و دوباره خواندن، برای دیدنِ اینکه چه چیزی گم میشود |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
تا اینجا فرض کردیم داده «همان چیزی است که انتظار داریم». نیست. فصلِ بعد یک اسکیمای واقعی مینویسد — انتظار از هر ستون، بازه، یکتایی — و آن را روی همین ۱۲۰۰ ردیف اجرا میکند. تعدادِ تخلفهایی که پیدا میشود از چیزی که حدس میزنی بیشتر است، و مهمتر از عددش این است که یاد بگیری کدامشان باید مسیر را متوقف کند و کدام فقط باید ثبت شود.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.