http://stackoverflow.com/questions/19277685/fastest-way-to-compare-one-string-of-two-lengths

gistfile1.txt

>>> import dis

>>> s = str(range(100))
>>> t = str(range(101))

>>> x = lambda s, t: abs(len(s) - len(t)) > 1
>>> y = lambda s, t: len(s) > len(t) + 1 and len(s) < len(t) - 1
>>> z = lambda s, t: 1 >= len(s) - len(t) >= -1

>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (abs)
              3 LOAD_GLOBAL              1 (len)
              6 LOAD_FAST                0 (s)
              9 CALL_FUNCTION            1
             12 LOAD_GLOBAL              1 (len)
             15 LOAD_FAST                1 (t)
             18 CALL_FUNCTION            1
             21 BINARY_SUBTRACT     
             22 CALL_FUNCTION            1
             25 LOAD_CONST               1 (1)
             28 COMPARE_OP               4 (>)
             31 RETURN_VALUE        

# BINARY_SUBTRACT 1
# CALL_FUNCTION 3
# COMPARE_OP 1
# LOAD_CONST 1
# LOAD_FAST 2
# LOAD_GLOBAL 3
# RETURN_VALUE 1

# Total: 12

>>> dis.dis(y)
  1           0 LOAD_GLOBAL              0 (len)
              3 LOAD_FAST                0 (s)
              6 CALL_FUNCTION            1
              9 LOAD_GLOBAL              0 (len)
             12 LOAD_FAST                1 (t)
             15 CALL_FUNCTION            1
             18 LOAD_CONST               1 (1)
             21 BINARY_ADD          
             22 COMPARE_OP               4 (>)
             25 JUMP_IF_FALSE_OR_POP    53
             28 LOAD_GLOBAL              0 (len)
             31 LOAD_FAST                0 (s)
             34 CALL_FUNCTION            1
             37 LOAD_GLOBAL              0 (len)
             40 LOAD_FAST                1 (t)
             43 CALL_FUNCTION            1
             46 LOAD_CONST               1 (1)
             49 BINARY_SUBTRACT     
             50 COMPARE_OP               0 (<)
        >>   53 RETURN_VALUE        


# BINARY_ADD 1
# BINARY_SUBTRACT 1
# CALL_FUNCTION 4
# COMPARE_OP 2
# JUMP_IF_FALSE_OR_POP 1
# LOAD_CONST 2
# LOAD_FAST 4
# LOAD_GLOBAL 4
# RETURN_VALUE 1

# Total: 20

>>> dis.dis(z)
  1           0 LOAD_CONST               1 (1)
              3 LOAD_GLOBAL              0 (len)
              6 LOAD_FAST                0 (s)
              9 CALL_FUNCTION            1
             12 LOAD_GLOBAL              0 (len)
             15 LOAD_FAST                1 (t)
             18 CALL_FUNCTION            1
             21 BINARY_SUBTRACT     
             22 DUP_TOP             
             23 ROT_THREE           
             24 COMPARE_OP               5 (>=)
             27 JUMP_IF_FALSE_OR_POP    37
             30 LOAD_CONST               2 (-1)
             33 COMPARE_OP               5 (>=)
             36 RETURN_VALUE        
        >>   37 ROT_TWO             
             38 POP_TOP             
             39 RETURN_VALUE        

# BINARY_SUBTRACT 1
# CALL_FUNCTION 2
# COMPARE_OP 2
# DUP_TOP 1
# JUMP_IF_FALSE_OR_POP 1
# LOAD_CONST 2
# LOAD_FAST 2
# LOAD_GLOBAL 2
# POP_TOP 1
# RETURN_VALUE 2
# ROT_THREE 1
# ROT_TWO 1

# Total: 18

termdump.py

Python 2.7.4 (default, Sep 26 2013, 03:20:26) 
Type "copyright", "credits" or "license" for more information.

IPython 1.0.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: s = str(range(100))

In [2]: t = str(range(101))

In [3]: %timeit len(s) > len(t) + 1 and len(s) < len(t) - 1
10000000 loops, best of 3: 106 ns per loop

In [4]: %timeit abs(len(s) - len(t)) > 1
10000000 loops, best of 3: 113 ns per loop

In [5]: %timeit 1 >= len(s) - len(t) >= -1
10000000 loops, best of 3: 124 ns per loop