Gibt es eine Möglichkeit, um split einen string, indem jeder N-te separator in Python?

Zum Beispiel, wenn ich den folgenden string:

"dies-ist-ein-string"

Könnte ich es teilen, durch die jeder 2." -", anstatt alle "-" also, es gibt zwei Werte ("dies-is" und "a-string") anstelle der Rückgabe von vier?

InformationsquelleAutor Gnuffo1 | 2009-10-25

31

Hier ist eine andere Lösung:
```
span = 2
words = "this-is-a-string".split("-")
print ["-".join(words[i:i+span]) for i in range(0, len(words), span)]
```
Danke, Nick D.
Warum nach unten Stimmen? Was ist falsch an dieser Antwort?
Dies scheint die einfachste, für die Arbeit, für eine variable Länge zwischen den Trennungen.

InformationsquelleAutor Gumbo

>>> s="a-b-c-d-e-f-g-h-i-j-k-l"         # use zip(*[i]*n)
>>> i=iter(s.split('-'))                # for the nth case    
>>> map("-".join,zip(i,i))    
['a-b', 'c-d', 'e-f', 'g-h', 'i-j', 'k-l']

>>> i=iter(s.split('-'))
>>> map("-".join,zip(*[i]*3))
['a-b-c', 'd-e-f', 'g-h-i', 'j-k-l']
>>> i=iter(s.split('-'))
>>> map("-".join,zip(*[i]*4))
['a-b-c-d', 'e-f-g-h', 'i-j-k-l']

Manchmal itertools.izip ist schneller, wie Sie können sehen in den Ergebnissen

>>> from itertools import izip
>>> s="a-b-c-d-e-f-g-h-i-j-k-l"
>>> i=iter(s.split("-"))
>>> ["-".join(x) for x in izip(i,i)]
['a-b', 'c-d', 'e-f', 'g-h', 'i-j', 'k-l']

Hier ist eine version, die Art arbeitet mit einer ungeraden Anzahl von teilen je nachdem, welche Ausgabe Sie wünschen. Sie könnten es vorziehen, schneiden Sie die '-' aus dem Ende des letzten Elements mit .rstrip('-') zum Beispiel.

>>> from itertools import izip_longest
>>> s="a-b-c-d-e-f-g-h-i-j-k-l-m"
>>> i=iter(s.split('-'))
>>> map("-".join,izip_longest(i,i,fillvalue=""))
['a-b', 'c-d', 'e-f', 'g-h', 'i-j', 'k-l', 'm-']

Hier sind einige timings

$ python -m timeit -s 'import re;r=re.compile("[^-]+-[^-]+");s="a-b-c-d-e-f-g-h-i-j-k-l"' 'r.findall(s)'
100000 loops, best of 3: 4.31 usec per loop

$ python -m timeit -s 'from itertools import izip;s="a-b-c-d-e-f-g-h-i-j-k-l"' 'i=iter(s.split("-"));["-".join(x) for x in izip(i,i)]'
100000 loops, best of 3: 5.41 usec per loop

$ python -m timeit -s 's="a-b-c-d-e-f-g-h-i-j-k-l"' 'i=iter(s.split("-"));["-".join(x) for x in zip(i,i)]'
100000 loops, best of 3: 7.3 usec per loop

$ python -m timeit -s 's="a-b-c-d-e-f-g-h-i-j-k-l"' 't=s.split("-");["-".join(t[i:i+2]) for i in range(0, len(t), 2)]'
100000 loops, best of 3: 7.49 usec per loop

$ python -m timeit -s 's="a-b-c-d-e-f-g-h-i-j-k-l"' '["-".join([x,y]) for x,y in zip(s.split("-")[::2], s.split("-")[1::2])]'
100000 loops, best of 3: 9.51 usec per loop

+1 Schöne, saubere Lösung...
Wow, das ist großartig!
pythonic Eleganz
Bist du mit dem falschen code für meinen Vorschlag. Ich bewege mich auf die Worte ein, die nicht die Zeichenfolge. python -m timeit -s 's="a-b-c-d-e-f-g-h-i-j-k-l".split("-")' '["-".join(s[i:i+2]) for i in range(0, len(s), 2)]'
Schön gemacht, aber nicht für eine ungerade Anzahl von Elementen. Es sollte nicht allzu schwer zu überwinden, obwohl.

