ලැයිස්තුවකට ලිපිගොනු පේළියක් කියවන්නේ කෙසේද?

පයිතන් හි ගොනුවක සෑම පේළියක්ම කියවා එක් එක් පේළිය ලැයිස්තුවක මූලද්‍රව්‍යයක් ලෙස ගබඩා කරන්නේ කෙසේද?

මට අවශ්‍ය වන්නේ ගොනු රේඛාව පේළියෙන් කියවා එක් එක් පේළිය ලැයිස්තුවේ අවසානයට එකතු කිරීමයි.

with open(filename) as f:
    content = f.readlines()
# you may also want to remove whitespace characters like `\n` at the end of each line
content = [x.strip() for x in content] 

ආදානය සහ ප්‍රතිදානය බලන්න :

with open('filename') as f:
    lines = f.readlines()

හෝ නව රේඛා අක්‍ෂරය ඉවත් කිරීම සමඟ:

with open('filename') as f:
    lines = [line.rstrip() for line in f]

මෙය අවශ්‍ය ප්‍රමාණයට වඩා පැහැදිලිය, නමුත් ඔබට අවශ්‍ය දේ කරයි.

with open("file.txt") as file_in:
    lines = []
    for line in file_in:
        lines.append(line)

මෙය ගොනුවෙන් පේළි "අරාවක්" ලබා දෙනු ඇත.

lines = tuple(open(filename, 'r'))

openනැවත නැවත කළ හැකි ගොනුවක් නැවත ලබා දෙයි. ඔබ ගොනුවක් හරහා නැවත කියවන විට, ඔබට එම ගොනුවෙන් රේඛා ලැබේ. tupleඔබට එය ලබා දෙන අනුකාරකයෙන් අනුකාරකයක් ගෙන ක්ෂණික අවස්ථාවක් ලබා ගත හැකිය. linesයනු ගොනුවේ රේඛාවලින් සාදන ලද ටුපල් ය.

\nඇතුළත් කිරීමට ඔබට අවශ්‍ය නම් :

with open(fname) as f:
    content = f.readlines()

\nඇතුළත් කිරීමට ඔබට අවශ්‍ය නැතිනම් :

with open(fname) as f:
    content = f.read().splitlines()

පයිතන්ගේ ගොනු වස්තු ක්‍රමයට අනුව, පෙළ ගොනුවක් a බවට පරිවර්තනය කිරීමේ සරලම ක්‍රමය list:

with open('file.txt') as f:
    my_list = list(f)

ඔබට පෙළ ගොනු රේඛා හරහා නැවත කියවීමට අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ හැකිය:

with open('file.txt') as f:
    for line in f:
       ...

පැරණි පිළිතුර:

භාවිතා කිරීම withසහ readlines():

with open('file.txt') as f:
    lines = f.readlines()

ගොනුව වැසීම ගැන ඔබ තැකීමක් නොකරන්නේ නම්, මෙම එක් ලයිනර් ක්‍රියා කරයි:

lines = open('file.txt').readlines()

මෙම සාම්ප්රදායික ක්රමය:

f = open('file.txt') # Open file on read mode
lines = f.read().split("\n") # Create a list containing all lines
f.close() # Close file

යෝජනා කර ඇති පරිදි ඔබට පහත සඳහන් දෑ කළ හැකිය:

with open('/your/path/file') as f:
    my_lines = f.readlines()

මෙම ප්‍රවේශයට අවාසි 2 ක් ඇති බව සලකන්න:

1) ඔබ සියලු රේඛා මතකයේ ගබඩා කරයි. පොදුවේ ගත් කල, මෙය ඉතා නරක අදහසකි. ගොනුව ඉතා විශාල විය හැකි අතර ඔබට මතක ශක්තිය නැති වී යා හැකිය. එය විශාල නොවුනත් එය හුදෙක් මතකය නාස්තියකි.

2) ඔබ එක් එක් පේළිය කියවන විට ඒවා සැකසීමට මෙය ඉඩ නොදේ. එබැවින් ඔබ මෙයින් පසු ඔබේ රේඛා සකසන්නේ නම්, එය කාර්යක්ෂම නොවේ (එකකට වඩා පාස් දෙකක් අවශ්‍ය වේ).

සාමාන්‍ය නඩුව සඳහා වඩා හොඳ ප්‍රවේශයක් පහත දැක්වේ:

with open('/your/path/file') as f:
    for line in f:
        process(line)

ඔබේ ක්‍රියාවලි ක්‍රියාකාරිත්වය ඔබට අවශ්‍ය ආකාරයට අර්ථ දක්වන තැන. උදාහරණයක් වශයෙන්:

def process(line):
    if 'save the world' in line.lower():
         superman.save_the_world()

( Supermanපන්තිය ක්‍රියාත්මක කිරීම ඔබට අභ්‍යාසයක් ලෙස ඉතිරිව ඇත).

මෙය ඕනෑම ගොනු ප්‍රමාණයකට හොඳින් ක්‍රියා කරන අතර ඔබ ඔබේ ගොනුව 1 පාස් එකකින් යන්න. සාමාන්‍යයෙන් සාමාන්‍ය විග්‍රහ කරන්නන් ක්‍රියා කරන්නේ කෙසේද යන්නයි.

දත්ත ලැයිස්තුවට

පහත දැක්වෙන රේඛාවල මෙන් අපගේ දත්ත සමඟ පෙළ ගොනුවක් ඇතැයි උපකල්පනය කරන්න,

පෙළ ගොනු අන්තර්ගතය:

line 1
line 2
line 3

