Schnellste Weg, um entfernen die ersten und die letzten Zeilen aus einem Python-string

Erste split bei '\n' einmal und prüfen Sie dann, ob der string am letzten index enthält '\n' wenn ja str.rsplit bei '\n' einmal und wählen Sie das Element bei index 0. andernfalls wird ein leerer string zurückgegeben:

def solve(s):
    s = s.split('\n', 1)[-1]
    if s.find('\n') == -1:
        return ''
    return s.rsplit('\n', 1)[0]
... 
>>> s = '''*** START OF DATA ***
data
data
data
*** END OF DATA ***'''
>>> solve(s)
'data\ndata\ndata'
>>> s = '''*** START OF DATA ***
*** END OF DATA ***'''
>>> solve(s)
''
>>> s = '\n'.join(['a'*100]*10**5)
>>> %timeit solve(s)
100 loops, best of 3: 4.49 ms per loop

Oder nicht aufgeteilt, an alle, finden den index der '\n' von beiden enden und schneiden Sie die Zeichenfolge:

>>> def solve_fast(s):
    ind1 = s.find('\n')
    ind2 = s.rfind('\n')
    return s[ind1+1:ind2]
... 
>>> s = '''*** START OF DATA ***
data
data
data
*** END OF DATA ***'''
>>> solve_fast(s)
'data\ndata\ndata'
>>> s = '''*** START OF DATA ***
*** END OF DATA ***'''
>>> solve_fast(s)
''
>>> s = '\n'.join(['a'*100]*10**5)
>>> %timeit solve_fast(s)
100 loops, best of 3: 2.65 ms per loop

Abhängig von der Art und Weise, dass Ihre Nutzung Fall verbrauchen wird der string, der schnellere Weg, um es zu entfernen kann, indem nicht es zu entfernen.

Wenn Sie planen, um den Zugriff auf die Zeilen in der Zeichenfolge nacheinander können Sie bauen einen generator, der das überspringen der ersten und der letzten Zeile, während die nachgeben, jede Zeile als konsumiert wird, eher als der Bau einer neuen Reihe von Kopien aller Linien insgesamt.

Einer ad-hoc-Weise zu vermeiden, die erste und die Letzte Zeile ist die Iteration über die saite, ohne dass unnötige Kopien ist durch die Verfolgung von drei weiteren Linien und nur die Rückgabe der 2. ein, so wird die iteration abschließen wird vor erreichen der letzten Zeile, ohne zu wissen, die position von der letzten Zeile Pause.

Folgende Funktion sollte geben Sie die gewünschte Ausgabe:

def split_generator(s):
  # Keep track of start/end positions for three lines
  start_prev = end_prev = 0
  start = end = 0
  start_next = end_next = 0

  nr_lines = 0

  for idx, c in enumerate(s):
    if c == '\n':
      nr_lines += 1

      start_prev = start
      end_prev = end
      start = start_next
      end = end_next
      start_next = end_next
      end_next = idx

      if nr_lines >= 3:
        yield s[(start + 1) : end]

  # Handle the case when input string does not finish on "\n"
  if s[-1] != '\n' and nr_lines >= 2:
    yield s[(start_next+1):end_next]

Kippe Sie testen es mit:

print("1st example")
for filtered_strs in split_generator('first\nsecond\nthird'):
  print(filtered_strs)

print("2nd example")
for filtered_strs in split_generator('first\nsecond\nthird\n'):
  print(filtered_strs)

print("3rd example")
for filtered_strs in split_generator('first\nsecond\nthird\nfourth'):
  print(filtered_strs)

print("4th example")
for filtered_strs in split_generator('first\nsecond\nthird\nfourth\n'):
  print(filtered_strs)

print("5th example")
for filtered_strs in split_generator('first\nsecond\nthird\nfourth\nfifth'):
  print(filtered_strs)

Wird die Ausgabe erzeugt:

1st example
second
2nd example
second
3rd example
second
third
4th example
second
third
5th example
second
third
fourth

Beachten Sie, dass der größte Vorteil von diesem Ansatz ist, dass nur eine neue Zeile an der Zeit und nehmen praktisch keine Zeit zum generieren der ersten Zeile der Ausgabe (statt zu warten, bis alle Zeilen gefunden werden, bevor Sie fortfahren), aber, wieder, das kann nützlich sein oder nicht, je nach Ihrem Anwendungsfall.