InformationsquelleAutor John La Rooy

9

Reguläre Ausdrücke dies leicht zu handhaben:
```
import re
s = "aaaa-aa-bbbb-bb-c-ccccc-d-ddddd"
print re.findall("[^-]+-[^-]+", s)
```
Ausgabe:
```
['aaaa-aa', 'bbbb-bb', 'c-ccccc', 'd-ddddd']
```
Update für Nick D:
```
n = 3
print re.findall("-".join(["[^-]+"] * n), s)
```
Ausgabe:
```
['aaaa-aa-bbbb', 'bb-c-ccccc']
```
Wahrscheinlich die eleganteste Lösung, die ist noch lesbar, der rest sind stretching es.
gute Antwort aber es ist nur für jeden 2. separator.
... und nur für eine gerade Anzahl von Wörtern.
Nick: Nicht so. Siehe mein update. Gumbo: Auch nicht so. Nur eine einfache änderung der regex wird, behandeln diesen Fall als gut, wenn es gewünscht ist.
ok, aber ich sehe nicht, das d-ddddd in den Ausgang 😉

InformationsquelleAutor recursive
0
```
l = 'this-is-a-string'.split()
nl = []
ss = ""
c = 0
for s in l:
   c += 1
   if c%2 == 0:
       ss = s
   else:
       ss = "%s-%s"%(ss,s)
       nl.insert(ss)

print nl
```
Was ist n? Ich bekomme einen Namen-Fehler, da es nicht definiert.
sorry, habe ich falsch verstanden, deine Frage ersten mal und schrieb es, n war ein überbleibsel aus früheren. Nun es gibt eine Liste von strings.
Das ist sehr kompliziert (zu lange zu Lesen/entziffern), im Vergleich zu vielen anderen Lösungen, die hier vorgeschlagen wird...
Müll. es ist eigentlich viel einfacher zu entschlüsseln. Länge weitgehend irrelevant ist und es könnte verkürzt werden, so dass es weniger lesbar. Es sollte eine gute performance, da die Schleife hat nur eine einfache Bedingung zu behandeln. Auch hat er die größte Flexibilität für einen Umgang mit der Verarbeitung innerhalb der Schleife. Auch die Gewinner Antwort Absturz auf einen string mit einer ungeraden Anzahl von Bindestrichen. Iter und die Liste ops könnte pythonic aber das bedeutet nicht unbedingt, dass Sie 'besser'.

InformationsquelleAutor SpliFF
0

EDIT: Der ursprüngliche code, den ich gepostet hat nicht funktioniert. Diese version ist:

Ich glaube nicht, können Sie aufgeteilt auf alle anderen, aber Sie könnten aufgeteilt auf alle - und kommen jedes paar.
```
chunks = []
content = "this-is-a-string"
split_string = content.split('-')

for i in range(0, len(split_string) - 1,2) :
    if i < len(split_string) - 1:
        chunks.append("-".join([split_string[i], split_string[i+1]]))
    else:
        chunks.append(split_string[i])
```
Das funktioniert nicht, ich bekomme ["-", "-", "-", "-"]
Funktioniert dies nicht. Die Ausgabe besteht aus einer Liste von 1 Zeichen-strings mit einem Bindestrich.
Seine Idee ist gut, Sie schreiben, könnte die Umsetzung Ihrer eigenen.
Ja. Splice hat nicht funktioniert, wie ich dachte, es Tat, ich habe behoben, das implementatino.
Downvote entfernt. Sie könnten genauso gut tun split_string[i:i+2] anstatt eine Liste wörtlich, da Sie wissen, die Größe schon.

InformationsquelleAutor EmFi

Ich denke, dass einige der bereits gegebenen Lösungen sind gut genug, aber nur zum Spaß, habe ich diese version:

def twosplit(s,sep):
  first=s.find(sep)
  if first>=0:
    second=s.find(sep,first+1)
      if second>=0:
        return [s[0:second]] + twosplit(s[second+1:],sep)
      else:
        return [s]
    else:
      return [s]
  print twosplit("this-is-a-string","-")

InformationsquelleAutor elzapp

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.