Replace numbers in an array with letters

The way I would do this is by creating a dictionary mapping integers to letters, and use it to map the values in the array using np.vectorize with dict.get:

from string import ascii_uppercase
d = dict(enumerate(ascii_uppercase))
# {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F'...
np.vectorize(d.get)(a.astype(int)-1)

array([['A', 'A', 'A', 'U'],
       ['A', 'A', 'A', 'V'],
       ['F', 'I', 'S', 'P'],
       ['F', 'I', 'S', 'Q'],
       ['S', 'Y', 'A', 'Y'],
       ['S', 'Y', 'B', 'V'],
       ['Y', 'M', 'Y', 'Y'],
       ['Y', 'N', 'Q', 'Y'],
       ['Y', 'N', 'T', 'Y'],
       ['Y', 'O', 'V', 'Y'],
       ['Y', 'O', 'Y', 'Y'],
       ['Y', 'Q', 'Q', 'Y'],
       ['Y', 'Q', 'Q', 'Y']], dtype='<U1')

If speed is an issue you can vectorize this operation if you create a mapping array and cast your array to real integers first.

import string
map = np.array(list(string.ascii_uppercase))
data = data.astype(int)

map[data - 1]
# array([['A', 'A', 'A', 'U'],
#        ['A', 'A', 'A', 'V'],
#        ['F', 'I', 'S', 'P'],
#        ['F', 'I', 'S', 'Q'],
#        ['S', 'Y', 'A', 'Y'],
#        ['S', 'Y', 'B', 'V'],
#        ['Y', 'M', 'Y', 'Y'],
#        ['Y', 'N', 'Q', 'Y'],
#        ['Y', 'N', 'T', 'Y'],
#        ['Y', 'O', 'V', 'Y'],
#        ['Y', 'O', 'Y', 'Y'],
#        ['Y', 'Q', 'Q', 'Y'],
#        ['Y', 'Q', 'Q', 'Y']], dtype='<U1')

I would suggest using "chr()" like so:

def numToChar(num):
    asciiInt = int(num) + 64
    character = str(chr(asciiInt))
    return character

a = '002'    
print(numToChar(a)) # prints 'B'

EDIT :

Supposing your data looks like this:

arr = ['001', '001', '001', '021', '001', '001', '001', '022', '006', '009', '019', '016', '006', '009', '019', '017', '019', '025', '001', '025', '019', '025', '002', '022', '025', '013', '025', '025', '025', '014', '017', '025']


def numToChar(num):
    asciiInt = int(num) + 64
    character = str(chr(asciiInt))
    return character


for i in range(len(arr)):
    arr[i] = numToChar(arr[i])


print(arr)
# Would print ['A', 'A', 'A', 'U', 'A', 'A', 'A', 'V', 'F', 'I', 'S', 'P', 'F', 'I', 'S', 'Q', 'S', 'Y', 'A','Y', 'S', 'Y', 'B', 'V', 'Y', 'M', 'Y', 'Y', 'Y', 'N', 'Q', 'Y']

You can use the string modules to create a mapping between integers and ascii characters:

import string

alphabet = string.ascii_uppercase

numbers = ["001", "0022", "003", "005"]
letters = [alphabet[int(number)-1] for number in numbers]
print(letters)

Returns

['A', 'V', 'C', 'E']

We could convert to int/uint dtype, add 64 to it to make it convert to ascii equivalent of those numbers and then simply view as the string format. The view part would be virtually free on runtime and hence should be pretty efficient -

# a is input array
def convert_to_char_typeconv(a):
    return (a.astype(np.uint32)+64).view('U1')

Another way would be to view as uint8/uint4 dtype values, convert each triplet as a number each, then view as the string format. Again, the ascii equivalent idea would come into the method. Hence, the implementation would be -

def convert_to_char_view_sumr(a):    
    b = (a.view('u4')-48).reshape(-1,3)[:,1:]
    return (b[:,0]*10+b[:,1]+64).view('U1').reshape(len(a),-1)

Sample run -

# Input array of dtype <U3
In [419]: a
Out[419]: 
array([['001', '001', '001', '021'],
       ['001', '017', '001', '022']], dtype='<U3')

In [420]: convert_to_char_typeconv(a)
Out[420]: 
array([['A', 'A', 'A', 'U'],
       ['A', 'Q', 'A', 'V']], dtype='<U1')

In [421]: convert_to_char_view_sumr(a)
Out[421]: 
array([['A', 'A', 'A', 'U'],
       ['A', 'Q', 'A', 'V']], dtype='<U1')

Benchmarking

Other posted approaches -

import string
from string import ascii_uppercase

# @neko's soln
def neko(numbers):
    alphabet = string.ascii_uppercase
    letters = [alphabet[int(number)-1] for number in numbers]
    return letters

# @yatu's soln
def yatu(a):
    d = dict(enumerate(ascii_uppercase))
    return np.vectorize(d.get)(a.astype(int)-1)

# @Nils Werner's soln
def nils(data):
    map = np.array(list(string.ascii_uppercase))
    data = data.astype(int)
    return map[data - 1]

Timings on 180000 rows data -

To setup input data let's use the sample a with 2 rows and repeat it 90000x times along rows to simulate OP's case of 180000 rows.

In [425]: a
Out[425]: 
array([['001', '001', '001', '021'],
       ['001', '017', '001', '022']], dtype='<U3')

In [426]: a = np.repeat(a,90000,axis=0)

In [427]: %timeit neko(a.ravel())
     ...: %timeit yatu(a)
     ...: %timeit nils(a)
254 ms ± 1.89 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
285 ms ± 1.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
206 ms ± 882 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [428]: %timeit convert_to_char_typeconv(a)
     ...: %timeit convert_to_char_view_sumr(a)
206 ms ± 1.61 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
2.83 ms ± 20.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)