Question

# [Solved] Convert alphabet letters to number in Python

How can the following be finished?

``````characters = ['a''b''c''d''e''f''g''h''i''j''k''l''m''n''o''p''q''r''t''u''v''w''x''y''z']
numbers = ['1''2''3''4''5''6''7''8''9''10''11''12''13''14''15''16''17''18''19''20''21''22''23''24']
text = raw_input(' Write text: ')
``````

I’ve tried to solve it many ways, but couldn’t get to the pint. I want to make exc. If I type “hello” the output to be in numbers lined like in alphabet. Example a = 1 < in alphabet.

## Solution #1:

What about something like this:

``````print [ord(char) - 96 for char in raw_input('Write Text: ').lower()]
``````

EDIT
Since you asked me to explain I will… though it has been explained pretty well in the comments already by [?].

Let’s do this in more that one line to start.

``````input = raw_input('Write Text: ')
input = input.lower()
output = []
for character in input:
number = ord(character) - 96
output.append(number)
print output
``````

This does the same thing, but is more readable. Make sure you can understand what is going on here before you try to understand my first answer. Everything here is pretty standard, simple Python. The one thing to note is the `ord` function. ord stand for ordinal, and pretty much every high level language will have this type of function available. It gives you a mapping to the numerical representation of any character. The inverse function of ord is called chr.

``````chr(ord('x')) == 'x' # for any character, not just x.
``````

If you test for yourself, the ordinal of a is 97 (the third link I posted above will show the complete ASCII character set.) Each lower case letter is in the range 97-122 (26 characters.) So, if you just subtract 96 from the ordinal of any lower case letter, you will get its position in the alphabet assuming you take ‘a’ == 1. So, ordinal of ‘b’ == 98, ‘c’ == 99, etc. When you subtract 96, ‘b’ == 2, ‘c’ == 3, etc.

The rest of the initial solution I posted is just some Python trickery you can learn called list comprehension. But, I wouldn’t focus on that as much as I would focus on learning to solve the problem in any language, where ord is your friend. I hope this helps.

## Solution #2:

You can use chr() and ord() to convert betweeen letters and int numbers.

Here is a simple example.

``````>>> chr(97)
'a'
>>> ord('a')
97
``````

## Solution #3:

Not to be too basic, but this:

``````>>> char1 = ['a''b''c''d''e''f''g''h''i''j''k''l'
'm''n''o''p''q''r''s''t''u''v''w''x''y''z']
``````

is very different than this:

``````>>> char2 = ['a','b','c','d','e','f','g','h','i','j','k','l',
'm','n','o','p','q','r','s','t','u','v','w','x','y','z']
``````

The first, without commas and what you have in your question, is a one element list with a 26 element string. The second is a 26 element list each a single character in length.

If you print each:

``````>>> print char1, len(char1), len(char1)
['abcdefghijklmnopqrstuvwxyz'] 1 26
>>> print char2, len(char2), len(char2)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
'm', 'n', 'o', 'p', 'q','r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] 26 1
``````

It becomes apparent that it takes an additional step to turn the individual characters of `char1` into an iterable.

If you have the sequence of characters ‘a’ through ‘z’ and/or ‘A’ through ‘Z’, you can easily return the number of the character with list comprehension:

``````>>> [ord(x)%32 for x in char2]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
``````

For the type of data structure you have, you need to access the string first:

``````>>> [ord(x)%32 for x in char1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
``````

So if your code listing is the same as in your question, that may be your issue.

A reasonable alternative is: `[ord(x.lower())-96 for x in char1]`

You can see that your `characters=['a''b''c'...]`, without the commas, is just the same as typing all the characters in a string in a list like this `['abc...']`.

So now try:

`````` >>> import string
>>> [ord(x.lower())-96 for x in string.letters]
[1,2,...26, 1,2,3...26]      # my ellipses
>>> char3=[string.letters]   # one string as element
>>> [ord(x)%32 for x in char3]
>>> [ord(x)%32 for x in [string.letters]]
``````

## Solution #4:

If you are going to use this conversion a lot, consider calculating once and putting the results in a dictionary:

``````>>> import string
>>> di=dict(zip(string.letters,[ord(c)%32 for c in string.letters]))
>>> di['c']
3
``````

The advantage is dictionary lookups are very fast vs iterating over a list on every call.

``````>>> for c in sorted(di.keys()):
>>>    print "{0}:{1}  ".format(c, di[c])
# what you would expect....
``````

## Solution #5:

This is a function I used to use for this purpose. Works for both uppercase and lowercase.

``````def convert_char(old):
if len(old) != 1:
return 0
new = ord(old)
if 65 <= new <= 90:
# Upper case letter
return new - 64
elif 97 <= new <= 122:
# Lower case letter
return new - 96
# Unrecognized character
return 0
``````

## Solution #6:

Something like this

``````[str(ord(c)&31) for c in text]
``````

## Solution #7:

``````def letter_to_int(letter):
alphabet = list('abcdefghijklmnopqrstuvwxyz')
return alphabet.index(letter) + 1
``````

here, the index (x) function returns the position value of x if the list contains x.

## Solution #8:

You can map the alphabet to a list and return the index of each one as per the below :

``````import string

alphabet=string.ascii_lowercase
#alphabet="abcdefghijklmnopqrstuvwxyz"

#Get the character index , ex: e
print(chars.find('e'))
#This will return 4
``````

## Solution #9:

``````>>> [str(ord(string.lower(c)) - ord('a') + 1) for c in string.letters]
['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17',
'18', '19', '20', '21', '22', '23', '24', '25', '26', '1', '2', '3', '4', '5', '6', '7', '8',
'9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24',
'25', '26']
``````

## Solution #10:

Here’s something I use to convert excel column letters to numbers (so a limit of 3 letters but it’s pretty easy to extend this out if you need more). Probably not the best way but it works for what I need it for.

``````def letter_to_number(letters):
letters = letters.lower()
dictionary = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}
strlen = len(letters)
if strlen == 1:
number = dictionary[letters]
elif strlen == 2:
first_letter = letters
first_number = dictionary[first_letter]
second_letter = letters
second_number = dictionary[second_letter]
number = (first_number * 26) + second_number
elif strlen == 3:
first_letter = letters
first_number = dictionary[first_letter]
second_letter = letters
second_number = dictionary[second_letter]
third_letter = letters
third_number = dictionary[third_letter]
number = (first_number * 26 * 26) + (second_number * 26) + third_number
return number
``````

