ලිපිගොනු ලිපිගොනු ලිවීමට නිවැරදි ක්‍රමය කුමක්ද?

මම පුරුදු වෙලා print >>f, "hi there"

කෙසේ වෙතත්, එය ක්ෂය print >>වෙමින් පවතින බව පෙනේ . ඉහත පේළිය කිරීමට නිර්දේශිත ක්‍රමය කුමක්ද?

යාවත්කාලීන කිරීම : මේ සියලු පිළිතුරු සමඟ "\n"... මෙය විශ්වීය හෝ යුනික්ස් විශේෂිතද? IE, මම "\r\n"වින්ඩෝස් හි කළ යුතුද?

මෙය තරම් සරල විය යුතුය:

with open('somefile.txt', 'a') as the_file:
    the_file.write('Hello\n')

ප්‍රලේඛනයෙන්:

os.linesepපෙළ ප්‍රකාරයේදී ගොනු විවෘත කිරීමේදී රේඛීය ටර්මිනේටරයක් ​​ලෙස භාවිතා නොකරන්න (සුපුරුදු පරිදි); සියලු වේදිකාවල ඒ වෙනුවට තනි '\ n' භාවිතා කරන්න.

සමහර ප්‍රයෝජනවත් කියවීම:

• මෙම withප්රකාශය
• open()
  • 'a' යනු එකතු කිරීම හෝ භාවිතය සඳහා ය
  • කප්පාදුවෙන් ලිවීමට 'w'
• os(විශේෂයෙන් os.linesep)

print()පයිතන් 2.6+ සිට ලබා ගත හැකි ශ්‍රිතය ඔබ භාවිතා කළ යුතුය

from __future__ import print_function  # Only needed for Python 2
print("hi there", file=f)

පයිතන් 3 සඳහා ඔබට අවශ්‍ය නොවේ import, මන්ද print()ශ්‍රිතය පෙරනිමිය වේ.

විකල්පය වනුයේ:

f = open('myfile', 'w')
f.write('hi there\n')  # python will convert \n to os.linesep
f.close()  # you can omit in most cases as the destructor will call it

සිට උපුටා දැක්වීම නව රේඛා සම්බන්ධයෙන් පයිතන් ප්‍රලේඛනයෙන් :

නිමැවුමේදී, නව '\n'රේඛාව කිසිවක් නොමැති නම්, ලියා ඇති ඕනෑම අක්ෂර පද්ධති පෙරනිමි රේඛා බෙදුම්කරුට පරිවර්තනය කරනු ලැබේ os.linesep. නව රේඛාවක් නම් '', පරිවර්තනයක් සිදු නොවේ. නව රේඛාව වෙනත් නෛතික අගයන් නම්, '\n'ලියා ඇති ඕනෑම අක්ෂර ලබා දී ඇති නූලට පරිවර්තනය කරනු ලැබේ.

මෙම පිඹුරා ලේඛන මේ ආකාරයට නිර්දේශ:

with open('file_to_write', 'w') as f:
    f.write('file contents\n')

ඉතින් මම සාමාන්‍යයෙන් කරන ක්‍රමය මෙයයි :)

Docs.python.org වෙතින් ප්‍රකාශය :

ගොනු වස්තු සමඟ කටයුතු කිරීමේදී 'with' යතුර භාවිතා කිරීම හොඳ පුරුද්දකි . මෙමඟින් වාසියක් ඇත්තේ ගොනුව එහි කට්ටලය අවසන් වූ පසු නිසි පරිදි වසා දැමීමයි. සමාන උත්සාහක-අවසාන වාරණ ලිවීමට වඩා එය කෙටි ය.

Os.linesep සම්බන්ධයෙන්:

වින්ඩෝස් හි හරියටම සංස්කරණය නොකළ පයිතන් 2.7.1 පරිවර්තක සැසිය මෙන්න:

Python 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.linesep
'\r\n'
>>> f = open('myfile','w')
>>> f.write('hi there\n')
>>> f.write('hi there' + os.linesep) # same result as previous line ?????????
>>> f.close()
>>> open('myfile', 'rb').read()
'hi there\r\nhi there\r\r\n'
>>>

