相关疑难解决方法(0)

以下代码

import numpy as np
import itertools

a_p1 = np.arange(0, 4, 1)
a_p2 = np.arange(20, 25, 1)

params = itertools.product(a_p1, a_p2)
for (p1, p2) in params:
    print(p1, p2)

输出

(0, 20) (0, 21) (0, 22) (0, 23) (0, 24) (1, 20) (1, 21) (1, 22) (1, 23) (1, 24) (2, 20) (2, 21) (2, 22) (2, 23) (2, 24) (3, 20) (3, 21) (3, 22) (3, 23) (3, 24)

2嵌套for循环也可以输出相同的结果

for i, p1 in enumerate(a_p1):
    for j, p2 in enumerate(a_p2): …

在 Python 中绘制 3d 数组的最有效方法是什么？

例如：

volume = np.random.rand(512, 512, 512)

其中数组项表示每个像素的灰度颜色。

以下代码运行速度太慢：

import matplotlib as mpl
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.gca(projection='3d')
volume = np.random.rand(20, 20, 20)
for x in range(len(volume[:, 0, 0])):
    for y in range(len(volume[0, :, 0])):
        for z in range(len(volume[0, 0, :])):
            ax.scatter(x, y, z, c = tuple([volume[x, y, z], volume[x, y, z], volume[x, y, z], 1]))
plt.show()

我有一个多维numpy数组，试图将其粘贴到熊猫数据框中。我想展平数组，并创建一个反映预展平数组索引的熊猫索引。

请注意，我使用3D来缩小示例，但我想将其推广到至少4D

A = np.random.rand(2,3,4)
array([[[ 0.43793885,  0.40078139,  0.48078691,  0.05334248],
    [ 0.76331509,  0.82514441,  0.86169078,  0.86496111],
    [ 0.75572665,  0.80860943,  0.79995337,  0.63123724]],

   [[ 0.20648946,  0.57042315,  0.71777265,  0.34155005],
    [ 0.30843717,  0.39381407,  0.12623462,  0.93481552],
    [ 0.3267771 ,  0.64097038,  0.30405215,  0.57726629]]])

df = pd.DataFrame(A.flatten())

我正在尝试生成像这样的x / y / z列：

           A  z  y  x
0   0.437939  0  0  0
1   0.400781  0  0  1
2   0.480787  0  0  2
3   0.053342  0  0  3
4   0.763315  0  1  0
5   0.825144  0  1  1
6   0.861691 …

有没有更好的方法在 numpy 中使用 FOR 循环创建多维数组，而不是创建列表？这是我能想到的唯一方法：

import numpy as np

a = []
for x in range(1,6):
    for y in range(1,6):
        a.append([x,y])
a = np.array(a)
print(f'Type(a) = {type(a)}.  a = {a}')

编辑：我尝试做这样的事情：

a = np.array([range(1,6),range(1,6)])
a.shape = (5,2)
print(f'Type(a) = {type(a)}.  a = {a}')

但是，输出并不相同。我确信我错过了一些基本的东西。

在Numpy中有一种简单的方法可以从2个1D numpy数组(向量)生成一组数字对,而不需要循环吗？

输入:

a = [1, 2, 3]
b = [4, 5, 6]

输出:

c = [(1,4), (1,5), (1,6), (2,4), (3,5), (2,6), (3,4), (3,5), (3,6)]

我想知道是否有一个功能类似于此:

c = []
for i in range(len(a)):
    for j in range(len(b)):
        c.append((a[i], b[j]))

我希望生成相对大量阵列的笛卡尔积,以跨越高维网格.由于高维度,不可能将笛卡尔积计算的结果存储在存储器中; 而是它将被写入硬盘.由于这种约束,我需要在生成中间结果时访问它们.到目前为止我一直在做的是:

for x in xrange(0, 10):
    for y in xrange(0, 10):
        for z in xrange(0, 10):
            writeToHdd(x,y,z)

除了非常讨厌之外,它不可扩展(即它需要我编写与维度一样多的循环).我试图使用这里提出的解决方案,但这是一个递归解决方案,因此很难在生成时动态获取结果.除了每个维度有一个硬编码循环之外,还有什么"整洁"的方法吗？

