Basic Data Types

Python's Basic Data Types

Class	Basic Type
int	integer numbers
float	floating-point numbers
complex	complex numbers
str	strings and characters
bytr, bytearray	bytes
bool	boolean value

Integer Numbers

Integer Literals
Integer Methods
The Built-in int() Function

Integer Literals

no limit to size of an int
can be as big as the machine's memory will allow
a long, long integer can generate a ValueError when converted to a string

>>> 123 ** 10000
Traceback (most recent call last):
  ...
ValueError: Exceeds the limit (4300 digits) for integer string conversion;
            use sys.set_int_max_str_digits() to increase the limit

can also use other bases to represent integers

Prefix	Representation	Base
0b or 0B (Zero + b or B)	binary	2
0o or 0O (Zero + o or O)	octal	8
0x or 0X (Zero + x or X)	hexadecimal	16

underlying type of all bases is an int

Integer Methods

Method	Description
.as_integer_ratio()	returns a pair of integers whose ratio is equal to the original integer and has a positive denominator
.bit_count()	returns the number of ones in the binary representation of the absolute value of the integer
.bit_length()	returns the number of bits necessary to represent an integer in binary, excluding the sign and leading zeros
.from_bytes()	returns the integer represented by the given array of bytes
.to_bytes()	returns an array of bytes representing an integer
.is_integer()	returns True exists for duck-typing compatibility with floats

to access an integer method on a literal, need to wrap the literal in parentheses

>>> (42).as_integer_ratio()
(42, 1)

>>> 42.as_integer_ratio()
  File "<input>", line 1
    42.as_integer_ratio()
      ^
SyntaxError: invalid decimal literal

.bit_count() and .bit_length() methods can help when working on dsp

>>> signal = 0b11010110
>>> set_bits = signal.bit_count()

>>> if set_bits % 2 == 0:
...     print("Even parity")
... else:
...     print("Odd parity")
...
Odd parity

.from_bytes() and .to_bytes() methods can be useful in network programming need to send and receive data over the network in binary format
can use .to_bytes() to convert the message for network transmission
can use .from_bytes() to convert the message back

The Built-in int() Function

int() can be a c'tor which returns zero if there is no argument
commonly used to convert other type to an int
when using int() function to convert a float, the function just removes the decimal or fractional part
when convering a string there is an optional second argument which is the base of the int
arg defaults to base 10

>>> int("0b10", base=2)
2

>>> int("10", base=8)
8

>>> int("10", base=16)
16

Floating-Point Numbers

Floating-Point Literals
Floating-Point Numbers Representation
Floating-Point Methods
The Built-in float() Function

Floating-Point Literals

must have a decimal point
can use scientific notation

>>> .4e7
4000000.0

>>> 4.2E-4
0.00042

Floating-Point Numbers Representation

most all platforms represent Python float values as 64-bit (double-precision) values
a floating-point's maximum value is approximately 1.8 ⨉ 10308
Python will indicate any numbers greater than that with the "inf" string

>>> 1.79e308
1.79e+308
>>> 1.8e308
inf

the closest a nonzero number can be to zero is approximately 5.0 ⨉ 10-324
anything closer to zero than that is effectively considered to be zero

>>> 5e-324
5e-324
>>> 1e-324
0.0

Floating-Point Methods

Method	Description
.as_integer_ratio()	returns a pair of integers whose ratio is exactly equal to the original float
.is_integer()	returns True if the float instance is finite with integral value, and False otherwise
.hex()	returns a representation of a floating-point number as a hexadecimal string
.fromhex(string)	builds the float from a hexadecimal string

the .as_integer_ratio() method on a float value returns a pair of integers
the ratio of the two equals the original number
can use this method in scientific computations that require high precision
need to avoid precision loss due to floating-point rounding errors

>>> G = 6.67430e-11

>>> G.as_integer_ratio()
(1290997375656627, 19342813113834066795298816)

the .is_integer() method checks whether a given float value is an integer
when the number after the decimal point is 0, True is returned
otherwise False is returned

>>> (42.0).is_integer()
True

>>> (42.42).is_integer()
False

the .hex() and .fromhex() methods work with floating-point values using a hexadecimal representation

>>> (42.0).hex()
'0x1.5000000000000p+5'

>>> float.fromhex("0x1.5000000000000p+5")
42.0

the hexadecimal string has the format

[sign] ["0x"] integer ["." fraction] ["p" exponent]

Argument	Description
sign	defines whether the number is positive or negative may be either + or - the - sign is required because + is the default
"0x"	the hexadecimal prefix.
integer	a string of hexadecimal digits representing the whole part of the float number
"."	separates the whole and fractional parts of the number
fraction	a string of hexadecimal digits representing the fractional part of the float number
"p"	allows for adding an exponent value.
exponent	a decimal integer with an optional leading sign

The Built-in float() Function

with no argument float() is a c'tor

>>> float()
0.0

float() functioncan convert valid numeric values into floats

Complex Numbers

