हर स्ट्रिंग चरित्र को विभाजित करें?

Question

क्या प्रत्येक स्ट्रिंग चरित्र को विभाजित करना संभव है?

उदाहरण के लिए, मान लें कि मेरे पास एक स्ट्रिंग है जिसमें निम्नलिखित हैं:

'1234567890'

मैं इसे इस तरह कैसे देख सकता हूं:

['12','34','56','78','90']

Answer 1

>>> line = '1234567890'
>>> n = 2
>>> [line[i:i+n] for i in range(0, len(line), n)]
['12', '34', '56', '78', '90']

Comments

यह वास्तव में बहुत अच्छा जवाब है क्योंकि इसकी किसी भी तरह से पुष्टि नहीं की गई है और यह तथ्य आपको इसकी सादगी के कारण आसानी से याद रखने की अनुमति देता है

— ट्रेवर रूडोल्फ

@TrevorRudolph यह केवल वही करता है जो आप इसे बताते हैं। उपरोक्त उत्तर वास्तव में केवल लूप के लिए है, लेकिन अजगर द्वारा व्यक्त किया गया है। इसके अलावा, यदि आपको "सरलीकृत" उत्तर याद रखने की आवश्यकता है, तो उन्हें याद करने के कम से कम सैकड़ों हजारों तरीके हैं: स्टैकओवरफ़्लो पर पृष्ठ को अभिनीत करना; ईमेल में कॉपी करना और फिर चिपकाना; एक "सहायक" फ़ाइल रखना जिसे आप याद रखना चाहते हैं; जब भी आपको किसी चीज़ की आवश्यकता हो, बस एक आधुनिक खोज इंजन का उपयोग करना; (शायद) हर वेब ब्राउज़र में बुकमार्क का उपयोग करना; आदि

— dylnmc

दूसरा, हालांकि, यह प्रतीत होता है जैसे कि आप कर रहे हैं गंभीर। मुझे वास्तव में उम्मीद है कि आप गंभीर हैं क्योंकि यह वास्तव में जटिल नहीं है।

— 4

मैं गंभीर हो रहा था, मैंने अपने द्विआधारी कनवर्टर में एक एमुलेटर में इस कोड का उपयोग किया था, मुझे यह पसंद आया कि यह लूप हाहा के लिए एक पायथोनिक था, लेकिन आगे तोड़ने के लिए धन्यवाद कि मैं विधि का आनंद क्यों लेता हूं!

— ट्रेवर रुडोल्फ ने

विडंबना यह है कि शब्दों को इस तरह से इस्तेमाल करने की कोशिश की जाती है जिसमें छिपे हुए अर्थ नहीं होंगे, अक्सर परिणामी वाक्य होंगे।

— विलेख 02392

Answer 2

बस पूरा होने के लिए, आप इसे regex के साथ कर सकते हैं:

>>> import re
>>> re.findall('..','1234567890')
['12', '34', '56', '78', '90']

विषम संख्या के लिए आप यह कर सकते हैं:

>>> import re
>>> re.findall('..?', '123456789')
['12', '34', '56', '78', '9']

आप निम्नलिखित कार्य भी कर सकते हैं, लंबे समय तक विखंडू को सरल बनाने के लिए:

>>> import re
>>> re.findall('.{1,2}', '123456789')
['12', '34', '56', '78', '9']

और आप उपयोग कर सकते हैं re.finditerयदि स्ट्रिंग लंबे समय तक चंक द्वारा चंक उत्पन्न करने के लिए है।

Comments

यह अब तक का सबसे अच्छा जवाब है और इसके शीर्ष पर होना चाहिए। कोई '.'*nइसे और अधिक स्पष्ट करने के लिए लिख सकता है । कोई ज्वाइनिंग, नो जिपिंग, नो लूप्स, नो लिस्ट कॉम्प्रिहेंशन; बस एक दूसरे के बगल में अगले दो वर्णों को ढूंढें, जो वास्तव में एक मानव मस्तिष्क इसके बारे में कैसे सोचता है। यदि मोंटी पाइथन अभी भी जीवित थे, तो वह इस विधि को पसंद करेंगे!

— jdk1.0

यह यथोचित लंबे तारों के लिए सबसे तेज़ विधि है: gitlab.com/snippets/1908857

— राल्फ बोल्टन

यह काम नहीं करेगा यदि स्ट्रिंग में नई सुर्खियाँ हों। इसकी जरूरत है flags=re.S।

— अरन-फे

आह .... रेगेक्स .... मैंने उस XD के बारे में क्यों नहीं सोचा

— श्रीमान पिज़्ज़ा

Answer 3

इसके लिए पहले से ही अजगर में एक इनबिल्ट फ़ंक्शन है।

>>> from textwrap import wrap
>>> s = '1234567890'
>>> wrap(s, 2)
['12', '34', '56', '78', '90']

इसे डॉकस्ट्रिंग फॉर रैप कहते हैं:

