पायथन

Question

में तारों को विभाजित करने का सबसे प्रभावी तरीका मेरे वर्तमान पायथन परियोजना को आने वाले पैकेजों को संसाधित करने के लिए बहुत सी स्ट्रिंग विभाजन की आवश्यकता होगी। चूंकि मैं इसे एक धीमी धीमी प्रणाली पर चला रहा हूं, इसलिए मैं सोच रहा था कि इसके बारे में जाने का सबसे प्रभावी तरीका क्या होगा। तार कुछ इस तरह से स्वरूपित किया जाएगा:

Item 1 | Item 2 | Item 3 <> Item 4 <> Item 5 

स्पष्टीकरण: यह विशेष रूप से उदाहरण के लिए, एक सूची जहां पहले दो आइटम एक शीर्षक और एक तारीख कर रहे हैं से आएगा, जबकि आइटम 5 के लिए आइटम 3 लोगों को आमंत्रित किया जा सकता है (उनमें से संख्या शून्य से एन तक कुछ भी हो सकती है, जहां सर्वर पर पंजीकृत उपयोगकर्ताओं की संख्या है)।

से मैं क्या देखते हैं, मैं निम्नलिखित विकल्प हैं:

1. बार-बार split()
2. रेगुलर एक्सप्रेशन का उपयोग का उपयोग करें और Regex
3. कुछ अन्य अजगर कार्यों के बारे में मैं अभी तक नहीं सोचा कार्य करता है (हैं शायद कुछ)

समाधान 1 में | पर विभाजन शामिल होगा और फिर परिणामस्वरूप सूची के अंतिम तत्व को विभाजित करना होगा इस उदाहरण के लिए <>, जबकि समाधान 2 शायद की तरह एक नियमित अभिव्यक्ति में परिणाम होगा:

((.+)|)+((.+)(<>)?)+

ठीक है, यह रेगुलर एक्सप्रेशन से भयानक है, मुझे लगता है कि अपने आप को देख सकते हैं। यह भी अवांछित है। लेकिन आप विचार समझ गये।

अब, मैं इस तरह की तलाश कर रहा हूं कि ए) कम से कम समय लेता है और बी) आदर्श रूप से कम से कम स्मृति का उपयोग करता है। यदि दोनों में से केवल एक संभव है, तो मैं कम समय पसंद करूंगा। आदर्श समाधान स्ट्रिंग्स के लिए भी काम करेगा जिसमें | और तारों की पूरी तरह से <> की कमी है। कम से कम नियमित अभिव्यक्ति आधारित समाधान करना होगा कि

मेरे समझ होगा कि split() अधिक स्मृति का प्रयोग करेंगे (जब से तुम मूल रूप से दो परिणामस्वरूप सूचियों, एक है कि | और दूसरा एक है कि <> पर विभाजन पर विभाजन मिलता है), लेकिन मुझे नियमित अभिव्यक्तियों के पाइथन क्रियान्वयन के बारे में पर्याप्त जानकारी नहीं है कि यह निर्णय लेने के लिए कि RegEx कैसे करेगा। split() नियमित अभिव्यक्ति की तुलना में भी कम गतिशील है यदि यह आइटम की विभिन्न संख्याओं और दूसरे सेपरेटर की अनुपस्थिति में आता है।

• हाँ मैं कर सकता बस बेंचमार्क दोनों समाधान,, लेकिन मैं कर रहा हूँ: फिर भी, मैं छाप हिला नहीं कर सकता कि अजगर नियमित अभिव्यक्ति के बिना इस बेहतर कर सकते हैं, यही कारण है कि मैं

  कुछ नोट पूछ रहा हूँ है सामान्य रूप से अजगर के बारे में कुछ सीखने की कोशिश कर रहा है और यह कैसे काम करता है, और यदि मैं इन दोनों को सिर्फ बेंचमार्क करता हूं, तो मुझे अभी भी पता नहीं है कि मैंने किस पायथन कार्यों को याद किया है।

• हां, इस स्तर पर अनुकूलित करने के लिए केवल उच्च प्रदर्शन सामग्री के लिए वास्तव में आवश्यक है, लेकिन जैसा कि मैंने कहा, मैं अजगर के बारे में चीजें सीखने की कोशिश कर रहा हूं।
• अलावा: मूल प्रश्न में, मैं पूरी तरह से है कि मैं (भागों कि विभाजक <> साथ भागों से | से अलग कर रहे थे, तो एक साधारण फ्लैट सूची के रूप में re.split(\||<>,input) द्वारा उत्पन्न भेद करने में सक्षम होने की जरूरत है उल्लेख करना भूल गया जैसा कि @obmarg द्वारा प्रस्तावित) बहुत अच्छी तरह से काम नहीं करेगा। इस मानदंड को फिट करने वाले समाधानों की बहुत सराहना की जाती है।

