blocks|key|1337292|text|>>>+t
[1,+3,+6]
>>>+[j-i+for+i,+j+in+zip(t[:-1],+t[1:])]++#+or+use+itertools.izip+in+py2k
[2,+3]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1337293|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>&gt;&gt;&gt; t
[1, 3, 6]
&gt;&gt;&gt; [j-i for i, j in zip(t[:-1], t[1:])] # or use itertools.izip in py2k
[2, 3]
</code></pre>

blocks|key|1337328|text|其他答案是正确的，但是如果你在做数值工作，你可能想要考虑numpy。使用numpy，答案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1337329|v+=+numpy.diff(t)|code-block|syntax|javascript|1337330|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The other answers are correct but if you're doing numerical work, you might want to consider numpy. Using numpy, the answer is:

<pre><code>v = numpy.diff(t)
</code></pre>

blocks|key|936182|text|如果您不想使用numpy或zip，可以使用以下解决方案：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|936183|>>>+t+=+[1,+3,+6]
>>>+v+=+[t[i%2B1]-t[i]+for+i+in+range(len(t)-1)]
>>>+v
[2,+3]|code-block|syntax|javascript|936184|entityMap^0|7|5|D|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

If you don't want to use <code>numpy</code> nor <code>zip</code>, you can use the following solution:

<pre><code>&gt;&gt;&gt; t = [1, 3, 6]
&gt;&gt;&gt; v = [t[i+1]-t[i] for i in range(len(t)-1)]
&gt;&gt;&gt; v
[2, 3]
</code></pre>

blocks|key|936208|text|您可以使用itertools.tee和zip高效地构建结果：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|936209|from+itertools+import+tee
#+python2+only:
#from+itertools+import+izip+as+zip

def+differences(seq):
++++iterable,+copied+=+tee(seq)
++++next(copied)
++++for+x,+y+in+zip(iterable,+copied):
++++++++yield+y+-+x|code-block|syntax|javascript|936210|或者改用itertools.islice：|936211|from+itertools+import+islice

def+differences(seq):
++++nexts+=+islice(seq,+1,+None)
++++for+x,+y+in+zip(seq,+nexts):
++++++++yield+y+-+x|936212|您还可以避免使用itertools模块：|936213|def+differences(seq):
++++iterable+=+iter(seq)
++++prev+=+next(iterable)
++++for+element+in+iterable:
++++++++yield+element+-+prev
++++++++prev+=+element|936214|如果你不需要存储所有的结果并支持无限的迭代，那么所有这些解决方案都可以在常量空间中工作。|936215|936216|以下是解决方案的一些微基准：|936217|In+[12]:+L+=+range(10**6)

In+[13]:+from+collections+import+deque
In+[15]:+%25timeit+deque(differences_tee(L),+maxlen=0)
10+loops,+best+of+3:+122+ms+per+loop

In+[16]:+%25timeit+deque(differences_islice(L),+maxlen=0)
10+loops,+best+of+3:+127+ms+per+loop

In+[17]:+%25timeit+deque(differences_no_it(L),+maxlen=0)
10+loops,+best+of+3:+89.9+ms+per+loop|936218|以及其他建议的解决方案：|936219|In+[18]:+%25timeit+[x[1]+-+x[0]+for+x+in+zip(L[1:],+L)]
10+loops,+best+of+3:+163+ms+per+loop

In+[19]:+%25timeit+[L[i%2B1]-L[i]+for+i+in+range(len(L)-1)]
1+loops,+best+of+3:+395+ms+per+loop

In+[20]:+import+numpy+as+np

In+[21]:+%25timeit+np.diff(L)
1+loops,+best+of+3:+479+ms+per+loop

