title: Python:16 bit one's complement addition implementation
body: <p>I implemented one's complement addition of 16 bit integers in python, however I am trying to see if there is a better way to do it.</p>
  
  <pre><code> # This function returns a string of the bits (exactly 16 bits)
   # for the number (in base 10 passed to it)
   def get_bits(some_num):
          binar = bin(some_num)[2::]
          zeroes = 16 - len(binar)
          padding = zeroes*"0"
          binar = padding + binar
          return binar
  
  
  # This function adds the numbers, and handles the carry over
  # from the most significant bit
  def add_bits(num1, num2):
          result = bin(int(num1,2) + int(num2,2))[2::]
          # There is no carryover
          if len(result) &lt;= 16 :
                  result = get_bits(int(result,2))
          # There is carryover
          else :
                  result = result[1::]
                  one = '0000000000000001'
                  result = bin(int(result,2) + int(one,2))[2::]
                  result = get_bits(int(result,2))
          return result
  </code></pre>
  
  <p>And now an example of running it would be:</p>
  
  <pre><code>print add_bits("1010001111101001", "1000000110110101")
  </code></pre>
  
  <p>returns :</p>
  
  <pre><code>0010010110011111
  </code></pre>
  
  <p>Is what wrote safe as far as results (Note I didn't do any negation here since that part is trivial, I am more interested in the intermediate steps)? Is there a better pythonic way to do it?
  Thanks for any help.</p>