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')

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.

Have you found a solution to do the casting?

A workaround of course is to return the real and imaginary part of the result seperately:

Return[{Re[res],Im[res]}];

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]]

I think you might want to do the following, depending on what's inside the object type and if there's no padding to worry about:

bane.view(np.complex64) or
bane.view(np.complex128)

However if that does not work, which it didn't for some small tuple example I tried, the following worked:

bane.astype(np.float).view(np.complex64)

Consider using numpy structures rather than objects for the base dtype, you may have an easier time over all.

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.

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']