In+[35]:+%25%25timeit
++++...:+res+=+[]
++++...:+for+i+in+range(len(L)+-+1):
++++...:+++++res.append(L[i%2B1]+-+L[i])
++++...:+
1+loops,+best+of+3:+234+ms+per+loop|936220|请注意：|936221|936222|zip(L[1:],+L)等同于L.|unordered-list-item|936223|Accessing，因为zip已经在最短的输入上终止，但是它避免了整个副本的list。索引的单个元素非常慢，因为每次索引访问都是方法调用在zip(L[1:],+L[:-1])中很慢，因为它必须首先将list转换为ndarray。显然，如果你从ndarray开始，它会快得多：|936224|936225|In+22:+arr+=+np.array(L)+In+23：%25timeit+np.diff(arr)+100个循环，最佳3:+3.02+ms+/循环|936226|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.4/library/itertools.html#itertools.tee|1|https://docs.python.org/3.4/library/itertools.html#itertools.islice^0|5|D|J|3|5|D|0|0|0|4|G|4|G|1|0|0|8|9|0|0|0|0|0|0|0|0|0|0|0|D|G|1|0|C|3|12|4|1X|I|2R|4|2Y|7|3D|7|0|0|0^^$0|@$1|2|3|4|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|F|3|G|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@$9|20|A|21|1|22]]|E|$]]|$1|M|3|N|5|H|7|23|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|24|8|@$9|25|A|26|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|27|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|28|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|29|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|2A|8|@]|D|@]|E|$]]|$1|X|3|Y|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|Z|3|10|5|6|7|2C|8|@]|D|@]|E|$]]|$1|11|3|12|5|H|7|2D|8|@]|D|@]|E|$I|J]]|$1|13|3|14|5|6|7|2E|8|@]|D|@]|E|$]]|$1|15|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]|$1|16|3|17|5|18|7|2G|8|@$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]]|D|@]|E|$]]|$1|19|3|1A|5|18|7|2L|8|@$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]|$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|2Y|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|2Z|8|@]|D|@]|E|$]]|$1|1E|3|-4|5|6|7|30|8|@]|D|@]|E|$]]]|1F|$1G|$5|1H|1I|1J|E|$1K|1L]]|1M|$5|1H|1I|1J|E|$1K|1N]]]]

You can use <a href="https://docs.python.org/3.4/library/itertools.html#itertools.tee" rel="noreferrer"><code>itertools.tee</code></a> and <code>zip</code> to efficiently build the result:

<pre><code>from itertools import tee
# python2 only:
#from itertools import izip as zip

def differences(seq):
 iterable, copied = tee(seq)
 next(copied)
 for x, y in zip(iterable, copied):
 yield y - x
</code></pre>

Or using <a href="https://docs.python.org/3.4/library/itertools.html#itertools.islice" rel="noreferrer"><code>itertools.islice</code></a> instead:

<pre><code>from itertools import islice

def differences(seq):
 nexts = islice(seq, 1, None)
 for x, y in zip(seq, nexts):
 yield y - x
</code></pre>

You can also avoid using the <code>itertools</code> module:

<pre><code>def differences(seq):
 iterable = iter(seq)
 prev = next(iterable)
 for element in iterable:
 yield element - prev
 prev = element
</code></pre>

All these solution work in constant space if you don't need to store all the results and support infinite iterables.

<hr>

Here are some micro-benchmarks of the solutions:

<pre><code>In [12]: L = range(10**6)

In [13]: from collections import deque
In [15]: %timeit deque(differences_tee(L), maxlen=0)
10 loops, best of 3: 122 ms per loop

In [16]: %timeit deque(differences_islice(L), maxlen=0)
10 loops, best of 3: 127 ms per loop

In [17]: %timeit deque(differences_no_it(L), maxlen=0)
10 loops, best of 3: 89.9 ms per loop
</code></pre>

And the other proposed solutions:

<pre><code>In [18]: %timeit [x[1] - x[0] for x in zip(L[1:], L)]
10 loops, best of 3: 163 ms per loop

In [19]: %timeit [L[i+1]-L[i] for i in range(len(L)-1)]
1 loops, best of 3: 395 ms per loop

In [20]: import numpy as np

In [21]: %timeit np.diff(L)
1 loops, best of 3: 479 ms per loop