>>> help(wrap)
'''
Help on function wrap in module textwrap:

wrap(text, width=70, **kwargs)
    Wrap a single paragraph of text, returning a list of wrapped lines.

    Reformat the single paragraph in 'text' so it fits in lines of no
    more than 'width' columns, and return a list of wrapped lines.  By
    default, tabs in 'text' are expanded with string.expandtabs(), and
    all other whitespace characters (including newline) are converted to
    space.  See TextWrapper class for available keyword args to customize
    wrapping behaviour.
'''

Comments

प्रिंट (रैप ((12345678 ’, 3)) स्ट्रिंग को 3 अंकों के समूहों में विभाजित करता है, लेकिन सामने शुरू होता है और पीछे नहीं। परिणाम: [

— ult

यह 'रैप' के बारे में सीखना दिलचस्प है, लेकिन यह ठीक वैसा नहीं है जैसा कि ऊपर पूछा गया था। यह एक स्ट्रिंग को वर्णों की एक निश्चित संख्या में विभाजित करने के बजाय पाठ प्रदर्शित करने की दिशा में अधिक उन्मुख है।

— ओरेन

wrapयदि स्ट्रिंग में स्थान है, तो जो वापस मांगा गया है वह वापस नहीं किया जा सकता है। उदाहरण के लिए wrap('0 1 2 3 4 5', 2)रिटर्न ['0', '1', '2', '3', '4', '5'](तत्व छीन लिए गए)

— satomacoto

यह वास्तव में सवाल का जवाब देता है, लेकिन क्या होता है अगर वहाँ रिक्त स्थान है और आप चाहते हैं कि उन्हें विभाजित वर्णों में बनाए रखा जाए? रैप () रिक्त स्थान को हटा देता है यदि वे पात्रों के विभाजन समूह के बाद सीधे गिरते हैं

— आयरन अटॉर्नी

यह खराब तरीके से काम करता है यदि आप हाइफ़न के साथ पाठ को विभाजित करना चाहते हैं (आप जिस नंबर को तर्क के रूप में देते हैं वह वास्तव में अधिकतम संख्या में वर्ण हैं, सटीक नहीं है, और यह हाइफ़न और सफेद स्थान पर टूट जाता है)।

— MrVocabulary

Answer 4

एन-लंबाई समूहों में तत्वों को समूहीकृत करने का एक और सामान्य तरीका:

>>> s = '1234567890'
>>> map(''.join, zip(*[iter(s)]*2))
['12', '34', '56', '78', '90']

इस विधि के लिए डॉक्स से सीधे आता है zip()।

Comments

[१ ९] में: a = "हैलो वर्ल्ड"; सूची (मानचित्र ("" .join, zip (* [iter (a)] * 4))) का परिणाम ['नरक', 'o wo'] मिलता है।

— truease.com

अगर किसी zip(*[iter(s)]*2)को समझने में मुश्किल होती है, तो पढ़िए कैसे zip(*[iter(s)]*n)काम करता है पायथन? ।

— बृजेश चौहान

यह विषम संख्या में वर्णों का हिसाब नहीं रखता है, यह बस उन वर्णों को छोड़ देगा: >>> map(''.join, zip(*[iter('01234567')]*5))->['01234']

— ब्योर्न

विषम संख्या में वर्णों को संभालने के लिए बस इसके zip()साथ बदलें itertools.zip_longest():map(''.join, zip_longest(*[iter(s)]*2, fillvalue=''))

— पाउलो फ्रीटस

इसके अलावा उपयोगी: डॉक्सmaps()

— winklerrr

Answer 5

मुझे लगता है कि यह itertools संस्करण की तुलना में छोटा और अधिक पठनीय है:

def split_by_n(seq, n):
    '''A generator to divide a sequence into chunks of n units.'''
    while seq:
        yield seq[:n]
        seq = seq[n:]

print(list(split_by_n('1234567890', 2)))

Comments

लेकिन वास्तव में कुशल नहीं है: जब स्ट्रिंग्स पर लागू किया जाता है: बहुत सारी प्रतियां

— एरिक

यह भी काम नहीं करता है अगर seq एक जनरेटर है, जो कि itertools संस्करण के लिए है । ऐसा नहीं है कि ओपी ने इसके लिए कहा, लेकिन इटर्टूल के संस्करण की आलोचना करना उचित नहीं है।

— रो रही

Answer 6

मुझे यह समाधान पसंद है:

s = '1234567890'
o = []
while s:
    o.append(s[:2])
    s = s[2:]

Answer 7

PyPI से अधिक-इटर्टूल का उपयोग करना :

>>> from more_itertools import sliced
>>> list(sliced('1234567890', 2))
['12', '34', '56', '78', '90']

Answer 8

आप grouper()नुस्खा का उपयोग कर सकते हैं itertools:

पायथन 2.x:

from itertools import izip_longest    

def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

अजगर 3.x:

from itertools import zip_longest

def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return zip_longest(*args, fillvalue=fillvalue)

ये फ़ंक्शन मेमोरी-कुशल हैं और किसी भी पुनरावृत्तियों के साथ काम करते हैं।

Answer 9

निम्नलिखित कोड का प्रयास करें:

from itertools import islice

def split_every(n, iterable):
    i = iter(iterable)
    piece = list(islice(i, n))
    while piece:
        yield piece
        piece = list(islice(i, n))

s = '1234567890'
print list(split_every(2, list(s)))

Comments

आपका उत्तर ओपी की आवश्यकता को पूरा नहीं करता है, आपको yield ''.join(piece)इसे उम्मीद के मुताबिक

— पाउलो

Answer 10

>>> from functools import reduce
>>> from operator import add
>>> from itertools import izip
>>> x = iter('1234567890')
>>> [reduce(add, tup) for tup in izip(x, x)]
['12', '34', '56', '78', '90']
>>> x = iter('1234567890')
>>> [reduce(add, tup) for tup in izip(x, x, x)]
['123', '456', '789']

Answer 11

इसे इस्तेमाल करे:

s='1234567890'
print([s[idx:idx+2] for idx,val in enumerate(s) if idx%2 == 0])

आउटपुट:

['12', '34', '56', '78', '90']

Answer 12

हमेशा की तरह, जो एक लाइनर्स से प्यार करते हैं

n = 2  
line = "this is a line split into n characters"  
line = [line[i * n:i * n+n] for i,blah in enumerate(line[::n])]

Comments

जब मैं इसे पायथन फिडेल में रन करता हूं तो मुझे आउटपुट के रूप में print(line)मिलता है this is a line split into n characters। क्या आप बेहतर डाल सकते हैं line = [line[i * n:i * n+n] for i,blah in enumerate(line[::n])]:? इसे ठीक करें और यह एक अच्छा जवाब है :)।

— को एक Google खोज में क्या है

क्या आप समझा सकते हैं ,blahऔर यह क्यों जरूरी है? मुझे लगता है कि मैं blahकिसी भी अल्फा चरित्र / एस के साथ बदल सकता हूं , लेकिन संख्या नहीं, और blah/ या अल्पविराम को हटा नहीं सकता । मेरे संपादक का सुझाव है कि इसके बाद ,

— व्हॉट्सएप

enumerateदो पुनरावृत्तियाँ लौटाता है, इसलिए आपको उन्हें लगाने के लिए दो स्थानों की आवश्यकता होती है। लेकिन आपको वास्तव में इस मामले में किसी भी चीज़ के लिए दूसरे पुनरावृत्ति की आवश्यकता नहीं है।

— डैनियल एफ

इसके बजाय blahमैं अंडरस्कोर या डबल अंडरस्कोर का उपयोग करना पसंद करता हूं, देखें: stackoverflow.com/questions/5893163/…

— एंडी रॉयल

Answer 13

छोटी स्ट्रिंग के लिए एक सरल पुनरावर्ती समाधान:

def split(s, n):
    if len(s) < n:
        return []
    else:
        return [s[:n]] + split(s[n:], n)

print(split('1234567890', 2))

या ऐसे रूप में:

def split(s, n):
    if len(s) < n:
        return []
    elif len(s) == n:
        return [s]
    else:
        return split(s[:n], n) + split(s[n:], n)

, जो ठेठ विभाजन को दिखाता है और पुनरावर्ती दृष्टिकोण में पैटर्न को अधिक स्पष्ट रूप से जीतता है (हालांकि व्यावहारिक रूप से यह इस तरह से करना आवश्यक नहीं है)

Answer 14

मैं उसी दर्शनीय स्थल में फंस गया था।

इसने मेरे लिए काम किया

x="1234567890"
n=2
list=[]
for i in range(0,len(x),n):
    list.append(x[i:i+n])
print(list)

उत्पादन

['12', '34', '56', '78', '90']

Answer 15

more_itertools.slicedपहले उल्लेख किया गया है । यहाँ more_itertoolsपुस्तकालय से चार और विकल्प हैं :

s = "1234567890"

["".join(c) for c in mit.grouper(2, s)]

["".join(c) for c in mit.chunked(s, 2)]

["".join(c) for c in mit.windowed(s, 2, step=2)]

["".join(c) for c in  mit.split_after(s, lambda x: int(x) % 2 == 0)]

बाद वाले विकल्पों में से प्रत्येक निम्नलिखित उत्पादन का उत्पादन करता है:

['12', '34', '56', '78', '90']

पर चर्चा की विकल्पों के लिए प्रलेखन: grouper, chunked, windowed,split_after

Answer 16

यह लूप के लिए एक सरल द्वारा प्राप्त किया जा सकता है।

a = '1234567890a'
result = []

for i in range(0, len(a), 2):
    result.append(a[i : i + 2])
print(result)

आउटपुट ऐसा लगता है जैसे ['12', '34', '56 ',' 78 ',' 90 ',' a ']

Comments

हालांकि यह कोड प्रश्न का उत्तर दे सकता है, क्यों और / या इस कोड के उत्तर के बारे में अतिरिक्त संदर्भ प्रदान करने से प्रश्न इसके दीर्घकालिक मूल्य में सुधार करता है।

— β.βοιτ.βε

यह यहाँ के रूप में एक ही समाधान है: stackoverflow.com/a/59091507/7851470

— Georgy