Python-இல் JSON: கோப்புகளைப் படித்தல் மற்றும் எழுதுதல், CSV, pathlib மற்றும் UTF-8 குறியாக்கம்

Python-இல் JSON-உடன் வேலை செய்ய மூன்றாம் தரப்பு நூலகம் தேவையில்லை: json தொகுதி நிலையான நூலகத்தில் உள்ளது; அது அகராதிகளையும் பட்டியல்களையும் உரையாக்கி மீண்டும் திருப்புகிறது. அதனுடன் கிட்டத்தட்ட எப்போதும் வேண்டியவை மூன்று: with கட்டமைப்புடன் கூடிய open செயல்பாடு, பாதைகளுக்கான pathlib, அட்டவணைகளுக்கான csv. கீழே எல்லாம் வரிசையாக, வேலை செய்யும் குறியீட்டுடனும், பெரும்பாலும் தடுமாறும் பொறிகளுடனும்.

Python open செயல்பாடு: முறைகளும் குறியாக்கமும்

எந்த உரைக் கோப்பையும் உள்ளமைவுச் செயல்பாடு open(path, mode, encoding=...) திறக்கிறது. அது read, readline, write முறைகள் உள்ள கோப்புப் பொருளைத் தரும்; அதை வரி வரியாக சுழலில் கடக்கலாம்.

with ஏன் தேவை

கோப்பை மூட வேண்டும்: இல்லையென்றால் தரவு வட்டில் எழுதப்படாமல் போகலாம், கணினி கோப்பு விவரிப்பியை பிடித்து வைத்திருக்கும். with கட்டமைப்பு கோப்பை தானாக மூடுகிறது — தொகுதிக்குள் பிழை வந்தாலும் கூட.

with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("முதல் வரி\n")
    f.write("இரண்டாம் வரி\n")