In [35]: %%timeit
 ...: res = []
 ...: for i in range(len(L) - 1):
 ...: res.append(L[i+1] - L[i])
 ...: 
1 loops, best of 3: 234 ms per loop
</code></pre>

Note that:

<ul>
<li><code>zip(L[1:], L)</code> is equivalent to <code>zip(L[1:], L[:-1])</code> since <code>zip</code> already terminates on the shortest input, however it avoids a whole copy of <code>L</code>.</li>
<li>Accessing the single elements by index is very slow because every index access is a method call in python</li>
<li><code>numpy.diff</code> is slow because it has to first convert the <code>list</code> to a <code>ndarray</code>. Obviously if you start with an <code>ndarray</code> it will be much faster:

<pre><code>In [22]: arr = np.array(L)

In [23]: %timeit np.diff(arr)
100 loops, best of 3: 3.02 ms per loop
</code></pre></li>
</ul>

blocks|key|2746557|text|从Python+3.10开始，使用新的pairwise函数，可以在元素对之间滑动，从而在滚动对上映射：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2746558|from+itertools+import+pairwise

[y-x+for+(x,+y)+in+pairwise([1,+3,+6,+7])]
#+[2,+3,+1]|code-block|syntax|javascript|2746559|2746560|中间结果是：|2746561|pairwise([1,+3,+6,+7])
#+[(1,+3),+(3,+6),+(6,+7)]|2746562|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.10/library/itertools.html?highlight=pairwise#itertools.pairwise^0|1|B|J|8|J|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|16|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|17|8|@]|D|@]|E|$]]|$1|N|3|O|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|Q|$R|$5|S|T|U|E|$V|W]]]]

Starting in <code>Python 3.10</code>, with the new <a href="https://docs.python.org/3.10/library/itertools.html?highlight=pairwise#itertools.pairwise" rel="nofollow noreferrer"><code>pairwise</code></a> function it's possible to slide through pairs of elements and thus map on rolling pairs:
<pre><code>from itertools import pairwise

[y-x for (x, y) in pairwise([1, 3, 6, 7])]
# [2, 3, 1]
</code></pre>
<hr />
The intermediate result being:
<pre><code>pairwise([1, 3, 6, 7])
# [(1, 3), (3, 6), (6, 7)]
</code></pre>

blocks|key|1337574|text|我建议使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1337575|v+=+np.diff(t)|code-block|syntax|javascript|1337576|这篇文章很简单，很容易阅读。|1337577|但是，如果您希望v具有与t相同的长度，那么|offset|length|style|CODE|1337578|v+=+np.diff([t[0]]+%2B+t)+#+for+python+3.x|1337579|或|1337580|v+=+np.diff(t+%2B+[t[-1]])|1337581|仅供参考:此功能仅适用于列表。|1337582|对于numpy数组|1337583|v+=+np.diff(np.append(t[0],+t))|1337584|entityMap^0|0|0|0|8|1|C|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@$K|16|L|17|M|N]|$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|11|$]]

I would suggest using

<pre><code>v = np.diff(t)
</code></pre>

this is simple and easy to read. 

But if you want <code>v</code> to have the same length as <code>t</code> then

<pre><code>v = np.diff([t[0]] + t) # for python 3.x
</code></pre>

or

<pre><code>v = np.diff(t + [t[-1]])
</code></pre>

FYI: this will only work for lists.

for numpy arrays

<pre><code>v = np.diff(np.append(t[0], t))
</code></pre>

blocks|key|187833|text|使用Python+3.8%2B中提供的:=+walrus运算符：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|187834|>>>+t+=+[1,+3,+6]
>>>+prev+=+t[0];+[-prev+%2B+(prev+:=+x)+for+x+in+t[1:]]
[2,+3]|code-block|syntax|javascript|187835|entityMap^0|H|2|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Using the <code>:=</code> walrus operator available in Python 3.8+:

<pre><code>&gt;&gt;&gt; t = [1, 3, 6]
&gt;&gt;&gt; prev = t[0]; [-prev + (prev := x) for x in t[1:]]
[2, 3]
</code></pre>

