python - पाइथन के साथ लिखी गई सीएसवी फ़ाइल में प्रत्येक पंक्ति के बीच खाली रेखाएं हैं





csv (5)


नोट: ऐसा लगता है कि विंडोज सिस्टम पर अतिरिक्त लाइन को कैसे जोड़ा जा रहा है, इस वजह से यह पसंदीदा समाधान नहीं है। जैसा कि पाइथन दस्तावेज में कहा गया है:

यदि csvfile एक फ़ाइल ऑब्जेक्ट है, तो इसे प्लेटफ़ॉर्म पर 'बी' ध्वज के साथ खोला जाना चाहिए जहां इससे कोई फर्क पड़ता है।

विंडोज एक ऐसा मंच है जहां इससे कोई फर्क पड़ता है। जैसा कि मैंने नीचे वर्णित लाइन टर्मिनेटर को बदल दिया है, समस्या को ठीक कर सकता है, फ़ाइल को द्विआधारी मोड में खोलकर पूरी तरह से बचा जा सकता है। कोई कह सकता है कि यह समाधान अधिक "सुंदर" है। लाइन टर्मिनेटर के साथ "फिडलिंग" के परिणामस्वरूप इस मामले में सिस्टम के बीच असंगत कोड हो सकता है, जहां यूनिक्स सिस्टम परिणामों पर बाइनरी मोड में फ़ाइल खोलना कोई प्रभाव नहीं पड़ता है। अर्थात। यह क्रॉस सिस्टम संगत कोड में परिणाम।

पायथन डॉक्स से :

विंडोज़ पर, मोड में जोड़ा गया 'बी' बाइनरी मोड में फ़ाइल खोलता है, इसलिए 'आरबी', 'डब्ल्यूबी' और 'आर + बी' जैसे मोड भी हैं। विंडोज़ पर पायथन टेक्स्ट और बाइनरी फाइलों के बीच एक अंतर बनाता है; जब डेटा पढ़ा या लिखा जाता है तो पाठ फ़ाइलों में अंत-पंक्ति वर्ण स्वचालित रूप से थोड़ा बदल जाते हैं। फ़ाइल डेटा में यह दृश्य-दृश्य दृश्य ASCII टेक्स्ट फ़ाइलों के लिए ठीक है, लेकिन यह जेपीईजी या EXE फ़ाइलों में बाइनरी डेटा दूषित कर देगा। ऐसी फाइलें पढ़ने और लिखते समय बाइनरी मोड का उपयोग करने के लिए बहुत सावधान रहें। यूनिक्स पर, यह मोड में 'बी' जोड़ने में कोई दिक्कत नहीं होती है, इसलिए आप इसे सभी बाइनरी फ़ाइलों के लिए स्वतंत्र रूप से मंच का उपयोग कर सकते हैं।

मूल :

Csv.writer के लिए वैकल्पिक paramaters के हिस्से के रूप में यदि आपको अतिरिक्त रिक्त रेखाएं मिल रही हैं तो आपको lineterminator ( here जानकारी) को बदलना पड़ सकता है। पाइथन पेज सीएसवी दस्तावेज़ों से अनुकूलित उदाहरण नीचे दिया गया है इसे '\ n' से जो कुछ भी होना चाहिए उसे बदलें। चूंकि यह समस्या पर अंधेरे में सिर्फ एक स्टैब है, यह काम कर सकता है या नहीं भी हो सकता है, लेकिन यह मेरा सबसे अच्छा अनुमान है।

>>> import csv
>>> spamWriter = csv.writer(open('eggs.csv', 'w'), lineterminator='\n')
>>> spamWriter.writerow(['Spam'] * 5 + ['Baked Beans'])
>>> spamWriter.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])
import csv

with open('thefile.csv', 'rb') as f:
  data = list(csv.reader(f))
  import collections
  counter = collections.defaultdict(int)

  for row in data:
        counter[row[10]] += 1


with open('/pythonwork/thefile_subset11.csv', 'w') as outfile:
    writer = csv.writer(outfile)
    for row in data:
        if counter[row[10]] >= 504:
           writer.writerow(row)

यह कोड thefile.csv पढ़ता है, परिवर्तन करता है, और thefile_subset1 को परिणाम लिखता है।

