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

начиная с Python3

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

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

вы можете прочитать больше об этом на что нового в Python 3.0.

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

Итак, каковы способы получения корыто это?

---

Случай 1-The 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-The list звонок через map без lambda

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

The 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-In-Place и эффективность космоса (Т-М-Т)

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

похоже, вы хотите что-то вроде Perl

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

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

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

от этого ссылке:

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

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

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

line = line.split()

и это все.

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

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

The lines получил все содержимое файла.

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

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

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

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

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

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

например:

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

test_str теперь Вишака

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

так что у вас есть:

fileName = '7.3\n'

потом просто сделать:

fileName.strip()

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

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

это работает, чтобы вывезти \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)
....

для обработки многих разделителей новой строки, включая комбинации символов, такие как \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 ''

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