Int

Help on class int in module builtins:

class int(object)
| int([x]) -> integer
| int(x, base=10) -> integer
|
| Convert a number or string to an integer, or return 0 if no arguments
| are given. If x is a number, return [Link](). For floating-point
| numbers, this truncates towards zero.
|
| If x is not a number or if base is given, then x must be a string,
| bytes, or bytearray instance representing an integer literal in the
| given base. The literal can be preceded by '+' or '-' and be surrounded
| by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
| Base 0 means to interpret the base from the string as an integer literal.
| >>> int('0b100', base=0)
| 4
|
| Built-in subclasses:
| bool
|
| Methods defined here:
|
| abs(self, /)
| abs(self)
|
| add(self, value, /)
| Return self+value.
|
| and(self, value, /)
| Return self&value.
|
| bool(self, /)
| True if self else False
|
| ceil(self, /)
| Ceiling of an Integral returns itself.
|
| divmod(self, value, /)
| Return divmod(self, value).
|
| eq(self, value, /)
| Return self==value.
|
| float(self, /)
| float(self)
|
| floor(self, /)
| Flooring an Integral returns itself.
|
| floordiv(self, value, /)
| Return self//value.
|
| format(self, format_spec, /)
| Convert to a string according to format_spec.
|
| ge(self, value, /)

Int 1
 | Return self>=value.
|
| getattribute(self, name, /)
| Return getattr(self, name).
|
| getnewargs(self, /)
|
| gt(self, value, /)
| Return self>value.
|
| hash(self, /)
| Return hash(self).
|
| index(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| int(self, /)
| int(self)
|
| invert(self, /)
| ~self
|
| le(self, value, /)
| Return self<=value.
|
| lshift(self, value, /)
| Return self<<value.
|
| lt(self, value, /)
| Return self<value.
|
| mod(self, value, /)
| Return self%value.
|
| mul(self, value, /)
| Return selfvalue.
|
| ne(self, value, /)
| Return self!=value.
|
| neg(self, /)
| -self
|
| or(self, value, /)
| Return self|value.
|
| pos(self, /)
| +self
|
| pow(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| radd(self, value, /)
| Return value+self.
|
| rand(self, value, /)
| Return value&self.
|
| rdivmod(self, value, /)
| Return divmod(value, self).

Int 2
 |
| repr(self, /)
| Return repr(self).
|
| rfloordiv(self, value, /)
| Return value//self.
|
| rlshift(self, value, /)
| Return value<<self.
|
| rmod(self, value, /)
| Return value%self.
|
| rmul(self, value, /)
| Return valueself.
|
| ror(self, value, /)
| Return value|self.
|
| round(self, ndigits=<unrepresentable>, /)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| rpow(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| rrshift(self, value, /)
| Return value>>self.
|
| rshift(self, value, /)
| Return self>>value.
|
| rsub(self, value, /)
| Return value-self.
|
| rtruediv(self, value, /)
| Return value/self.
|
| rxor(self, value, /)
| Return value^self.
|
| sizeof(self, /)
| Returns size in memory, in bytes.
|
| sub(self, value, /)
| Return self-value.
|
| truediv(self, value, /)
| Return self/value.
|
| trunc(self, /)
| Truncating an Integral returns itself.
|
| xor(self, value, /)
| Return self^value.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|

Int 3
 | The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(self, /)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| [Link] as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.

Int 4
 | Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| [Link] as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| new(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number

Int 5