मैं पायथन में एक फ़ाइल की प्रत्येक पंक्ति को कैसे पढ़ता हूं और प्रत्येक पंक्ति को एक सूची में एक तत्व के रूप में संग्रहीत करता हूं?
मैं फ़ाइल लाइन को लाइन से पढ़ना चाहता हूं और प्रत्येक पंक्ति को सूची के अंत तक जोड़ना चाहता हूं।
मैं पायथन में एक फ़ाइल की प्रत्येक पंक्ति को कैसे पढ़ता हूं और प्रत्येक पंक्ति को एक सूची में एक तत्व के रूप में संग्रहीत करता हूं?
मैं फ़ाइल लाइन को लाइन से पढ़ना चाहता हूं और प्रत्येक पंक्ति को सूची के अंत तक जोड़ना चाहता हूं।
जवाबों:
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] readlines()करना बहुत ही कुशल नहीं है क्योंकि इसके परिणामस्वरूप मेमोरी मेमोरी हो सकती है । इस मामले में for line in f:प्रत्येक lineचर के साथ काम करना और काम करना फ़ाइल पर पुनरावृत्त करना बेहतर है ।
.rstrip()अगर आप लाइनों के सिरों से व्हॉट्सएप छीन रहे हैं तो थोड़ा और तेजी से काम करेगा।
with open(filename) as f: content = [i.strip() for i in f.readlines()]
देखें इनपुट और ऊपुत :
with open('filename') as f:
lines = f.readlines()या न्यूलाइन वर्ण को अलग करने के साथ:
with open('filename') as f:
lines = [line.rstrip() for line in f]f.read().splitlines(), जो नए सिरे को हटाता है
for line in open(filename)सुरक्षित है? यानी क्या फाइल अपने आप बंद हो जाएगी?
lines = [x.rstrip('\n') for x in open('data\hsf.txt','r')]अगर मैं इस तरह से लिखता हूं, तो मैं पढ़ने के बाद फ़ाइल को कैसे बंद कर सकता हूं?
openसंदर्भ प्रबंधक के बिना उपयोग करने के लिए "सबसे अच्छा अभ्यास" नहीं है (या इसे बंद करने के लिए कुछ अन्य गारंटीकृत तरीका), यह वास्तव में उन मामलों में से एक नहीं है - जब ऑब्जेक्ट का कोई और संदर्भ नहीं है इसके लिए यह कचरा एकत्र किया जाएगा और फ़ाइल बंद हो जाएगी, जो कि सूची में गड़बड़ी होने पर प्रसंस्करण में त्रुटि या नहीं होने पर तुरंत होनी चाहिए।
यह आवश्यकता से अधिक स्पष्ट है, लेकिन वही करता है जो आप चाहते हैं।
with open("file.txt") as file_in:
lines = []
for line in file_in:
lines.append(line)arrayहालांकि संलग्न है , लेकिन अन्य परिस्थितियां हो सकती हैं)। निश्चित रूप से बड़ी फ़ाइलों के लिए यह दृष्टिकोण समस्याओं को कम कर सकता है।
यह फ़ाइल से लाइनों का "सरणी" निकलेगा।
lines = tuple(open(filename, 'r'))openएक फाइल लौटाता है जिसे ओवररेटेड किया जा सकता है। जब आप किसी फ़ाइल पर पुनरावृति करते हैं, तो आपको उस फ़ाइल से लाइनें मिलती हैं। tupleएक पुनरावृत्ति ले सकता है और आपके द्वारा दिए जाने वाले पुनरावृत्तार से आपके लिए एक टुपल उदाहरण को तुरंत लिख सकता है। linesफ़ाइल की तर्ज से बनाया गया एक tuple है।
lines = open(filename).read().split('\n')इसके बजाय @MarshallFarrier की कोशिश करें ।
lines = open(filename).read().splitlines()थोड़ा साफ लगता है, और मेरा मानना है कि यह डॉस लाइन एंडिंग्स को भी बेहतर तरीके से हैंडल करता है।
listतुलना में लगभग 13.22% अधिक स्थान लेता है tuple। नतीजे आते हैं from sys import getsizeof as g; i = [None] * 1000; round((g(list(i)) / g(tuple(i)) - 1) * 100, 2)। बनाना एक tupleएक बनाने की तुलना में 4.17% का अधिक समय लगता है list(के साथ एक 0.16% मानक विचलन)। परिणाम from timeit import timeit as t; round((t('tuple(i)', 'i = [None] * 1000') / t('list(i)', 'i = [None] * 1000') - 1) * 100, 2)30 बार चलने से आते हैं । मेरा समाधान गति से अधिक स्थान का पक्षधर है जब परिवर्तनशीलता की आवश्यकता अज्ञात है।
यदि आप \nशामिल करना चाहते हैं:
with open(fname) as f:
content = f.readlines()यदि आप \nशामिल नहीं करना चाहते हैं:
with open(fname) as f:
content = f.read().splitlines()फ़ाइल ऑब्जेक्ट्स के पायथन के तरीकों के अनुसार , टेक्स्ट फ़ाइल को एक में बदलने का सबसे सरल तरीका 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 पास में अपनी फ़ाइल के माध्यम से जाएंगे। यह आम तौर पर सामान्य पार्सर्स कैसे काम करेगा।
open('file_path', 'r+')
सूची में डेटा
मान लें कि हमारे पास हमारे डेटा के साथ एक पाठ फ़ाइल है जैसे निम्नलिखित पंक्तियों में,
पाठ फ़ाइल सामग्री:
line 1
line 2
line 3pythonऔर दुभाषिया में लिखें:पायथन लिपि:
>>> with open("myfile.txt", encoding="utf-8") as file:
... x = [l.strip() 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']या:
>>> y = [x.rstrip() for x in open("my_file.txt")]
>>> y
['line 1','line 2','line 3']
with open('testodiprova.txt', 'r', encoding='utf-8') as file:
file = file.read().splitlines()
print(file)
with open('testodiprova.txt', 'r', encoding='utf-8') as file:
file = file.readlines()
print(file)encoding="utf-8"आवश्यक है?
read().splitlines()आपको पायथन द्वारा प्रदान किया गया है: यह बस है readlines()(जो शायद तेज है, क्योंकि यह कम बेकार है)।
फ़ाइल को एक सूची में पढ़ने के लिए आपको तीन काम करने होंगे:
सौभाग्य से पायथन को इन चीजों को करना बहुत आसान हो जाता है इसलिए किसी फ़ाइल को सूची में पढ़ने का सबसे छोटा तरीका है:
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एक अपवाद फेंकता है। आपको लगता है कि से बचने के सकता है एक का उपयोग करके 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वस्तु और यह अजगर यात्रा प्रोटोकॉल का समर्थन करता। प्रत्येक पुनरावृत्ति आपको एक पंक्ति देगी:
with open(filename) as f:
for line in f:
print(line)यह फ़ाइल की प्रत्येक पंक्ति को प्रिंट करेगा। हालाँकि, ध्यान दें कि प्रत्येक पंक्ति \nमें अंत में एक नई पंक्ति वर्ण होगा (आप जाँच सकते हैं कि आपका पायथन सार्वभौमिक नएलाइन समर्थन के साथ बनाया गया है - अन्यथा आप \r\nविंडोज \rपर या मैक पर भी नए रूप में हो सकते हैं )। यदि आप नहीं चाहते हैं कि आप अंतिम वर्ण (या Windows पर अंतिम दो वर्ण) निकाल सकें:
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)लेकिन आप बस स्ट्रिंग\n के अंत से सभी व्हाट्सएप ( चरित्र सहित ) को हटा सकते हैं, यह अन्य सभी अनुगामी व्हाट्सएप को भी हटा देगा ताकि आपको सावधान रहना पड़े यदि ये महत्वपूर्ण हैं:
with open(filename) as f:
for line in f:
print(f.rstrip())हालाँकि अगर लाइनें \r\n(विंडोज "newlines") के साथ समाप्त होती हैं , तो .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()ये स्वचालित रूप से अनुगामी newlines की देखभाल करते हैं क्योंकि 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.इसके बजाय, मैं पढ़ने और लिखने दोनों के लिए फ़ाइलों को खोलने की नीचे दी गई विधि को पसंद करता हूं क्योंकि यह बहुत साफ है, और एक बार फाइल को बंद करने के अतिरिक्त चरण की आवश्यकता नहीं होती है जब आप इसका उपयोग करते हैं। नीचे दिए गए विवरण में, हम फ़ाइल को पढ़ने के लिए खोल रहे हैं, और इसे चर 'शिशु' को सौंप रहे हैं। एक बार जब इस स्टेटमेंट का कोड चलना बंद हो जाएगा, तो फाइल अपने आप बंद हो जाएगी।
# 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')]यह अधिक कुशल तरीका होना चाहिए क्योंकि अधिकांश कार्य पायथन दुभाषिया के अंदर किया जाता है।
rstrip()संभावित रूप से सभी अनुगामी व्हॉट्सएप स्ट्रिप्स , न केवल \n; का उपयोग करें .rstrip('\n')।
पायथन 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
अधिक उन्नत फ़ाइल लिखना / पढ़ना
आपके आवेदन के लिए, निम्नलिखित महत्वपूर्ण हो सकता है:
यह भी देखें: डेटा क्रमांकन प्रारूपों की तुलना
यदि आप विन्यास फाइल बनाने के लिए रास्ता ढूंढ रहे हैं, तो आप पायथन में मेरी संक्षिप्त लेख विन्यास फाइल पढ़ना चाहते हैं ।
एक अन्य विकल्प है numpy.genfromtxt, उदाहरण के लिए:
import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")यह dataआपकी फ़ाइल में उतनी ही पंक्तियों के साथ एक NumPy सरणी बना देगा ।
यदि आप कमांड लाइन या स्टड से फाइल पढ़ना चाहते हैं, तो आप 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
इसे करने का सबसे सरल तरीका
एक सरल तरीका है:
एक पंक्ति में, जो देगा:
lines = open('C:/path/file.txt').read().splitlines()हालांकि, यह काफी अक्षम तरीका है क्योंकि यह मेमोरी में सामग्री के 2 संस्करणों को संग्रहीत करेगा (शायद छोटी फ़ाइलों के लिए एक बड़ा मुद्दा नहीं है, लेकिन फिर भी)। [थैंक्स मार्क अमेरी]।
2 आसान तरीके हैं:
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')]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()].read().splitlines()केवल कॉलिंग की तुलना में कॉलिंग किसी भी तरह से "सरल" नहीं है .readlines()। दूसरे के लिए, यह स्मृति-अक्षम है; आपको अनावश्यक रूप से फ़ाइल सामग्री के दो संस्करण (एकल स्ट्रिंग द्वारा लौटाए गए तार .read(), और उसके द्वारा दिए गए तार की सूची splitlines()) को एक बार में मेमोरी में स्टोर करना होगा ।
बस स्प्लिटलाइन () फ़ंक्शन का उपयोग करें। यहाँ एक उदाहरण है।
inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3आउटपुट में आपके पास लाइनों की सूची होगी।
.readlines()। यह फ़ाइल सामग्री की दो प्रतियां एक बार में मेमोरी में डालती है (एक एकल विशाल स्ट्रिंग के रूप में, एक लाइनों की सूची के रूप में)।
यदि आप एक बहुत बड़ी / विशाल फ़ाइल के साथ सामना करना चाहते हैं और तेजी से पढ़ना चाहते हैं (कल्पना करें कि आप एक टॉपकोडर / हैकर्रानक कोडिंग प्रतियोगिता में हैं), तो आप एक समय में मेमोरी बफर में लाइनों की एक बड़ी संख्या को पढ़ सकते हैं, बजाय फ़ाइल स्तर पर लाइन द्वारा सिर्फ iterate लाइन।
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)process(line)एक फ़ंक्शन है जिसे आपको डेटा को संसाधित करने के लिए लागू करने की आवश्यकता है। उदाहरण के लिए, उस पंक्ति के बजाय, यदि आप उपयोग करते हैं print(line), तो वह प्रत्येक पंक्ति को लाइनों_बफ़र से प्रिंट करेगी।
lines = list(open('filename'))या
lines = tuple(open('filename'))या
lines = set(open('filename'))इस मामले में set, हमें याद रखना चाहिए कि हमारे पास लाइन ऑर्डर संरक्षित नहीं है और डुप्लिकेट लाइनों से छुटकारा पाएं।
चूंकि आप
.closeफ़ाइल ऑब्जेक्ट पर कॉल नहीं कर रहे हैं और न ही किसीwithस्टेटमेंट का उपयोग कर रहे हैं , कुछ पायथन कार्यान्वयन में फ़ाइल पढ़ने के बाद बंद नहीं हो सकती है और आपकी प्रक्रिया एक खुली फ़ाइल हैंडल को लीक कर देगी ।में CPython (सामान्य अजगर कार्यान्वयन कि ज्यादातर लोगों का उपयोग करें), यह एक समस्या के बाद से फ़ाइल वस्तु तुरंत कचरा-एकत्र मिल जाएगा और इस फाइल को बंद हो जाएगा नहीं है, लेकिन यह फिर भी आम तौर पर की तरह कुछ करने के लिए सबसे अच्छा अभ्यास माना जाता है :
with open('filename') as f: lines = list(f) यह सुनिश्चित करने के लिए कि आपके द्वारा उपयोग किए जा रहे पायथन कार्यान्वयन की परवाह किए बिना फ़ाइल बंद हो जाती है ।
.closeफ़ाइल ऑब्जेक्ट पर कॉल नहीं कर रहे हैं और न ही एक withस्टेटमेंट का उपयोग कर रहे हैं , कुछ पायथन कार्यान्वयन में फ़ाइल पढ़ने के बाद बंद नहीं हो सकती है और आपकी प्रक्रिया एक खुली फ़ाइल हैंडल को लीक कर देगी। CPython में (सामान्य पायथन कार्यान्वयन जो कि अधिकांश लोग उपयोग करते हैं), यह कोई समस्या नहीं है क्योंकि फ़ाइल ऑब्जेक्ट को तुरंत कचरा एकत्र किया जाएगा और यह फ़ाइल को बंद कर देगा, लेकिन यह आमतौर पर सबसे अच्छा अभ्यास माना जाता 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.valuesdataएक डेटाफ़्रेम प्रकार है, और ndarray प्राप्त करने के लिए मूल्यों का उपयोग करता है। आप का उपयोग करके भी एक सूची प्राप्त कर सकते हैं array.tolist()।
pandas.read_csv()CSV डेटा पढ़ने के लिए , यह यहाँ कैसे उचित है?
एक साथ 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)यहाँ से एप्रोपोस जहां थोड़ा अधिक टोन का उपयोग करूंगा ।
पायथन में, मैं एक सूची में फ़ाइल लाइन-बाय-लाइन कैसे पढ़ूं ?
आह, लेकिन आप इसे किसी कारण से सूची में चाहते हैं? यदि संभव हो तो मैं इससे बचता हूँ। लेकिन अगर आप जोर देते हैं ... बस का परिणाम पारित 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)यदि आप इसे विभाजित करने से पहले पूरे पाठ को एक स्ट्रिंग के रूप में मेमोरी में पढ़ने का मन नहीं करते हैं, तो आप इसे Pathऑब्जेक्ट और splitlines()स्ट्रिंग विधि के साथ वन-लाइनर के रूप में कर सकते हैं । डिफ़ॉल्ट रूप से, नया splitlinesअंक निकालता है:
path.read_text().splitlines()यदि आप नई सीमाएँ रखना चाहते हैं, तो पास करें keepends=True:
path.read_text().splitlines(keepends=True)मैं फ़ाइल लाइन को लाइन से पढ़ना चाहता हूं और प्रत्येक पंक्ति को सूची के अंत तक जोड़ना चाहता हूं।
अब यह पूछने के लिए थोड़ा मूर्खतापूर्ण है, यह देखते हुए कि हमने अंतिम परिणाम को कई तरीकों से आसानी से प्रदर्शित किया है। लेकिन आपको अपनी सूची बनाते समय लाइनों को फ़िल्टर या संचालित करने की आवश्यकता हो सकती है, तो चलिए इस अनुरोध को मज़ाक करते हैं।
उपयोग list.appendकरने से पहले आपको इसे संलग्न करने से पहले प्रत्येक पंक्ति पर फ़िल्टर या संचालित करने की अनुमति होगी:
line_list = []
for line in fileinput.input(filename):
line_list.append(line)
line_listउपयोग list.extendकरना थोड़ा और अधिक प्रत्यक्ष होगा, और शायद उपयोगी हो अगर आपके पास एक सूची है:
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 में लोडटेक्स्ट कमांड का उपयोग भी कर सकते हैं। यह जीनफ्रॉमटेक्स की तुलना में कम स्थितियों की जांच करता है, इसलिए यह तेज हो सकता है।
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()]readlines(), यहां तक कि एक स्मृति जुर्माना भी लगाया जाता है। आप बस इसे हटा सकते हैं, क्योंकि एक पाठ (पाठ) फ़ाइल पर पुनरावृत्ति बदले में प्रत्येक पंक्ति देता है।
withफ़ाइल खोलने (और अंतर्निहित रूप से बंद) के लिए एक कथन का उपयोग करना चाहिए ।
मैं नीचे बताए गए तरीकों में से एक की कोशिश करूंगा। मेरे द्वारा उपयोग की जाने वाली उदाहरण फ़ाइल का नाम है 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 अजगर मानक पुस्तकालय से मॉड्यूल :
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दो विधियों में लगभग बराबर है।
delimiter=' 'तर्क क्या है ?
यहाँ एक पायथन (3) सहायक पुस्तकालय वर्ग है जिसका उपयोग मैं फ़ाइल I / O को सरल बनाने के लिए करता हूँ:
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।
lines = FileIO.lines(path)वास्तव में with open(path) as f: lines = f.readlines()इस सहायक के अस्तित्व को सही ठहराने के लिए पर्याप्त सरल है? आप प्रति कॉल 17 वर्णों की तरह बचत कर रहे हैं। (और अधिकांश समय, प्रदर्शन और स्मृति कारणों से, आप किसी भी सूची में इसकी पंक्तियों को पढ़ने के बजाय सीधे फ़ाइल ऑब्जेक्ट पर लूप करना चाहेंगे, इसलिए आप इसे अक्सर उपयोग नहीं करना चाहेंगे!) अक्सर छोटे उपयोगिता कार्यों को बनाने का एक प्रशंसक है, लेकिन यह मुझे लगता है कि यह अनावश्यक रूप से कुछ लिखने का एक नया तरीका बना रहा है जो मानक पुस्तकालय के साथ पहले से ही छोटा और आसान है जो हमें देता है।
#!/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
file.readlines()इन-forलूप में उपयोग न करें , एक फ़ाइल ऑब्जेक्ट ही पर्याप्त है:lines = [line.rstrip('\n') for line in file]