පයිතන් හි ඇති ගොනුවකට ඔබ එකතු කරන්නේ කෙසේද?

ගොනුව නැවත ලිවීම වෙනුවට ඔබ එය එකතු කරන්නේ කෙසේද? ගොනුවට එකතු වන විශේෂ කාර්යයක් තිබේද?

with open("test.txt", "a") as myfile:
    myfile.write("appended text")

"A" හෝ "ab" මාදිලිය ලෙස සැකසීමෙන් ඔබ ගොනුව ඇපෙන්ඩ් ප්‍රකාරයේදී විවෘත කළ යුතුය. විවෘත () බලන්න .

ඔබ "a" මාදිලියකින් විවෘත කළ විට, ලිවීමේ ස්ථානය සෑම විටම ගොනුවේ අවසානයේ ඇත (උපග්‍රන්ථයක්). ඔබට කියවීමට ඉඩ දීම සඳහා "a +" සමඟ විවෘත කළ හැකිය, පසුපසට ගොස් කියවීමට (නමුත් සියලුම ලිවීම් තවමත් ගොනුවේ අවසානයේ පවතිනු ඇත!).

උදාහරණයක්:

>>> with open('test1','wb') as f:
        f.write('test')
>>> with open('test1','ab') as f:
        f.write('koko')
>>> with open('test1','rb') as f:
        f.read()
'testkoko'

සටහන : 'a' භාවිතා කිරීම 'w' සමඟ විවෘත කිරීම හා ගොනුවේ අවසානය දක්වා සෙවීම හා සමාන නොවේ - වෙනත් වැඩසටහනක් ගොනුව විවෘත කර සෙවීම සහ ලිවීම අතර ලිවීම ආරම්භ කළහොත් කුමක් සිදුවිය හැකිදැයි සලකා බලන්න. සමහර මෙහෙයුම් පද්ධති වලදී, 'a' සමඟ ගොනුව විවෘත කිරීමෙන් ඔබගේ පහත සඳහන් සියලුම ලිපිගොනු පරමාණුකව ගොනුවේ අවසානයට එකතු වන බවට සහතික වේ (ගොනුව වෙනත් ලිවීම් මගින් වර්ධනය වන විට පවා).

"A" මාදිලිය ක්‍රියාත්මක වන ආකාරය පිළිබඳ තවත් විස්තර කිහිපයක් ( ලිනක්ස් මත පමණක් පරීක්ෂා කර ඇත ). ඔබ ආපසු හැරී ගියත්, සෑම ලිවීමක්ම ගොනුවේ අවසානයට එකතු වේ:

>>> f = open('test','a+') # Not using 'with' just to simplify the example REPL session
>>> f.write('hi')
>>> f.seek(0)
>>> f.read()
'hi'
>>> f.seek(0)
>>> f.write('bye') # Will still append despite the seek(0)!
>>> f.seek(0)
>>> f.read()
'hibye'

ඇත්ත වශයෙන්ම, fopen මෑන්පේජ් හි මෙසේ සඳහන් වේ:

ගොනුවක් ඇපෙන්ඩ් ප්‍රකාරයේදී විවෘත කිරීම (මාදිලියේ පළමු අක්‍ෂරය ලෙස) මෙම ප්‍රවාහයට පසුව ලිවීමේ සියලු ක්‍රියාකාරකම් ගොනුවේ අවසානයේ සිදුවීමට හේතු වේ, ඇමතුමට පෙර මෙන්:

fseek(stream, 0, SEEK_END);

පැරණි සරල පිළිතුර (භාවිතා නොකිරීම with):

උදාහරණය: ( සත්‍ය වැඩසටහනක ගොනුව වැසීමට භාවිතා withකරන්න - ප්‍රලේඛනය බලන්න )

>>> open("test","wb").write("test")
>>> open("test","a+b").write("koko")
>>> open("test","rb").read()
'testkoko'

මම නිතරම මෙය කරනවා,

f = open('filename.txt', 'a')
f.write("stuff")
f.close()