blocks|key|1337302|text|好的。我想我找到了正确的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1337303|v+=+[x[0]-x[1]+for+x+in+zip(t[1:],t[:-1])]|code-block|syntax|javascript|1337304|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Ok. I think I found the proper solution:
<pre><code>v = [x[0]-x[1] for x in zip(t[1:],t[:-1])]
</code></pre>

blocks|key|2746378|text|函数式方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2746379|>>>+import+operator
>>>+a+=+[1,3,5,7,11,13,17,21]
>>>+map(operator.sub,+a[1:],+a[:-1])
[2,+2,+2,+4,+2,+4,+4]|code-block|syntax|javascript|2746380|使用生成器：|2746381|>>>+import+operator,+itertools
>>>+g1,g2+=+itertools.tee((x*x+for+x+in+xrange(5)),2)
>>>+list(itertools.imap(operator.sub,+itertools.islice(g1,1,None),+g2))
[1,+3,+5,+7]|2746382|使用索引：|2746383|>>>+[a[i%2B1]-a[i]+for+i+in+xrange(len(a)-1)]
[2,+2,+2,+4,+2,+4,+4]|2746384|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

A functional approach:

<pre><code>&gt;&gt;&gt; import operator
&gt;&gt;&gt; a = [1,3,5,7,11,13,17,21]
&gt;&gt;&gt; map(operator.sub, a[1:], a[:-1])
[2, 2, 2, 4, 2, 4, 4]
</code></pre>

Using generator:

<pre><code>&gt;&gt;&gt; import operator, itertools
&gt;&gt;&gt; g1,g2 = itertools.tee((x*x for x in xrange(5)),2)
&gt;&gt;&gt; list(itertools.imap(operator.sub, itertools.islice(g1,1,None), g2))
[1, 3, 5, 7]
</code></pre>

Using indices:

<pre><code>&gt;&gt;&gt; [a[i+1]-a[i] for i in xrange(len(a)-1)]
[2, 2, 2, 4, 2, 4, 4]
</code></pre>

