Actually, none of the proposed solutions worked in my case (Python 2.7.6, NumPy 1.8.2). But I've found out, that change of dtype from complex (standard Python library) to numpy.complex_ may help:

>>> import numpy as np
>>> x = 1 + 2 * 1j
>>> C = np.zeros((2,2),dtype=np.complex_)
>>> C
array([[ 0.+0.j,  0.+0.j],
       [ 0.+0.j,  0.+0.j]])
>>> C[0,0] = 1+1j + x
>>> C
array([[ 2.+3.j,  0.+0.j],
       [ 0.+0.j,  0.+0.j]])

Python has built-in support for complex numbers. You can just enter them like that:

>>> a = 2 + 3j # or: complex(2,3)
>>> a
(2+3j)
>>> type(a)
<type 'complex'>
>>> a.real
2.0
>>> a.imag
3.0
>>> 

As for the container, in Python you can start with a list:

>>> complex_nums_list = [2+3j, 3+4j, 4+5j]
>>> complex_nums_list
[(2+3j), (3+4j), (4+5j)]

Or you can use numpy.array, which would be more suited for numerical applications.

If you want to create an array containing complex values, you need to specify a complex type to numpy:

>>> A = np.zeros((3,3), dtype=complex)

>>> print A
[[ 0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j]]

>>> A[0,0] = 1. + 2.j

>>> print A
[[ 1.+2.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j]]

You can think about it as each list within a list being a separate item. Whatever is in the list is irrelevant until you access it.

For your example:

place = ["high up", [...]]

place[0] is "high up" because the first item in place is that string.

complex_list = [[...], 42]

complex_list[0] is the whole list except 42 because the list is the first item.

This seems to do what you want:

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

Here is another solution:

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

And yet another simpler solution:

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

PS: If you want to save memory (no intermediate array):

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

devS' solution below is also fast.

This should work

parts = [[1, 2], [3, 4], [5, 6]]

complex_list = [complex(*x) for x in parts]

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

Note: Each complex number will be a complex object (1+2j). If you need it to be a string '1+2j' or '1+2i'; use:

# f"{a}+{b}j" or f"{a}+{b}i"
complex_list = [f"{a}+{b}i" for a, b in parts]

['1+2i', '3+4i', '5+6i']

Yes, use astype():

In [6]: b = a.astype(complex)
In [7]: b
Out[7]: array([ 1.+0.j,  2.+0.j,  3.+0.j])

In [8]: b.dtype
Out[8]: dtype('complex128')

Probably better than going through CSV is to use "PythonExpression" as an exporting format, e.g.

ExportString[{1+2I,3+4I},"PythonExpression"]
(*"[Complex(1,2), Complex(3,4)]"*)

EDIT: Python seems to expect complex numbers defined through complex(real,imag) and not Complex(real,imag), so the full workflow would be:

• In Mathematica

Export["data.txt",{1+2I,3+4I},"PythonExpression"]

• In Python

with open("data.txt","r") as datafile:
    data = eval(datafile.read().lower())

I haven't really tested the efficiency of this approach, but unless that's a concern this technique seems rather convenient.

Use reshape to turn a 1D array to 2D (or any other shapes).

>>> x_max = 12
>>> y_max = 4
>>> vec1d = np.arange(x_max*y_max, dtype=complex)
>>> vec1d.reshape([x_max, y_max])
array([[  0.+0.j,   1.+0.j,   2.+0.j,   3.+0.j],
       [  4.+0.j,   5.+0.j,   6.+0.j,   7.+0.j],
       [  8.+0.j,   9.+0.j,  10.+0.j,  11.+0.j],
       [ 12.+0.j,  13.+0.j,  14.+0.j,  15.+0.j],
       [ 16.+0.j,  17.+0.j,  18.+0.j,  19.+0.j],
       [ 20.+0.j,  21.+0.j,  22.+0.j,  23.+0.j],
       [ 24.+0.j,  25.+0.j,  26.+0.j,  27.+0.j],
       [ 28.+0.j,  29.+0.j,  30.+0.j,  31.+0.j],
       [ 32.+0.j,  33.+0.j,  34.+0.j,  35.+0.j],
       [ 36.+0.j,  37.+0.j,  38.+0.j,  39.+0.j],
       [ 40.+0.j,  41.+0.j,  42.+0.j,  43.+0.j],
       [ 44.+0.j,  45.+0.j,  46.+0.j,  47.+0.j]])