වින්ඩෝස් මත:

බලාපොරොත්තු වූ පරිදි, os.linesep කරන්නේ නැති එකම ප්රතිඵලය නිෂ්පාදනය '\n'. එය එකම ප්‍රති come ල ලබා ගත හැකි ක්‍රමයක් නොමැත. 'hi there' + os.linesepට සමාන 'hi there\r\n'වන අතර එය සමාන නොවේ'hi there\n' .

මෙය සරලයි: භාවිතය \nස්වයංක්‍රීයව os.linesep වෙත පරිවර්තනය වේ. පයිතන් සිට වින්ඩෝස් දක්වා වූ පළමු වරායේ සිට එය එතරම් සරල ය.

වින්ඩෝස් නොවන පද්ධති වල os.linesep භාවිතා කිරීමේ කිසිදු තේරුමක් නැති අතර එය වින්ඩෝස් මත වැරදි ප්‍රති results ල ලබා දෙයි.

Os.linesep භාවිතා නොකරන්න!

"නිවැරදි" ක්‍රමයක් ඇතැයි මම නොසිතමි.

මම භාවිතා කරන්නේ:

with open ('myfile', 'a') as f: f.write ('hi there\n')

මතක සටහන් වල ටිම් ටෝඩි .

පයිතන් 3 හි එය ශ්‍රිතයකි, නමුත් පයිතන් 2 හි ඔබට මෙය ප්‍රභව ගොනුවේ ඉහළට එක් කළ හැකිය:

from __future__ import print_function

එහෙනම් ඔයා කරනවා

print("hi there", file=f)

ඔබ බොහෝ දත්ත හා වේගය ලියන්නේ නම් ඔබ සැලකිලිමත් විය යුතුය f.write(...). මම ඉක්මන් වේග සංසන්දනයක් කළ අතර එය print(..., file=f)විශාල සංඛ්‍යාවක් ලිවීමට වඩා සැලකිය යුතු වේගයකින් සිදු විය.

import time    

start = start = time.time()
with open("test.txt", 'w') as f:
    for i in range(10000000):
        # print('This is a speed test', file=f)
        # f.write('This is a speed test\n')
end = time.time()
print(end - start)

සාමාන්‍යයෙන් writeමගේ යන්ත්‍රයේ තත්පර 2.45 කින් නිම කර ඇතprint 4 ගුණයක් (තත්පර 9.76) පමණ ගත විය. එසේ පැවසුවහොත්, බොහෝ තාත්වික තත්වයන් තුළ මෙය ගැටළුවක් නොවනු ඇත.

ඔබ සමඟ යාමට තෝරා ගන්නේ නම්, print(..., file=f)වරින් වර නව රේඛාව යටපත් කිරීමට ඔබට අවශ්‍ය වනු ඇත, නැතහොත් එය වෙනත් දෙයක් සමඟ ප්‍රතිස්ථාපනය කරන්න. විකල්ප endපරාමිතිය සැකසීමෙන් මෙය කළ හැකිය , උදා;

with open("test", 'w') as f:
    print('Foo1,', file=f, end='')
    print('Foo2,', file=f, end='')
    print('Foo3', file=f)

ඔබ තෝරාගන්නා ඕනෑම ආකාරයකින් withකේතය කියවීමට පහසු වන බැවින් භාවිතා කිරීමට මම යෝජනා කරමි .

යාවත්කාලීන කිරීම : කාර්ය සාධනයේ මෙම වෙනස පැහැදිලි කරනුයේ writeඉහළ බෆරයකින් යුක්ත වන අතර ඕනෑම තැටියක් ලිවීමට පෙර නැවත පැමිණේ ( මෙම පිළිතුර බලන්න ), නමුත් print(බොහෝ විට) රේඛීය බෆරින් භාවිතා කරයි. මේ සඳහා සරල පරීක්‍ෂණයක් වනුයේ දිගු ලිවීම් සඳහා කාර්ය සාධනය පරීක්ෂා කිරීමයි, එහිදී රේඛීය බෆරින් සඳහා අවාසි (වේගය අනුව) අඩු ලෙස ප්‍රකාශ වේ.

