厉害

不客气。我很久没鼓捣过这玩意儿了，我记得 numba 的各路 jit 处理这个问题是很嗨的，你要是经常遇到这种问题，去看看 numba 吧，有 GPU 加速更开心 ^_^

In [1]: from numba import guvectorize, float64

In [2]: a = np.random.random((100000,2,2))

In [3]: b = np.random.random((100000,2,2))

In [4]: c = np.matmul(a, b)

In [5]: d = np.array([np.dot(i,j) for i,j in zip(a,b)])

In [6]: @guvectorize([(float64[:,:],float64[:,:], float64[:,:])], '(n,m),(m,n)->(n,n)', target='parallel') #target='cpu','gpu'
...: def mydot(a,b,res):
...: for i in range(res.shape[0]):
...: for j in range(res.shape[1]):
...: tmp = 0.
...: for k in range(a.shape[1]):
...: tmp += a[i, k] * b[k, j]
...: res[i, j] = tmp
...:

In [7]: e = mydot(a, b)

In [8]: np.allclose(c,e)
Out[8]: True

In [9]: np.allclose(c,d)
Out[9]: True

In [10]: %timeit mydot(a,b)
234 µs ± 4.02 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [11]: %timeit np.array(list(map(np.dot, a, b)))
210 ms ± 2.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [12]: %timeit np.array([np.dot(i,j) for i, j in zip(a,b)])
235 ms ± 5.87 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [13]: %timeit np.matmul(a,b)
41.1 ms ± 90 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

加上 vectorize 的：

In [28]: def mydot(a, b):
...: return np.dot(a,b)
...:
...:

In [29]:

In [29]: vmydot = np.vectorize(mydot, signature='(n,m),(m,n)->(n,n)')

In [30]: e = vmydot(a, b)

In [31]: np.allclose(d,e)
Out[31]: True

In [32]: %timeit vmydot(a,b)
467 ms ± 4.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

matmul(...)
matmul(a, b, out=None)

Matrix product of two arrays.

The behavior depends on the arguments in the following way.

- If both arguments are 2-D they are multiplied like conventional
matrices.
- If either argument is N-D, N > 2, it is treated as a stack of
matrices residing in the last two indexes and broadcast accordingly.
...

所以 np.matmul(m1, m2) 就行了。

In [1]: a = np.random.random((100000,2,2))

In [2]: b = np.random.random((100000,2,2))

In [3]: c = np.matmul(a, b)

In [4]: d = np.array([np.dot(i,j) for i,j in zip(a,b)])

In [5]: np.allclose(c,d)
Out[5]: True

In [6]: %timeit np.matmul(a,b)
41.1 ms ± 81.6 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [7]: %timeit np.array([np.dot(i,j) for i, j in zip(a,b)])
231 ms ± 5.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

不过 histogram 函数应该可以…… histogram(time, bins=xxx, range=(xx, xx), weights=data)，调整好 range 和 bins 就可以了吧。

我说错了……这个不叫 histogram …… 我的意思就是按天把数据加起来……横轴的时间就变成天，这样可以降低条数，但保留趋势

histogram? 比如按天 histogram 然后输出就成了每天数据的总和

newton mail

1. 循环列表，构建一个 hashtable, 初始 T[item] = 0;
2. 循环列表，T[item] += 1
3. 按值排序 T, 方法具体找找 stackoverflow

现用 XZ2，感觉挺好的，流畅，不怎么发热，我不怎么玩儿手机所以待机时间也不错。

锻炼，跑起来。不想跑步找人打球，拼个输赢的运动还是很 high 的

xbox1x

布地奈德喷剂和生理盐水洗鼻子。不严重的话大约 15 天能好。

21 天精通 C++
21 天精通 Java
21 天精通 PHP
21 天精通 C 语言
21 天精通素描
21 天精通攻防策略

要是读数据的话可以试试 pandas
import pandas as pd
f = pd.read_csv(<file_name>, chunksize =10000, ...)
更多参数看 https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html
然后
for chunk in f:
do_sth(chunk)

EDIT:
1. [ (i, j) for i,x in enumerate(a) for j,y in enumerate(a) if i<j and x + y == target ]
2. [ idxes for idxes in ( (i, binary_search(a, target - x, i+1, n-1) ) for i, x in enumerate(a) ) if idxes[1] != -1 ]


def binary_search(arr, hkey, start, end):
....while start <= end:
........mid = start + (end - start) // 2
........if arr[mid] < hkey:
............start = mid + 1
........elif arr[mid] > hkey:
............end = mid - 1
........else:
............return mid
....return -1

假定数组是 a，长度是 n, [ (i, j) for i,x in enumerate(a) for j,y in enumerate(a) if x + y == target and i<j ] 比较直观，复杂度是 O(n^2)，大致看了下，至少你的 a!=i 就不允许列表中出现重复元素；并且最后也少放了另一个元素 a 的标号在结果里。

第二个就是用 binary_search，当然，假定你的数组 a 是排好序的：

[ idxes for idxes in ( (i, binary_search(target - x, i+1, n)) for i, x in enumerate(a) ) if idxes[1] != -1 ]，比如用楼上那个失败返回 -1 的 binary_search，这样是 O(nlog(n))