说我有一个这样的列表:
[1, 4, None, 6, 9, None, 3, 9, 4 ]
我决定将其拆分为嵌套列表None,以获得:
[ [ 1, 4 ], [ 6, 9 ], [ 3, 9, 4 ] ]
当然,我可能想要这样做,(9, None)在这种情况下,我们会得到:
[ [ 1, 4 ], [ 6 ], [ 3 ], [ 4 ] ]
通过迭代使用列表追加(在for循环中)这是微不足道的
我很想知道这是否可以更快地完成 - 比如列表理解？
如果没有,为什么不(例如,列表推导每次迭代不能返回多个列表元素？)
我有一个列表列表,如我附上的代码.如果有任何常见值,我想链接每个子列表.然后,我想用列表的精简列表替换列表列表.示例: 如果我有一个[[1,2,3],[3,4]]我想要的列表[1,2,3,4].如果我有[[4,3],[1,2,3]]我想要的[4,3,1,2].如果我有[[1,2,3],[a,b],[3,4],[b,c]]我想要[[1,2,3,4],[a,b,c]]或者[[a,b,c],[1,2,3,4]]我不在乎哪一个.
我几乎在那里......
我的问题是,当我有一个像[[1,2,3],[10,5],[3,8,5]]我想要的情况,[1,2,3,10,5,8]但我得到了我当前的代码[1,2,3,8,10,5]
这是我的代码:
import itertools
a = [1,2,3]
b = [3,4]
i = [21,22]
c = [88,7,8]
e = [5,4]
d = [3, 50]
f = [8,9]
g= [9,10]
h = [20,21]
lst = [a,b,c,i,e,d,f,g,h,a,c,i]*1000
#I have a lot of list but not very many different lists
def any_overlap(a, b):
sb = set(b)
return any(itertools.imap(sb.__contains__, a))
def find_uniq(lst): …目标是将有时包含缺失记录的嵌套列表转换为数据框.缺少记录时的结构示例如下:
str(mylist)
List of 3
$ :List of 7
..$ Hit : chr "True"
..$ Project: chr "Blue"
..$ Year : chr "2011"
..$ Rating : chr "4"
..$ Launch : chr "26 Jan 2012"
..$ ID : chr "19"
..$ Dept : chr "1, 2, 4"
$ :List of 2
..$ Hit : chr "False"
..$ Error: chr "Record not found"
$ :List of 7
..$ Hit : chr "True"
..$ Project: chr "Green"
..$ Year : chr "2004" …好的,让我用一个简单的例子来解释这个问题:
l = [[0]]*3 # makes the array [[0], [0], [0]]
l[0][0] = 42 # l becomes [[42], [42], [42]]
from copy import deepcopy
m = deepcopy(l) # m becomes [[42], [42], [42]]
m[0][0] = 2 # m becomes [[2], [2], [2]]
这是一个基本的共享参考问题.除了通常情况,当发生这样的问题时,deepcopy我们的朋友.目前,我这样做是为了解决我的deepcopy背叛问题:
l = [[0]]*3 # makes the array [[0], [0], [0]]
import JSON
m = JSON.loads(JSON.dumps(l)) # m becomes [[0], [0], [0]] with no self references
我正在寻找一种效率较低且不那么愚蠢的处理自共享引用的方法.
当然我不会故意制作这样的数组,但是我需要处理有人给我的代码一个的情况.在大型阵列上运行我的"解决方案"很慢,而且我有很多级别的嵌套数组,我不能为这些野兽制作这么大的字符串.
想象一下,你有一个简单的矩阵类
template <typename T = double>
class Matrix {
T* data;
size_t row, col;
public:
Matrix(size_t m, size_t n) : row(m), col(n), data(new T[m*n]) {}
//...
friend std::ostream& operator<<(std::ostream& os, const Matrix& m) {
for (int i=0; i<m.row; ++i) {
for (int j=0; j<m.col; ++j)
os<<" "<<m.data[i + j*m.row];
os<<endl;
}
return os;
}
};
有没有办法用初始化列表初始化这个矩阵？我的意思是从初始化列表中获取矩阵和元素的大小.类似下面的代码:
Matrix m = { {1., 3., 4.}, {2., 6, 2.}};
会打印
1 3 4
2 6 2
期待您的回答.谢谢你们.AA
编辑
所以我研究了你的建议来制作一个使用初始化列表初始化元素的通用数组.但这是我能获得的最通用的.如果你们中的任何人有任何建议可以使它成为一个更通用的课程,我将不胜感激.还有几个问题:
我需要访问 a 的第一个元素list。问题在于列表的嵌套深度不同。这是一个例子：
list1 <- list(ts(1:100),
list(1:19,
factor(letters)))
list2 <- list(list(list(ts(1:100), data.frame(a= rnorm(100))),
matrix(rnorm(10))),
NA)
我的预期输出是获取ts(1:100)两个列表的时间序列，即list1[[1]]和list2[[1]][[1]][[1]]。我尝试过不同的东西，其中包括lapply(list2, `[[`, 1)，这里不起作用。
我正在尝试编写一个函数,添加两个矩阵来传递以下doctests:
>>> a = [[1, 2], [3, 4]]
>>> b = [[2, 2], [2, 2]]
>>> add_matrices(a, b)
[[3, 4], [5, 6]]
>>> c = [[8, 2], [3, 4], [5, 7]]
>>> d = [[3, 2], [9, 2], [10, 12]]
>>> add_matrices(c, d)
[[11, 4], [12, 6], [15, 19]]
所以我写了一个函数:
def add(x, y):
return x + y
然后我写了以下函数:
def add_matrices(c, d):
for i in range(len(c)):
print map(add, c[i], d[i])
我排序的得到正确的答案.
我有一个嵌套列表,如下所示:
List<Hotel> Hotels;
public class Hotel
{
List<RoomType> RoomType;
}
public class RoomType
{
Room Room;
}
public class Room
{
int RoomId;
}
这有点令人费解,抱歉想不出一个更好的模型模型.我的想法是,我有很多酒店,每个酒店都有很多房型,并假设每个房型都有一个房间对象.
现在从酒店列表,我只想选择所有RoomId的..我被困在这里,同时试图嵌套所有列表..
现在,我正在尝试这个:
//cant do this some invalid error
int[] AllRoomIds = Hotels.selectMany(x => x.Rooms)
.selectMany(y => y.RoomType.Room.Id).Distinct().ToArray()
//cant do this - z doesnt have anything
int[] AllRoomIds = Hotels.selectMany(x => x.Rooms)
.selectMany(y => y.RoomType)
.select(z => z.
我该怎么办？
访问嵌套列表中所有项目的所有ID ...偶尔会抱怨,cannot convert int to boolean我不知道这意味着什么......
谢谢..希望这个问题是可以理解的
我的输入包含一个嵌套列表列表,如下所示:
l = [[[[[39]]]], [1, 2, 3], [4, [5, 3], 1], [[[[8, 9], 10], 11], 12]]
我想根据嵌套列表中所有数字的总和对此列表进行排序...因此,我想要按l排序的值将如下所示:
[39, 6, 13, 50]
然后我想根据这些进行排序.所以输出应该是:
[[1, 2, 3], [4, [5, 3], 1], [[[[39]]]], [[[[8, 9], 10], 11], 12]]
这样做有什么好的pythonic方式？
给定一个任意大小的任意深度嵌套列表的列表,我想在树中的所有元素上使用一个平坦的,深度优先的迭代器,但是路径指示也是如此:
for x, y in flatten(L), x == L[y[0]][y[1]]...[y[-1]].
那是
L = [[[1, 2, 3], [4, 5]], [6], [7,[8,9]], 10]
flatten(L)
应该产量:
(1, (0, 0, 0)),
(2, (0, 0, 1)),
(3, (0, 0, 2)),
(4, (0, 1, 0)),
(5, (0, 1, 1)),
(6, (1, 0)),
(7, (2, 0)),
(8, (2, 1, 0)),
(9, (2, 1, 1)),
(10, (3,))
我使用带yield语句的生成器为此做了一个递归实现:
def flatten(l):
for i, e in enumerate(l):
try:
for x, y in flatten(e):
yield x, (i,) + y
except: …