我需要找到多边形内部和多边形上的所有格点。

输入：

from shapely.geometry import Polygon, mapping
sh_polygon = Polygon(((0,0), (2,0), (2,2), (0,2)))

输出：

(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2), (1, 2), (2, 2)

请建议是否有办法在使用或不使用 Shapely 的情况下获得预期结果。

我编写了这段代码，它给出了多边形内部的点，但它没有给出多边形上的点。还有更好的方法来做同样的事情：

from shapely.geometry import Polygon, Point

def get_random_point_in_polygon(poly):
    (minx, miny, maxx, maxy) = poly.bounds
    minx = int(minx)
    miny = int(miny)
    maxx = int(maxx)
    maxy = int(maxy)
    print("poly.bounds:", poly.bounds)
    a = []
    for x in range(minx, maxx+1):
        for y in range(miny, maxy+1):
            p = Point(x, y) …

给定一个数组：

arr = np.array([[1, 3, 7], [4, 9, 8]]); arr

array([[1, 3, 7],
       [4, 9, 8]])

并给出其索引：

np.indices(arr.shape)

array([[[0, 0, 0],
        [1, 1, 1]],

       [[0, 1, 2],
        [0, 1, 2]]])

如何将它们整齐地堆叠在一起以形成新的2D​​阵列？这就是我想要的：

array([[0, 0, 1],
       [0, 1, 3],
       [0, 2, 7],
       [1, 0, 4],
       [1, 1, 9],
       [1, 2, 8]])

这是我目前的解决方案：

def foo(arr):
    return np.hstack((np.indices(arr.shape).reshape(2, arr.size).T, arr.reshape(-1, 1)))

它可以工作，但是执行此操作是否更短/更优雅？

我有这个数据集：

import pandas as pd
import itertools

A = ['A','B','C']
M = ['1','2','3']
F = ['plus','minus','square']

df = pd.DataFrame(list(itertools.product(A,M,F)), columns=['A','M','F'])
print(df)

示例输出如下：

   A  M       F
0   A  1    plus
1   A  1   minus
2   A  1  square
3   A  2    plus
4   A  2   minus
5   A  2  square

我想对该数据帧中的每一行进行成对比较（杰卡德相似度），例如，比较

A 1 plus并A 2 square得到这两个集合之间的相似度值。

我写了一个jaccard函数：

def jaccard(a, b):
    c = a.intersection(b)
    return float(len(c)) / (len(a) + len(b) - len(c))

这只能在现场工作，因为我用过intersection

我想要这样的输出（这个预期结果值只是随机数）：

    0     1     2     3 …

数学问题是：

总和中的表达式实际上比上面的表达式复杂得多，但这是一个最小的工作示例，不会使事情复杂化。我已经使用6个嵌套的for循环在Python中编写了此代码，并且正如预期的那样，即使在Numba，Cython和朋友的帮助下，它的性能也很差（真正的形式效果很差，需要评估数百万次）。在这里，它是使用嵌套的for循环和累积和编写的：

import numpy as np

def func1(a,b,c,d):
    '''
    Minimal working example of multiple summation
    '''
    B = 0
    for ai in range(0,a):
        for bi in range(0,b):
            for ci in range(0,c):
                for di in range(0,d):
                    for ei in range(0,ai+bi):
                        for fi in range(0,ci+di):
                            B += (2)**(ei-fi-ai-ci-di+1)*(ei**2-2*(ei*fi)-7*di)*np.math.factorial(ei)


    return a, b, c, d, B

表达控制与4个数字作为输入，并为func1(4,6,3,4)输出为B是21769947.844726562。

我到处寻找帮助，并找到了一些Stack帖子，其中包括一些示例：

NumPy中的外部产品：矢量化六个嵌套循环

向量化具有不同数组形状的Python / Numpy中的Triple for循环

Python向量化嵌套循环

我尝试使用从这些有用的帖子中学到的知识，但是经过多次尝试，我一直得出错误的答案。即使对其中一个和进行矢量化处理，也将为真正的问题带来巨大的性能提升，但是和范围不同的事实似乎使我无法接受。有人对如何进行此操作有任何提示吗？