පෙළ ගොනුවක් නූල් විචල්‍යයකට කියවා නව රේඛා ඉවත් කරන්නේ කෙසේද?

පයිතන් හි ගොනුවක් කියවීමට මම පහත කේත කොටස භාවිතා කරමි:

with open ("data.txt", "r") as myfile:
    data=myfile.readlines()

ආදාන ගොනුව:

LLKKKKKKKKMMMMMMMMNNNNNNNNNNNNN
GGGGGGGGGHHHHHHHHHHHHHHHHHHHHEEEEEEEE

මම දත්ත මුද්‍රණය කරන විට මට ලැබෙනවා

['LLKKKKKKKKMMMMMMMMNNNNNNNNNNNNN\n', 'GGGGGGGGGHHHHHHHHHHHHHHHHHHHHEEEEEEEE']

මා දකින පරිදි දත්ත listස්වරූපයෙන් පවතී. මම එය නූල් කරන්නේ කෙසේද? තවද "\n", එයින් "[", සහ "]"අක්ෂර ඉවත් කරන්නේ කෙසේද?

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

with open('data.txt', 'r') as file:
    data = file.read().replace('\n', '')

ඔබට එක් පේළියකින් ගොනුවකින් කියවිය හැකිය:

str = open('very_Important.txt', 'r').read()

මෙය ගොනුව පැහැදිලිවම වසා නොදමන බව කරුණාවෙන් සලකන්න.

කසළ එකතු කිරීමේ කොටසක් ලෙස ගොනුව පිටවන විට CPython එය වසා දමනු ඇත.

නමුත් වෙනත් පයිතන් ක්‍රියාත්මක කිරීම් සිදු නොවේ. අතේ ගෙන යා හැකි කේතයක් ලිවීමට, withගොනුව පැහැදිලිව භාවිතා කිරීම හෝ වසා දැමීම වඩා හොඳය . කෙටි සෑම විටම වඩා හොඳ නොවේ. Https://stackoverflow.com/a/7396043/362951 බලන්න

සියලුම රේඛා නූලකට සම්බන්ධ කර නව රේඛා ඉවත් කිරීමට, මම සාමාන්‍යයෙන් භාවිතා කරන්නේ:

with open('t.txt') as f:
  s = " ".join([x.strip() for x in f]) 

පයිතන් 3.5 හෝ ඊට පසු, පාත්ලිබ් භාවිතා කරමින් ඔබට පෙළ ගොනු අන්තර්ගතය විචල්‍යයකට පිටපත් කර ගොනුව එක් පේළියකින් වසා දැමිය හැකිය :

from pathlib import Path
txt = Path('data.txt').read_text()

නව රේඛා ඉවත් කිරීමට ඔබට str.replace භාවිතා කළ හැකිය :

txt = txt.replace('\n', '')

with open("data.txt") as myfile:
    data="".join(line.rstrip() for line in myfile)

join () නූල් ලැයිස්තුවකට සම්බන්ධ වන අතර කිසිදු තර්කයක් නොමැති rstrip () නව රේඛා ඇතුළු සුදු අවකාශය නූල් අවසානයේ සිට කපා දමනු ඇත.

කියවීමේ () ක්‍රමය භාවිතයෙන් මෙය කළ හැකිය:

text_as_string = open('Your_Text_File.txt', 'r').read()

නැතහොත් පෙරනිමි ප්‍රකාරය 'r' (කියවීම) බැවින් සරලව භාවිතා කරන්න,

text_as_string = open('Your_Text_File.txt').read()

මම ටික කලක් තිස්සේ මේ පිළිබඳව විග්‍රහ කර ඇති අතර ඒ readසමඟ ඒකාබද්ධව භාවිතා කිරීමට කැමැත්තෙමි rstrip. නොමැතිව rstrip("\n"), පයිතන් නූල් කෙළවරට නව රේඛාවක් එක් කරයි, එය බොහෝ අවස්ථාවලදී එතරම් ප්‍රයෝජනවත් නොවේ.

