为什么Python有“反转”？

为什么Python有内置函数

为什么不直接使用

x[：-1]

而不是

reversed（x）

---

Edit：@TanveerAlam，

reversed

实际上不是一个函数，而是一个类，尽管在页面上列出了它。

>a=[1,2,3,4,5,6,7,8,9,10]
>>>a[：-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>>（a）

---

第一种符号是热切地生成反面；第二个是提供一个反向迭代器，它可能更便宜，因为它有可能只根据需要生成元素，因为反向会返回一个迭代器

aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
print type(reversed(aList))

bList = [123, 'xyz', 'zara', 'abc', 'xyz'];
print type(bList[::-1])

输出：

<type 'listreverseiterator'>
<type 'list'>

---

reversed

函数返回一个反向迭代器。

[：：-1]

返回一个列表

首先，

反向

不是内置函数

>>> type(reversed)
<type 'type'>

当我们传递一个参数给它时，它就像一个迭代器

>>> l = [1, 2, 3, 4]
>>> obj = reversed(l)
>>> obj
<listreverseiterator object at 0x0220F950>
>>> obj.next()
4
>>> obj.next()
3
>>> obj.next()
2
>>> obj.next()
1
>>> obj.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

---

反向返回一个反向迭代器

x[：-1]返回一个列表

In [1]: aaa = [1,2,3,4,5]

In [4]: aaa[::-1]
Out[4]: [5, 4, 3, 2, 1]

In [5]: timeit(aaa[::-1])
1000000 loops, best of 3: 206 ns per loop

In [6]: reversed(aaa)
Out[6]: <listreverseiterator at 0x104310d50>

In [7]: timeit(reversed(aaa))
10000000 loops, best of 3: 182 ns per loop

[1]中的

aaa=[1,2,3,4,5]
在[4]：aaa[：-1]
Out[4]：[5,4,3,2,1]
在[5]：timeit（aaa[：-1]）
1000000个循环，最好3个：每个循环206纳秒
[6]中：反向（aaa）
出[6]：
In[7]：timeit（反向（aaa））
10000000个循环，最佳3个：每个循环182纳秒

反向

返回反向迭代器

[：：-1]

向对象请求切片

Python对象尝试返回您可能期望的内容

>>> [1, 2, 3][::-1]
[3, 2, 1]
>>> "123"[::-1]
'321'

这很方便，特别是对于字符串和元组

但是请记住，大多数代码不需要反转字符串

reversed（）

最重要的作用是使代码更易于阅读和理解

它返回迭代器而不创建新序列这一事实是次要的

PEP 322：反向迭代一个新的内置函数，反向（seq）（）， 获取序列并返回循环元素的迭代器 按相反的顺序排列

与扩展切片相比，比如范围（1,4）[：：-1]，reversed（）是 更易于阅读，运行速度更快，占用的内存更少

请注意，reversed（）只接受序列，不接受任意迭代器。 如果要反转迭代器，请首先使用 列表（）

---

问圭多？他是会知道的人。

对于我名单中的x[：：-1]

简直是丑陋。

x[：-1]

的效率远远低于

反向（x）

；它创建了一个全新的列表，而

reversed（）

只是创建了一个相反方向的迭代器good@Hackaholic，我不同意。“为什么X有Y？”本质上要求研究公开的电子邮件档案（关于创作者的意图）或第一手知识（即决定出席StackOverflow的人）以获得客观和真实的答案；否则就是猜测和意见，这些都是离题的。现在，“Y有什么好处而X没有？”是一个很好的问题，但这是一个不同的问题，如果这是我们想要问的，那么这就是我们应该问的问题。

（listOfThings[：-1]中elem的elem）

@Legostrmtroopr，是的，但这个问题构造了一个倒排的列表并对其进行迭代，完全违背了这一点（关于内存和性能效率）。我并不是说使用切片更好，但正如其他答案所示，“返回迭代器”并不是它的全部原因。我猜这个页面有点误导，因为我现在看到了两个类（

反向

，

压缩

，等等）和函数。

>>> l[::-1]
[4, 3, 2, 1]

In [1]: aaa = [1,2,3,4,5]

In [4]: aaa[::-1]
Out[4]: [5, 4, 3, 2, 1]

In [5]: timeit(aaa[::-1])
1000000 loops, best of 3: 206 ns per loop

In [6]: reversed(aaa)
Out[6]: <listreverseiterator at 0x104310d50>

In [7]: timeit(reversed(aaa))
10000000 loops, best of 3: 182 ns per loop

>>> [1, 2, 3][::-1]
[3, 2, 1]
>>> "123"[::-1]
'321'

>>>
>>> for i in reversed(xrange(1,4)):
...    print i
...
3
2
1

>>>
>>> input = open('/etc/passwd', 'r')
>>> for line in reversed(list(input)):
...   print line
...