blocks|key|933660|text|我怀疑这就是numpy+diff命令所做的事情，但为了完整起见，您可以简单地对子向量进行区分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|933661|from+numpy+import+array+as+a
a(x[1:])-a(x[:-1])|code-block|syntax|javascript|933662|此外，我想将这些解决方案添加到问题的泛化中：|933663|具有周期边界的解|offset|length|style|BOLD|933664|有时，对于数值积分，您需要使用周期性边界条件对列表进行差分(因此第一个元素计算到最后一个元素的差值。在这种情况下，numpy.roll函数很有用：|933665|v-np.roll(v,1)|933666|为零的解决方案|933667|另一种numpy解决方案(只是为了完整性)是使用|933668|numpy.ediff1d(v)|933669|这与numpy.diff一样工作，但仅对向量起作用(它使输入数组变平)。它提供了在结果向量中添加或附加数字的功能。当处理通常是气象变量(例如，降雨、潜热等)中的通量的累积场时，这是很有用的，因为您需要与输入变量具有相同长度的结果列表，并且第一个条目保持不变。|933670|然后你会写下|933671|np.ediff1d(v,to_begin=v[0])|933672|当然，您也可以使用np.diff命令来执行此操作，在这种情况下，您需要使用prepend关键字在序列前面加上零：|933673|np.diff(v,prepend=0.0)+|933674|上面所有的解决方案都返回一个与输入长度相同的向量。|933675|entityMap|0|LINK|mutability|MUTABLE|url|https://numpy.org/doc/stable/reference/generated/numpy.ediff1d.html?highlight=ediff#numpy.ediff1d^0|0|0|0|7|1|0|0|0|3|4|0|0|O|3|5|0|0|0|0|3L|0|0|6|0|0|0|1K|0|0|0|P|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1K|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1L|8|@$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1Q|8|@$K|1R|L|1S|M|N]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1T|8|@$K|1U|L|1V|M|N]]|9|@$K|1W|L|1X|1|1Y]]|A|$]]|$1|W|3|X|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|20|8|@$K|21|L|22|M|N]]|9|@]|A|$]]|$1|10|3|11|5|6|7|23|8|@$K|24|L|25|M|N]]|9|@]|A|$]]|$1|12|3|13|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|27|8|@$K|28|L|29|M|N]]|9|@]|A|$]]|$1|16|3|17|5|D|7|2A|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|2B|8|@$K|2C|L|2D|M|N]]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]]]

I suspect this is what the numpy diff command does anyway, but just for completeness you can simply difference the sub-vectors:
<pre><code>from numpy import array as a
a(x[1:])-a(x[:-1])
</code></pre>
In addition, I wanted to add these solutions to generalizations of the question:
Solution with periodic boundaries
Sometimes with numerical integration you will want to difference a list with periodic boundary conditions (so the first element calculates the difference to the last. In this case the numpy.roll function is helpful:
<pre><code>v-np.roll(v,1)
</code></pre>
Solutions with zero prepended
Another <a href="https://numpy.org/doc/stable/reference/generated/numpy.ediff1d.html?highlight=ediff#numpy.ediff1d" rel="nofollow noreferrer">numpy</a> solution (just for completeness) is to use
<pre><code>numpy.ediff1d(v)
</code></pre>
This works as numpy.diff, but only on a vector (it flattens the input array). It offers the ability to prepend or append numbers to the resulting vector. This is useful when handling accumulated fields that is often the case fluxes in meteorological variables (e.g. rain, latent heat etc), as you want a resulting list of the same length as the input variable, with the first entry untouched.
Then you would write
<pre><code>np.ediff1d(v,to_begin=v[0])
</code></pre>
Of course, you can also do this with the np.diff command, in this case though you need to prepend zero to the series with the prepend keyword:
<pre><code>np.diff(v,prepend=0.0) 
</code></pre>
All the above solutions return a vector that is the same length as the input.

blocks|key|1337726|text|还可以使用以下命令将差异转换为易于阅读的转换矩阵|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1337727|v+=+t.reshape((c,r)).T+-+t.T|code-block|syntax|javascript|1337728|其中c+=列表中的项数，r+=1，因为列表基本上是一个向量或一维数组。|offset|length|style|CODE|1337729|entityMap^0|0|0|2|1|C|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

You can also convert the difference into an easily readable transition matrix using
<pre><code>v = t.reshape((c,r)).T - t.T
</code></pre>
Where <code>c</code> = number of items in the list and <code>r</code> = 1 since a list is basically a vector or a 1d array.

blocks|key|2746252|text|我的方式|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2746253|>>>v+=+[1,2,3,4,5]
>>>[v[i]+-+v[i-1]+for+i,+value+in+enumerate(v[1:],+1)]
[1,+1,+1,+1]|code-block|syntax|javascript|2746254|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My way

<pre><code>&gt;&gt;&gt;v = [1,2,3,4,5]
&gt;&gt;&gt;[v[i] - v[i-1] for i, value in enumerate(v[1:], 1)]
[1, 1, 1, 1]
</code></pre>

Given a list of numbers, how does one find differences between every (<code>i</code>)-th elements and its (<code>i+1</code>)-th?

Is it better to use a <code>lambda</code> expression or maybe a list comprehension?

For example: 

Given a list <code>t=[1,3,6,...]</code>, the goal is to find a list <code>v=[2,3,...]</code> because <code>3-1=2</code>, <code>6-3=3</code>, etc.

Python: Finding differences between elements of a list

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

给定一个数字列表，如何找到每个(i)-th元素和它的(i+1)-th之间的差异？使用lambda表达式还是使用列表理解更好？例如：给定一个列表t=[1,3,6,...]，目标是找到一个列表v=[2,3,...]，因为3-1=2、6-3=3等。

问Python:查找列表元素之间的差异
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python:查找列表元素之间的差异EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python:查找列表元素之间的差异
EN