प्रश्न को समेटने के लिए: कौन सा समाधान सबसे प्रभावी होगा, किस कारण से।

import timeit 
import re 

def splitit(input): 
    res0 = input.split("|") 
    res = [] 
    for element in res0: 
     t = element.split("<>") 
     if t != [element]: 
      res0.remove(element) 
      res.append(t) 
    return (res0, res) 

def regexit(input): 
    return re.split("\||<>", input) 


def mgibsonbr(input): # Solution by @mgibsonbr 
    items = re.split(r'\||<>', input) # Split input in items 
    offset = 0 
    result = [] # The result: strings for regular itens, lists for <> separated ones 
    acc = None 
    for i in items: 
     delimiter = '|' if offset+len(i) < len(input) and input[offset+len(i)] == '|' else '<>' 
     offset += len(i) + len(delimiter) 
     if delimiter == '<>': # Will always put the item in a list 
      if acc is None: 
       acc = [i] # Create one if doesn't exist 
       result.append(acc) 
      else: 
       acc.append(i) 
     else: 
      if acc is not None: # If there was a list, put the last item in it 
       acc.append(i) 
      else: 
       result.append(i) # Add the regular items 
      acc = None # Clear the list, since what will come next is a regular item or a new list 
    return result 

def split2(input): # Solution by @duncan 
    res0 = input.split("|") 
    res1, res2 = [], [] 
    for r in res0: 
     if "<>" in r: 
      res2.append(r.split("<>")) 
     else: 
      res1.append(r) 
    return res1, res2 

print "mgibs:", timeit.Timer("mgibsonbr('a|b|c|de|f<>ge<>ah')","from __main__ import mgibsonbr").timeit() 
print "split:", timeit.Timer("splitit('a|b|c|de|f<>ge<>ah')","from __main__ import splitit").timeit() 
print "split2:", timeit.Timer("split2('a|b|c|de|f<>ge<>ah')","from __main__ import split2").timeit() 
print "regex:", timeit.Timer("regexit('a|b|c|de|f<>ge<>ah')","from __main__ import regexit").timeit() 
print "mgibs:", timeit.Timer("mgibsonbr('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import mgibsonbr").timeit() 
print "split:", timeit.Timer("splitit('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import splitit").timeit() 
print "split:", timeit.Timer("split2('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import split2").timeit() 
print "regex:", timeit.Timer("regexit('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import regexit").timeit() 

परिणाम:

अधिक अनुरोध के कारण, मैं split() -solution पर कुछ timeit और @obmarg द्वारा पहले प्रस्तावित नियमित अभिव्यक्ति है, साथ ही @mgibsonbr और @duncan द्वारा समाधान चलाने :

mgibs: 14.7349407408 
split: 6.403942732 
split2: 3.68306812233 
regex: 5.28414318792 
mgibs: 107.046683735 
split: 46.0844590775 
split2: 26.5595985591 
regex: 28.6513302646 

