फ़ाइलें और एक्सेप्शन
अधिकांश प्रोग्राम जो वास्तविक काम करते हैं, फ़ाइल सिस्टम से जुड़ते हैं: कॉन्फ़िग पढ़ना, परिणाम लिखना, डेटा लोड करना। और जब कुछ गलत होता है, तो Python एक एक्सेप्शन उठाता है, एक संकेत कि कुछ अप्रत्याशित हुआ। यह अध्याय दोनों को कवर करता है: फ़ाइलों से डेटा अंदर और बाहर लाना, और ऐसा कोड लिखना जो क्रैश होने के बजाय त्रुटियों को सहजता से संभालता है।
फ़ाइलें खोलना
open() एक फ़ाइल खोलता है और एक ऑब्जेक्ट लौटाता है जिससे आप पढ़ या लिख सकते हैं। आप उसे पथ और फ़ाइल के साथ क्या करना है (पढ़ना, लिखना, या जोड़ना) बताते हैं। जब आपका काम हो जाए, तो फ़ाइल को हमेशा बंद करें; with स्टेटमेंट यह स्वचालित रूप से करता है।
f = open("data.txt", "r") # "r" = पढ़ना
content = f.read()
f.close()"r" मोड है:
| मोड | अर्थ |
|---|---|
"r" | पढ़ना। फ़ाइल का होना ज़रूरी है। डिफ़ॉल्ट मोड। |
"w" | लिखना। फ़ाइल बनाता है या ओवरराइट करता है। |
"a" | जोड़ना। मिटाए बिना अंत में जोड़ता है। |
"x" | बनाना। यदि फ़ाइल पहले से मौजूद हो तो विफल होता है। |
"r+" | पढ़ना और लिखना। |
"b" | बाइनरी। किसी भी मोड में जोड़ें: "rb", "wb"। |
जब आपका काम हो जाए तो हमेशा .close() कॉल करें। इसे भूलने से फ़ाइल लॉक रह जाती है और डेटा भ्रष्टाचार हो सकता है। इसे संभालने का विश्वसनीय तरीका with स्टेटमेंट है।
with स्टेटमेंट
with open(...) आपके लिए फ़ाइल का प्रबंधन करता है, इंडेंटेड ब्लॉक समाप्त होने पर इसे स्वचालित रूप से बंद कर देता है, भले ही कोई त्रुटि हो जाए। मैन्युअल open()/close() के बजाय हमेशा with open(...) का उपयोग करें। यह अधिक सुरक्षित है और मानक है।
with open("data.txt", "r") as f:
content = f.read()
# f यहाँ बंद है, गारंटीशुदाwith क्या करता है?
with Python की कॉन्टेक्स्ट मैनेजर सिंटैक्स है। यह आपके लिए सेटअप और टियरडाउन कोड कॉल करता है; इस मामले में, फ़ाइल को खोलना और विश्वसनीय रूप से बंद करना। आपको यह जानने की ज़रूरत नहीं है कि यह आंतरिक रूप से कैसे काम करता है। बस open() के साथ इसका उपयोग करें।
फ़ाइलें पढ़ना
पढ़ने के लिए तीन विधियाँ। .read() पूरी फ़ाइल को एक स्ट्रिंग के रूप में लोड करता है। .readline() एक लाइन पढ़ता है। फ़ाइल ऑब्जेक्ट पर सीधे इटरेट करना लाइन-दर-लाइन पढ़ता है, जो बड़ी फ़ाइलों के लिए सबसे कुशल तरीका है क्योंकि यह सब कुछ एक साथ मेमोरी में लोड नहीं करता।
with open("data.txt", "r") as f:
content = f.read() # पूरी फ़ाइल एक स्ट्रिंग के रूप में
with open("data.txt", "r") as f:
first_line = f.readline() # एक समय में एक लाइन
with open("data.txt", "r") as f:
lines = f.readlines() # लाइनों की सूची, प्रत्येक "\n" में समाप्तबड़ी फ़ाइलों के लिए, लाइन-दर-लाइन पढ़ना सब कुछ एक साथ लोड करने से अधिक कुशल है:
with open("big_file.txt", "r") as f:
for line in f: # फ़ाइल को सीधे इटरेट करें, मेमोरी-कुशल
print(line.strip()) # strip() ट्रेलिंग न्यूलाइन को हटाता हैफ़ाइल ऑब्जेक्ट पर सीधे इटरेट करना (for line in f) बड़ी फ़ाइल पढ़ने का सबसे कुशल और मुहावरेदार तरीका है।
फ़ाइलें लिखना
"w" मोड फ़ाइल को पूरी तरह से ओवरराइट करता है यदि वह मौजूद हो। "a" मोड अंत में जोड़ता है। .write() स्वचालित रूप से न्यूलाइन नहीं जोड़ता; प्रत्येक लाइन के अंत में स्पष्ट रूप से "\n" शामिल करें। एक साथ कई लाइनें लिखने के लिए, उन्हें "\n".join() के साथ जोड़ें।
with open("output.txt", "w") as f:
f.write("Hello, world\n")
with open("output.txt", "a") as f:
f.write("Another line\n")"w" फ़ाइल को पूरी तरह से ओवरराइट करता है यदि वह मौजूद हो। "a" अंत में जोड़ता है।
f.write() स्वचालित रूप से न्यूलाइन नहीं जोड़ता, इसलिए स्पष्ट रूप से "\n" शामिल करें। एक साथ कई लाइनें लिखने के लिए:
lines = ["Line one", "Line two", "Line three"]
with open("output.txt", "w") as f:
f.write("\n".join(lines) + "\n")एक्सेप्शन
जब Python किसी ऐसी समस्या से टकराता है जिसे वह संभाल नहीं सकता, तो यह एक एक्सेप्शन उठाता है: एक त्रुटि जो बताती है कि क्या गलत हुआ और कहाँ। यदि आप इसे संभालते नहीं हैं, तो आपका प्रोग्राम क्रैश हो जाता है और एक ट्रेसबैक प्रिंट करता है। नीचे दी गई तालिका सबसे आम एक्सेप्शन दिखाती है जिनका आप सामना करेंगे।
आम एक्सेप्शन जिनका आप सामना करेंगे:
| एक्सेप्शन | कब होता है |
|---|---|
FileNotFoundError | open() फ़ाइल नहीं ढूँढ़ सकता |
ValueError | फ़ंक्शन को सही प्रकार लेकिन गलत सामग्री का मान मिलता है, जैसे int("abc") |
TypeError | पूरी तरह से गलत प्रकार, जैसे "hello" + 5 |
KeyError | डिक्शनरी कुंजी मौजूद नहीं है |
IndexError | सूची इंडेक्स सीमा से बाहर |
ZeroDivisionError | शून्य से विभाजन |
AttributeError | ऑब्जेक्ट के पास वह विशेषता या विधि नहीं है |
try / except
विफल हो सकने वाले कोड को try ब्लॉक में रैप करें। यदि कोई एक्सेप्शन होता है, तो मेल खाने वाला except ब्लॉक क्रैश होने के बजाय इसे संभालता है। आप किस एक्सेप्शन को पकड़ते हैं, इसके बारे में विशिष्ट रहें: खाली except: के साथ सब कुछ पकड़ना वास्तविक बग्स को छुपाता है।
try:
value = int("abc")
except ValueError:
print("That's not a valid number")आप किस एक्सेप्शन को पकड़ते हैं, इसके बारे में विशिष्ट रहें। खाली except: के साथ सभी एक्सेप्शन पकड़ना बग्स को छुपाता है:
# बुरा, प्रोग्रामर की गलतियों सहित सब कुछ पकड़ता है
try:
result = do_something()
except:
pass
# अच्छा, केवल वही पकड़ता है जिसकी आप अपेक्षा करते हैं और वास्तव में संभाल सकते हैं
try:
result = do_something()
except FileNotFoundError:
print("File not found")एकाधिक एक्सेप्शन पकड़ना
आप अलग-अलग except ब्लॉक में विभिन्न त्रुटि प्रकारों को संभाल सकते हैं, या एक ट्यूपल का उपयोग करके एक ब्लॉक में कई प्रकारों को पकड़ सकते हैं। as e हिस्सा आपको त्रुटि संदेश तक पहुँच देता है।
try:
data = int(user_input)
result = 100 / data
except ValueError:
print("Not a number")
except ZeroDivisionError:
print("Can't divide by zero")या एक ट्यूपल में कई पकड़ें:
except (ValueError, ZeroDivisionError) as e:
print(f"Input error: {e}")as e एक्सेप्शन ऑब्जेक्ट को एक नाम से बाइंड करता है ताकि आप संदेश का निरीक्षण कर सकें।
else और finally
else केवल तब चलता है जब कोई एक्सेप्शन नहीं हुआ हो। finally हमेशा चलता है, चाहे एक्सेप्शन हुआ हो या नहीं। finally ऐसी सफ़ाई के लिए उपयोगी है जो किसी भी स्थिति में होनी चाहिए।
try:
with open("data.txt") as f:
content = f.read()
except FileNotFoundError:
print("File not found, using defaults")
content = ""
else:
print("File loaded successfully")
finally:
print("Done attempting to load file") # हमेशा चलता हैfinally सफ़ाई के लिए सबसे उपयोगी है (कनेक्शन बंद करना, लॉक रिलीज़ करना) तब भी जब आप फ़ाइलों के लिए पहले से with का उपयोग कर रहे हों।
raise
आप स्वयं raise के साथ एक्सेप्शन उठा सकते हैं। यह वह तरीका है जिससे आप अपने फ़ंक्शनों को कॉलर्स को चुपचाप गलत मान लौटाने के बजाय समस्याओं को स्पष्ट रूप से संकेत देते हैं।
def divide(a, b):
if b == 0:
raise ValueError("Cannot divide by zero")
return a / bयह आपके फ़ंक्शनों को इस बारे में स्पष्ट बनाता है कि वे क्या अपेक्षा करते हैं और कॉलर्स को समस्याओं को स्पष्ट रूप से संकेत देते हैं।
कस्टम एक्सेप्शन क्लास
बड़े प्रोग्रामों के लिए, आप Exception से इनहेरिट करके अपने स्वयं के एक्सेप्शन प्रकार परिभाषित कर सकते हैं। यह कॉलर्स को आपकी विशिष्ट त्रुटियों को अन्य प्रकार की त्रुटियों से अलग पकड़ने देता है।
class InsufficientFundsError(Exception):
pass
class BankAccount:
def __init__(self, balance):
self.balance = balance
def withdraw(self, amount):
if amount > self.balance:
raise InsufficientFundsError(
f"Cannot withdraw {amount}, balance is {self.balance}"
)
self.balance -= amounttry:
account.withdraw(1000)
except InsufficientFundsError as e:
print(f"Transaction declined: {e}")JSON
JSON वह प्रारूप है जो सब कुछ बोलता है: APIs, कॉन्फ़िग फ़ाइलें, डेटा निर्यात। Python का json मॉड्यूल इसे सीधे संभालता है। json.load() एक फ़ाइल से JSON पढ़कर Python dict या list में लाता है। json.dump() Python dict या list को JSON के रूप में फ़ाइल में लिखता है।
फ़ाइल से JSON पढ़ें:
import json
with open("config.json", "r") as f:
config = json.load(f) # JSON को Python dict/list में पार्स करता है
print(config["setting"])फ़ाइल में JSON लिखें:
import json
data = {"name": "आरव", "score": 87, "active": True}
with open("output.json", "w") as f:
json.dump(data, f, indent=2) # indent= इसे मानव-पठनीय बनाता हैJSON से Python प्रकार मैपिंग:
| JSON | Python |
|---|---|
object {} | dict |
array [] | list |
string "" | str |
| number | int या float |
true / false | True / False |
null | None |
फ़ाइल को छुए बिना JSON स्ट्रिंग्स और Python ऑब्जेक्ट के बीच कनवर्ट करने के लिए:
import json
# स्ट्रिंग से Python में
data = json.loads('{"name": "आरव", "score": 87}')
# Python से स्ट्रिंग में
text = json.dumps({"name": "आरव", "score": 87}, indent=2)json.load() एक फ़ाइल ऑब्जेक्ट से पढ़ता है। json.loads() ("s" के साथ) एक स्ट्रिंग से पढ़ता है।
व्यवहार में
एक साधारण गेम के लिए सेव/लोड पैटर्न: स्थिति को JSON में लिखें, अगली रन पर इसे वापस लोड करें, और यदि कोई सेव फ़ाइल अभी तक मौजूद नहीं है तो डिफ़ॉल्ट पर वापस आ जाएँ:
import json
SAVE_FILE = "save_game.json"
def save_game(player_data: dict) -> None:
with open(SAVE_FILE, "w") as f:
json.dump(player_data, f, indent=2)
print("Game saved.")
def load_game() -> dict:
try:
with open(SAVE_FILE, "r") as f:
return json.load(f)
except FileNotFoundError:
print("No save file found, starting fresh.")
return {"name": "Player", "score": 0, "level": 1}
state = load_game()
state["score"] += 50
save_game(state)