10 examples of 'python byte to int' in Python

9
def byte_to_int(byte):  # already byte
10
    return byte

226
def _bytes_to_int(b):
227
    return int(codecs.encode(b, "hex"), 16)

115
def bytes_to_int(bytes):
116
    return reduce(lambda s, x: (s << 8) + x, bytearray(bytes))

42
def bytes_to_int(be_bytes):
43
    """ Interprets a big-endian sequence of bytes as an integer. """
44
    return int(hexlify(be_bytes), 16)

178
def bytes_to_int(byte_array):
179
    """
180
    Converts the provided bytearray in an Integer.
181
    This integer is result of concatenate all components of `byte_array`
182
    and convert that hex number to a decimal number.
183
184
    Args:
185
        byte_array (Bytearray): bytearray to convert in integer.
186
187
    Returns:
188
        Integer: the integer corresponding to the provided bytearray.
189
190
    Example:
191
        >>> x = bytearray([0xA,0x0A,0x0A]) #this is 0xA0A0A
192
        >>> print(bytes_to_int(x))
193
        657930
194
        >>> b = bytearray([0x0A,0xAA])    #this is 0xAAA
195
        >>> print(bytes_to_int(b))
196
        2730
197
    """
198
    if len(byte_array) == 0:
199
        return 0
200
    return int("".join(["%02X" % i for i in byte_array]), 16)

92
def int_from_bytes(mybytes, byteorder='big', signed=False):
93
    """
94
    Return the integer represented by the given array of bytes.
95
    The mybytes argument must either support the buffer protocol or be an
96
    iterable object producing bytes.  Bytes and bytearray are examples of
97
    built-in objects that support the buffer protocol.
98
    The byteorder argument determines the byte order used to represent the
99
    integer.  If byteorder is 'big', the most significant byte is at the
100
    beginning of the byte array.  If byteorder is 'little', the most
101
    significant byte is at the end of the byte array.  To request the
102
    native byte order of the host system, use `sys.byteorder' as the byte
103
    order value.
104
    The signed keyword-only argument indicates whether two's complement is
105
    used to represent the integer.
106
    """
107
    if byteorder not in ('little', 'big'):
108
        raise ValueError("byteorder must be either 'little' or 'big'")
109
    if isinstance(mybytes, unicode):
110
        raise TypeError("cannot convert unicode objects to bytes")
111
    # mybytes can also be passed as a sequence of integers on Py3.
112
    # Test for this:
113
    elif isinstance(mybytes, collections.Iterable):
114
        mybytes = bytes(mybytes)
115
    b = mybytes if byteorder == 'big' else mybytes[::-1]
116
    if len(b) == 0:
117
        b = b'\x00'
118
    # The encode() method has been disabled by newbytes, but Py2's
119
    # str has it:
120
    num = int(b.encode('hex'), 16)
121
    if signed and (b[0] & 0x80):
122
        num = num - (2 ** (len(b)*8))
123
    return num

171
def decodeint(s):
172
    return int(binascii.hexlify(s[:32][::-1]), 16)

162
def _deserialize_int(bytes):
163
    return int.from_bytes(bytes, 'big')

79
def bytes_to_int(b):        # Read as little endian.
80
    fmtmap = {1: 'b', 2: '

34
def _from_bytes(value, dummy, _int=int, _hexlify=binascii.hexlify):
35
    "An implementation of int.from_bytes for python 2.x."
36
    return _int(_hexlify(value), 16)