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

Я пытаюсь получить Python для чтения строки из файла .txt и записать элементы первой строки в список. Элементы в файле были разделены табуляцией, поэтому я использовалsplit("\t") отделить элементы. Поскольку в файле .txt много элементов, я сохранил данные, найденные в каждой строке, в отдельный список.

Проблема у меня в настоящее время заключается в том, что он показывает каждый список, как это:

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

Как я могу удалить\n из последнего элемента списка и сделать его просто'7.3'?

 JoshD03 окт. 2010 г., 13:26
С данными, которые у вас есть, просто используйте split () (без аргументов). Сначала будут удалены пробелы, а затем разделены пробелы.

Ответы на вопрос(15)

го элемента, я бы сбросил его с помощью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']

Это О (1).

включая комбинации символов, такие как\r\nиспользоватьsplitlines, скомбинироватьприсоединиться а также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 ''

Вы могли бы сделать -

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')]
 zach12 февр. 2012 г., 21:52
Я использую вариант этого подхода, чтобы превратить файл в одну строковую переменную javascript. отлично. спасибо Срикару

а затем сохраняете значение в переменной.

Так что у тебя есть:

fileName = '7.3\n'

тогда просто сделайте:

fileName.strip()

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

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

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

Например:

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

test_str сейчас Вишака

Решение Вопроса

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

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

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

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

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

line = line.strip()
# split line...
 Mr Wotan03 окт. 2010 г., 13:24
Ура! Оно работает! Большое спасибо.
 Bolo21 апр. 2019 г., 10:56
@ sc241 Вы должны создать отдельный вопрос в StackOverflow вместо комментария, так как ваш вопрос охватывает гораздо больше, чем просто удаление'\n', В этом вопросе, пожалуйста, укажите точный результат, который вы ожидаете от предоставленного вами материала - он прояснит ваши потребности.
 aaronasterling03 окт. 2010 г., 13:33
если бы я собирался перебрать список, я бы использовал[s.strip() for s in t] также. Я рассчитал это, и это 5,33 мсек для обработки["s\n"]*10000 против 9,73 мсек дляmap. map победит, если он отображает встроенную.
 John Machin04 окт. 2010 г., 00:00
line = line.strip() удалит ВСЕ ТРЕЙЛИНГОВЫЕ БЕЛАЯ. Это бойня. Прочитайте ответ Джима Денниса.
 sc24118 апр. 2019 г., 15:37
У меня есть списокcontents=['1 148766 15417.5 0.867096 2.00747 1.67202 [198.969, 189.629, 78.7315] [118.66, 120.51, 238.207] [117, 241, 83, 274, 23, 135] \n', '2 ...] в котором каждый элемент заканчивается\n, Длина содержимого - 3. Как удалить это из каждого элемента списка и сохранить список в массиве numpy
 Bolo04 окт. 2010 г., 09:49
@ Джон Правда. Мало того, это также удалит все ведущие пробелы. Во многих обстоятельствахline.strip() было бы более разумным, чемline.rstrip('\n') и именно поэтому я написал это без дальнейших объяснений. Однако в этом случае (значения, разделенные символом табуляции) вы на 100% правы: нужно действительно быть осторожным с удалением начальных и конечных пробелов, поскольку пустой первый или последний столбец может «исчезнуть».
 st0le03 окт. 2010 г., 13:21
Я бы сделал полоску перед разделением ... я чувствую ее более сжатой.

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')

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

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

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

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

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

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

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

 John Machin03 окт. 2010 г., 23:57
+1 При чтении текстового файла Python, проверяя наличие новой строки (или слепо удаляя его, если он существует,line = line.rstrip('\n')) должен быть выполнен как отдельный шаг ПЕРЕД разбором строки в поля.

Используя понимание списка:

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

[(el.strip()) for el in myList]
 Jim Dennis17 июл. 2019 г., 19:31
Это предполагает, что намерение состоит в том, чтобы убрать все начальные и конечные пробелы. Это не точное совпадение с «удалением новых строк».
new_list = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
for i in range(len(new_list)):
    new_list[i]=new_list[i].replace('\n','')
print(new_list)

Выход будет такой

['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

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

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

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

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

line = line.split()

И это все.

Начиная с Python3

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

>>> map(lambda x:x.

Вы можете прочитать больше об этом наЧто нового в 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 - Механизмы на месте и эффективность использования пространства (Т-М-Т)

Последний способ - сделать изменения на месте внутри самого списка. Это сэкономит много места в памяти. Это можно сделать с помощью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

ссылка на сайт:

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

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

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

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

и я решил ее с помощью функции 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)
....
 blm20 нояб. 2015 г., 19:50
Это похоже на дубликат предыдущих ответов. Если это что-то добавляет, проясните, что это такое.

Ваш ответ на вопрос