Complex Number Methods
The Built-in complex() Function

complex numbers are composed of real and imaginary parts
have the form a + bi
a and b are real numbers, and i is the imaginary unit
Python uses a j instead of an i

>>> type(2 + 3j)
<class 'complex'>

Complex Number Methods

the complex type has a single method called .conjugate()
function returns the conjugate
a conjugate is a pair of expressions that have the same terms but opposite arithmetic operators between them

>>> number = 2 + 3j

>>> number.conjugate()
(2-3j)

The Built-in complex() Function

can use the built-in complex() function to create complex numbers by providing the real and imaginary parts as arguments

>>> complex()
0j

>>> complex(1)
(1+0j)

>>> complex(0, 7)
7j

>>> complex(2, 3)
(2+3j)

>>> complex(2.4, 7.5)
(2.4+7.5j)

>>> complex(5, -3)
(5-3j)

can use complex() to convert strings to complex numbers

>>> complex("5-3j")
(5-3j)

>>> complex("5")
(5+0j)

>>> complex("5 - 3j")
Traceback (most recent call last):
    ...
ValueError: complex() arg is a malformed string

>>> complex("5", "3")
Traceback (most recent call last):
    ...
TypeError: complex() can't take second arg if first is a string

Strings and Characters

see Strings and Character Data

Bytes and Byte Arrays

Bytes Literals
The Built-in bytes() Function
The Built-in bytearray() Function
Bytes and Bytearray Methods

bytes are immutable sequences of single bytes
the bytes class builds sequences of bytes
data type is commonly used for

manipulating binary data
encoding and decoding text
processing file input and output
and communicating through networks

Bytes Literals

to create a bytes literal use a syntax which is largely the same as that for string literals
the difference is prepending a b to the string literal
can use different types of quotes to define bytes literals

>>> b'This is a bytes literal in single quotes'
b'This is a bytes literal in single quotes'

>>> b"This is a bytes literal in double quotes"
b'This is a bytes literal in double quotes'

can only use ASCII characters to define bytes literals
if binary values over the 127 characters are in the string, use the appropriate escape sequence

>>> b"Espa\xc3\xb1a"
b'Espa\xc3\xb1a'

>>> b"Espa\xc3\xb1a".decode("utf-8")
'España'

>>> b"España"
  File "<input>", line 1
    b"España"
            ^
SyntaxError: incomplete input

The Built-in bytes() Function

without an arg bytes is a c'tor
returns and empty bytes object

>>> bytes()
b''

can use the bytes() function to convert string literals to bytes objects

>>> bytes("Hello, World!", encoding='utf-8')
b'Hello, World!'

>>> bytes("Hello, World!")
Traceback (most recent call last):
    ...
TypeError: string argument without an encoding

can also use bytes() with an iterable of integers
each number is the Unicode code point of the individual characters

>>> bytes([65, 66, 67, 97, 98, 99])
b'ABCabc'

The Built-in bytearray() Function

Python doesn't have dedicated literal syntax for bytearray objects
to create them always use the class constructor bytearray()

>>> bytearray()
bytearray(b'')

>>> bytearray(5)
bytearray(b'\x00\x00\x00\x00\x00')

>>> bytearray([65, 66, 67, 97, 98, 99])
bytearray(b'ABCabc')

>>> bytearray(b"Using a bytes literal")
bytearray(b'Using a bytes literal')

the first example creates an empty bytearray object
the second example creates a bytearray with five zero-filled items
the third example uses a list of code points to create a bytearray
this call works the same as with bytes objects the fourth example uses a bytes literal to build up the bytearray object

Bytes and Bytearray Methods

because of their similarities with strings, the bytes and bytearray types mostly support the same methods as strings
both bytes and bytearray objects support common sequence operations

Booleans

Boolean Literals
The Built-in bool() Function

Boolean Literals

Python provides a built-in Boolean data type
may be either True or False
values are defined as built-in constants with values of 1 and 0
in practice the bool type is a subclass of int
thusly True and False are also instances of int

>>> issubclass(bool, int)
True

>>> isinstance(True, int)
True
>>> isinstance(False, int)
True

>>> True + True
2

The Built-in bool() Function

can use the built-in bool() function to convert any Python object to a Boolean value
internally Python uses the following rules to identify falsy objects:

constants that are defined to be false - None and False
the zero of any numeric type - 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
empty sequences and collections - '', (), [], {}, set(), range(0)

can also use the bool() function with custom classes

>>> class Point:
...     def __init__(self, x, y):
...         self.x = x
...         self.y = y
...

>>> point = Point(2, 4)
>>> bool(point)
True

by default all instances of custom classes are true
to modify this behavior use the .__bool__() dunder

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __bool__(self):
        if self.x == self.y == 0:
            return False
        return True

the .__bool__() method returns False when both coordinates are equal to 0 and True otherwise

>>> from point import Point

>>> origin = Point(0, 0)
>>> bool(origin)
False

>>> point = Point(2, 4)
>>> bool(point)
True