हालांकि, जब मैं माइक्रोसॉफ्ट एक्सेल में परिणामी सीएसवी खोलता हूं, तो प्रत्येक रिकॉर्ड के बाद एक अतिरिक्त खाली रेखा होती है!

क्या यह अतिरिक्त खाली लाइन नहीं डालने का कोई तरीका है?




सरल जवाब यह है कि सीएसवी फाइलों को हमेशा बाइनरी मोड में खोला जाना चाहिए चाहे इनपुट या आउटपुट के लिए, अन्यथा विंडोज़ पर लाइन समाप्त होने में समस्याएं हैं। विशेष रूप से आउटपुट पर सीएसवी मॉड्यूल \r\n (मानक सीएसवी पंक्ति टर्मिनेटर) लिखता है और फिर (पाठ मोड में) रनटाइम \r\n (विंडोज मानक लाइन टर्मिनेटर) द्वारा \r\n \r\r\n

lineterminator साथ lineterminator समाधान नहीं है।




बाइनरी मोड "wb" में फ़ाइल खोलना पायथन 3+ में काम नहीं करेगा। या इसके बजाय, आपको इसे लिखने से पहले अपने डेटा को बाइनरी में बदलना होगा। यह सिर्फ एक परेशानी है।

इसके बजाए, आपको इसे टेक्स्ट मोड में रखना चाहिए, लेकिन नई लाइन को खाली के रूप में ओवरराइड करना चाहिए। इस तरह:

with open('/pythonwork/thefile_subset11.csv', 'w', newline='') as outfile:



मैं इस जवाब wrt को पायथन 3 पर लिख रहा हूं, क्योंकि मुझे शुरुआत में एक ही समस्या मिली है।

मुझे PySerial का उपयोग करके Arduino से डेटा प्राप्त करना था, और उन्हें एक .csv फ़ाइल में लिखना था। मेरे मामले में प्रत्येक पठन '\r\n' साथ समाप्त हुआ, इसलिए नई लाइन हमेशा प्रत्येक पंक्ति को अलग कर रही थी।

मेरे मामले में, newline='' विकल्प काम नहीं किया। क्योंकि यह कुछ त्रुटि दिखाता है जैसे:

with open('op.csv', 'a',newline=' ') as csv_file:

ValueError: illegal newline value: ''

तो ऐसा लगता है कि वे यहां नई लाइन को छोड़ने को स्वीकार नहीं करते हैं।

केवल उत्तर में से एक को देखकर, मैंने लेखक ऑब्जेक्ट में लाइन टर्मिनेटर का उल्लेख किया, जैसे,

writer = csv.writer(csv_file, delimiter=' ',lineterminator='\r')

और यह अतिरिक्त न्यूलाइन छोड़ने के लिए मेरे लिए काम किया।




सूची विधियों के विस्तार और विस्तार के बीच क्या अंतर है?

  • append एक सूची के अंत में एक एकल तत्व के रूप में अपनी तर्क जोड़ता है। सूची की लंबाई स्वयं एक से बढ़ेगी।
  • सूची को विस्तारित करने के लिए प्रत्येक तत्व को सूची में जोड़कर अपने तर्क पर पुनरावृत्तियों का विस्तार करें। सूची की लंबाई में वृद्धि होगी हालांकि कई तत्व पुनरावर्तनीय तर्क में थे।

append

list.append विधि किसी ऑब्जेक्ट को सूची के अंत में जोड़ती है।

my_list.append(object) 

वस्तु चाहे जो भी हो, चाहे कोई संख्या, एक स्ट्रिंग, दूसरी सूची, या कुछ और, यह सूची में एक प्रविष्टि के रूप में my_list के अंत में जोड़ा जाता है।

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

तो ध्यान रखें कि एक सूची एक वस्तु है। यदि आप सूची में एक और सूची जोड़ते हैं, तो सूची के अंत में पहली सूची एक ही वस्तु होगी (जो आप जो चाहते हैं वह हो सकता है):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

extend

list.extend विधि एक पुनरावृत्त से तत्वों को जोड़कर एक सूची बढ़ाती है:

my_list.extend(iterable)

तो विस्तार के साथ, पुनरावृत्त के प्रत्येक तत्व सूची में संलग्न हो जाता है। उदाहरण के लिए:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