• එකම ඩිරෙක්ටරියේ cmd විවෘත කරන්න (මූසිකය මත දකුණු-ක්ලික් කර cmd හෝ PowerShell තෝරන්න)
• ධාවනය pythonකර පරිවර්තකයේ ලියන්න:

පයිතන් පිටපත:

>>> with open("myfile.txt", encoding="utf-8") as file:
...     x = [l.rstrip("\n") for l in file]
>>> x
['line 1','line 2','line 3']

උපග්‍රන්ථය භාවිතා කිරීම:

x = []
with open("myfile.txt") as file:
    for l in file:
        x.append(l.strip())

හෝ:

>>> x = open("myfile.txt").read().splitlines()
>>> x
['line 1', 'line 2', 'line 3']

හෝ:

>>> x = open("myfile.txt").readlines()
>>> x
['linea 1\n', 'line 2\n', 'line 3\n']

හෝ:

def print_output(lines_in_textfile):
    print("lines_in_textfile =", lines_in_textfile)

y = [x.rstrip() for x in open("001.txt")]
print_output(y)

with open('001.txt', 'r', encoding='utf-8') as file:
    file = file.read().splitlines()
    print_output(file)

with open('001.txt', 'r', encoding='utf-8') as file:
    file = [x.rstrip("\n") for x in file]
    print_output(file)

ප්‍රතිදානය:

lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']

ගොනුවක් ලැයිස්තුවකට කියවීමට ඔබට කරුණු තුනක් කළ යුතුය:

• ගොනුව විවෘත කරන්න
• ගොනුව කියවන්න
• අන්තර්ගතය ලැයිස්තුවක් ලෙස ගබඩා කරන්න

වාසනාවකට මෙන් පයිතන් මේ දේවල් කිරීම ඉතා පහසු කරයි, එබැවින් ගොනුවක් ලැයිස්තුවකට කියවීමට ඇති කෙටිම ක්‍රමය:

lst = list(open(filename))

කෙසේ වෙතත් මම තවත් පැහැදිලි කිරීමක් එකතු කරමි.

ගොනුව විවෘත කිරීම

ඔබට නිශ්චිත ගොනුවක් විවෘත කිරීමට අවශ්‍ය යැයි මම සිතමි, ඔබ ගොනු හසුරුව (හෝ ගොනුව වැනි හසුරුව) සමඟ කෙලින්ම ගනුදෙනු නොකරයි. පයිතන් හි ගොනුවක් විවෘත කිරීම සඳහා බහුලව භාවිතා වන කාර්යය නම් open, එය අනිවාර්ය තර්කයක් සහ පයිතන් 2.7 හි විකල්ප දෙකක් අවශ්‍ය වේ:

• ගොනුවේ නම
• මාදිලිය
• බෆරින් කිරීම (මෙම පිළිතුරේ මම මෙම තර්කය නොසලකා හරිමි)

ගොනු නාමය ගොනුව වෙත යන මාර්ගය නිරූපණය කරන නූලක් විය යුතුය . උදාහරණයක් වශයෙන්:

open('afile')   # opens the file named afile in the current working directory
open('adir/afile')            # relative path (relative to the current working directory)
open('C:/users/aname/afile')  # absolute path (windows)
open('/usr/local/afile')      # absolute path (linux)

ගොනු දිගුව නියම කළ යුතු බව සලකන්න. වින්ඩෝස් භාවිතා කරන්නන් සඳහා මෙය විශේෂයෙන් වැදගත් වන්නේ ගවේෂක තුළ බැලූ විට .txtහෝ වැනි ගොනු දිගු පෙරනිමියෙන්.doc සඟවා ඇති බැවිනි.

දෙවන තර්කය නම් mode, එය rපෙරනිමියෙන් "කියවීමට පමණි" යන්නයි. ඔබේ නඩුවේදී ඔබට අවශ්‍ය වන්නේ එයයි.

නමුත් ඔබට ඇත්ත වශයෙන්ම ගොනුවක් සෑදීමට සහ / හෝ ගොනුවකට ලිවීමට අවශ්‍ය නම් ඔබට මෙහි වෙනත් තර්කයක් අවශ්‍ය වේ. ඔබට දළ විශ්ලේෂණයක් අවශ්‍ය නම් විශිෂ්ට පිළිතුරක් ඇත .

ගොනුවක් කියවීම සඳහා ඔබට එය අතහැර දැමිය හැකිය mode.

open(filename)
open(filename, 'r')

දෙකම ගොනුව කියවීමට පමණි ආකාරයෙන් විවෘත කරනු ඇත. ඔබට වින්ඩෝස් හි ද්විමය ගොනුවකින් කියවීමට අවශ්‍ය නම් ඔබ මාදිලිය භාවිතා කළ යුතුය rb:

open(filename, 'rb')

වෙනත් වේදිකාවල 'b'(ද්විමය ප්‍රකාරය) සරලව නොසලකා හරිනු ලැබේ.

දැන් මම openගොනුව පෙන්වන ආකාරය පෙන්වා ඇති බැවින්, ඔබ සැමවිටම closeඑය නැවත අවශ්‍ය බව කතා කරමු . එසේ නොවුවහොත් එය ක්‍රියාවලිය පිටවන තුරු ගොනුවට විවෘත ගොනු හසුරුව තබා ගනී (හෝ පයිතන් ගොනු හසුරුව කුණු කසළ).

ඔබට භාවිතා කළ හැකි අතර:

f = open(filename)
# ... do stuff with f
f.close()

ඒ වන විට යම් දෙයක් අතර ගොනු වසා ගැනීමට අසමත් openහා closeව්යතිරේකයක් වීසි කරනවා. A tryසහ finally:

