关于python：如何从列表元素中删除 \n？


How to remove \n
from a list element?

我试图让python从.txt文件中读取一行，并将第一行的元素写入一个列表。文件中的元素是制表符分隔的，因此我使用了split("\t")来分隔元素。因为.txt文件有很多元素，所以我将每行中的数据保存到一个单独的列表中。

我目前的问题是，它显示的每个列表如下：

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

如何从列表的最后一个元素中删除\n
并使其仅为'7.3'？

相关讨论

如果只想从最后一个元素中删除
，请使用以下命令：

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

如果要从所有元素中删除
，请使用以下命令：

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

您还可以考虑在拆分行之前删除
：

1
2
line = line.strip()
# split line...
相关讨论

从python3起

map不再返回到list但是amapObject，因此答案看起来像

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

您可以在python 3.0的新功能上阅读更多关于它的信息。

map() and filter() return iterators. If you really need a list, a quick fix is e.g. list(map(...))

那么现在是什么方法来解决这个问题呢？

案例1-呼叫

map返回迭代器。list是一个可以将迭代器转换为列表的函数。因此，您需要包装一个list呼叫。所以现在的答案是，

1
2
3
4
>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']
>>> list(map(lambda x:x.strip(),l))
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

很好，我们得到输出。现在我们检查运行这段代码所需的时间。

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

2.22微秒。那还不错。但是有更有效的方法吗？

案例2-不带A的呼叫

在python社区(包括guido)中，许多人都不喜欢使用lambda。除此之外，它将大大降低程序的速度。因此，我们需要尽可能避免这种情况。顶层功能。你来帮助我们。

不使用lambda使用str.strip作为，可以重新编写map

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

现在是团队。

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

好极了！你可以看到这两种方法的效率差异。它快了近60%。因此，不使用lambda的方法在这里是更好的选择。

案例3-遵循指导原则，常规方法

python 3.0的另一个重要特点是它建议我们尽可能避免使用map。

Particularly tricky is map() invoked for the side effects of the
function; the correct transformation is to use a regular for loop
(since creating a list would just be wasteful).

因此，我们可以通过使用一个规则的循环来解决这个问题，而不需要一个map。

解决(暴力)的简单方法是：

1
2
3
4
5
6
7
8
>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']
>>> 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']

正时设置。

1
2
3
4
5
6
7
8
def f():
    l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']
    final_list = []
    for i in l:
         final_list.append(i.strip())
import timeit
print(min(timeit.repeat("f()","from __main__ import f")))

以及结果。

1
1.5322505849981098

如你所见，这里的蛮力有点慢。但是对于普通程序员来说，它绝对比一个子句更可读。

案例4-列出理解

这里的理解列表也是可能的，与python2相同。

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

现在开始计时：

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

如您所见，列表-理解比map更有效(即使没有lambda)。因此，python3的经验法则是使用理解，而不是使用理解。

案例5：就地机制和空间效率(t-m-t)

最后一种方法是在列表中进行适当的更改。这将节省大量的内存空间。这可以使用enumerate来完成。

1
2
3
4
5
6
7
>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']
>>> 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)

1
2
3
4
5
6
7
8
9
----------------------------------------------------
|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   |
----------------------------------------------------

最后请注意，列表理解是最好的方法，而使用lambda是最差的方法。但同样——只在Python3

听起来您想要Perl函数。

在python中，这很简单：

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

……假设您使用的是Python2.6或更高版本。否则只需稍微使用更详细：

