Как удалить \n из элемента списка?

Ответ 1

Если вы хотите удалить \n только из последнего элемента, используйте это:

t[-1] = t[-1].strip()

Если вы хотите удалить \n из всех элементов, используйте это:

t = map(lambda s: s.strip(), t)

Вы также можете рассмотреть возможность удаления \n перед:

line = line.strip()
# split line...

Ответ 2

От Python3 вперед

map больше не возвращает list, но a mapObject, поэтому ответ будет выглядеть примерно так:

>>> map(lambda x:x.strip(),l)
<map object at 0x7f00b1839fd0>

Подробнее об этом можно узнать в Что нового в Python 3.0.

map() и filter() возвращают итераторы. Если вам действительно нужен list, быстрое исправление, например. list(map(...))

Итак, какие способы получить это?

Случай 1 - вызов list через map с lambda

map возвращает итератор. list - это функция, которая может конвертировать итератор в список. Следовательно, вам нужно будет обернуть вызов list вокруг map. Таким образом, ответ теперь становится,

>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> list(map(lambda x:x.strip(),l))
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

Очень хорошо, мы получаем результат. Теперь мы проверяем количество времени, которое требуется для выполнения этой части кода.

$ python3 -m timeit "l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n'];list(map(lambda x:x.strip(),l))"
100000 loops, best of 3: 2.22 usec per loop

2,22 микросекунды. Это не так уж плохо. Но есть ли более эффективные способы?

Случай 2 - вызов list через map с выводом lambda

lambda недоволен многими в сообществе Python (включая Guido). Кроме того, это значительно снизит скорость программы. Следовательно, мы должны избегать этого как можно больше. Функция верхнего уровня str.strip. Приходит к нам на помощь.

map можно переписать без использования lambda с помощью str.strip в качестве

>>> list(map(str.strip,l))
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

А теперь на время.

$ python3 -m timeit "l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n'];list(map(str.strip,l))"
1000000 loops, best of 3: 1.38 usec per loop

Фантастические. Вы можете увидеть различия в эффективности между двумя способами. Это почти на 60% быстрее. Таким образом, подход без использования lambda является лучшим выбором здесь.

Случай 3 - Следующие рекомендации, Обычный способ

Еще один важный момент из Что нового в Python 3.0 заключается в том, что нам рекомендуется избегать map, где это возможно.

Особенно сложно использовать map() для побочных эффектов функция; правильное преобразование состоит в использовании регулярного цикла for(поскольку создание списка будет просто расточительным).

Таким образом, мы можем решить эту проблему без map с помощью регулярного цикла for.

Тривиальный способ решения (грубой силы) был бы: -

>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> final_list = []
>>> for i in l:
...     final_list.append(i.strip())
... 
>>> final_list
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

Настройка синхронизации

def f():
    l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
    final_list = []
    for i in l:
         final_list.append(i.strip())
import timeit
print(min(timeit.repeat("f()","from __main__ import f")))

И результат.

1.5322505849981098

Как вы можете видеть, грубая сила здесь немного медленнее. Но это определенно более читаемо для обычного программиста, чем предложение map.

Случай 4 - Список понятий

A понимание списка здесь также возможно и такое же, как в Python2.

>>> [i.strip() for i in l]
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

Теперь для таймингов:

$ python3 -m timeit "l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n'];[i.strip() for i in l]"
1000000 loops, best of 3: 1.28 usec per loop

Как вы можете видеть, понимание списка более эффективно, чем map (даже без lambda). Следовательно, правило большого пальца в Python3 заключается в использовании понимания списка вместо map

Случай 5 - Механизмы на месте и эффективность использования пространства (T-M-T)

Последний способ - внести изменения в место в самом списке. Это позволит сэкономить много места в памяти. Это можно сделать, используя enumerate.

>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> for i,s in enumerate(l):
...     l[i] = s.strip()
... 
>>> l
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

Результат синхронизации будет 1.4806894720022683. Но, тем не менее, этот путь является пространственно эффективным.

Заключение

Сравнительный список таймингов (оба Python 3.4.3 и Python 3.5.0)

----------------------------------------------------
|Case| method          | Py3.4 |Place| Py3.5 |Place|
|----|-----------------|-------|-----|-------|-----|
| 1  | map with lambda | 2.22u | 5   | 2.85u | 5   |
| 2  | map w/o lambda  | 1.38u | 2   | 2.00u | 2   |
| 3  | brute-force     | 1.53u | 4   | 2.22u | 4   |
| 4  | list comp       | 1.28u | 1   | 1.25u | 1   |
| 5  | in-place        | 1.48u | 3   | 2.14u | 3   |
----------------------------------------------------

Наконец, обратите внимание, что наилучшим способом является понимание списка, а map с использованием lambda является наихудшим. Но снова --- ТОЛЬКО В PYTHON3

Ответ 3

Похоже, вы хотите что-то вроде функции Perl chomp().

Это тривиально делать в Python:

def chomp(s):
    return s[:-1] if s.endswith('\n') else s

... если вы используете Python 2.6 или новее. В противном случае просто используйте слегка более подробный:

def chomp(s):
    if s.endwith('\n'):
        return s[:-1]
    else:
        return s