with open("myfile.txt") as f:
    file_content = f.read().rstrip("\n")
    print file_content

මට පුදුමයි splitlines()තවම කිසිවෙකු සඳහන් නොකිරීම.

with open ("data.txt", "r") as myfile:
    data = myfile.read().splitlines()

විචල්‍යය dataදැන් මුද්‍රණය කරන විට මේ ආකාරයට පෙනෙන ලැයිස්තුවකි:

['LLKKKKKKKKMMMMMMMMNNNNNNNNNNNNN', 'GGGGGGGGGHHHHHHHHHHHHHHHHHHHHEEEEEEEE']

නව රේඛා ( \n) නොමැති බව සලකන්න .

එම අවස්ථාවේදී, ඔබට කොන්සෝලය සඳහා පේළි නැවත මුද්‍රණය කිරීමට අවශ්‍ය බව පෙනේ, එය ඔබට ලූපයක් සමඟ සාක්ෂාත් කරගත හැකිය:

for line in data:
    print line

ඔබ පසු වූ දේ හරියටම පැවසීම දුෂ්කර ය, නමුත් මෙවැනි දෙයක් ඔබ ආරම්භ කළ යුතුය:

with open ("data.txt", "r") as myfile:
    data = ' '.join([line.replace('\n', '') for line in myfile.readlines()])

ඔබට එක් එක් පේළිය ඉවත් කර අවසාන නූලකට සම්බන්ධ කළ හැකිය.

myfile = open("data.txt","r")
data = ""
lines = myfile.readlines()
for line in lines:
    data = data + line.strip();

මෙයද හොඳින් ක්‍රියාත්මක වේ.

python3: වර්ග වරහන් සින්ටැක්ස් ඔබට අලුත් නම් ගූගල් “ලැයිස්තු සංසන්දනය” කරන්න.

 with open('data.txt') as f:
     lines = [ line.strip( ) for line in list(f) ]

ඔබට මෙය කේත පේළි දෙකකට බෙදිය හැකිය !!!

content = open('filepath','r').read().replace('\n',' ')
print(content)

ඔබේ ගොනුව කියවන්නේ නම්:

hello how are you?
who are you?
blank blank

python ප්‍රතිදානය

hello how are you? who are you? blank blank

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

_ = open('data.txt', 'r'); data = _.read(); _.close()

f = open('data.txt','r')
string = ""
while 1:
    line = f.readline()
    if not line:break
    string += line

f.close()


print string

ඔබ මෙය උත්සාහ කර තිබේද?

x = "yourfilename.txt"
y = open(x, 'r').read()

print(y)

පයිතන් භාවිතයෙන් රේඛා බිඳීම් ඉවත් කිරීමට ඔබට නූලක replaceක්‍රියාකාරිත්වය භාවිතා කළ හැකිය .

මෙම උදාහරණය මඟින් සියලු ආකාරයේ රේඛා බිඳීම් ඉවත් කරයි:

my_string = open('lala.json').read()
print(my_string)

my_string = my_string.replace("\r","").replace("\n","")
print(my_string)

උදාහරණ ගොනුව:

{
  "lala": "lulu",
  "foo": "bar"
}

මෙම නැවත ධාවනය කිරීමේ අවස්ථාව භාවිතා කර ඔබට එය උත්සාහ කළ හැකිය:

https://repl.it/repls/AnnualJointHardware

ඔබේ ප්‍රශ්නයේ [කිසිවෙකු] කිසිවෙකු ආමන්ත්‍රණය කළ බව මට හැඟෙන්නේ නැත. ඔබ එක් එක් පේළිය ඔබේ විචල්‍යයට කියවන විට, ඔබ lines n වෙනුවට ආදේශ කිරීමට පෙර පේළි කිහිපයක් තිබූ බැවින් ඔබ ලැයිස්තුවක් නිර්මාණය කිරීම අවසන් කළේය. ඔබට x විචල්‍යයක් තිබේ නම් එය මුද්‍රණය කරන්න