f = open(filename)
# nothing in between!
try:
    # do stuff with f
finally:
    f.close()

කෙසේ වෙතත්, පයිතන් මනරම් වාක්‍ය ඛණ්ඩයක් ඇති සන්දර්භ කළමණාකරුවන් සපයයි (නමුත් openඑය ඊට tryහා finallyඊට ඉහළින් බොහෝ දුරට සමාන වේ ):

with open(filename) as f:
    # do stuff with f
# The file is always closed after the with-scope ends.

අවසාන ප්‍රවේශය වන්නේ පයිතන් හි ගොනුවක් විවෘත කිරීම සඳහා නිර්දේශිත ප්‍රවේශයයි!

ගොනුව කියවීම

හරි, ඔබ ගොනුව විවෘත කළා, දැන් එය කියවන්නේ කෙසේද?

මෙම openකාර්යය සඳහා නැවත fileවස්තුව සහ එය Pythons ප්රතිඵලයක්ම ප්රොටෝකෝලය සඳහා සහය දක්වයි. සෑම පුනරාවර්තනයක්ම ඔබට රේඛාවක් ලබා දෙනු ඇත:

with open(filename) as f:
    for line in f:
        print(line)

මෙය ගොනුවේ එක් එක් පේළිය මුද්‍රණය කරයි. කෙසේ වෙතත්, සෑම පේළියකම \nඅවසානයේ නව රේඛා අක්ෂරයක් අඩංගු වන බව සලකන්න (ඔබේ පයිතන් විශ්වීය නව රේඛා සහාය ඇතිව ගොඩනගා ඇත්දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය විය හැකිය - එසේ නොමැතිනම් ඔබට \r\nවින්ඩෝස් හෝ \rමැක්හි නව රේඛා ලෙස තිබිය හැකිය). ඔබට අවශ්‍ය නැතිනම් ඔබට අවසාන අක්‍ෂරය ඉවත් කළ හැකිය (හෝ වින්ඩෝස් හි අවසාන අක්ෂර දෙක):

with open(filename) as f:
    for line in f:
        print(line[:-1])

නමුත් අවසාන පේළියේ අළුත් පේළියක් තිබිය යුතු නැත, එබැවින් යමෙක් එය භාවිතා නොකළ යුතුය. යමෙකුට එය නව රේඛාවකින් අවසන් වේදැයි පරීක්ෂා කළ හැකි අතර එසේ නම් එය ඉවත් කරන්න:

with open(filename) as f:
    for line in f:
        if line.endswith('\n'):
            line = line[:-1]
        print(line)

එහෙත්, ඔබ හුදෙක් සියලු whitespaces (ද ඇතුළුව ඉවත් කළ හැකි \nසිට චරිතය) වැල අවසානය , මෙය අනෙකුත් සියලුම ඉවත් කරනු ඇත අගින් ඇද whitespaces ඔබ මේ වැදගත් නම් පරිස්සම් විය යුතු නිසා:

with open(filename) as f:
    for line in f:
        print(f.rstrip())

කෙසේ වෙතත් රේඛා අවසන් වුවහොත් \r\n(වින්ඩෝස් "නව රේඛා ") .rstrip()එය ද බලා ගනී \r!

අන්තර්ගතය ලැයිස්තුවක් ලෙස ගබඩා කරන්න

ගොනුව විවෘත කර එය කියවිය යුතු ආකාරය දැන් ඔබ දන්නා බැවින්, අන්තර්ගතය ලැයිස්තුවක ගබඩා කිරීමට කාලයයි. සරලම විකල්පය වනුයේ listශ්‍රිතය භාවිතා කිරීමයි :

with open(filename) as f:
    lst = list(f)

ඔබට පිටුපස ඇති නව රේඛා ඉවත් කිරීමට අවශ්‍ය නම් ඒ වෙනුවට ඔබට ලැයිස්තු අවබෝධයක් භාවිතා කළ හැකිය:

with open(filename) as f:
    lst = [line.rstrip() for line in f]

හෝ ඊටත් වඩා සරල ය: වස්තුවේ .readlines()ක්‍රමය fileපෙරනිමියෙන් listරේඛා කිහිපයක් ලබා දෙයි:

with open(filename) as f:
    lst = f.readlines()

නව [line.rstrip() for line in f]රේඛා අක්ෂර පසුපසින් මෙයට ඇතුළත් වනු ඇත, ඔබට ඒවා අවශ්‍ය නැතිනම් මම ප්‍රවේශය නිර්දේශ කරමි, මන්ද එය සියලු පේළි මතකයේ ලැයිස්තු දෙකක් තබා ගැනීමෙන් වළක්වයි.

අපේක්ෂිත ප්‍රතිදානය ලබා ගැනීම සඳහා අමතර විකල්පයක් ඇත, කෙසේ වෙතත් එය තරමක් “උප ප්‍රශස්ත” ය: readසම්පූර්ණ ගොනුව නූලක දමා නව රේඛා වලට බෙදන්න:

with open(filename) as f:
    lst = f.read().split('\n')

හෝ:

with open(filename) as f:
    lst = f.read().splitlines()

splitචරිතය ඇතුළත් නොවන නිසා මේවා ස්වයංක්‍රීයව නව රේඛා ගැන සැලකිලිමත් වේ . කෙසේ වෙතත් ඒවා පරමාදර්ශී නොවන්නේ ඔබ ගොනුව නූල් ලෙස සහ මතකයේ රේඛා ලැයිස්තුවක් ලෙස තබා ඇති බැවිනි!

සාරාංශය