फिलहाल, यह Split2 तरह से @duncan सभी अन्य एल्गोरिदम धड़कता है, (कम से कम इस सीमित डाटासेट के साथ) लग रहा है, भले ही लंबाई की, और यह भी लग रहा है @ mgibsonbr के समाधान की तरह कुछ प्रदर्शन के मुद्दों है (माफ करना 'बोउट कि, बी बिना किसी समाधान के समाधान के लिए धन्यवाद।

इनपुट के लिए धन्यवाद, हर कोई।

Answer 1

मुझे आश्चर्य हुआ कि split() आपके कोड में इतनी बुरी तरह से प्रदर्शन कर रहा था, इसलिए मैंने इसे थोड़ा अधिक बारीकी से देखा और देखा कि आप आंतरिक लूप में list.remove() पर कॉल कर रहे हैं। इसके अलावा आप प्रत्येक स्ट्रिंग पर split() पर एक अतिरिक्त समय कॉल कर रहे हैं। split() का उपयोग करके उन समाधानों से छुटकारा पाएं और छोटे तारों पर रेगेक्स हाथों को धड़कता है और लंबे समय तक एक बहुत करीब दूसरा आता है।

import timeit 
import re 

def splitit(input): 
    res0 = input.split("|") 
    res = [] 
    for element in res0: 
     t = element.split("<>") 
     if t != [element]: 
      res0.remove(element) 
      res.append(t) 
    return (res0, res) 

def split2(input): 
    res0 = input.split("|") 
    res1, res2 = [], [] 
    for r in res0: 
     if "<>" in r: 
      res2.append(r.split("<>")) 
     else: 
      res1.append(r) 
    return res1, res2 

def regexit(input): 
    return re.split("\||<>", input) 


print "split:", timeit.Timer("splitit('a|b|c|de|f<>ge<>ah')","from __main__ import splitit").timeit() 
print "split2:", timeit.Timer("split2('a|b|c|de|f<>ge<>ah')","from __main__ import split2").timeit() 
print "regex:", timeit.Timer("regexit('a|b|c|de|f<>ge<>ah')","from __main__ import regexit").timeit() 
print "split:", timeit.Timer("splitit('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import splitit").timeit() 
print "split2:", timeit.Timer("split2('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import split2").timeit() 
print "regex:", timeit.Timer("regexit('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import regexit").timeit() 

निम्नलिखित में से कौन परिणाम देता है:

split: 6.14933066757 
split2: 4.09465555192 
regex: 5.10777759588 
split: 47.0092413098 
split2: 26.9300592585 
regex: 25.9168630604 

और पाठ्यक्रम split2() की नेस्टेड सूचियों कि आप चाहते थे जबकि रेगुलर एक्सप्रेशन से समस्या का समाधान नहीं करता है देता है।

Answer 2

मुझे यकीन है कि अगर यह सबसे कारगर है, लेकिन निश्चित रूप से कोड के लिए सबसे आसान कुछ इस तरह हो रहा है नहीं कर रहा हूँ:

>>> input = "Item 1 | Item 2 | Item 3 <> Item 4 <> Item 5" 
>>> re.split("\||<>", input) 
>>> ['Item 1 ', ' Item 2 ', ' Item 3 ', ' Item 4 ', ' Item 5'] 

मैं वहाँ यह एक सादे से अधिक कुशल होने का एक उचित मौका है लगता होगा पुराना विभाजन भी (इनपुट डेटा के आधार पर) क्योंकि आपको पहले विभाजन से प्रत्येक स्ट्रिंग आउटपुट पर दूसरा स्प्लिट ऑपरेशन करने की आवश्यकता होगी, जो स्मृति या समय के लिए सक्षम होने की प्रतीत नहीं होती है।

हालांकि ऐसा कहा जाता है कि मैं आसानी से गलत हो सकता हूं, और यह सुनिश्चित करने का एकमात्र तरीका यह होगा कि यह समय होगा।

Answer 3

कॉलिंग कई बार विभाजित करना अनावश्यक होने की संभावना है, क्योंकि यह अनियंत्रित मध्यवर्ती तार बना सकता है। प्रस्तावित आपके जैसे रेगेक्स का उपयोग करना काम नहीं करेगा, क्योंकि कैप्चरिंग समूह को केवल अंतिम आइटम मिलेगा, न कि उनमें से प्रत्येक। एक रेगेक्स का उपयोग करके विभाजन करना, जैसा कि ओबमार्ग सुझाया गया है, सबसे अच्छा मार्ग प्रतीत होता है, मानते हुए कि "फ़्लैटेड" सूची वह है जिसे आप ढूंढ रहे हैं।

आप एक चपटा सूची नहीं करना चाहते हैं, तो आप मूल इनपुट की जाँच को देखने के लिए जो सीमांकक इस्तेमाल किया गया था एक regex का उपयोग कर पहले और उसके बाद परिणामों पर पुनरावृति विभाजित कर सकते हैं,:

items = re.split(r'\||<>', input) 
offset = 0 
for i in items: 
    delimiter = '|' if input[offset+len(i)] == '|' else '<>' 
    offset += len(i) + len(delimiter) 
    # Do something with i, depending on whether | or <> was the delimiter 

पिछले है, अगर आप नहीं चाहते हैं कि सबस्ट्रिंग्स बिल्कुल बनाया जाए (उदाहरण के लिए, केवल स्थान बचाने के लिए प्रारंभ और अंत सूचकांक का उपयोग करके), re.finditer नौकरी कर सकता है। Delimiters पर Iterate, और उनके बीच पाठ के लिए कुछ करें जो कि delimiter (| या <>) के आधार पर पाया गया था। यह एक और जटिल ऑपरेशन है, क्योंकि आपको कई कोने के मामलों को संभालना होगा, लेकिन आपकी ज़रूरतों के आधार पर इसका लायक हो सकता है।

अद्यतन: आपके विशेष मामले के लिए, जहां इनपुट प्रारूप समान है, ओबर्ग का समाधान सबसे अच्छा है। यदि आप चाहिए, बाद प्रक्रिया परिणाम एक नेस्टेड सूची के लिए:

split_result = re.split("\||<>", input) 
result = [split_result[0], split_result[1], [i for i in split_result[2:] if i]] 

(है कि पिछले सूची समझ सुनिश्चित करने के लिए आप [] बजाय [''] मिल जाएगा अगर वहाँ के बाद पिछले | कोई आइटम नहीं हैं)

अद्यतन 2: अद्यतन प्रश्न पढ़ने के बाद, मुझे अंत में समझ में आया कि आप क्या हासिल करने की कोशिश कर रहे हैं।यहाँ पूर्ण उदाहरण है, ढांचे के सुझाव पहले का उपयोग कर:

items = re.split(r'\||<>', input) # Split input in items 
offset = 0 
result = [] # The result: strings for regular itens, lists for <> separated ones 
acc = None 
for i in items: 
    delimiter = '|' if offset+len(i) < len(input) and input[offset+len(i)] == '|' else '<>' 
    offset += len(i) + len(delimiter) 
    if delimiter == '<>': # Will always put the item in a list 
     if acc is None: 
      acc = [i] # Create one if doesn't exist 
      result.append(acc) 
     else: 
      acc.append(i) 
    else: 
     if acc is not None: # If there was a list, put the last item in it 
      acc.append(i) 
     else: 
      result.append(i) # Add the regular items 
     acc = None # Clear the list, since what will come next is a regular item or a new list 
print result 

अपने उदाहरण के साथ यह परीक्षण किया गया, परिणाम था:

['a', 'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c','de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'aha'], 
'b', 'c', 'de', ['f', 'ge', 'ah']] 

Answer 4

आप जानते हैं कि <> तो स्ट्रिंग में कहीं और प्रकट करने के लिए नहीं जा रहा है, तो आप '<>' को '|' से बदल सकते हैं इसके बाद एक स्प्लिट:

>>> input = "Item 1 | Item 2 | Item 3 <> Item 4 <> Item 5" 
>>> input.replace("<>", "|").split("|") 
['Item 1 ', ' Item 2 ', ' Item 3 ', ' Item 4 ', ' Item 5'] 

यह लगभग कई विभाजन करने से लगभग निश्चित रूप से तेज़ होगा। Re.split - timeit का उपयोग करने से यह तेज़ हो सकता है या नहीं हो सकता है आपका मित्र है।

संपादित: नमूना स्ट्रिंग आप की आपूर्ति की मेरी संस्करण re.split से तीन से अधिक बार तेजी से होता है के साथ अपने सिस्टम पर:

>>> timeit input.replace("<>", "|").split("|") 
1000000 loops, best of 3: 980 ns per loop 
>>> import re 
>>> timeit re.split(r"\||<>", input) 
100000 loops, best of 3: 3.07 us per loop 

(एनबी इस IPython उपयोग कर रहा है, जो timeit एक के रूप में है अंतर्निहित कमांड)।

Answer 5

आप का उपयोग को प्रतिस्थापित कर सकते हैं। सबसे पहले <> को | के साथ प्रतिस्थापित करें, और फिर | द्वारा विभाजित करें।

def replace_way(input): 
    return input.replace('<>','|').split('|') 

समय प्रदर्शन:

import timeit 
import re 

def splitit(input): 
    res0 = input.split("|") 
    res = [] 
    for element in res0: 
     t = element.split("<>") 
     if t != [element]: 
      res0.remove(element) 
      res.append(t) 
    return (res0, res) 

def regexit(input): 
    return re.split("\||<>", input) 

def replace_way(input): 
    return input.replace('<>','|').split('|') 


print "split:", timeit.Timer("splitit('a|b|c|de|f<>ge<>ah')","from __main__ import splitit").timeit() 
print "regex:", timeit.Timer("regexit('a|b|c|de|f<>ge<>ah')","from __main__ import regexit").timeit() 
print "replace:",timeit.Timer("replace_way('a|b|c|de|f<>ge<>ah')","from __main__ import replace_way").timeit() 
print "split:", timeit.Timer("splitit('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import splitit").timeit() 
print "regex:", timeit.Timer("regexit('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import regexit").timeit() 
print "replace:",timeit.Timer("replace_way('a|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>aha|b|c|de|f<>ge<>ah')","from __main__ import replace_way").timeit() 

मेरी मशीन पर परिणाम:

split: 11.8682055461 
regex: 12.7430856814 
replace: 2.54299265006 
split: 79.2124379066 
regex: 68.6917008003 
replace: 10.944842347