x

හෝ මුද්‍රණය කරන්න (x)

හෝ str (x)

ඔබ සම්පූර්ණ ලැයිස්තුව වරහන් සමඟ දකිනු ඇත. ඔබ එක් එක් මූලද්‍රව්‍යය අමතන්නේ නම් (විවිධ වර්ගවල)

x [0] එවිට එය වරහන් මඟ හැරේ. ඔබ str () ශ්‍රිතය භාවිතා කරන්නේ නම් ඔබට පෙනෙන්නේ දත්ත පමණක් මිස '' නොවේ. str (x [0])

සමහර විට ඔබට මෙය උත්සාහ කළ හැකිද? මම මෙය මගේ වැඩසටහන් වල භාවිතා කරමි.

Data= open ('data.txt', 'r')
data = Data.readlines()
for i in range(len(data)):
    data[i] = data[i].strip()+ ' '
data = ''.join(data).strip()

නිත්‍ය ප්‍රකාශනය ද ක්‍රියාත්මක වේ:

import re
with open("depression.txt") as f:
     l = re.split(' ', re.sub('\n',' ', f.read()))[:-1]

print (l)

['මම', 'හැඟීම', 'හිස්', 'සහ', 'මළ', 'ඇතුළත']

මෙය ක්‍රියාත්මක වේ: ඔබගේ ගොනුව පහත පරිදි වෙනස් කරන්න:

LLKKKKKKKKMMMMMMMMNNNNNNNNNNNNN GGGGGGGGGHHHHHHHHHHHHHHHHHHHHEEEEEEEE

ඉන්පසු:

file = open("file.txt")
line = file.read()
words = line.split()

මෙය wordsසමාන නම් සහිත ලැයිස්තුවක් සාදයි :

['LLKKKKKKKKMMMMMMMMNNNNNNNNNNNNN', 'GGGGGGGGGHHHHHHHHHHHHHHHHHHHHEEEEEEEE']

එය "\ n" ඉවත් කර ඇත. වරහන් ඔබේ මාර්ගයට පිවිසීම පිළිබඳ කොටසට පිළිතුරු දීමට, මෙය කරන්න:

for word in words: # Assuming words is the list above
    print word # Prints each word in file on a different line

හෝ:

print words[0] + ",", words[1] # Note that the "+" symbol indicates no spaces
#The comma not in parentheses indicates a space

මෙය නැවත පැමිණේ:

LLKKKKKKKKMMMMMMMMNNNNNNNNNNNNN, GGGGGGGGGHHHHHHHHHHHHHHHHHHHHEEEEEEEE

with open(player_name, 'r') as myfile:
 data=myfile.readline()
 list=data.split(" ")
 word=list[0]

මෙම කේතය ඔබට පළමු පේළිය කියවීමට උපකාරී වන අතර පසුව ලැයිස්තුව සහ බෙදීම් විකල්පය භාවිතා කිරීමෙන් ඔබට පළමු පේළියේ වචනය අවකාශයෙන් වෙන් කොට ලැයිස්තුවක් තුළ ගබඩා කළ හැකිය.

ඔබට ඕනෑම වචනයකට පහසුවෙන් ප්‍රවේශ විය හැකිය, නැතහොත් එය නූලක ගබඩා කරන්න.

For for loop එකක් භාවිතා කිරීමෙන් ඔබට එකම දේ කළ හැකිය.

file = open("myfile.txt", "r")
lines = file.readlines()
str = ''                                     #string declaration

for i in range(len(lines)):
    str += lines[i].rstrip('\n') + ' '

print str

පහත සඳහන් දෑ උත්සාහ කරන්න:

with open('data.txt', 'r') as myfile:
    data = myfile.read()

    sentences = data.split('\\n')
    for sentence in sentences:
        print(sentence)

අවවාදයයි: එය ඉවත් නොකරයි \n. එය හුදෙක් පෙළ නොමැති ලෙස බැලීම සඳහා පමණි\n