• with open(...) as fලිපිගොනු විවෘත කිරීමේදී භාවිතා කරන්න , මන්ද ඔබ විසින්ම ගොනුව වැසීම ගැන සැලකිලිමත් විය යුතු නැති අතර යම් ව්‍යතිරේකයක් සිදු වුවද එය ගොනුව වසා දමයි.
• fileවස්තූන් පුනරාවර්තන ප්‍රොටෝකෝලය සඳහා සහය දක්වයි, එබැවින් ලිපිගොනු රේඛාවක් කියවීම තරම් සරල ය for line in the_file_object:.
• පවතින කාර්යයන් / පන්ති සඳහා සෑම විටම ප්‍රලේඛනය පිරික්සන්න. බොහෝ විට කාර්යය සඳහා පරිපූර්ණ ගැලපීමක් හෝ අවම වශයෙන් හොඳ එකක් හෝ දෙකක් තිබේ. මෙම නඩුවේ පැහැදිලි තේරීම වනු ඇත, readlines()නමුත් ඔබට ලැයිස්තුවේ ගබඩා කිරීමට පෙර රේඛා සැකසීමට අවශ්‍ය නම් මම සරල ලැයිස්තු-අවබෝධයක් නිර්දේශ කරමි.

ලැයිස්තුවකට ගොනුවක රේඛා කියවීමේ පිරිසිදු හා පයිතොනික් ක්‍රමය

පළමුවෙන්ම හා ප්‍රධාන වශයෙන්, ඔබේ ගොනුව විවෘත කිරීම සහ එහි අන්තර්ගතය කාර්යක්ෂම හා පයිතොනික් ආකාරයෙන් කියවීම කෙරෙහි අවධානය යොමු කළ යුතුය. මම පෞද්ගලිකව කැමති නැති ආකාරය පිළිබඳ උදාහරණයක් මෙන්න:

infile = open('my_file.txt', 'r')  # Open the file for reading.

data = infile.read()  # Read the contents of the file.

infile.close()  # Close the file since we're done using it.

ඒ වෙනුවට, කියවීම සහ ලිවීම යන දෙකම සඳහා ලිපිගොනු විවෘත කිරීමේ ක්‍රමයට මම වඩාත් කැමැත්තක් දක්වන්නේ එය ඉතා පිරිසිදු බැවින් වන අතර ඔබ එය භාවිතා කළ පසු ගොනුව වැසීමට අමතර පියවරක් අවශ්‍ය නොවේ. පහත දැක්වෙන ප්‍රකාශයේ දී, අපි ගොනුව කියවීම සඳහා විවෘත කර විචල්‍ය 'infile' වෙත පවරමු. මෙම ප්‍රකාශයේ කේතය ක්‍රියාත්මක වූ පසු ගොනුව ස්වයංක්‍රීයව වසා දමනු ඇත.

# Open the file for reading.
with open('my_file.txt', 'r') as infile:

    data = infile.read()  # Read the contents of the file into memory.

දැන් අපි මෙම දත්ත පයිතන් ලැයිස්තුවකට ගෙන ඒම කෙරෙහි අවධානය යොමු කළ යුත්තේ ඒවා ක්‍රියාකාරී, කාර්යක්ෂම හා නම්‍යශීලී බැවිනි. ඔබේ නඩුවේදී, අපේක්ෂිත ඉලක්කය වන්නේ පෙළ ගොනුවේ එක් එක් පේළිය වෙනම අංගයකට ගෙන ඒමයි. මෙය සිදු කිරීම සඳහා, අපි පහත පරිදි බෙදීම් () ක්‍රමය භාවිතා කරමු :

# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()

අවසාන නිෂ්පාදනය:

# Open the file for reading.
with open('my_file.txt', 'r') as infile:

    data = infile.read()  # Read the contents of the file into memory.

# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()

අපගේ කේතය පරීක්ෂා කිරීම:

• පෙළ ගොනුවේ අන්තර්ගතය:

     A fost odatã ca-n povesti,
     A fost ca niciodatã,
     Din rude mãri împãrãtesti,
     O prea frumoasã fatã.

• පරීක්ෂණ අරමුණු සඳහා ප්‍රකාශ මුද්‍රණය කරන්න:

    print my_list  # Print the list.

    # Print each line in the list.
    for line in my_list:
        print line

    # Print the fourth element in this list.
    print my_list[3]

