Question

我发誓这应该很容易......为什么不呢？：（

实际上，我想组合同一个数组的两个部分来构成一个复杂的数组：

Data[:,:,:,0] , Data[:,:,:,1]

这些不起作用：

x = np.complex(Data[:,:,:,0], Data[:,:,:,1])
x = complex(Data[:,:,:,0], Data[:,:,:,1])

我错过了什么吗？ numpy不喜欢在复数上执行数组函数吗？这是错误：

TypeError: only length-1 arrays can be converted to Python scalars

Answer 1

这似乎可以做你想要的：

numpy.apply_along_axis(lambda args: [complex(*args)], 3, Data)

这是另一种解决方案：

# The ellipsis is equivalent here to ":,:,:"...
numpy.vectorize(complex)(Data[...,0], Data[...,1])

另一个更简单的解决方案：

Data[...,0] + 1j * Data[...,1]

PS ：如果你想节省内存（没有中间数组）：

result = 1j*Data[...,1]; result += Data[...,0]

下面的

devS'解决方案也很快。

Answer 2

当然有相当明显的：

Data[...,0] + 1j * Data[...,1]

Answer 3

如果您的实部和虚部是最后一个维度的切片，并且您的数组沿着最后一个维度是连续的，那么您可以这样做

A.view(dtype=np.complex128)

如果使用单精度浮点数，则为

A.view(dtype=np.complex64)

这是一个更全面的例子

import numpy as np
from numpy.random import rand
# Randomly choose real and imaginary parts.
# Treat last axis as the real and imaginary parts.
A = rand(100, 2)
# Cast the array as a complex array
# Note that this will now be a 100x1 array
A_comp = A.view(dtype=np.complex128)
# To get the original array A back from the complex version
A = A.view(dtype=np.float64)

如果你想摆脱施法中留下的额外维度，你可以做类似

的事情

A_comp = A.view(dtype=np.complex128)[...,0]

这是有效的，因为在内存中，复数实际上只是两个浮点数。第一个代表实部，第二个代表虚部。数组的视图方法更改数组的dtype以反映您要将两个相邻的浮点值视为单个复数并相应地更新维度。

此方法不会复制数组中的任何值或执行任何新计算，它所做的只是创建一个新的数组对象，以不同方式查看同一块内存。这样就可以比任何涉及复制值的操作更快地执行此操作。这也意味着复值数组中的任何更改都将反映在具有实部和虚部的数组中。

如果在类型转换后立即删除那里的额外轴，恢复原始数组也可能有点棘手。像A_comp[...,np.newaxis].view(np.float64)这样的东西目前不起作用，因为在撰写本文时，NumPy在添加新轴时没有检测到数组仍然是C连续的。见this issue。 A_comp.view(np.float64).reshape(A.shape)似乎在大多数情况下都有用。

Answer 4

这就是你要找的东西：

from numpy import array

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

a + 1j*b

->array([ 1.+4.j,  2.+5.j,  3.+6.j])

Answer 5

我是python新手所以这可能不是最有效的方法，但是，如果我正确理解了问题的意图，下面列出的步骤对我有效。

>>> import numpy as np
>>> Data = np.random.random((100, 100, 1000, 2))
>>> result = np.empty(Data.shape[:-1], dtype=complex)
>>> result.real = Data[...,0]; result.imag = Data[...,1]
>>> print Data[0,0,0,0], Data[0,0,0,1], result[0,0,0]
0.0782889873474 0.156087854837 (0.0782889873474+0.156087854837j)

Answer 6

import numpy as np

n = 51 #number of data points
# Suppose the real and imaginary parts are created independently
real_part = np.random.normal(size=n)
imag_part = np.random.normal(size=n)

# Create a complex array - the imaginary part will be equal to zero
z = np.array(real_part, dtype=complex)
# Now define the imaginary part:
z.imag = imag_part
print(z)

Answer 7

如果您真的想提高性能（使用大型阵列），可以使用numexpr，它利用了多个内核。

设置：

>>> import numpy as np
>>> Data = np.random.randn(64, 64, 64, 2)
>>> x, y = Data[...,0], Data[...,1]

使用numexpr：

>>> import numexpr as ne
>>> %timeit result = ne.evaluate("complex(x, y)")
573 µs ± 21.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

与快速numpy方法相比：

>>> %timeit result = np.empty(x.shape, dtype=complex); result.real = x; result.imag = y
1.39 ms ± 5.74 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Answer 8

我使用以下方法：

@EnableRedisRepositories

Answer 9

这对我有用：

<强>输入

[complex(a,b) for a,b in zip([1,2,3],[1,2,3])]

<强>输出：

[(1+4j), (2+5j), (3+6j)]

Numpy：从2个真实阵列创建一个复杂的数组？

9 个答案: