How does the
int()
function work I. Python and could you write your own function?
The
int(x, base=10)
function in Python takes two parameters: the first parameter
x
being either a number or string and the second representing the
base
number to return (
10
being default which represents the decimal number system) and converts
x
into a whole integer number.
A simple example of converting a string is demonstrated below:
>>> my_string = "1234" >>> int(my_string) 1234
You can further test the conversion has worked properly by performing a simple mathematical operation like multiplying by 2:
>>> my_string = "1234"
>>> my_string * 2
'12341234'
>>> int(my_string) * 2
2468
As you can see from the above code if you multiply a string you get the string repeated
x
number of times, but if you get multiply a number then you should get a correct numerical result.
Another simple example demonstrating the conversion of a decimal number is as follows:
>>> my_float = 1234.56
>>> int(my_float)
1234
As you can see from the above code the
int()
function truncates the decimal portion of a
float
number.
How Does
int()
Work?
Several decisions have already been made for you when using the built-in
int()
function. What if these design decisions don’t match your expectations and you need something different?
Understanding how the
int()
function works helps in being able to design your own should you need something different.
One way to get a better understanding of the
int()
function is to copy how it works, then you can change your copied design to match your own expectations.
The first thing I would do with the first parameter
x
is to convert it into a string. By converting the parameter to a string the rest of the code would be easier to handle as you would be dealing with one data type.
Operating on the string would then require starting from the end of the string and by parsing through each character in the string checking the characters’ ordinal position.
If the ordinal number of the character is within the range of the ordinal numbers of the digits from 0 to 9 then we have a string that can be converted to a number .
To find out the ordinal number of a character use the built-in
ord(char)
function
which takes only one parameter:
a string character
.
For example, the ordinal number of the character
'a'
is
97
. The ordinal number of the character
'1'
is
49
.
>>> ord('a')
97
>>> ord('1')
49
All the numerical digits from 0 to 9 are represented by the ordinal numbers from
48
to
57
respectively.
Custom
int()
Alternative
To begin creating your own custom replacement of the built-in
int()
function you would need to loop through each of the characters in the original string and in reverse then calculate their corresponding number.
Finally, to position the numbers correctly they would need to be raised to the base
10
(or whatever base you input) and then accumulated to give the final result as a number.
Here’s how I tackled this problem with my own custom
int()
function:
def my_int(x, base = 10):
x = str(x)
index = 0
result = 0
for char in x[::-1]:
o = ord(char) - 48
if base > o >= 0:
result += (base ** index) * o
index += 1
if char == "-":
result *= -1
return result
So what is happening with the above custom function
my_int()
?
Firstly, the custom function takes two parameters:
x
the string or number to change and the
base
number used to convert the digits. The default
base
number is
10
which represents the decimal number system.
Once inside the function, there are a few declarations. The first is to make sure the data type of the first parameter is an actual string so the built-in
str()
method is used.
Next, I define the
index
and
result
variables as these values will increment and accumulate throughout the for loop with each character.
Next in the for loop that will loop through each character in the string, I use the
slice operator
[::-1]
to reverse the string so that I can start at the last character and work to the front.
Within the for loop, a simple calculation is performed on the difference between the
character’s ordinal number
and the ordinal number for zero – being
48
. This calculation will produce the actual digit as a number.
The if condition then checks the result from the difference in the ordinal numbers is less than the base and greater than or equal to zero. This ensures no character or number outside the base range is processed.
If the condition is true the next calculation needed is to raise the base to the index power and to multiply that number by the actual digit. Once this is done the index is incremented by one.
To demonstrate this calculation here is what the
result
variable looks like at each successful iteration:
(10 ** 0) * 4 = 4
(10 ** 1) * 3 = 30
(10 ** 2) * 2 = 200
(10 ** 3) * 1 = 1000
result = 1234
The last if condition checks for a negative sign and if it does then it multiplies the result by negative 1.
Trying this function in the wild produces the following results for this handful of tests:
>>> my_int('1,234')
1234
>>> my_int('$1,234')
1234
>>> my_int('01234')
1234
>>> my_int('1234.56')
123456
As you can see from the results it does a great job of removing unnecessary characters such as dollar signs and thousands separators (because the standard
int()
function does not!), but it looks like it needs help when operating with decimals.
How To Handle Decimals
As shown previously the current implementation of the
int()
function truncates the decimal portion.
To truncate the decimal portion an identifier is needed in the parameters of the function to determine
what the decimal character is
, by default it should be set to your country’s locale, mine will be set to
"."
. Besides this another minor change needed will be on the for loop and an additional portion of code is to be added, but overall the change to the custom
my_int()
function is fairly simple.
Here is what the custom code would look like:
def my_int(x, base = 10, decimal_char = "."):
x = str(x)
index = 0
result = 0
for idx, char in enumerate(x[::-1]):
o = ord(char) - 48
if base > o >= 0:
result += (base ** index) * o
index += 1
if char == "-":
result *= -1
if char == decimal_char:
return my_int(x[:-idx-1], base, decimal_char)
return result
The main additional piece of code is seen in the second
if
condition within the for loop. Here I check to see if the current character in the for loop matches the newly inserted third parameter
decimal_char
and if it does then I know I have the decimal portion all that is needed is to start again.
This is why the function is run again with the decimal portion removed.
Here’s how the result of this function turned out:
>>> my_int(1234.56)
1234
>>> my_int('1234.99')
1234
>>> my_int('US$1,234.50')
1234
>>> my_int("-$1,234.50")
-1234
The custom
int()
function works as anticipated and has helped to handle thousands separators, negative signs, and characters that should be removed but not hinder the conversion process.
Summary
The standard
int()
function converts a string or number to a whole number including any single negative sign. The
int()
function also truncates any decimal portion from a number.
To design something similar that would require more functionality on handling characters that shouldn’t prevent conversion (such as a currency symbol or thousands separator) then a custom function will be needed.
The resulting custom function I designed that handled this was the following:
def my_int(x, base = 10, decimal_char = "."):
x = str(x)
index = 0
result = 0
for idx, char in enumerate(x[::-1]):
o = ord(char) - 48
if base > o >= 0:
result += (base ** index) * o
index += 1
if char == "-":
result *= -1
if char == decimal_char:
return my_int(x[:-idx-1], base, decimal_char)
return result