• ප්‍රතිදානය (යුනිකෝඩ් අක්ෂර නිසා වෙනස් පෙනුමක්):

     ['A fost odat\xc3\xa3 ca-n povesti,', 'A fost ca niciodat\xc3\xa3,',
     'Din rude m\xc3\xa3ri \xc3\xaemp\xc3\xa3r\xc3\xa3testi,', 'O prea
     frumoas\xc3\xa3 fat\xc3\xa3.']

     A fost odatã ca-n povesti, A fost ca niciodatã, Din rude mãri
     împãrãtesti, O prea frumoasã fatã.

     O prea frumoasã fatã.

පයිතන් 3.4 හි හඳුන්වා දී pathlibඇති පහත සඳහන් පරිදි ලිපිගොනු වලින් පෙළ කියවීමට පහසු ක්‍රමයක් ඇත:

from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()

( splitlinesඇමතුම යනු ගොනුවේ සම්පූර්ණ අන්තර්ගතය අඩංගු නූලකින් එය ගොනුවේ පේළි ලැයිස්තුවකට හරවන දෙයයි).

pathlibඑහි පහසු පහසුවක් ඇත. read_textහොඳයි, සංක්ෂිප්තයි, ගොනුව විවෘත කිරීම සහ වැසීම ගැන ඔබට කරදර විය යුතු නැහැ. ගොනුව සමඟ ඔබට කළ යුතු සියල්ල එකවර කියවා ඇත්නම් එය හොඳ තේරීමකි.

ලිපිගොනු වල ලැයිස්තු අවබෝධය භාවිතා කිරීමෙන් තවත් එක් විකල්පයක් මෙන්න;

lines = [line.rstrip() for line in open('file.txt')]

පයිතන් පරිවර්තකය තුළ බොහෝ වැඩ කටයුතු සිදු කරන බැවින් මෙය වඩාත් කාර්යක්ෂම ක්‍රමයක් විය යුතුය.

f = open("your_file.txt",'r')
out = f.readlines() # will append in the list out

දැන් විචල්ය අවුට් යනු ඔබට අවශ්ය දේ ලැයිස්තුවකි (අරාව). ඔබට කළ හැක්කේ:

for line in out:
    print (line)

හෝ:

for line in f:
    print (line)

ඔබට එකම ප්‍රති .ල ලැබෙනු ඇත.

පයිතන් 2 සහ පයිතන් 3 සමඟ පෙළ ලිපිගොනු කියවා ලියන්න; එය යුනිකෝඩ් සමඟ ක්‍රියා කරයි

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Define data
lines = ['     A first string  ',
         'A Unicode sample: €',
         'German: äöüß']

# Write text file
with open('file.txt', 'w') as fp:
    fp.write('\n'.join(lines))

# Read text file
with open('file.txt', 'r') as fp:
    read_lines = fp.readlines()
    read_lines = [line.rstrip('\n') for line in read_lines]

print(lines == read_lines)

සැලකිල්ලට ගත යුතු කරුණු:

• withයනු ඊනියා සන්දර්භ කළමනාකරුවෙකි . විවෘත කළ ගොනුව නැවත වසා ඇති බවට එය සහතික කරයි.
• හුදෙක් ඇති කරන මෙහි සියලු විසඳුම් .strip()හෝ .rstrip()ප්රතිනිෂ්පාදනය කිරීමට අපොහොසත් වනු ඇත linesඔවුන් ද, සුදු අවකාශය අහිමි විය.

පොදු ගොනු අවසානය

.txt

වඩාත් දියුණු ගොනු ලිවීම / කියවීම

• CSV: සුපිරි සරල ආකෘතිය ( කියවීම සහ ලිවීම )
• JSON: මිනිසුන්ට කියවිය හැකි දත්ත ලිවීම සතුටක්; බහුලව භාවිතා වන ( කියවීම සහ ලිවීම )
• YAML: YAML යනු JSON හි සුපිරි කට්ටලයක් වන නමුත් කියවීමට පහසුය ( කියවීම සහ ලිවීම , JSON සහ YAML සංසන්දනය )
• අච්චාරු: පයිතන් අනුක්‍රමිකකරණ ආකෘතියක් ( කියවීම සහ ලිවීම )
• MessagePack ( පයිතන් පැකේජය ): වඩාත් සංයුක්ත නිරූපණය ( කියවීම සහ ලිවීම )
• HDF5 ( පයිතන් පැකේජය ): මෙට්‍රික්ස් සඳහා හොඳයි ( කියවන්න සහ ලිවීමට )
• XML: ද පවතී * සුසුමක් * ( කියවීමට සහ ලිවීම් )

ඔබගේ යෙදුම සඳහා, පහත සඳහන් දෑ වැදගත් විය හැකිය:

• වෙනත් ක්‍රමලේඛන භාෂාවලින් සහාය
• කියවීමේ / ලිවීමේ කාර්ය සාධනය
• සංයුක්තතාවය (ගොනු ප්‍රමාණය)

මෙයද බලන්න: දත්ත අනුක්‍රමිකකරණ ආකෘති සංසන්දනය කිරීම

ඔබ වින්‍යාස ලිපිගොනු සෑදීමට ක්‍රමයක් සොයන්නේ නම්, ඔබට මගේ කෙටි ලිපිය පයිතන් හි වින්‍යාස ගොනු කියවීමට අවශ්‍ය විය හැකිය .

තවත් විකල්පයක් නම් numpy.genfromtxt, උදාහරණයක් ලෙස:

import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")

මෙය dataඔබගේ ගොනුවේ ඇති පේළි තරම් සංඛ්‍යාවක් සහිත NumPy අරාවක් සාදනු ඇත.

විධාන රේඛාවෙන් හෝ stdin වෙතින් ගොනුවක් කියවීමට ඔබ කැමති නම්, ඔබට fileinputමොඩියුලය ද භාවිතා කළ හැකිය :

# reader.py
import fileinput

content = []
for line in fileinput.input():
    content.append(line.strip())

fileinput.close()

ලිපිගොනු ඒ ආකාරයට යවන්න:

$ python reader.py textfile.txt 

වැඩි විස්තර මෙතැනින් කියවන්න: http://docs.python.org/2/library/fileinput.html

එය කළ හැකි සරලම ක්‍රමය

සරල ක්‍රමයක් නම්:

1. සම්පූර්ණ ගොනුව නූලක් ලෙස කියවන්න
2. නූල් රේඛාව රේඛාවෙන් බෙදන්න

එක් පේළියකින්, එය ලබා දෙන්නේ:

lines = open('C:/path/file.txt').read().splitlines()

කෙසේ වෙතත්, මෙය තරමක් අකාර්යක්ෂම ක්‍රමයක් වන අතර මෙය අන්තර්ගතයේ අනුවාද 2 ක් මතකයේ ගබඩා කරනු ඇත (බොහෝ විට කුඩා ලිපිගොනු සඳහා විශාල ගැටළුවක් නොව, තවමත්). [ස්තූතියි මාර්ක් අමරි].

පහසු ක්‍රම 2 ක් ඇත:

1. ගොනුව අනුකාරකයක් ලෙස භාවිතා කිරීම

lines = list(open('C:/path/file.txt'))
# ... or if you want to have a list without EOL characters
lines = [l.rstrip() for l in open('C:/path/file.txt')]

2. ඔබ භාවිතා කරන්නේ පයිතන් 3.4 හෝ ඊට වැඩි නම්, pathlibඔබේ වැඩසටහනේ වෙනත් මෙහෙයුම් සඳහා භාවිතා කළ හැකි ඔබේ ගොනුව සඳහා මාර්ගයක් නිර්මාණය කිරීම වඩා හොඳය :

from pathlib import Path
file_path = Path("C:/path/file.txt") 
lines = file_path.read_text().split_lines()
# ... or ... 
lines = [l.rstrip() for l in file_path.open()]

ස්ප්ලිට්ලයින් () ශ්‍රිත භාවිතා කරන්න. මෙන්න උදාහරණයක්.

inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3

නිමැවුමේ ඔබට පේළි ලැයිස්තුවක් ඇත.

ඔබට ඉතා විශාල / විශාල ගොනුවකට මුහුණ දීමට අවශ්‍ය නම් සහ වේගයෙන් කියවීමට අවශ්‍ය නම් (ඔබ ටොප් කෝඩර් / හැකර්රන්ක් කේතීකරණ තරඟයක සිටින බව සිතන්න), ඔබට එකවර සැලකිය යුතු තරම් විශාල රේඛා ප්‍රමාණයක් මතක බෆරයකට කියවිය හැකිය. ගොනු මට්ටමින් පේළියකින් රේඛාව නැවත කියන්න.

buffersize = 2**16
with open(path) as f: 
    while True:
        lines_buffer = f.readlines(buffersize)
        if not lines_buffer:
            break
        for line in lines_buffer:
            process(line)

අමතර ප්‍රතිලාභ කිහිපයක් සමඟ එය කිරීමට ඇති පහසුම ක්‍රම නම්:

lines = list(open('filename'))

හෝ

lines = tuple(open('filename'))

හෝ

lines = set(open('filename'))

නඩුවේදී set, අප මතක තබා ගත යුතු කරුණක් වන්නේ අප සතුව රේඛා අනුපිළිවෙල සංරක්‍ෂණය කර නොමැති අතර අනුපිටපත් රේඛා ඉවත් කිරීමයි.

පහත මම arkMarkAmery වෙතින් වැදගත් අතිරේකයක් එක් කළෙමි :

ඔබ .closeගොනු වස්තුවට ඇමතුමක් හෝ withප්‍රකාශයක් භාවිතා නොකරන බැවින් , සමහර පයිතන් ක්‍රියාත්මක කිරීමේදී ගොනුව කියවීමෙන් පසු වසා නොයනු ඇති අතර ඔබේ ක්‍රියාවලිය විවෘත ගොනු හසුරුවීමක් කාන්දු වේ.

දී CPython (සාමාන්ය python, බොහෝ මිනිසුන් භාවිතා කරන ක්රියාත්මක කිරීම), මෙම ගොනුව වස්තුව වහාම කුණු-එකතු ලැබෙනු ඇති අතර, මෙම ගොනුව වසා ඇත, නමුත් එය එසේ තිබියදී සාමාන්යයෙන් වගේ දෙයක් කරන්න, විශිෂ්ට පිළිවෙත් සලකා වෙනවා සිට නොවේ ප්රශ්නය :

with open('filename') as f: lines = list(f) 

ඔබ භාවිතා කරන පයිතන් ක්‍රියාත්මක කිරීම නොසලකා ගොනුව වසා ඇති බව සහතික කිරීමට .

මෙය භාවිතා කරන්න:

import pandas as pd
data = pd.read_csv(filename) # You can also add parameters such as header, sep, etc.
array = data.values

dataදත්ත රාමු වර්ගයක් වන අතර ndarray ලබා ගැනීම සඳහා අගයන් භාවිතා කරයි. භාවිතා කිරීමෙන් ඔබට ලැයිස්තුවක් ද ලබා ගත හැකිය array.tolist().

ලුහු line ු සටහන් සහ සාරාංශය

A සමඟ filename, Path(filename)වස්තුවකින් ගොනුව හැසිරවීම , හෝ කෙලින්ම සමඟ open(filename) as f, පහත සඳහන් දේවලින් එකක් කරන්න:

• list(fileinput.input(filename))
• භාවිතා කරමින් with path.open() as f, අමතන්නf.readlines()
• list(f)
• path.read_text().splitlines()
• path.read_text().splitlines(keepends=True)
• පුරා වඩාත් කැපීපෙනේ fileinput.inputහෝ fසහ list.appendවරකට එක් එක් පේළියක ම එක්
• සමත් fවූ බැඳී කිරීමට list.extendක්රමයක්
• fලැයිස්තු අවබෝධය තුළ භාවිතා කරන්න

පහත එක් එක් සඳහා භාවිතා කිරීමේ අවස්ථාව මම පැහැදිලි කරමි.

පයිතන්හිදී, මම රේඛීයව ලිපිගොනු කියවන්නේ කෙසේද?

මෙය විශිෂ්ට ප්‍රශ්නයකි. පළමුව, අපි නියැදි දත්ත කිහිපයක් නිර්මාණය කරමු:

from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')

ගොනු වස්තූන් කම්මැලි අනුකාරක වේ, එබැවින් එය නැවත නැවත කරන්න.

filename = 'filename'
with open(filename) as f:
    for line in f:
        line # do something with the line

විකල්පයක් ලෙස, ඔබ සතුව බහු ලිපිගොනු තිබේ නම් fileinput.input, තවත් කම්මැලි අනුකාරකයක් භාවිතා කරන්න . එක් ගොනුවක් සමඟ:

import fileinput

for line in fileinput.input(filename): 
    line # process the line

හෝ බහු ලිපිගොනු සඳහා, එය ගොනු නාම ලැයිස්තුවක් යවන්න:

for line in fileinput.input([filename]*2): 
    line # process the line

නැවතත්, fසහ fileinput.inputදෙකටම වඩා / ආපසු කම්මැලි අනුකාරක වේ. ඔබට භාවිතා කළ හැක්කේ එක් වරක් පමණි, එබැවින් වාචිකතාවයෙන් වැළකී ක්‍රියාකාරී කේතයක් ලබා දීම සඳහා මම fileinput.input(filename)මෙතැනින් ඇප්‍රොපොස් ඇති තැනට වඩා තරමක් තදින් භාවිතා කරමි .

පයිතන්හිදී, මම ලැයිස්තුවකට ලිපිගොනු රේඛාවක් කියවන්නේ කෙසේද?

අහ් නමුත් ඔබට එය කිසියම් හේතුවක් නිසා ලැයිස්තුවකට අවශ්‍යද? හැකි නම් මම එය වළක්වා ගනිමි. නමුත් ඔබ අවධාරනය කරන්නේ නම් ... මෙහි ප්‍රති result ලය fileinput.input(filename)ලබා දෙන්න list:

list(fileinput.input(filename))

තවත් සෘජු පිළිතුරක් ඇමතුමක් කිරීමට f.readlines, (විකල්ප දක්වා ගොනුවේ අන්තර්ගතය නැවත වන hintඔබ එසේ, චරිත සංඛ්යාව හැකි ආකාරයට බහු ලැයිස්තු බවට බිඳ).

ඔබට මෙම ගොනු වස්තුව වෙත ක්‍රම දෙකක් ලබා ගත හැකිය. එක් ක්‍රමයක් නම් ගොනු නාමය openබිල්ඩින් වෙත යැවීම :

filename = 'filename'

with open(filename) as f:
    f.readlines()

හෝ pathlibමොඩියුලයෙන් නව පාත් වස්තුව භාවිතා කිරීම (මම බෙහෙවින් ප්‍රිය කර ඇති අතර මෙතැන් සිට භාවිතා කරමි):

from pathlib import Path

path = Path(filename)

with path.open() as f:
    f.readlines()

list ගොනු අනුකාරකය පරිභෝජනය කර ලැයිස්තුවක් නැවත ලබා දෙනු ඇත - තරමක් සෘජු ක්‍රමයක් ද වේ:

with path.open() as f:
    list(f)

සම්පූර්ණ පා text ය බෙදීමට පෙර තනි නූලක් ලෙස මතකයට කියවීමට ඔබට අවශ්‍ය නැතිනම්, ඔබට මෙය Pathවස්තුව සහ splitlines()නූල් ක්‍රමය සමඟ එක් ලයිනර් ලෙස කළ හැකිය . පෙරනිමියෙන්, splitlinesනව රේඛා ඉවත් කරයි:

path.read_text().splitlines()

ඔබට නව රේඛා තබා ගැනීමට අවශ්‍ය නම්, සමත් වන්න keepends=True:

path.read_text().splitlines(keepends=True)

මට අවශ්‍ය වන්නේ ගොනු රේඛාව පේළියෙන් කියවා එක් එක් පේළිය ලැයිස්තුවේ අවසානයට එකතු කිරීමයි.

දැන් මෙය ක්‍රම කිහිපයක් සමඟ පහසුවෙන් අවසාන ප්‍රති result ලය නිරූපණය කර ඇති බැවින් ඉල්ලීම ටිකක් මෝඩ වැඩකි. නමුත් ඔබ ඔබේ ලැයිස්තුව සකස් කරන විට රේඛා පෙරීමට හෝ ක්‍රියාත්මක කිරීමට අවශ්‍ය විය හැකිය, එබැවින් මෙම ඉල්ලීම හාස්‍ය කරමු.

භාවිතා කිරීමෙන් list.appendඔබට එක් එක් පේළිය එකතු කිරීමට පෙර එය පෙරීමට හෝ ක්‍රියාත්මක කිරීමට ඉඩ දෙනු ඇත:

line_list = []
for line in fileinput.input(filename):
    line_list.append(line)

line_list

භාවිතා කිරීම list.extendතව ටිකක් direct ජු වනු ඇති අතර ඔබට පෙර ලැයිස්තුවක් තිබේ නම් සමහර විට ප්‍රයෝජනවත් වේ:

line_list = []
line_list.extend(fileinput.input(filename))
line_list

හෝ වඩාත් මුග්ධ ලෙස, අපට ඒ වෙනුවට ලැයිස්තු අවබෝධයක් භාවිතා කළ හැකි අතර, අවශ්‍ය නම් සිතියම සහ පෙරණය කළ හැකිය:

[line for line in fileinput.input(filename)]

නැතහොත් ඊටත් වඩා කෙලින්ම, රවුම වැසීමට, පේළි මත ක්‍රියාත්මක නොවී නව ලැයිස්තුවක් කෙලින්ම නිර්මාණය කිරීම සඳහා එය ලැයිස්තුවට යොමු කරන්න:

list(fileinput.input(filename))

නිගමනය

ගොනුවකින් පේළි ලැයිස්තුවකට ලබා ගැනීම සඳහා ඔබ බොහෝ ක්‍රම දැක ඇත, නමුත් විශාල දත්ත ප්‍රමාණයක් ලැයිස්තුවක් තුළට ගෙන යාමෙන් වළකින්න, හැකි නම් දත්ත සැකසීමට පයිතන්ගේ කම්මැලි ක්‍රියාවලිය භාවිතා කරන්න.

එනම්, කැමති fileinput.inputහෝ with path.open() as f.

ලේඛනයේ හිස් රේඛා ද තිබේ නම්, අන්තර්ගතය කියවීමට සහ filterහිස් නූල් මූලද්‍රව්‍ය වැළැක්වීම සඳහා එය හරහා යාමට මම කැමතියි

with open(myFile, "r") as f:
    excludeFileContent = list(filter(None, f.read().splitlines()))

ඔබට NumPy හි loadtxt විධානය භාවිතා කළ හැකිය. මෙය genfromtxt ට වඩා අඩු කොන්දේසි සඳහා පරික්ෂා කරයි, එබැවින් එය වේගවත් විය හැකිය.

import numpy
data = numpy.loadtxt(filename, delimiter="\n")

මම පහත සඳහන් දෑ භාවිතා කිරීමට කැමතියි. පේළි වහාම කියවීම.

contents = []
for line in open(filepath, 'r').readlines():
    contents.append(line.strip())

හෝ ලැයිස්තු අවබෝධය භාවිතා කිරීම:

contents = [line.strip() for line in open(filepath, 'r').readlines()]

මම පහත සඳහන් ක්‍රම වලින් එකක් උත්සාහ කරමි. මා භාවිතා කරන උදාහරණ ගොනුවේ නම dummy.txtඇත. ඔබට මෙහි ගොනුව සොයාගත හැකිය . මම හිතන්නේ ගොනුව කේතයට සමාන ඩිරෙක්ටරියේම ඇති බවයි ( fpathනිසි ගොනු නාමය සහ ෆෝල්ඩර මාර්ගය ඇතුළත් කිරීමට ඔබට වෙනස් කළ හැකිය .)

පහත සඳහන් උදාහරණ දෙකෙහිම, ඔබට අවශ්‍ය ලැයිස්තුව ලබා දී ඇත lst.

1.> පළමු ක්‍රමය :

fpath = 'dummy.txt'
with open(fpath, "r") as f: lst = [line.rstrip('\n \t') for line in f]

print lst
>>>['THIS IS LINE1.', 'THIS IS LINE2.', 'THIS IS LINE3.', 'THIS IS LINE4.']

2.> මාසයේදී දෙවැනි ක්රමය, , භාවිතා කළ හැකි csv.reader Python සම්මත පුස්තකාලය මොඩියුල :

import csv
fpath = 'dummy.txt'
with open(fpath) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter='   ')
    lst = [row[0] for row in csv_reader] 

