相关疑难解决方法(0)

实现cumsum的优雅和pythonic方式是什么？
或者 - 如果已经有一种内置的方式来做,那当然会更好......

我知道如何将列表拆分成偶数组,但我无法将其拆分为不均匀的组.

基本上这就是我所拥有的:一些列表,我们称之为mylist包含x元素的列表.

我还有另一个文件,我们称之为second_list,看起来像这样:

{2, 4, 5, 9, etc.}

现在我想做的是mylist通过second_list中的间距划分为不均匀的组.所以,我希望我的第一组成为前两个元素mylist,第二组成为接下来的4个元素mylist,第三组成为接下来的5个元素mylist,第四组成为下一个9元素的"mylist",等等.

有一些简单的方法来做到这一点？如果你想将它分成偶数组,我尝试做类似的事情:

for j in range(0, len(second_list)):
    for i in range(0, len(mylist), second_list[j]):
        chunk_mylist = mylist[i:i+second_list[j]]

然而,这不会像我想要的那样分裂它.我想用我的#子列表是的,结束了len(second_list),也正常分裂,这给比这更大量的(也是分裂不正确地).

你可以帮助我使用返回文本文件中部分数字总和的代码吗？我必须导入文本文件,然后在没有工具的情况下为部分总和制作代码..等等.

我的意见:

4
13
23
21
11

输出应该是(没有括号或逗号):

4 
17
40
61 
72

我试图在python中创建代码,但只能做总和而不是部分.如果我使用+=运算符生成器,​​它会给我一个错误!

在Python中，如果我想使用显式函数式编程来总结一个列表，我可以这样做

>>> import operator
>>> reduce(operator.add, [3, -1, 2])
4

Mathematica 比 Python 更接近纯函数式语言，将其称为Fold而不是reduce，但结果是相同的。

In[1]:= Fold[Plus, {3, -1, 2}]
Out[1]= 4

所以现在，在 Mathematica 中，如果我想在迭代过程中的每一步获得“折叠”的结果，我可以使用函数FoldList。

In[2]:= FoldList[Plus, {3, -1, 2}]
Out[2]= {3, 2, 4}

如何在 Python 中获取这样的列表（或者最好是迭代器）？一般来说，这个函数操作有名字吗？

我有一个旧列表,我想将每个元素总结为一个新列表:

    lst_old = [1, 2, 3, 4, 5]
    lst_new = [1, 3, 6, 10, 15]

有没有一种优雅的方法在Python 3中使用短代码和快速代码实现它？除了sum()打印最后一个元素,我无法找到适合我的问题的解决方案.

我有一个 int 元素列表。

我想将该列表更改为斐波那契数列序列。

data = [1,0,2,4,5]
output_data = [1,1,3,7,12]

鉴于以下列表:

a=[1,2,3]

我想生成一个新列表,其中每个数字是它和它之前的值的总和,如下所示:

result = [1,3,6]

逻辑:

1没有先前的值,所以它保持不变.

3是从第一个值(1)加到列表中的第二个数字的值(2)

6是来自前两个元素的1和2的总和,加上3的第三个值.

提前致谢!

我正在研究实验数据,我将温度曲线从45°C创建到5°C,然后再创建到45°C.绘制数据得到一个循环,因为记录从45°C冷却到5°C并从5°C加热到45°C.但由于我需要按照时间顺序显示每个温度需要独特的情节.

图像显示了我需要的视觉解释.

因此,我所做的是使用numpys"diff"函数从每个连续的温度区间获得差异.到现在为止还挺好.现在为了制作一个有用的图,我需要以某种方式创建一个新的列表,其中每个项目都是之前的总和.

我正在寻找的一个小例子:

my_list = [1,2,5,1,4,2,3]
#some operation
result_list = [1,3,8,9,13,15,18]

如果有人知道如何做到这一点,或者有更聪明的想法如何完成工作,那将会很棒!

我有一个清单，[0, 1, 2, 3, 4, 5, 6]并总结了各个部分，以便：

l = [0, 1, 2, 3, 4, 5, 6] -> 21

l = [1, 2, 3, 4, 5, 6] -> 21

l = [2, 3, 4, 5, 6] -> 20

l = [3, 4, 5, 6] -> 18

l = [4, 5, 6] -> 15

l = [5, 6] -> 11

l = [6] -> 6

l = [] -> 0

因此，我得到了列表各部分的相应总和： [21, 21, 20, 18, 15, 11, 6, 0]

我使用的代码是： …

假设我们有以下列表

lst = [3,6,1,4]

我希望能够从此列表中获得以下结果

result = [4, 10, 11, 15]

计算模式如下：

1 + 3 = 4

1 + 3 + 6 = 10

1 + 3 + 6 + 1 = 11

1 + 3 + 6 + 1 + 4 = 15

换句话说，结果是1加上输入数组的累加和。

如何定义一种可以解决此问题的功能？

L = [('key1', 14), ('key2', 20), ('key3', 13), ('key4', 10), ('key5', 11)]

假设我得到了list如上所述.每个元组的第二个元素在概念上表示块存储器的大小.这些块存储器是相邻的和顺序的.他们的关系可以表示为:

0 ____ 14 ____ 14 + 20 14 ____ + 20 + 13 14 ____ + 20 + 13 + 10 14 ____ + 20 + 13 + 10 + 11

现在用户将给我'绝对地址',我应该给他一个密钥来解密整个内存块.例如,如果他想访问地址'10',那么我应该为他返回key1.如果他想访问'15',那么我应该返回key2.

我的实现现在必须每次都从头开始搜索.实际上,有许多内存块,用户希望一直访问.表现不好.

L = [('key1', 14), ('key2', 20), ('key3', 13), ('key4', 10), ('key5', 11)]
def get_key(address):
    c = 0
    offset = 0
    for i in L:
        if address < i[1] + offset:
            break
        c …

如何使用列表推导获得此列表的累积总和:

list_comp=[1,4,9,16] 

这是我尝试过的,但它会打印列表中每个项目的两倍

print([x+x for x in list_comp])

我希望结果是:list_comp = [1,5,14,30]但是我得到了这个:

>> [2, 8, 18, 32]