# Python-இல் JSON: கோப்புகளைப் படித்தல் மற்றும் எழுதுதல், CSV, pathlib மற்றும் UTF-8 குறியாக்கம் URL: https://skillaria.top/ta/guides/python/json-python Python-இல் JSON-உடன் வேலை செய்ய உள்ளமைவுத் தொகுதி json உள்ளது: json.load திறந்த கோப்பிலிருந்து தரவைப் படிக்கும், json.dump கோப்பில் எழுதும்; json.loads மற்றும் json.dumps அதே வேலையை சரங்களுடன் செய்கின்றன. கோப்பை with open(path, encoding="utf-8") மூலம் திறக்கிறோம், பாதைகளை pathlib.Path மூலம் கட்டுகிறோம், அட்டவணைகளை csv தொகுதியால் படிக்கிறோம். Python-இல் JSON-உடன் வேலை செய்ய மூன்றாம் தரப்பு நூலகம் தேவையில்லை: `json` தொகுதி நிலையான நூலகத்தில் உள்ளது; அது அகராதிகளையும் பட்டியல்களையும் உரையாக்கி மீண்டும் திருப்புகிறது. அதனுடன் கிட்டத்தட்ட எப்போதும் வேண்டியவை மூன்று: `with` கட்டமைப்புடன் கூடிய `open` செயல்பாடு, பாதைகளுக்கான `pathlib`, அட்டவணைகளுக்கான `csv`. கீழே எல்லாம் வரிசையாக, வேலை செய்யும் குறியீட்டுடனும், பெரும்பாலும் தடுமாறும் பொறிகளுடனும். ## Python open செயல்பாடு: முறைகளும் குறியாக்கமும் எந்த உரைக் கோப்பையும் உள்ளமைவுச் செயல்பாடு `open(path, mode, encoding=...)` திறக்கிறது. அது `read`, `readline`, `write` முறைகள் உள்ள கோப்புப் பொருளைத் தரும்; அதை வரி வரியாக சுழலில் கடக்கலாம். | முறை | என்ன செய்கிறது | | --- | --- | | `"r"` | படிக்க (இயல்பு). கோப்பு இல்லையென்றால் `FileNotFoundError` | | `"w"` | எழுத. கோப்பு உருவாகும் அல்லது **திறந்த உடனேயே காலியாகும்** | | `"a"` | இறுதியில் சேர்க்க; ஏற்கனவே உள்ள உள்ளடக்கம் தொடப்படாது | | `"x"` | புதிய கோப்பை உருவாக்க; ஏற்கனவே இருந்தால் `FileExistsError` | | `"b"` | முறைக்கான சேர்க்கை: பைட்டுகளுடன் வேலை (`"rb"`, `"wb"`) | ### 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-இல் பெரும்பாலும் cp1252 போன்ற பழைய ANSI குறியாக்கம். சேவையகத்தில் சரியாக வேலை செய்த ஸ்கிரிப்ட் சக ஊழியரின் மடிக்கணினியில் "தமிழ" போன்ற குப்பையை அச்சிட்டது, அல்லது `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="cp1252") # cp1252-இல் சேமிக்கப்பட்ட கோப்பு ``` மறுபக்கம்: Excel அல்லது Windows ஸ்கிரிப்டிலிருந்து cp1252-இல் சேமிக்கப்பட்ட பழைய CSV இப்போது UTF-8 என்று படிக்கப்பட்டு `UnicodeDecodeError` தரும். தீர்வு: `encoding="cp1252"`-உடன் படித்து 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 உரை) மற்றும் நீக்கத் தொடராக்கம் (உரை → பொருள்). முறைகள் நான்கு; அவற்றிடையே குழப்பம் பொதுவான கேள்வி. | செயல்பாடு | என்ன செய்கிறது | | --- | --- | | `json.dumps(obj)` | பொருள் → JSON சரம் | | `json.loads(s)` | JSON சரம் → பொருள் | | `json.dump(obj, f)` | பொருள் → திறந்த கோப்பில் எழுது | | `json.load(f)` | திறந்த கோப்பிலிருந்து JSON-ஐப் படி | நினைவில் கொள்வது எளிது: இறுதியில் உள்ள `s` எழுத்து string — சரத்துடன் வேலை; அது இல்லையென்றால் கோப்புடன். ### வகைகளின் பொருத்தம் | Python | JSON | | --- | --- | | `dict` | பொருள் `{}` | | `list`, `tuple` | வரிசை `[]` | | `str` | சரம் | | `int`, `float` | எண் | | `True` / `False` | `true` / `false` | | `None` | `null` | மீண்டும் படிக்கும்போது 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` — கோப்பு வேறு குறியாக்கத்தில்; அதை வெளிப்படையாகக் குறியுங்கள் (`cp1252`, `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-ஆக சேமிக்கிறது. ## FAQ **json.load மற்றும் json.loads இடையே வேறுபாடு என்ன?** json.load திறந்த கோப்புப் பொருளிலிருந்து JSON-ஐப் படிக்கிறது, json.loads சரத்தை அலசுகிறது. அதேபோல json.dump கோப்பில் எழுதுகிறது, json.dumps சரத்தைத் திருப்புகிறது. **JSON-இல் தமிழ் எழுத்துகளை \u வடிவம் இல்லாமல் எப்படி சேமிப்பது?** json.dump அல்லது json.dumps-இல் ensure_ascii=False கொடுங்கள், கோப்பை encoding="utf-8"-உடன் திறவுங்கள். **JSON-உடன் வேலை செய்ய நூலகம் நிறுவ வேண்டுமா?** இல்லை, json தொகுதி நிலையான நூலகத்தில் உள்ளது; import json எழுதினால் போதும். **JSON-இல் தேதியையோ set-ஐயோ சேமிக்க முடியுமா?** நேரடியாக முடியாது: அவற்றை மாற்ற வேண்டும் — தேதியை isoformat மூலம் ISO சரமாக, set-ஐ பட்டியலாக; அல்லது default அளவுருவுக்கு செயல்பாட்டை அனுப்புங்கள். **நினைவகத்தில் பொருந்தாத பெரிய JSON-ஐ எப்படிப் படிப்பது?** நிலையான json.load கோப்பை முழுவதும் படிக்கும்; பெரிய தரவுக்கு JSON Lines வடிவத்தில் சேமித்து, ஒவ்வொரு வரியையும் json.loads மூலம் அலசுங்கள். --- Source: Skillaria.Top (https://skillaria.top)