with open("notes.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip("\n"))

கோப்பை சுழலில் கடப்பது அதை ஒவ்வொரு வரியாகப் படிக்கும்; முழுவதும் நினைவகத்தில் ஏற்றாது — அதனால் கிகாபைட் அளவுள்ள பதிவுக் கோப்புகளையும் செயலாக்கலாம். f.read() முழு உள்ளடக்கத்தையும் ஒரே சரமாகத் தரும், f.readlines() வரிகளின் பட்டியலைத் தரும்.

ஏற்கனவே உள்ளதை அழிக்காமல் கோப்பில் எழுதுவது எப்படி

தொடக்கநிலையாளரின் மிகப் பொதுவான தவறு — ஒரு வரியை "சேர்ப்பதற்காக" "w" முறையில் கோப்பைத் திறப்பது. "w" முறை திறக்கும் தருணத்திலேயே, முதல் write-க்கு முன்பே கோப்பை காலியாக்குகிறது. பதிவை இறுதியில் சேர்க்க "a" பயன்படுத்துங்கள்; பிறருடைய கோப்பை மேலெழுதாமல் உறுதிப்படுத்த "x".

with open("log.txt", "a", encoding="utf-8") as f:
    f.write("புதிய பதிவு\n")

write வரி முறிவைத் தானாகச் சேர்க்காது — "\n" வெளிப்படையாக எழுத வேண்டும். print(..., file=f) பயன்படுத்தலாம்: அது அடுத்த வரிக்கு மாற்றுவதை உங்களுக்காகச் செய்யும்.

UTF-8 குறியாக்கம்: "உடைந்த எழுத்துகள்" ஏன் தோன்றுகின்றன

Python 3.15-க்கு முன், encoding அளவுரு இல்லாமல் open() கணினியின் குறியாக்கத்தை எடுத்துக்கொண்டது. Linux மற்றும் macOS-இல் அது UTF-8; தமிழ் லோக்கல் கொண்ட Windows-இல் பெரும்பாலும் cp1251 அல்லது அதற்கு இணையானது. சேவையகத்தில் சரியாக வேலை செய்த ஸ்கிரிப்ட் சக ஊழியரின் மடிக்கணினியில் "Еда" போன்ற குப்பையை அச்சிட்டது, அல்லது UnicodeDecodeError-உடன் விழுந்தது.

Python 3.15-இல் PEP 686-இன்படி UTF-8 முறை இயல்பாக இயக்கப்பட்டுள்ளது: encoding இல்லாமல் open() எல்லா இயக்க முறைமைகளிலும் UTF-8-ஐப் படித்து எழுதும். பழைய நடத்தையைத் திரும்பப் பெற PYTHONUTF8=0 சூழல் மாறி அல்லது -X utf8=0 கொடி; கணினி குறியாக்கத்தை வெளிப்படையாகக் கேட்க — encoding="locale".

import sys
print(sys.flags.utf8_mode)   # Python 3.15-இல் 1

open("legacy.txt", encoding="locale")   # கணினி குறியாக்கம்
open("old_excel.csv", encoding="cp1251")  # cp1251-இல் சேமிக்கப்பட்ட கோப்பு

மறுபக்கம்: Excel அல்லது Windows ஸ்கிரிப்டிலிருந்து cp1251-இல் சேமிக்கப்பட்ட பழைய CSV இப்போது UTF-8 என்று படிக்கப்பட்டு UnicodeDecodeError தரும். தீர்வு: encoding="cp1251"-உடன் படித்து UTF-8-ஆக மீண்டும் சேமிப்பது. நல்ல பழக்கம் மாறவில்லை — encoding-ஐ வெளிப்படையாகக் குறியுங்கள்; அப்போது குறியீடு எந்தப் பதிப்பிலும் ஒரே மாதிரி நடந்துகொள்ளும்.

Python pathlib: பாதைகள் பொருட்களாக

பாதைகளை சரங்களாக இணைப்பது ("data" + "/" + name) சிரமமானது, வெவ்வேறு இயக்க முறைமைகளில் உடையும். pathlib தொகுதியின் Path வகுப்பில் பாதைகள் / இயக்கியால் இணைகின்றன; பொருளுக்கு தெளிவான பண்புக்கூறுகளும் உண்டு.

from pathlib import Path

data = Path("data")
csv_path = data / "expenses.csv"

print(csv_path.name)    # expenses.csv
print(csv_path.stem)    # expenses
print(csv_path.suffix)  # .csv
print(csv_path.parent)  # data
print(csv_path.exists())

data.mkdir(parents=True, exist_ok=True)
(data / "hello.txt").write_text("வணக்கம்", encoding="utf-8")
print((data / "hello.txt").read_text(encoding="utf-8"))

for p in data.glob("*.csv"):
    print(p)

read_text மற்றும் write_text முறைகள் சிறிய கோப்புகளுக்கு open + with இணையை மாற்றுகின்றன. Path பொருளை சாதாரண open, json மற்றும் csv எல்லாவற்றுக்கும் அனுப்பலாம் — அனைத்தும் அதை ஏற்கும். ஸ்கிரிப்டின் அடைவைப் பொறுத்த பாதை, தற்போதைய அடைவைப் பொறுத்தது அல்ல: Path(__file__).parent / "data".

Python 3.14-இல் Path-க்கு copy() மற்றும் move() முறைகள் வந்தன; எளிய நகலுக்கு shutil இனி தேவையில்லை. அதே பதிப்பில் நிலையான நூலகத்தில் Zstandard சுருக்கத்துக்கான compression.zstd தொகுதியும் சேர்ந்தது (PEP 784).

Python JSON: load, dump, loads, dumps

JSON என்பது தரவுப் பரிமாற்றத்துக்கான உரை வடிவம்: API-கள் அதை அனுப்புகின்றன, அமைப்புகளும் அறிக்கைகளும் அதில் சேமிக்கப்படுகின்றன. json தொகுதி இரண்டு செயல்பாடுகளைச் செய்கிறது: தொடராக்கம் (Python பொருள் → JSON உரை) மற்றும் நீக்கத் தொடராக்கம் (உரை → பொருள்). முறைகள் நான்கு; அவற்றிடையே குழப்பம் பொதுவான கேள்வி.

நினைவில் கொள்வது எளிது: இறுதியில் உள்ள s எழுத்து string — சரத்துடன் வேலை; அது இல்லையென்றால் கோப்புடன்.

வகைகளின் பொருத்தம்

மீண்டும் படிக்கும்போது tuple பட்டியலாக மாறும்; set, தேதிகள் மற்றும் Decimal-ஐ தொகுதிக்குத் தெரியாது — TypeError: Object of type ... is not JSON serializable வரும்.

JSON-ஐ கோப்பில் சேமிப்பது

import json
from pathlib import Path

report = {
    "month": "2026-10",
    "total": 15230.5,
    "categories": {"உணவு": 8200, "போக்குவரத்து": 2100},
    "tags": ["வீடு", "வேலை"],
}

path = Path("data/report.json")
path.parent.mkdir(parents=True, exist_ok=True)
with path.open("w", encoding="utf-8") as f:
    json.dump(report, f, ensure_ascii=False, indent=2)

ensure_ascii=False தமிழ் எழுத்துகளை அப்படியே வைத்திருக்கும். அது இல்லையென்றால் கோப்பில் "உணவு" என்பதற்குப் பதிலாக "உ..." வடிவம் வரும் — அது சரியான JSON, ஆனால் மனிதர்களால் படிக்க முடியாது. indent=2 உள்தள்ளல்களுடன் அழகான வடிவமைப்பைத் தரும்.

கோப்பிலிருந்து JSON-ஐப் படிப்பது

with open("data/report.json", encoding="utf-8") as f:
    data = json.load(f)

print(data["total"])               # 15230.5
print(data["categories"]["உணவு"])   # 8200

முடிவு சாதாரண அகராதி அல்லது பட்டியல்; அதை வழக்கமான கருவிகளால் கையாளலாம். கோப்பு JSON அல்ல அல்லது துண்டிக்கப்பட்டிருந்தால் வரி மற்றும் நிலை எண்ணுடன் json.JSONDecodeError வரும் — தரவு வெளியிலிருந்து வரும்போது அதைப் பிடிப்பது அவசியம்.

JSON சரத்தை அலசுவதும் அழகாக அச்சிடுவதும்

import json

raw = '{"name": "அன்னா", "skills": ["python", "sql"], "active": true}'
user = json.loads(raw)
print(user["skills"][0])   # python

print(json.dumps(user, ensure_ascii=False, indent=2, sort_keys=True))

sort_keys=True வெளியீட்டில் விசைகளை வரிசைப்படுத்தும் — git-இல் கோப்புகளை ஒப்பிட வசதியானது. Terminal-இலிருந்து கோப்பை அழகாக வடிவமைக்க உள்ளமைவுக் கருவி உண்டு: python -m json.tool data/report.json.

HTTP API-இன் பதிலும் JSON சரமே. requests நூலகம் அதை response.json() முறையால் அலசுகிறது; உள்ளே இருப்பது அதே json.loads.

பொறி: JSON விசைகள் எப்போதும் சரங்கள்

d = {1: "ஜனவரி", 2: "பிப்ரவரி"}
back = json.loads(json.dumps(d))
print(back == d)   # False
print(back)        # {'1': 'ஜனவரி', '2': 'பிப்ரவரி'}
# back[1] -> KeyError, back["1"] என்று எழுத வேண்டும்

fixed = {int(k): v for k, v in back.items()}

JSON-இல் பொருளின் விசைகள் சரங்களாக மட்டுமே இருக்க முடியும்; அதனால் எண் விசைகள் தொடராக்கம் சுற்றுக்குப் பின் சரங்களாக மாறும். படிக்கும்போது அவற்றை மீண்டும் மாற்றுங்கள்.

சொந்த வகைகள்: தேதிகளும் Decimal-உம்

import json
from datetime import date

def default(obj):
    if isinstance(obj, date):
        return obj.isoformat()
    raise TypeError(f"{type(obj).__name__} வகையை தொடராக்க முடியாது")

print(json.dumps({"day": date(2026, 10, 1)}, default=default))
# {"day": "2026-10-01"}

default அளவுருவில் உள்ள செயல்பாடு அறியாத ஒவ்வொரு பொருளுக்கும் அழைக்கப்படுகிறது. சிக்கலான நிலைகளில் json.JSONEncoder-இலிருந்து மரபுரிமை பெற்று default முறையை மேலெழுதலாம்.

JSON வரிசையில் ஒரு உறுப்பைச் சேர்ப்பது

JSON-ஐ உரைப் பதிவு போல இறுதியில் சேர்க்க முடியாது: கோப்பை முழுவதும் படித்து, மாற்றி, முழுவதுமாக எழுத வேண்டும்.

path = Path("data/items.json")
items = json.loads(path.read_text(encoding="utf-8")) if path.exists() else []
items.append({"id": len(items) + 1, "title": "புதியது"})
path.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8")

பதிவுகள் அதிகமாக இருந்து தொடர்ந்து சேர்க்கப்பட்டால், JSON Lines வடிவம் வசதியானது: ஒரு வரியில் ஒரு JSON பொருள், கோப்பு "a" முறையில் திறக்கப்படுகிறது.

Python-இல் CSV: csv தொகுதி

CSV என்பது உரைக் கோப்பிலுள்ள அட்டவணை: வரிகள் பதிவுகள், மதிப்புகள் காற்புள்ளிகளால் பிரிக்கப்படுகின்றன. csv தொகுதி மேற்கோள்கள், மதிப்புகளுக்குள் உள்ள காற்புள்ளிகள் மற்றும் வரி முறிவுகளை சரியாகக் கையாள்கிறது; கைமுறை split(",") அதைச் செய்யாது.

import csv

with open("data/expenses.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    total = 0.0
    for row in reader:
        total += float(row["amount"])
        print(row["date"], row["category"], row["amount"])
print("மொத்தம்:", total)

csv.DictReader ஒவ்வொரு வரியையும் கோப்பின் தலைப்பால் அகராதியாக மாற்றும். எல்லா மதிப்புகளும் சரங்கள்: எண்களையும் தேதிகளையும் நீங்களே மாற்றுங்கள் (float, int, date.fromisoformat). ";" பிரிப்பான் கொண்ட கோப்பு (தமிழ் Excel இப்படித்தான் சேமிக்கிறது) delimiter=";" அளவுருவுடன் படிக்கப்படுகிறது.

rows = [
    {"date": "2026-10-01", "category": "உணவு", "amount": 450},
    {"date": "2026-10-02", "category": "போக்குவரத்து", "amount": 60},
]
with open("data/out.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["date", "category", "amount"])
    writer.writeheader()
    writer.writerows(rows)

எழுதும்போது newline="" கட்டாயம்: இல்லையென்றால் Windows-இல் வரிகளுக்கு இடையே வெற்று வரிகள் தோன்றும். கோப்பை Excel-இல் திறக்கப் போகிறீர்கள் என்றால் encoding="utf-8-sig" பயன்படுத்துங்கள் — BOM குறி Excel-க்கு UTF-8-ஐ அடையாளம் காண உதவும்.

CSV-இலிருந்து JSON-க்கு: முழு எடுத்துக்காட்டு

import csv
import json
from collections import defaultdict
from pathlib import Path

src = Path("data/expenses.csv")
dst = Path("data/report.json")

by_category = defaultdict(float)
with src.open(newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        by_category[row["category"]] += float(row["amount"])

report = {"total": sum(by_category.values()), "categories": dict(by_category)}
dst.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
print(dst.read_text(encoding="utf-8"))

எந்த அறிக்கை ஸ்கிரிப்டின் அடிப்படையும் இதுதான்: CSV-இல் நுழைவு, அகராதியில் தொகுப்பு, JSON-இல் வெளியீடு.

பொதுவான தவறுகள்

• FileNotFoundError — பாதை உறவினர் வகையில், ஓட்டத்தின் தற்போதைய அடைவிலிருந்து கணக்கிடப்படுகிறது, ஸ்கிரிப்டிலிருந்து அல்ல. Path(__file__).parent பயன்படுத்துங்கள்.
• கோப்பு காலியானது — "a"-க்குப் பதிலாக "w"-இல் திறந்துவிட்டீர்கள்.
• UnicodeDecodeError — கோப்பு வேறு குறியாக்கத்தில்; அதை வெளிப்படையாகக் குறியுங்கள் (cp1251, utf-8-sig).
• TypeError: Object of type set is not JSON serializable — பட்டியலாக மாற்றுங்கள் அல்லது default-ஐ அனுப்புங்கள்.
• JSON ஏற்றிய பின் KeyError — எண் விசைகள் சரங்களாக மாறிவிட்டன.
• சொந்தக் கோப்புக்கு json.py அல்லது csv.py என்று பெயரிடுவது — அது நிலையான தொகுதியை மறைக்கும், import json உங்கள் கோப்பை இறக்குமதி செய்யும்.

சுருக்கம்

Python-இல் JSON-க்கு நிலையான நூலகம் போதும்: கோப்புகளுக்கு json.load/json.dump, சரங்களுக்கு loads/dumps, படிக்கக்கூடிய வெளியீட்டுக்கு ensure_ascii=False மற்றும் indent. கோப்புகளை வெளிப்படையான குறியாக்கத்துடன் with-ஆல் திறவுங்கள், பாதைகளை pathlib-ஆல் கட்டுங்கள், அட்டவணைகளை csv.DictReader-ஆல் படியுங்கள். Python பாடநெறியில் இந்தத் தலைப்பு நடைமுறையில் விளக்கப்பட்டுள்ளது: செலவு கண்காணிப்பான் செலவுகளை CSV-இலிருந்து படித்து அறிக்கையை JSON-ஆக சேமிக்கிறது.