我有以下数据框-df：
crs Band1 level
lat lon
34.595694 32.929028 b'' 4.000000e+00 1000
32.937361 b'' 1.200000e+01 950
32.945694 b'' 2.900000e+01 925
34.604028 32.929028 b'' 7.000000e+00 1000
32.937361 b'' 1.300000e+01 950
... ... ...
71.179028 25.679028 b'' 6.000000e+01 750
71.187361 25.662361 b'' 1.000000e+00 725
25.670694 b'' 6.000000e+01 1000
25.679028 b'' 4.000000e+01 800
71.529028 19.387361 b'' 1.843913e-38 1000
[17671817 rows x 3 columns]
和两个数组：
lon1=np.arange(-11,47,0.25)
lat1=np.arange(71.5,34.5,-0.25)
这两个数组（lat1和lon1）产生的坐标对间隔为0.25度。
数据帧df包含点（lat和lon），这些点在lon1和lat1数组定义的点内密集间隔。我想做的是：
df，lat1定义的点开始，在0.125度以内找到（过滤）lon1中的所有点max的{{1}}和min值，并将它们存储在与level和lon1相同大小的单独数组中。到目前为止，我所做的是过滤数据框：
lat1但是它的性能非常慢。我相信有一个更快的。 我也已经标记了scikit-learn，因为它可能可以完成，但是我对此打包软件缺乏经验。 可以得到任何帮助。
答案 0 :(得分：4)
在开始之前，让我们将您的垃圾箱转换为每个垃圾箱的起始位置，而不是中心位置：
lon1=np.arange(-11.125,47.125,0.25)
lat1=np.arange(71.625,34.125,-0.25)
为每行分配纬度和经度容器（请注意lat1的相反顺序，否则您需要将ordered=False传递给pd.cut()）。
df['latcat'] = pd.cut(df.index.get_level_values(0), lat1[::-1])
df['loncat'] = pd.cut(df.index.get_level_values(1), lon1)
对于您的示例数据，我们现在有：
crs Band1 level latcat loncat
lat lon
34.595694 32.929028 b'' 4.000000e+00 1000 (34.375, 34.625] (32.875, 33.125]
32.937361 b'' 1.200000e+01 950 (34.375, 34.625] (32.875, 33.125]
32.945694 b'' 2.900000e+01 925 (34.375, 34.625] (32.875, 33.125]
34.604028 32.929028 b'' 7.000000e+00 1000 (34.375, 34.625] (32.875, 33.125]
32.937361 b'' 1.300000e+01 950 (34.375, 34.625] (32.875, 33.125]
71.179028 25.679028 b'' 6.000000e+01 750 (71.125, 71.375] (25.625, 25.875]
71.187361 25.662361 b'' 1.000000e+00 725 (71.125, 71.375] (25.625, 25.875]
25.670694 b'' 6.000000e+01 1000 (71.125, 71.375] (25.625, 25.875]
25.679028 b'' 4.000000e+01 800 (71.125, 71.375] (25.625, 25.875]
71.529028 19.387361 b'' 1.843913e-38 1000 (71.375, 71.625] (19.375, 19.625]
现在使用groupby获取每个区域的最低和最高水平：
res = df.groupby([df.latcat.cat.codes, df.loncat.cat.codes])['level'].agg(['min', 'max'])
哪个给你：
min max
0 176 925 1000
147 147 725 1000
148 122 1000 1000
索引的第一级是反向lat1数组中的位置，其中-1表示“超出范围”，您的某些示例数据在其中。第二层是lon1数组中的位置。
要根据要求转换为矩阵：
minlevel = np.full((len(lat1), len(lon1)), np.nan)
maxlevel = np.full((len(lat1), len(lon1)), np.nan)
x = len(lat1) - res.index.get_level_values(0) - 1 # reverse to original order
y = res.index.get_level_values(1)
minlevel[x, y] = res['min']
maxlevel[x, y] = res['max']
答案 1 :(得分：1)
首先让我们回顾一下您的解决方案：对于lon1中的每个值和lat1中的每个值（如果大小为n，则为n ^ 2迭代），您尝试过滤数据帧，从而扫描了整个df：您的代码在数据帧中运行了n ^ 2次，效率很低。
我的解决方案只需要扫描数据帧一次，并且每次扫描都执行n次操作。它使用的pandas apply函数不是很有效，但是没有它，我找不到方法。我很想听听不使用Apply即可过滤的解决方案。
我使用了一个可重现的小示例，您可能需要调整索引以使其与您的代码匹配。我相信这个示例更容易理解。
import pandas as pd
import numpy as np
df = pd.DataFrame({"lat":[22.5, 10.76, 7.341, 22.5], "log":[3.64, 7.234, 135, 3.644], "level":[2, 8, 19, 9]})
lat1 = np.array([22.51, 7.33])
lon1 = np.array([3.6, 135.02])
接下来的几行创建一个元组列表，每个元组包含一个pandas.Interval对象。这里的元组表示（lat1 [i] +-x，lon1 [i] +-x）。注意，我不必使用pandas.Interval-我可以构建另一个元组（lat1 [i] -x，lat1 [i] + x）。但是我决定与大熊猫间隔走，真的没关系。
结果：对于每对[lat1，lon1]，我们有两个熊猫间隔的元组，每个为+ -0.125
interval_list = []
const_add = 0.125
for i, item in enumerate(lat1):
interval_list.append((pd.Interval(left=lat1[i]-const_add, right=lat1[i]+const_add),pd.Interval(left=lon1[i]-const_add, right=lon1[i]+const_add)))
现在，我们要过滤数据帧。为了使用apply，我创建了一个自定义函数：它检查当前行是否在元组中，如果是，则返回lat1数组中的索引（您将在后面看到为什么有用）
def within_range(row, interval_list):
for i, item in enumerate(interval_list):
if row[0] in item[0] and row[1] in item[1]:
return i
return np.nan
df["point"] = df.apply(lambda x: within_range(x, interval_list), axis=1)
在代码的那一点上，我们有一个列名“ point”。它的值如下：如果该行靠近点i（其中i是lat1 [i]和lon1 [i]中的索引），则该值为i。如果没有闭合点，则值为nan。
现在剩下的就是找到每个点的最大值和最小值，可以使用groupby轻松实现：
max_series = df.groupby(by="point")["level"].max()
min_series = df.groupby(by="point")["level"].min()
您有两个系列，其索引与lat1和lon [1]中的索引相同。您可以使用Series.array轻松地将它们转换为数组。
值得一提的是，您没有说过如何处理缺失值-如果df中没有点接近点（lat1 [50]，lon1 [50]），那么最大值和最小值数组中的值是多少？这就是为什么我将其保留为系列，我相信在将其更改为数组之前更容易进行操作。
整个代码在一起：
import pandas as pd
import numpy as np
df = pd.DataFrame({"lat":[22.5, 10.76, 7.341, 22.5], "log":[3.64, 7.234, 135, 3.644], "level":[2, 8, 19, 9]})
lat1 = np.array([22.51, 7.33])
lon1 = np.array([3.6, 135.02])
interval_list = []
const_add = 0.125
for i, item in enumerate(lat1):
interval_list.append((pd.Interval(left=lat1[i]-const_add, right=lat1[i]+const_add),pd.Interval(left=lon1[i]-const_add, right=lon1[i]+const_add)))
def within_range(row, interval_list):
for i, item in enumerate(interval_list):
if row[0] in item[0] and row[1] in item[1]:
return i
return np.nan
df["point"] = df.apply(lambda x: within_range(x, interval_list), axis=1)
max_arr = df.groupby(by="point")["level"].max()
min_arr = df.groupby(by="point")["level"].min()
# or:
# max_arr = df.groupby(by="point")["level"].max().array
答案 2 :(得分：1)
我使用了this中描述的技巧来有效地获取与1D中bin相对应的索引，然后遍历lon和lat的组以获取两者的交集。
我在这里使用numpy，但不直接应用min / max，而是专注于索引。
import numpy as np
from scipy.sparse import csr_matrix
def digitize_group(x, bins):
idx_x = np.digitize(x, bins)
n, m = len(x), len(bins) + 1
s = csr_matrix((np.arange(n), [idx_x, np.arange(n)]), shape=(m, n))
return [group for group in np.split(s.data, s.indptr[1:-1])]
# Create dummy data
n = 100000 # 17671817
step = 0.25 # Note the shift by step/2 to transform your arrays to bins
bins_lon = np.arange(-11-step/2, 47+step/2, step)
bins_lat = np.arange(71.5+step/2, 34.5-step/2, -step)
lon = np.random.uniform(low=bins_lon.min(), high=bins_lon.max(), size=n)
lat = np.random.uniform(low=bins_lat.min(), high=bins_lat.max(), size=n)
# Get the 1D groups
group_lon = digitize_group(lon, bins_lon)
group_lat = digitize_group(lat, bins_lat)
# Combine to 2D groups
group_lonlat = np.zeros((len(group_lon), len(group_lat)), dtype=object)
for i, lo in enumerate(group_lon):
for j, la in enumerate(group_lat):
group_lonlat[i, j] = np.intersect1d(lo, la, assume_unique=True)
print(group_lonlat[13, 17])
# array([ 15606, 131039, 168479, 171734, 174281, 266717, ....
通过访问group_lonlat[i, j]，您可以获得索引K的列表，其中每个元素k都满足：
bins_lon[i] < lon[k] < bins_lon[i+1] & bins_lat[j] < lat[k] < bins_lat[j+1]
通过这些索引，您可以访问数据框并执行所有进一步的计算。
我的一台笔记本电脑花了180s来计算n=17671817的索引。
这种方法的一个瓶颈是交点搜索的次优处理。
sortednp承诺在这里比numpy更好。对于大型n，删除使用的索引以加快搜索速度会更有效。
import sortednp as snp
for i in range(len(group_lon)):
for j in range(len(group_lat)):
group_lonlat[i, j], (ii, jj) = snp.intersect(group_lon[i], group_lat[j],
indices=True)
group_lon[i] = np.delete(group_lon[i], ii)
group_lat[j] = np.delete(group_lat[j], jj)
这使20s的{{1}}和n=17671817的{{1}}下降。