## Solution #11:

If you are just looking to map a number to a letter, then just do something simple like this:

``````def letter_to_index(letter):
_alphabet = 'abcdefghijklmnopqrstuvwxyz'
return next((i for i, _letter in enumerate(_alphabet) if _letter == letter), None)
``````

Of course if you want to have it start at 1, then just add (i+1 for i, … etc.

## Solution #12:

If you are looking the opposite like 1 = A , 2 = B etc, you can use the following code. Please note that I have gone only up to 2 levels as I had to convert divisions in a class to A, B, C etc.

``````loopvariable = 0
numberofdivisions = 53
while (loopvariable <numberofdivisions):
if(loopvariable<26):
print(chr(65+loopvariable))
loopvariable +=1
if(loopvariable > 26 and loopvariable <53):
print(chr(65)+chr(65+(loopvariable-27)))
``````

## Solution #13:

Use this function. It converts a string of alphabet to its equivalent digit value:

``````def convAlph2Num(sent):
alphArray = list(string.ascii_lowercase)
alphSet = set(alphArray)
sentArray = list(sent.lower())
x = []
for u in sentArray:
if u in alphSet:
u = alphArray.index(u) + 1
x.append(u)
print(x)
return
``````

## Solution #14:

If the goal is to transform only the letters abcd….xyz and ABCD….XYZ , I would use a function:

``````from string import letters
def rank(x, d = dict((letr,n%26+1) for n,letr in enumerate(letters[0:52]))):
return d[x]
``````

I’ve written [0:52] because my Python 2.7 version displays the value

*ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz*ƒŠŒŽšœžŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ

for the string.letters argument.

Because the parameter d receives a value as a default argument, the calculus of this value is performed only once, at the moment when the definition of the function is executed to produce the function object.
So, the function can then be used without this value to be calculated again, even if the function is appealed three thousand times.

By the way, lower() isn’t used again for each appeal of the function. The case of upper letters has been treated during the construction of the default argument.

.

One example of use:

``````word = 'supercalifragilisticexpialidocious'
print ''.join( letter if rank(letter)%3!=0 else '.' for letter in word)
``````

result:

s.pe..a….ag…st..e.p.a..d…..s

.

It can be used with map() too :

``````print map(rank,'ImmunoElectroPhoresis')
``````

result:

[9, 13, 13, 21, 14, 15, 5, 12, 5, 3, 20, 18, 15, 16, 8, 15, 18, 5, 19, 9, 19]

## Solution #15:

Here is my solution for a problem where you want to convert all the letters in a string with position of those letters in English alphabet and return a string of those nos.

https://gist.github.com/bondnotanymore/e0f1dcaacfb782348e74fac8b224769e

Let me know if you want to understand it in detail.I have used the following concepts
– List comprehension
– Dictionary comprehension

## Solution #16:

``````import string
# Amin
my_name = str(input("Enter a your name: "))
numbers      = []
characters   = []
output       = []
for x, y in zip(range(1, 27), string.ascii_lowercase):
numbers.append(x)
characters.append(y)

print(numbers)
print(characters)
print("----------------------------------------------------------------------")

input = my_name
input = input.lower()

for character in input:
number = ord(character) - 96
output.append(number)
print(output)
print("----------------------------------------------------------------------")

sum = 0
lent_out = len(output)
for i in range(0,lent_out):
sum = sum + output[i]

print("resulat sum is : ")
print("-----------------")

print(sum)

resualt is :
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
----------------------------------------------------------------------
[1, 13, 9, 14]
----------------------------------------------------------------------
resulat sum is :
-----------------
37
``````

## Solution #17:

This is very simple script to do what you are asking for ! try this:

``````#!/usr/bin/env python3

def remove(string):
return string.replace(" ", "")

dict = {'a': '1',
'b': '2',
'c': '3',
'd': '4',
'e': '5',
'f': '6',
'g': '7',
'h': '8',
'i': '9',
'j': '10',
'k': '11',
'l': '12',
'm': '13',
'n': '14',
'o': '15',
'p': '16',
'q': '17',
'r': '18',
's': '19',
't': '20',
'u': '21',
'v': '22',
'w': '23',
'x': '24',
'y': '25',
'z': '26',
}

word = remove(input(''))

for x in word:
print(dict[x])

## or ##
#index = 0
#for x in word:
#   print(dict[word[index]])
#   index = index + 1
``````

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .
To Top
India and Pakistan’s steroid-soaked rhetoric over Kashmir will come back to haunt them both clenbuterol australia bossier man pleads guilty for leadership role in anabolic steriod distribution conspiracy