එය සරලයි, නමුත් ඉතා ප්‍රයෝජනවත්.

පයිතන් ප්‍රධාන ක්‍රම තුනෙන් බොහෝ වෙනස්කම් ඇත, මෙම ක්‍රම තුන නම්:

'w'   write text
'r'   read text
'a'   append text

එබැවින් ගොනුවකට එකතු කිරීම පහසුය:

f = open('filename.txt', 'a') 
f.write('whatever you want to write here (in append mode) here.')

එවිට ඔබේ කේතය පේළි අඩු කරන මාතයන් ඇත:

'r+'  read + write text
'w+'  read + write text
'a+'  append + read text

අවසාන වශයෙන්, ද්විමය ආකෘතියෙන් කියවීමේ / ලිවීමේ ක්‍රම තිබේ:

'rb'  read binary
'wb'  write binary
'ab'  append binary
'rb+' read + write binary
'wb+' read + write binary
'ab+' append + read binary

"a"මාදිලියේ තර්කය ලෙස සම්මත වීමට ඔබට අවශ්‍ය විය හැකිය . විවෘත () සඳහා ලියකියවිලි බලන්න .

with open("foo", "a") as f:
    f.write("cool beans...")

යාවත්කාලීන කිරීම (+), කප්පාදු කිරීම (w) සහ ද්විමය (ආ) මාදිලිය සඳහා මාදිලියේ තර්කයේ වෙනත් ප්‍රේරණයන් ඇත, නමුත් ආරම්භ "a"කිරීම ඔබේ හොඳම ඔට්ටුවයි.

අපි මෙම රේඛාව භාවිතා කරන විට open(filename, "a"), එමඟින් aගොනුව එකතු වන බව පෙන්නුම් කරයි, එයින් අදහස් කරන්නේ පවතින ගොනුවට අමතර දත්ත ඇතුළත් කිරීමට ඉඩ දීමයි.

ඔබේ ගොනුවේ ඇති පෙළ එකතු කිරීමට ඔබට මෙම පහත පේළි භාවිතා කළ හැකිය

def FileSave(filename,content):
    with open(filename, "a") as myfile:
        myfile.write(content)

FileSave("test.txt","test1 \n")
FileSave("test.txt","test2 \n")

printඒ වෙනුවට ඔබට එය කළ හැකිය write:

with open('test.txt', 'a') as f:
    print('appended text', file=f)

නම් test.txt නොපවතියි, එය නිර්මාණය කරනු ඇත ...

ඔබට ගොනුව r+ප්‍රකාරයෙන් විවෘත කර ගොනුවේ පිහිටීම ගොනුවේ අවසානයට සකසා ගත හැකිය .

import os

with open('text.txt', 'r+') as f:
    f.seek(0, os.SEEK_END)
    f.write("text to add")

දී ගොනුව විවෘත r+මාදිලිය අවසන් අතර, අමතරව ඔබ වෙනත් ගොනු තනතුරු ලියන්න ඉඩ ඇත aහා a+අවසානය දක්වා බලය ලිවීම.

ඔබට ගොනුවකට එකතු කිරීමට අවශ්‍ය නම්

with open("test.txt", "a") as myfile:
    myfile.write("append me")

myfileගොනුවක් විවෘත කිරීම සඳහා අපි විචල්‍යය ප්‍රකාශ කළෙමු test.txt. විවෘත කිරීම තර්ක 2 ක් ගනී, අපට විවෘත කිරීමට අවශ්‍ය ගොනුව සහ ගොනුවේ අපට කිරීමට අවශ්‍ය අවසරය හෝ ක්‍රියාකාරිත්වය නියෝජනය කරන නූලක්

මෙන්න ගොනු මාදිලි විකල්ප

ප්‍රකාර විස්තරය

