जवाबों:
यदि पढ़ने के लिए फ़ाइल बड़ी है, और आप एक ही बार में पूरी फ़ाइल को पढ़ना नहीं चाहते हैं:
fp = open("file")
for i, line in enumerate(fp):
if i == 25:
# 26th line
elif i == 29:
# 30th line
elif i > 29:
break
fp.close()ध्यान दें कि i == n-1के लिए nवीं लाइन।
पायथन में 2.6 या बाद में:
with open("file") as fp:
for i, line in enumerate(fp):
if i == 25:
# 26th line
elif i == 29:
# 30th line
elif i > 29:
breakenumerate(x)का उपयोग करता है x.next, तो यह स्मृति में पूरी फ़ाइल की आवश्यकता नहीं है।
big file। लूप को सूचकांक तक पहुंचने में कई साल लगेंगे
त्वरित उत्तर:
f=open('filename')
lines=f.readlines()
print lines[25]
print lines[29]या:
lines=[25, 29]
i=0
f=open('filename')
for line in f:
if i in lines:
print i
i+=1कई पंक्तियों को निकालने के लिए एक और अधिक सुरुचिपूर्ण समाधान है: लिनेशे ( "अजगर का सौजन्य : एक विशाल पाठ फ़ाइल में किसी विशेष पंक्ति में कैसे कूदना है?" , एक पिछले stackoverflow.com प्रश्न)।
ऊपर दिए गए अजगर प्रलेखन का हवाला देते हुए:
>>> import linecache
>>> linecache.getline('/etc/passwd', 4)
'sys:x:3:3:sys:/dev:/bin/sh\n'4अपनी इच्छित पंक्ति संख्या में परिवर्तन करें , और आप चालू हैं। ध्यान दें कि 4, पांचवीं पंक्ति लाएगा क्योंकि गिनती शून्य-आधारित है।
यदि फ़ाइल बहुत बड़ी हो सकती है, और मेमोरी में पढ़ने पर समस्याएँ पैदा हो सकती हैं, तो @ आलोक की सलाह लेना और एन्यूमरेट () का उपयोग करना एक अच्छा विचार हो सकता है ।
समाप्त करने के लिए:
fileobject.readlines()या for line in fileobjectत्वरित समाधान के रूप में उपयोग करें ।linecacheअधिक सुरुचिपूर्ण समाधान के लिए उपयोग करें , जो कई फ़ाइलों को पढ़ने के लिए काफी तेज होगा, बार-बार संभव है।enumerate() लें और फाइलों के लिए उपयोग करें जो बहुत बड़ी हो सकती हैं, और स्मृति में फिट नहीं होंगी। ध्यान दें कि इस पद्धति का उपयोग धीमा हो सकता है क्योंकि फ़ाइल क्रमिक रूप से पढ़ी जाती है।linecacheमॉड्यूल के स्रोत को देखा , और ऐसा लगता है कि यह पूरी फ़ाइल को मेमोरी में पढ़ता है। इसलिए, यदि रैंडम एक्सेस साइज़ ऑप्टिमाइज़ेशन से अधिक महत्वपूर्ण है, linecacheतो सबसे अच्छा तरीका है।
linecacheअब केवल अजगर स्रोत फ़ाइलों के लिए काम करने के लिए प्रकट होता है
linecache.getlines('/etc/passwd')[0:4]पहली, दूसरी, तीसरी और चौथी पंक्ति में पढ़ने के लिए भी उपयोग कर सकते हैं ।
एक तेज और कॉम्पैक्ट दृष्टिकोण हो सकता है:
def picklines(thefile, whatlines):
return [x for i, x in enumerate(thefile) if i in whatlines]यह किसी भी खुली फ़ाइल जैसी वस्तु को स्वीकार करता है thefile(कॉलर को छोड़ कर कि क्या इसे डिस्क फ़ाइल से खोला जाना चाहिए, या उदाहरण के लिए सॉकेट, या अन्य फ़ाइल जैसी स्ट्रीम) और शून्य-आधारित लाइन सूचकांकों का एक सेट whatlines, और एक रिटर्न सूची, कम स्मृति पदचिह्न और उचित गति के साथ। यदि दी जाने वाली लाइनों की संख्या बहुत बड़ी है, तो आप एक जनरेटर पसंद कर सकते हैं:
def yieldlines(thefile, whatlines):
return (x for i, x in enumerate(thefile) if i in whatlines)जो मूल रूप से केवल लूपिंग के लिए अच्छा है - ध्यान दें कि केवल अंतर returnबयान में वर्ग कोष्ठक के बजाय गोल का उपयोग करने से आता है , क्रमशः एक सूची समझ और एक जनरेटर अभिव्यक्ति बनाता है।
आगे ध्यान दें कि "लाइनों" और "फ़ाइल" के उल्लेख के बावजूद ये फ़ंक्शन बहुत अधिक हैं , बहुत अधिक सामान्य हैं - वे किसी भी चलने योग्य पर काम करेंगे , यह एक खुली फाइल या कोई अन्य हो, वस्तुओं की सूची (या जनरेटर) लौटा सकता है उनके प्रगतिशील आइटम-नंबरों के आधार पर। तो, मैं और अधिक सामान्य नामों का उपयोग करने का सुझाव दूंगा ;-)।
whatlinesयह एक होना चाहिए set, क्योंकि if i in whatlinesएक सेट (क्रमबद्ध) सूची के बजाय तेजी से निष्पादित होगा। मैंने इसे पहले नोटिस नहीं किया और इसके बजाय अपने स्वयं के बदसूरत समाधान को सॉर्ट की गई सूची के साथ तैयार किया (जहां मुझे हर बार एक सूची को स्कैन करने की ज़रूरत नहीं थी, जबकि if i in whatlinesबस ऐसा होता है), लेकिन प्रदर्शन में अंतर नगण्य था (मेरे डेटा के साथ) और यह समाधान बहुत अधिक सुरुचिपूर्ण है।
दूसरे समाधान की पेशकश के लिए:
import linecache
linecache.getline('Sample.txt', Number_of_Line)मुझे आशा है कि यह त्वरित और आसान है :)
यदि आप लाइन 7 चाहते हैं
लाइन = खुला ("file.txt", "r")। रीडलाइन () [7]
close()इस तरह से खोलने पर आप फ़ाइल कैसे करते हैं ?
पूर्णता के लिए, यहाँ एक और विकल्प है।
चलो अजगर डॉक्स से एक परिभाषा के साथ शुरू करते हैं :
टुकड़ा आमतौर पर एक अनुक्रम के एक हिस्से से युक्त एक वस्तु। एक स्लाइस सबस्क्रिप्ट नोटेशन का उपयोग करके बनाया जाता है, [] संख्याओं के बीच कॉलनों के साथ जब कई दिए जाते हैं, जैसे कि variable_name [1: 3: 5]। ब्रैकेट (सबस्क्रिप्ट) संकेतन आंतरिक रूप से (या पुराने संस्करणों में, __getslice __ () और __setslice __ ()) का उपयोग करता है।
हालांकि टुकड़ा संकेतन सीधे तौर पर पुनरावृत्तियों पर लागू नहीं होता है, itertoolsपैकेज में एक प्रतिस्थापन कार्य होता है:
from itertools import islice
# print the 100th line
with open('the_file') as lines:
for line in islice(lines, 99, 100):
print line
# print each third line until 100
with open('the_file') as lines:
for line in islice(lines, 0, 100, 3):
print lineफ़ंक्शन का अतिरिक्त लाभ यह है कि यह अंत तक पुनरावृत्त नहीं पढ़ता है। तो आप और अधिक जटिल चीजें कर सकते हैं:
with open('the_file') as lines:
# print the first 100 lines
for line in islice(lines, 100):
print line
# then skip the next 5
for line in islice(lines, 5):
pass
# print the rest
for line in lines:
print lineऔर मूल प्रश्न का उत्तर देने के लिए:
# how to read lines #26 and #30
In [365]: list(islice(xrange(1,100), 25, 30, 4))
Out[365]: [26, 30]फ़ाइलों को पढ़ना अविश्वसनीय तेज है। 100MB फ़ाइल पढ़ने में 0.1 सेकंड से कम समय लगता है (देखें मेरा लेख पायथन के साथ पढ़ना और लिखना फ़ाइलें )। इसलिए आपको इसे पूरी तरह से पढ़ना चाहिए और फिर एकल लाइनों के साथ काम करना चाहिए।
यहां जो सबसे अधिक उत्तर देता है वह गलत नहीं है, लेकिन बुरी शैली है। फाइल को हमेशा खोलकर रखना चाहिए withक्योंकि यह सुनिश्चित करता है कि फाइल फिर से बंद हो।
तो आपको इसे इस तरह करना चाहिए:
with open("path/to/file.txt") as f:
lines = f.readlines()
print(lines[26]) # or whatever you want to do with this line
print(lines[30]) # or whatever you want to do with this lineयदि आपके पास एक बहुत बड़ी फ़ाइल है और मेमोरी की खपत एक चिंता है, तो आप इसे लाइन द्वारा लाइन कर सकते हैं:
with open("path/to/file.txt") as f:
for i, line in enumerate(f):
pass # process line iइनमें से कुछ प्यारे हैं, लेकिन इसे बहुत सरलता से किया जा सकता है:
start = 0 # some starting index
end = 5000 # some ending index
filename = 'test.txt' # some file we want to use
with open(filename) as fh:
data = fin.readlines()[start:end]
print(data)यह बस सूची स्लाइसिंग का उपयोग करेगा, यह पूरी फ़ाइल को लोड करता है, लेकिन अधिकांश सिस्टम उचित रूप से मेमोरी उपयोग को कम कर देंगे, यह ऊपर दिए गए अधिकांश तरीकों से तेज है, और मेरी 10G + डेटा फ़ाइलों पर काम करता है। सौभाग्य!
आप एक खोज () कॉल कर सकते हैं जो फ़ाइल के भीतर एक निर्दिष्ट बाइट के लिए आपके रीड हेड को स्थित करता है। यह तब तक आपकी मदद नहीं करेगा जब तक आप यह नहीं जानते कि जिस लाइन को आप पढ़ना चाहते हैं, उससे पहले फाइल में कितने बाइट्स (अक्षर) लिखे हैं। शायद आपकी फ़ाइल को कड़ाई से स्वरूपित किया गया है (प्रत्येक पंक्ति बाइट्स की एक्स संख्या है?) या, आप स्वयं वर्णों की संख्या की गणना कर सकते हैं (याद रखें कि अदृश्य अक्षर जैसे लाइन ब्रेक शामिल हैं) यदि आप वास्तव में गति को बढ़ावा देना चाहते हैं।
अन्यथा, आपको उस पंक्ति से पहले हर पंक्ति को पढ़ना होगा जिसे आप चाहते हैं, यहाँ पहले से प्रस्तावित कई समाधानों में से एक के अनुसार।
यदि आपकी बड़ी पाठ फ़ाइल fileसख्ती से संरचित है (जिसका अर्थ है कि प्रत्येक पंक्ति की लंबाई समान है l), तो आप n-th लाइन का उपयोग कर सकते हैं
with open(file) as f:
f.seek(n*l)
line = f.readline()
last_pos = f.tell()अस्वीकरण यह केवल एक ही लंबाई वाली फाइलों के लिए काम करता है!
इस बारे में कैसा है:
>>> with open('a', 'r') as fin: lines = fin.readlines()
>>> for i, line in enumerate(lines):
if i > 30: break
if i == 26: dox()
if i == 30: doy()यदि आपको आयात करने में कोई आपत्ति नहीं है, तो फाइलइनपुट आपको वही करता है जो आपको चाहिए (यह आप वर्तमान लाइन की लाइन संख्या पढ़ सकते हैं)
def getitems(iterable, items):
items = list(items) # get a list from any iterable and make our own copy
# since we modify it
if items:
items.sort()
for n, v in enumerate(iterable):
if n == items[0]:
yield v
items.pop(0)
if not items:
break
print list(getitems(open("/usr/share/dict/words"), [25, 29]))
# ['Abelson\n', 'Abernathy\n']
# note that index 25 is the 26th itemमैं इस दृष्टिकोण को पसंद करता हूं क्योंकि यह अधिक सामान्य-उद्देश्य है, अर्थात आप इसका उपयोग किसी फ़ाइल पर f.readlines(), किसी StringIOवस्तु पर, जो भी हो , पर कर सकते हैं :
def read_specific_lines(file, lines_to_read):
"""file is any iterable; lines_to_read is an iterable containing int values"""
lines = set(lines_to_read)
last = max(lines)
for n, line in enumerate(file):
if n + 1 in lines:
yield line
if n + 1 > last:
return
>>> with open(r'c:\temp\words.txt') as f:
[s for s in read_specific_lines(f, [1, 2, 3, 1000])]
['A\n', 'a\n', 'aa\n', 'accordant\n']यहाँ मेरे छोटे 2 सेंट हैं, इसके लायक क्या है;)
def indexLines(filename, lines=[2,4,6,8,10,12,3,5,7,1]):
fp = open(filename, "r")
src = fp.readlines()
data = [(index, line) for index, line in enumerate(src) if index in lines]
fp.close()
return data
# Usage below
filename = "C:\\Your\\Path\\And\\Filename.txt"
for line in indexLines(filename): # using default list, specify your own list of lines otherwise
print "Line: %s\nData: %s\n" % (line[0], line[1])फ़ाइल ऑब्जेक्ट में एक .readlines () विधि है जो आपको फ़ाइल की सामग्री की एक सूची, प्रति सूची आइटम की एक पंक्ति देगी। उसके बाद, आप सामान्य सूची स्लाइसिंग तकनीकों का उपयोग कर सकते हैं।
@, आप एन्यूमरेट का उपयोग कर सकते हैं
for n,line in enumerate(open("file")):
if n+1 in [26,30]: # or n in [25,29]
print line.rstrip()file = '/path/to/file_to_be_read.txt'
with open(file) as f:
print f.readlines()[26]
print f.readlines()[30]स्टेटमेंट के साथ, यह फाइल को खोलता है, 26 और 30 को प्रिंट करता है, फिर फाइल को बंद कर देता है। सरल!
readlines()इट्रेटर को पहली कॉल के बाद समाप्त हो जाएगा और दूसरा कॉल या तो एक खाली सूची वापस करेगा या एक त्रुटि फेंक देगा (जो याद नहीं कर सकता)
आप इसे इस सिंटैक्स के साथ बहुत सरलता से कर सकते हैं, जो किसी ने पहले ही उल्लेख किया है, लेकिन यह इसे करने का सबसे आसान तरीका है:
inputFile = open("lineNumbers.txt", "r")
lines = inputFile.readlines()
print (lines[0])
print (lines[2])# 3 लाइन प्रिंट करने के लिए,
line_number = 3
with open(filename,"r") as file:
current_line = 1
for line in file:
if current_line == line_number:
print(file.readline())
break
current_line += 1मूल लेखक: फ्रैंक हॉफमैन
पाठ फ़ाइल में कुछ पंक्तियाँ मुद्रित करने के लिए। एक "लाइन्स 2प्रिंट" सूची बनाएं और फिर लाइन्स 2 प्रिंट लिस्ट में "एन्यूमरेशन" होने पर बस प्रिंट करें। अतिरिक्त '\ n' उपयोग से छुटकारा पाने के लिए लाइन (strip) (या line.strip ('\ n') का उपयोग करें। मुझे बस "सूची समझ" पसंद है और जब मैं कर सकता हूं तो उपयोग करने का प्रयास करें। मुझे किसी भी कारण से फ़ाइल खोलने से रोकने के लिए पाठ फ़ाइलों को पढ़ने के लिए "साथ" विधि पसंद है।
lines2print = [26,30] # can be a big list and order doesn't matter.
with open("filepath", 'r') as fp:
[print(x.strip()) for ei,x in enumerate(fp) if ei in lines2print]या यदि सूची छोटी है तो सूची को सूची में लिखें समझ के अनुसार।
with open("filepath", 'r') as fp:
[print(x.strip()) for ei,x in enumerate(fp) if ei in [26,30]]वांछित लाइन प्रिंट करने के लिए। आवश्यक रेखा के ऊपर / नीचे लाइन प्रिंट करने के लिए।
def dline(file,no,add_sub=0):
tf=open(file)
for sno,line in enumerate(tf):
if sno==no-1+add_sub:
print(line)
tf.close()निष्पादित ----> dline ("D: \ dummy.txt", 6) यानी dline ("फाइल पाथ", लाइन_नंबर, अगर आप चाहते हैं कि सर्च की गई लाइन का ऊपरी भाग 1 के लिए कम 1 दे - यह वैकल्पिक डिफ़ॉल्ट मान होगा लिया जा 0)
यदि आप विशिष्ट लाइनों को पढ़ना चाहते हैं, जैसे कि कुछ थ्रेसहोल्ड लाइन के बाद शुरू होने वाली रेखा तो आप निम्न कोड का उपयोग कर सकते हैं,
file = open("files.txt","r")
lines = file.readlines() ## convert to list of lines
datas = lines[11:] ## raed the specific lines
f = open(filename, 'r')
totalLines = len(f.readlines())
f.close()
f = open(filename, 'r')
lineno = 1
while lineno < totalLines:
line = f.readline()
if lineno == 26:
doLine26Commmand(line)
elif lineno == 30:
doLine30Commmand(line)
lineno += 1
f.close()मुझे लगता है कि यह काम करेगा
open_file1 = open("E:\\test.txt",'r')
read_it1 = open_file1.read()
myline1 = []
for line1 in read_it1.splitlines():
myline1.append(line1)
print myline1[0]