print lst
>>>['THIS IS LINE1.', 'THIS IS LINE2.', 'THIS IS LINE3.', 'THIS IS LINE4.']

ඔබට ක්‍රම දෙකෙන් එකක් භාවිතා කළ හැකිය. නිර්මාණය සඳහා ගතවන කාලය lstක්‍රම දෙකෙහිම පාහේ සමාන වේ.

I / O ගොනුව සරල කිරීම සඳහා මා භාවිතා කරන පයිතන් (3) උපකාරක පුස්තකාල පන්තියක් මෙන්න:

import os

# handle files using a callback method, prevents repetition
def _FileIO__file_handler(file_path, mode, callback = lambda f: None):
  f = open(file_path, mode)
  try:
    return callback(f)
  except Exception as e:
    raise IOError("Failed to %s file" % ["write to", "read from"][mode.lower() in "r rb r+".split(" ")])
  finally:
    f.close()


class FileIO:
  # return the contents of a file
  def read(file_path, mode = "r"):
    return __file_handler(file_path, mode, lambda rf: rf.read())

  # get the lines of a file
  def lines(file_path, mode = "r", filter_fn = lambda line: len(line) > 0):
    return [line for line in FileIO.read(file_path, mode).strip().split("\n") if filter_fn(line)]

  # create or update a file (NOTE: can also be used to replace a file's original content)
  def write(file_path, new_content, mode = "w"):
    return __file_handler(file_path, mode, lambda wf: wf.write(new_content))

  # delete a file (if it exists)
  def delete(file_path):
    return os.remove() if os.path.isfile(file_path) else None

එවිට ඔබ මේ ආකාරයට FileIO.linesශ්‍රිතය භාවිතා කරනු ඇත :

file_ext_lines = FileIO.lines("./path/to/file.ext"):
for i, line in enumerate(file_ext_lines):
  print("Line {}: {}".format(i + 1, line))

mode( "r"පෙරනිමියෙන්) සහ filter_fn(පෙරනිමියෙන් හිස් රේඛා සඳහා පරික්ෂා කිරීම) පරාමිතීන් අත්‍යවශ්‍ය නොවන බව මතක තබා ගන්න .

ඔබ පවා ඉවත් කළ හැකි read, writeසහ deleteක්රම සහ පමණක් හැර FileIO.lines, හෝ නමින් වෙනම ක්රමය බවට හැරවීම read_lines.

විධාන රේඛා අනුවාදය

#!/bin/python3
import os
import sys
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
filename = dname + sys.argv[1]
arr = open(filename).read().split("\n") 
print(arr)

සමඟ ධාවනය කරන්න:

python3 somefile.py input_file_name.txt