'r' මෙය පෙරනිමි ප්‍රකාරයයි. එය කියවීම සඳහා ගොනුව විවෘත කරයි.
'w' මෙම ප්‍රකාරය ලිවීම සඳහා ගොනුව විවෘත කරයි. 
ගොනුව නොපවතී නම්, එය නව ගොනුවක් නිර්මාණය කරයි.
ගොනුව තිබේ නම් එය ගොනුව කපා දමයි.
'x' නව ගොනුවක් සාදයි. ගොනුව දැනටමත් තිබේ නම්, මෙහෙයුම අසාර්ථක වේ.
උපග්‍රන්ථයේ ගොනුවක් විවෘත කරන්න. 
ගොනුව නොපවතී නම්, එය නව ගොනුවක් නිර්මාණය කරයි.
't' මෙය පෙරනිමි ප්‍රකාරයයි. එය පෙළ ප්‍රකාරයේදී විවෘත වේ.
'b' මෙය ද්විමය ආකාරයෙන් විවෘත වේ.
'+' මෙය කියවීම සහ ලිවීම සඳහා ගොනුවක් විවෘත කරනු ඇත (යාවත්කාලීන කිරීම)

මෙම 'a'පරාමිතිය හැඟවුම්කරණය මාදිලිය ඇතුලත්. ඔබට with openඑක් එක් අවස්ථාව භාවිතා කිරීමට අවශ්‍ය නැතිනම් , ඔබට එය කිරීමට පහසුවෙන් ශ්‍රිතයක් ලිවිය හැකිය:

def append(txt='\nFunction Successfully Executed', file):
    with open(file, 'a') as f:
        f.write(txt)

ඔබ කොහේ හරි වෙන වෙනත් අවසන් ලිවීමට වඩා අවශ්ය නම්, ඔබ භාවිතා කළ හැකිය 'r+'^† :

import os

with open(file, 'r+') as f:
    f.seek(0, os.SEEK_END)
    f.write("text to add")

අවසාන වශයෙන්, 'w+'පරාමිතිය ඊටත් වඩා නිදහසක් ලබා දෙයි. ගොනුව නොපවතින නම් එය නිර්මාණය කිරීමට මෙන්ම දැනට පවතින ගොනුවක අන්තර්ගතය හිස් කිරීමටද එය ඔබට ඉඩ දෙයි.

^† මෙම උත්සවය සඳහා ක්රෙඩිට් @Primusa යයි

ගොනුවක අවසානයට තවත් පෙළ එකතු කිරීම සඳහා සරලම ක්‍රමය වනුයේ:

with open('/path/to/file', 'a+') as file:
    file.write("Additions to file")
file.close()

මෙම a+තුළ open(...)ඇතුලත් ආකාරයෙන් ගොනුව විවෘත කිරීමට ප්රකාශයක් බවට උපදෙස් හා කියවීමට සහ ලිවීමේ ප්රවේශ.

file.close()ඔබ විවෘත කළ ඕනෑම ලිපිගොනු භාවිතයෙන් පසු ඒවා වසා දැමීමට භාවිතා කිරීම සැමවිටම හොඳ පුරුද්දකි .

මෙන්න මගේ ස්ක්‍රිප්ට් එක, මූලික වශයෙන් පේළි ගණන ගණනය කර, පසුව එකතු කර නැවත ඒවා ගණන් කරයි, එවිට එය ක්‍රියාත්මක වූ බවට සාක්ෂි තිබේ.

shortPath  = "../file_to_be_appended"
short = open(shortPath, 'r')

## this counts how many line are originally in the file:
long_path = "../file_to_be_appended_to" 
long = open(long_path, 'r')
for i,l in enumerate(long): 
    pass
print "%s has %i lines initially" %(long_path,i)
long.close()

long = open(long_path, 'a') ## now open long file to append
l = True ## will be a line
c = 0 ## count the number of lines you write
while l: 
    try: 
        l = short.next() ## when you run out of lines, this breaks and the except statement is run
        c += 1
        long.write(l)

    except: 
        l = None
        long.close()
        print "Done!, wrote %s lines" %c 

## finally, count how many lines are left. 
long = open(long_path, 'r')
for i,l in enumerate(long): 
    pass
print "%s has %i lines after appending new lines" %(long_path, i)
long.close()