ध्यान रखें कि एक स्ट्रिंग एक पुनरावर्तनीय है, इसलिए यदि आप एक स्ट्रिंग के साथ एक सूची का विस्तार करते हैं, तो आप प्रत्येक वर्ण को जोड़ देंगे जैसे आप स्ट्रिंग पर पुनरावृत्त करते हैं (जो आप जो चाहते हैं वह नहीं हो सकता है):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

ऑपरेटर अधिभार, __add__ ( + ) और __iadd__ ( += )

दोनों + और += ऑपरेटरों को list लिए परिभाषित किया गया है। वे विस्तार से समान रूप से समान हैं।

my_list + another_list स्मृति में तीसरी सूची बनाता है, ताकि आप इसका परिणाम वापस कर सकें, लेकिन इसकी आवश्यकता है कि दूसरा पुनरावर्तनीय एक सूची हो।

my_list += another_list सूची में सूची को संशोधित करता है (यह इन-प्लेस ऑपरेटर है, और सूचियां म्यूटेबल ऑब्जेक्ट्स हैं, जैसा कि हमने देखा है) इसलिए यह एक नई सूची नहीं बनाता है। यह विस्तार की तरह काम करता है, जिसमें दूसरा पुनरावर्तनीय किसी भी प्रकार का पुनरावर्तनीय हो सकता है।

भ्रमित न हों - my_list = my_list + another_list += बराबर नहीं है - यह आपको my_list को सौंपा गया एक नई सूची देता है।

समय जटिलता

परिशिष्ट में निरंतर समय जटिलता है , ओ (1)।

विस्तारित समय जटिलता है, ओ (के)।

append करने के लिए कई कॉलों के माध्यम से जटिलता को append जटिलता में जोड़ दिया जाता है, और इसे विस्तारित करने के बराबर बना दिया जाता है, और चूंकि विस्तार का पुनरावृत्ति सी में लागू किया जाता है, इसलिए यदि आप लगातार वस्तुओं को एक सूची में पुन: सक्रिय करने का इरादा रखते हैं तो यह हमेशा तेज़ होगा।

प्रदर्शन

आप सोच सकते हैं कि अधिक प्रदर्शन करने वाला क्या है, क्योंकि विस्तार के रूप में एक ही परिणाम प्राप्त करने के लिए परिशिष्ट का उपयोग किया जा सकता है। निम्नलिखित कार्य एक ही काम करते हैं:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

तो चलो उन्हें समय दें:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

समय पर एक टिप्पणी को संबोधित करते हुए

एक टिप्पणीकार ने कहा:

बिल्कुल सही जवाब, मैं केवल एक तत्व जोड़ने की तुलना करने के समय को याद करता हूं

अर्थात् सही चीज करें। यदि आप सभी तत्वों को एक पुनरावर्तनीय में जोड़ना चाहते हैं, तो extend उपयोग करें। यदि आप केवल एक तत्व जोड़ रहे हैं, तो append करें का उपयोग append

ठीक है, तो आइए यह देखने के लिए एक प्रयोग बनाएं कि यह समय पर कैसे काम करता है:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

और हम देखते हैं कि विस्तार का उपयोग करने के लिए एक पुनरावर्तनीय बनाने के हमारे रास्ते से बाहर निकलने का समय (मामूली) समय बर्बाद है:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

हम इससे सीखते हैं कि extend का उपयोग extend से कुछ भी हासिल नहीं हुआ है जब हमारे पास संलग्न करने के लिए केवल एक तत्व है।

साथ ही, ये समय महत्वपूर्ण नहीं हैं। मैं उन्हें सिर्फ यह इंगित करने के लिए दिखा रहा हूं कि, पायथन में, अर्थात् सही काम करने से चीजें सही तरीके से कर रही हैं।

यह कल्पना की जा सकती है कि आप दो तुलनात्मक परिचालनों पर समय का परीक्षण कर सकते हैं और एक संदिग्ध या उलटा परिणाम प्राप्त कर सकते हैं। बस अर्थात् सही चीज करने पर ध्यान केंद्रित करें।

निष्कर्ष

हम देखते हैं कि extend अर्द्धिक रूप से स्पष्ट है, और यह एक तत्व में प्रत्येक तत्व को एक सारणी में जोड़ने का इरादा रखता है , जब यह append से ज्यादा तेज़ी से चला सकता है

यदि सूची में जोड़ने के लिए आपके पास केवल एक तत्व (एक पुनरावृत्त में नहीं) है, तो append करें का उपयोग append





python csv