Theory
બધું database માં વસતું નથી
ResultDesk marks માટે college.db રાખે છે, પણ દુનિયા સાદી files મોકલતી રહે છે: notes.txt માં હાજરીનું log, .csv તરીકે marksheet, ક્યાંક લખવાના ભૂલના logs.
csv નું module અલ્પવિરામ ઉકેલે (આગલો પાઠ) એ પહેલાં, તમારે file પોતે પકડવી પડે: એ ખોલવી, લીટીઓ બહાર વાંચવી, લીટીઓ અંદર લખવી, અને data ગુમાવ્યા વગર બંધ કરવી.
Python એ બધું એક function, open(), દ્વારા કરે છે, અને એમાંનો એક અક્ષર નક્કી કરે છે કે તમે વાંચો છો, લખો છો, કે અકસ્માતે નાશ કરો છો.
Theory
નોટબુક ખોલવાની ત્રણ રીત
એ જ નોટબુક, ત્રણ ઇરાદા:
- r: વાંચવા ખોલો, કશું અડો નહીં. નોટબુક ખૂટે છે? હવા વંચાય નહીં: ભૂલ.
- w: દરેક પાનું ફાડી નાખો અને પહેલા પાનેથી લખવાનું શરૂ કરો. ખૂટે છે? નવી નોટબુક ખરીદાય છે.
- a: છેલ્લા લખાયેલા પાને ખોલો અને નીચે ચાલુ રાખો. ખૂટે છે? નવી નોટબુક, એ જ વર્તન.
ફાડેલાં પાનાં જ યાદ રાખવાનો મુદ્દો છે: mode w એ પેન જડેલું કાગળ કાપવાનું યંત્ર છે.
At a glance
File નાં modes
| Mode | File હોય તો | File ખૂટે તો |
|---|---|---|
| r (વાંચવું) | વાંચવા ખૂલે છે | FileNotFoundError |
| w (લખવું) | ખાલી કરી નાખે છે, પછી લખે છે | નવી બનાવે છે |
| a (ઉમેરવું) | હયાત સામગ્રી પછી લખે છે | નવી બનાવે છે |
| r+ (વાંચવું વત્તા લખવું) | બંને માટે ખૂલે છે | FileNotFoundError |
| b નો પ્રત્યય (rb, wb) | Binary mode (images, .db files) | પાયાના mode પ્રમાણે |
Practical
વાંચો, લખો, ઉમેરો: with ની ભાત
# WRITE a fresh report (destroys any old report.txt!)
with open('report.txt', 'w') as f:
f.write('DBMS average: 61.5\n') # \n is YOUR job
f.write('Maths average: 73.2\n')
# APPEND to a running log (never destroys)
with open('activity.log', 'a') as f:
f.write('report generated\n')
# READ it back, line by line
with open('report.txt', 'r') as f:
for line in f: # the file object is iterable
print(line.strip()) # strip() removes the trailing \n
# other reading tools:
# f.read() -> the whole file as one string
# f.readline() -> one line
# f.readlines() -> list of all lines
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Theory
open/close ને બદલે with કેમ
તમે f = open(...) અને પછી f.close() લખી શકો છો. વ્યાવસાયિકો લગભગ ક્યારેય લખતા નથી, કારણ કે જે ક્ષણે ભૂલ એની ઉપરથી કૂદે એ ક્ષણે close છોડાઈ જાય છે, અને files lock રહી જાય તથા લખાણ flush ન થાય.
with open('report.txt', 'w') as f: file ને આપોઆપ બંધ કરે છે, block ભાંગી પડે તો પણ. એ transactions ના વચનનું file સંભાળવાનું સમકક્ષ છે: એવી સફાઈ જે ભૂલી શકાય નહીં.
વધુ એક ટેવ: દરેક write() તમે જે આપો બરાબર એ જ છાપે છે, કોઈ newline ઉમેરાતું નથી. લીટીના ભાગલા તમારું કામ છે: '\n'.
Quiz
attendance.log માં એક મહિનાની નોંધ છે. એક script આજની નોંધ ઉમેરવા open('attendance.log', 'w') થી એને ખોલે છે, એક લીટી લખે છે, બંધ કરે છે. હવે file માં શું છે?
- ફક્ત આજની લીટી: mode w એ ખોલવાના સમયે જ મહિનાની નોંધ ખાલી કરી નાખી
- મહિનાની નોંધ વત્તા અંતે આજની લીટી
- મહિનાની નોંધ, ઉપર આજની લીટી સાથે
- કશું નહીં: w mode માટે file અસ્તિત્વમાં ન હોવી જોઈએ
Show the answer
ફક્ત આજની લીટી: mode w એ ખોલવાના સમયે જ મહિનાની નોંધ ખાલી કરી નાખી
Mode w હયાત file ને એ ખૂલે એ જ ક્ષણે ખાલી કરી નાખે છે, કોઈ પણ લખાણ પહેલાં: script open() પછી તરત ભાંગી પડી હોત તો પણ મહિનાનો ઇતિહાસ ગયો હોત. અંતે ઉમેરવા માટે જ a (append) છે. આ ચૂપચાપ ખાલી કરી નાખવાનો અકસ્માત એ શરૂઆત કરનારનો સૌથી મોંઘો file નો bug છે: logs, અહેવાલો અને CSV બધું એનાથી મરે છે.
Think first
બેવડી ખાલી જગ્યાની આગાહી કરો
report.txt માં બે લીટી છે. એક student ચલાવે છે:
with open('report.txt') as f:
for line in f:
print(line)
Tap કરતાં પહેલાં: output કેવું દેખાય છે, અને કેમ?
Show the answer
દરેક લીટી પછી એક ખાલી લીટી સાથે છપાય છે. File માંથી વંચાયેલી દરેક લીટી પોતાનું છેલ્લું \n રાખે છે, અને print() બીજું ઉમેરે છે: લીટી દીઠ બે newline, બેવડું અંતર.
ઉકેલ: print(line.strip()) (કે line.rstrip('\n'), કે print(line, end='')). નાની વિગત, પણ file ના loops વિશેના લગભગ દરેક output-લખો પરીક્ષાના પ્રશ્નમાં એ આવે છે. એ પણ નોંધો: કોઈ mode ન અપાય તો 'r' છે, default.
Watch out
File સંભાળવાના ત્રણ marks-ખાનારા
a જોઈતું હતું ત્યાં w: ઇતિહાસ ચૂપચાપ નાશ પામ્યો. લખવા માટે ખોલતાં પહેલાં દર વખતે પોતાને પૂછો: નવી file, કે ચાલુ રાખવાનું?
write() માં ખૂટતું \n: બધું એક જ લીટીમાં ઊતરે છે; write() કશું ઉમેરતું નથી.
ખૂટતી file પર r: FileNotFoundError, w/a થી વિપરીત જે બનાવે છે. ઉપરનું પરીક્ષાનું કોષ્ટક જ "file નાં modes સમજાવો" નો જવાબ છે: હોય/ખૂટે નાં ખાનાં સાથે એ ફરી લખો.
Theory
CSV ની files એ ફક્ત લખાણની files છે
આ પાઠનાં ઓજારોથી marks.csv ખોલો અને તમને પ્રામાણિક લખાણ મળે છે: લીટી દીઠ 101,DBMS,78. તમે જાતે split(',') કરી શકો... જ્યાં સુધી કોઈ નામમાં અલ્પવિરામ ન આવે અને તમારો parser તૂટી ન પડે. બરાબર એટલા માટે જ csv નું module છે: એ જ open(), એ જ with, એ જ modes, વત્તા એવો parser જે સ્વરૂપની ધારની બાબતો જાણે છે. આગલો પાઠ: reader, writer, અને એમનાં Dict પિતરાઈ.
Summary
Key takeaways
- open(name, mode): r વાંચે છે (ખૂટે તો ભૂલ), w બનાવે/ખાલી કરે છે, a ઉમેરે છે (ખૂટે તો બનાવે છે).
- Mode w હયાત file ને ખોલવાના સમયે ખાલી કરી નાખે છે: ચૂપ વિનાશક.
- with open(...) as f: આપોઆપ બંધ કરે છે, ભૂલ થાય તો પણ: વ્યાવસાયિક default.
- Files માંથી વંચાયેલી લીટીઓ પોતાનું છેલ્લું \n રાખે છે: છાપતાં પહેલાં strip(); write() કોઈ newline ઉમેરતું નથી.
- read()/readline()/readlines()/iteration વાંચવાની બધી શૈલી આવરે છે.
- CSV ની files એ લખાણની files છે; csv નું module એની ઉપર અલ્પવિરામ-સલામત parsing ઉમેરે છે.
- Memory hook: નોટબુક વાંચો, ફાડીને લખો, કે છેલ્લા પાને ચાલુ રાખો.