Если вы хотите удалить все новые строки из конца строки (в нечетном случае, когда по какой-то причине может быть несколько конечных символов перевода строки):

def chomps(s):
    return s.rstrip('\n')

Очевидно, вы никогда не должны видеть такую ​​строку, возвращаемую любым обычным файлом Python readline() и readlines().

Я видел, как люди слепо удаляют последние символы (используя s[:-1] slicing) из результатов файла readline() и подобных функций. Это плохая идея, потому что это может привести к ошибке в последней строке файла (в случае, когда файл заканчивается чем-то другим, кроме новой строки).

Сначала вы можете быть усыплены ложным чувством безопасности, когда слепо зачищаете конечных персонажей с строк, которые вы читали. Если вы используете обычный текстовый редактор для создания файлов тестового набора, у большинства из них будет добавлена ​​новая строка, добавленная к концу последней строки. Чтобы создать правильный тестовый файл, используйте код:

f = open('sometest.txt', 'w')
f.write('some text')
f.close()

... а затем, если вы повторно откроете этот файл и используете методы файла readline() или readlines() на нем, вы обнаружите, что текст читается без завершающей строки новой строки.

Эта ошибка для учета текстовых файлов, заканчивающихся символами не-новой строки, в течение многих лет страдает от многих утилит UNIX и языков сценариев. Это глупая ошибка базовой базы, которая ползет в код достаточно часто, чтобы быть вредителем, но не настолько часто, чтобы люди могли учиться на ней. Мы можем утверждать, что "текстовые" файлы без окончательной новой строки являются "коррумпированными" или нестандартными; и это может быть применимо для некоторых спецификаций программирования.

Однако, слишком легко игнорировать угловые случаи в нашем кодировании и иметь это невежество укусить людей, которые в зависимости от вашего кода позже. Как говорит моя жена: когда дело доходит до программирования... поправляйте безопасный гекс!

Ответ 4

Использование списка:

myList = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']

[(el.strip()) for el in myList]

Ответ 5

из этой ссылки:

вы можете использовать метод rstrip(). Пример

mystring = "hello\n"    
print(mystring.rstrip('\n'))

Ответ 6

Как альтернативный метод, если вы знаете, что в ваших данных нет пробелов, что, кажется, так, вы можете использовать split() (без аргументов). Это разделяется на пробел и использует более эффективный алгоритм, чем другая версия split. Он также удаляет пробелы с обоих концов.

line = line.split()

И что это.

Ответ 7

Вы можете сделать -

DELIMITER = '\t'
lines = list()
for line in open('file.txt'):
    lines.append(line.strip().split(DELIMITER))

lines имеет все содержимое вашего файла.

Можно также использовать списки, чтобы сделать это более компактным.

lines = [ line.strip().split(DELIMITER) for line in open('file.txt')]

Ответ 8

str.strip() удаляет пробельные символы. вы также можете передавать пользовательские символы в качестве аргумента для полосы. Функция полосы удаляет пробельные/пользовательские символы на обоих концах строки. lstrip() и rstrip() - это функции левой полосы и правой полосы соответственно.

Например:

test_str = "Vishaka\n" 
test_str = test_str.strip()

test_str now Vishaka

Ответ 9

Это также будет работать,

f=open('in.txt','r')

    for line in f:
            parline = line[:-1].split(',')

Ответ 10

Вы получаете доступ к последнему элементу набора, а затем сохраняете значение в переменной.

Итак, у вас есть:

fileName = '7.3\n'

то просто выполните:

fileName.strip()

который оставит вас с 7.3. Затем сохраните это значение в последнем элементе набора.

Вы можете использовать lstrip() или rstrip() для удаления только левой или правой стороны.

Ответ 11

Это работает, чтобы вынуть \n (новую строку) с элемента в списке он просто берет первый элемент в строке off

def remove_end(s):
    templist=[]
    for i in s:
        templist.append(i)
    return(templist[0])

Ответ 12

У меня была эта проблема и она была решена с помощью функции chomp, описанной выше:

def chomp(s):
    return s[:-1] if s.endswith('\n') else s

def trim_newlines(slist):
    for i in range(len(slist)):
        slist[i] = chomp(slist[i])
    return slist
.....
names = theFile.readlines()
names = trim_newlines(names)
....

Ответ 13

Чтобы обрабатывать множество разделителей строк, включая комбинации символов, такие как \r\n, используйте splitlines. Объедините join и splitlines, чтобы удалить/замените все строки новой строки на строку s:

''.join(s.splitlines())

Чтобы удалить ровно одну конечную новую строку, передайте True в качестве аргумента keepends, чтобы сохранить разделители, удалив только разделители в последней строке:

def chomp(s):
    if len(s):
        lines = s.splitlines(True)
        last = lines.pop()
        return ''.join(lines + last.splitlines())
    else:
        return ''

Ответ 14

Поскольку вопрос OP заключается в том, чтобы удалить символ новой строки из последнего элемента, я бы reset с the_list[-1].rstrip():

>>> the_list = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> the_list[-1] = ls[-1].rstrip()
>>> the_list
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

Это O (1).