thinkpad x1c ？好像有 4k/2k ，都是集显，i7-1185G7

@acone2003 新年快乐！
会，这个是我脑残……这个方法大概就是暴力循环
for f in features:
....for val in f:
........for l, r, val
这样，使用 numpy 的索引大概是这个计算量（按大小判定）的两倍，但是 numpy 的各种操作非常快。我觉得这个问题可以通过边界问题搞定，例如 NBins = [a.min(), 0.3, ...., np.inf]，然后 vals 减掉一个值 V ，使所有的 vals 都小于 a.min()，即 vals-V < a.min()，然后替换完以后 a = a+V ，这个方法在数组大了以后会比循环快一些，小数组和循环没啥区别。

不过根据索引也许有个简单的方法，但是 binsize 如果非常不均匀可能需要非常小的 binsize ，你这个箱体 binsize=0.1 是刚好的，先令 NBins=np.array([0.3, ...7.6])，我觉得所以
a = np.asarray(a/binsize, dtype=np.int64)
然后生成新的 NBins:
nvals = np.diff(np.array(NBins/binsize, dtype=np.int64), prepend=0))
r = np.concatenate([ [val] * n for val, n in zip(vals, nvals)])
这里 r 会生成 2 个 3.5 ，52 个 7.8,...
然后处理边界
a[a<int(NBins[0]/0.1)] = len(r)
a[a>int(NBins[-1]/0.1)] = len(r)+1
r = np.append(r, left_bound_val)
r = np.append(r, right_bound_val)
然后 r[a] 就是结果。这样的计算量是最小的。不过需要注意两点，一是 NBins 里的值不总大于 0 ，二是很小 binsize 以及变化很急剧的 NBins 会导致一个巨长的数组 r ，也会很麻烦。不过这些可以通过线性变换你的样本和 NBins 一类的方法解决，就看具体情况了。

可以给 NBins 加上左边界然后用 for:
vals = [3.5, 7.8, ...]
NBins = [-np.inf, 0.3, 5.4..., np.inf]
for l, r, val in zip(NBins[:-1], NBins[1:], vals):
....a[np.logical_and(a > l, a< r)] = val

用 numpy.array (pandas.DataFrame)?
a[a<0.3] =3.5
a[np.logical_and(a < 5.4, a > 0.3)] = 7.8

@spongebobsun ipad 有蜂窝版，不过确实不能打电话收短信，但是流量卡微信是可以随时打接的吧。不过具体还是要看老人使用，如果碰到到处弹广告的应用大多数老人是真处理不好。这点苹果还是省心。

ipad 吧，省很多麻烦。老年人的话 android 产品很容易搞很多广告以及莫名其妙安装一堆 app

……能 tm 删帖就好了，我是傻逼……

对不起我还在脑残中……按照你的思路：
def test(a):
....a = a - np.diag(np.ones(a.shape[0])) # 主元不参与比较
....ind = np.sum(a >= 0.5, axis=0) # 每个节点大于 0.5 的计数
....g = a >= 0.5 # 节点对是否大于 0.5
....drops = []
....while (ind > 0).any():
........i_drop = np.argmax(ind)
........ind = ind - g[i_drop] # 剩下计数减掉被删掉的节点（大于 0.5 则-1 ，否则-0 ）
........ind[i_drop] = -1 # 每次删掉计数最大的
........drops.append(i_drop)
....ret = np.delete(a, drops, axis=0)
....ret = np.delete(ret, drops, axis=1)
....return ret, drops
这个很快。几万也行。

更正一下，这个对节点数好像是 O(N^3)，很蠢了……4000 节点需要 36s ，10000 节点应该是 560s ，2 万节点就得一小时+，几万节点的话可能还是不合适。

按照楼主的思路：
ret = a - np.diag(np.ones(a.shape[0])) # 主元不参与比较
drops = []
idx = np.arange(a.shape[0])
while (ret>=0.5).any():
....i_drop = np.argmax(np.sum(ret > 0.5, axis=0))
....drops.append(idx[i_drop])
....ret = np.delete(ret, i_drop, axis=0)
....ret = np.delete(ret, i_drop, axis=1)
....idx = np.delete(idx, i_drop)
抱歉，应该换算一下 index ，这样 drops 最后给出的就是应该被删除的元素编号，ret 最后是一个都小于 0.5 的矩阵。

按照楼主的思路：
ret = a - np.diag(np.ones(a.shape[0])) # 主元不参与比较
drops = []
while (ret>=0.5).any():
....i_drop = np.argmax(np.sum(ret > 0.5, axis=0))
....drops.append(i_drop)
....ret = np.delete(ret, i_drop, axis=0)
....ret = np.delete(ret, i_drop, axis=1)
我试了试 10000x10000 的随机数组，粗略估计一下可能需要 4000s+，但 1000x1000 还是挺快的，大约 0.5s ，也就是能容纳 10^3 的节点数，几万个节点估计还是扯淡

看你还有后续需求的样子……试试 mpi4py ？

一般就叫 Links 吧

试试坚果云？

矩阵分块

|A B| |E F| = | AE+BG AF +BH|
|C D| |G H| |CE+DG CF+DH|

@xiaowei0823 中枪

@ftu 虾仁猪心←_←