1
2
3
4
5
6
def chomp(s):
    if s.endwith('
'):
        return s[:-1]
    else:
        return s

如果要从字符串末尾删除所有新行(在奇数情况下，由于某些原因，可能会有多个尾随新行)：

1
2
3
def chomps(s):
    return s.rstrip('
')

显然，您不应该看到任何正常的python文件对象的readline()或readlines()方法返回的字符串。

我看到人们盲目地从文件和类似功能的结果中删除最后一个字符(使用切片)。这是一个坏主意，因为它会导致文件最后一行出错(在文件以换行符以外的任何内容结尾的情况下)。

一开始，当你盲目地从你读过的行中去掉最后的字符时，你可能会被哄骗到一种虚假的安全感。如果使用普通的文本编辑器创建测试套件文件，那么大多数文件都会在最后一行的末尾自动添加新行。要创建有效的测试文件，请使用以下代码：

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

……然后，如果您重新打开该文件并在其上使用readline()或readlines()文件方法，您会发现读取文本时不带尾随新行。

由于无法解释以非换行符结尾的文本文件，许多Unix实用程序和脚本语言多年来一直受到困扰。这是一个愚蠢的基于角落的bug，它潜入代码中的频率仅足以成为有害程序，但不足以让人们从中学习。我们可以争辩说，没有最终换行的"文本"文件是"损坏的"或非标准的；这可能对某些编程规范有效。

然而，在我们的代码中忽略角落的情况是非常容易的，并且这种无知会咬到那些以后依赖于您的代码的人。正如我妻子所说：说到编程…练习安全六角形！

相关讨论

使用列表理解：

1
2
3
4
myList = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']

[(el.strip()) for el in myList]
相关讨论

通过此链接：

您可以使用rstrip()方法。例子

1
2
3
4
mystring ="hello
"    
print(mystring.rstrip('
'))

这也会起作用，

1
2
3
4
f=open('in.txt','r')

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

str.strip()删除空白字符。也可以将自定义字符作为参数传递给strip。strip函数删除字符串两端的空白/自定义字符。lstrip()和rstrip()分别是左条函数和右条函数。

如：

1
2
3
test_str ="Vishaka
"
test_str = test_str.strip()

测试现在的维沙卡

你可以的-

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

lines已获取文件的所有内容。

我们也可以使用列表理解来使这个更紧凑。

1
lines = [ line.strip().split(DELIMITER) for line in open('file.txt')]
相关讨论

作为另一种方法，如果您知道数据中没有空格，那么您可以使用split()(不带参数)。这将在空白处进行拆分，并使用比其他版本的拆分更有效的算法。它还从两端剥离空白。

1
line = line.split()

就这样。

访问集合的最后一个元素，然后将值存储在变量中。

所以你有：

1
2
fileName = '7.3
'

那就做：

1
fileName.strip()

这将使您获得7.3。然后将该值存储回集合的最后一个元素中。

您可以使用lstrip()或rstrip()仅移除左侧或右侧。

1
2
3
4
5
6
new_list = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']
for i in range(len(new_list)):
    new_list[i]=new_list[i].replace('
','')
print(new_list)

输出如下

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

因为op的问题是从最后一个元素中剥离换行符，所以我将使用the_list[-1].rstrip()重置它：

1
2
3
4
5
>>> the_list = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3
']
>>> 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)。

要处理许多换行分隔符，包括字符组合，如

，请使用splitlines。合并联接和拆分线以从字符串中删除/替换所有换行符s：

1
''.join(s.splitlines())

要只删除一个尾随换行符，请将True作为keepends参数传递以保留分隔符，仅删除最后一行上的分隔符：

1
2
3
4
5
6
7
def chomp(s):
    if len(s):
        lines = s.splitlines(True)
        last = lines.pop()
        return ''.join(lines + last.splitlines())
    else:
        return ''

我遇到了这个问题，并使用上面描述的chomp函数解决了它：

1
2
3
4
5
6
7
8
9
10
11
12
def chomp(s):
    return s[:-1] if s.endswith('
') 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)
....
相关讨论

此操作用于从列表中的项目中删除
(新行)它只是去掉了字符串中的第一项

1
2
3
4
5
def remove_end(s):
    templist=[]
    for i in s:
        templist.append(i)
    return(templist[0])