start = start = time.time()
long_line = 'This is a speed test' * 100
with open("test.txt", 'w') as f:
    for i in range(1000000):
        # print(long_line, file=f)
        # f.write(long_line + '\n')
end = time.time()

print(end - start, "s")

කාර්ය සාධන වෙනස දැන් වඩා අඩුවෙන් උච්චාරණය වන අතර සාමාන්‍ය කාලය සඳහා 2.20s writeසහ 3.10s වේ print. මෙම ලූං රේඛා කාර්ය සාධනය ලබා ගැනීම සඳහා ඔබට නූල් පොකුරක් සංයුක්ත කිරීමට අවශ්‍ය නම්, printවඩාත් කාර්යක්ෂම වන භාවිත අවස්ථා ටිකක් දුර්ලභ ය.

3.5 සිට ඔබට ඒ pathlibසඳහා ද භාවිතා කළ හැකිය :

Path.write_text(data, encoding=None, errors=None)

පා mode මය ආකාරයෙන් පෙන්වා ඇති ගොනුව විවෘත කරන්න, එයට දත්ත ලිවීම සහ ගොනුව වසා දැමීම:

import pathlib

pathlib.Path('textfile.txt').write_text('content')

ඔබ රේඛාව පැවසූ විට එයින් අදහස් වන්නේ අනුක්‍රමික අක්ෂර '\ n' ලෙස අවසන් වීමයි. රේඛාව යම් අවස්ථාවක දී අවසාන විය යුතු බැවින් එක් එක් පේළියේ අවසානයේ '\ n' සලකා බැලිය යුතුය. මෙන්න විසඳුම:

with open('YOURFILE.txt', 'a') as the_file:
    the_file.write("Hello")

එක් එක් ලිවීමෙන් පසුව කර්සරය නව පේළියකට ගෙන යාමෙන් පසුව උපග්‍රන්ථයේ, ඔබට wමාදිලිය භාවිතා කිරීමට අවශ්‍ය නම් ශ්‍රිතය \nඅවසානයේ අක්ෂර එකතු කළ යුතුය write():

the_file.write("Hello\n")

කෙනෙකුට ioමොඩියුලය පහත පරිදි භාවිතා කළ හැකිය :

import io
my_string = "hi there"

with io.open("output_file.txt", mode='w', encoding='utf-8') as f:
    f.write(my_string)

නළයේ ඇති ගොනුවක පෙළ ලිවීමට භාවිතා කළ හැකිය:

filehandle = open("text.txt", "w")
filebuffer = ["hi","welcome","yes yes welcome"]
filehandle.writelines(filebuffer)
filehandle.close()

ඔබටත් උත්සාහ කළ හැකිය filewriter

pip install filewriter

from filewriter import Writer

Writer(filename='my_file', ext='txt') << ["row 1 hi there", "row 2"]

වෙත ලියයි my_file.txt

__str__ආධාරක සහිතව නැවත කළ හැකි හෝ වස්තුවක් ගනී .

මට නව පේළි ගොඩක් ලිවීමට අවශ්‍ය වූ විට, printශ්‍රිතයක් භාවිතා කරන ලැම්බඩා අර්ථ දක්වන්නෙමි :

out = open(file_name, 'w')
fwl = lambda *x, **y: print(*x, **y, file=out) # FileWriteLine
fwl('Hi')

මෙම ප්‍රවේශය මඟින් printශ්‍රිතය සමඟ ඇති සියලුම අංග භාවිතා කළ හැකිය .

යාවත්කාලීන කිරීම: අදහස් දැක්වීමේ කොටසෙහි ජෝර්ජි විසින් සඳහන් කර ඇති පරිදි, partialශ්‍රිතය සමඟ මෙම අදහස තවදුරටත් වැඩිදියුණු කළ හැකිය :

from functools import partial
fwl = partial(print, file=out)

IMHO, මෙය වඩාත් ක්‍රියාකාරී හා අඩු ගුප්ත ප්‍රවේශයකි.