Python supports several built-in data types that are integral part of programming language. Everything in Python is object. Built-in data types are object type of data. They are the easiest way to start using Python because of its simplicity. If you need complex types you will use instances of you own class.

Python is dynamically and strongly typed language at the same time. What does that mean? Dynamically corresponds to fact that you don’t need to explicitly defined type of the variable that is assigned to value. Just populate the value with the desired data type. Strong means once the variable is assigned you can only do operations related with data type. For example integer variable can do only numeric tasks and string variable can do only string operations.

Let’s see what kind of data types Python has:

  • Numeric data types (int, float, long, complex)
  • Sequence types (strings, lists, tuples, ranges, bytes, bytearray)
  • Mappings (dictionaries)
  • Sets
  • Function, Modules, Classes

Data types

Numeric data types

Numeric data types in Python 3.x are divided into three main types: integer, float and complex.

Integer are positive and negative whole numbers including zero. You can store numbers between –9223372036854775808 and 9223372036854775807.

Floats are positive and negative decimal numbers and complex numbers. You can store numbers, ranging from 2.2250738585072014 x 10308 to 1.7976931348623157 x 10308.

Complex numbers include real component and imaginary part j.

Integer numbers can be also represented by hexadecimal (base16), octal (base 8) or binary (base2) format. Hexadecimal numbers are represented by hexadecimal digits (A-F, 0-9). Octal start with 0o or 0O followed by digits (0-7). Binary have 0 and 1.

Sequence types (Strings, Lists, Tuples, Ranges, Bytes, ByteArray)

Sequence types include all data types that are ordered in position in the way they can be indexed and sliced. Indexed means that each element can be accessed by its index. Slicing the sequence takes only part of the sequence.

Text sequence types (Strings)

Strings represent text sequence type and one of the most popular data types to operate. Strings in Python 3.x are array bytes representing Unicode characters. Array of bytes? Yes, they are array of bytes with Unicode representation. It is your choice which type of encoding you will use. Encoding and decoding is done automatically while reading and writing data. Default encoding is UTF-8.

Strings are immutable which means that original string objects cannot be modified in any way. Check later in text details about this feature. Strings can be indexed and sliced which is one of a great way to manipulate strings. Because strings are objects it use their specific built-in method like upper, lowercase, split, encode and many more. Those methods are bound to string type of data only.

Binary sequence types

Bytes and bytearray are part of binary sequence types in Python. Both types of binary representation of string type of data.


Python 3 has a clear difference between the sequence of characters and the sequence of raw data machine format – bytes. Bytes are immutable string representations of data. Bytes can be stored in directly in memory but strings could not, because byte are machine representation of data. String must be encoded first to store its values into memory. The range bytes can display data is ASCII code format which means you can display integers from 0 to 256. If Unicode string is represented by ‘abc’ then bytes are represented by b’abc’. Let’s check the connection in the following figure:

C:\docs\stranice\binarymaps\docker\python\python strings bytes.jpg


Very similar to string but with one major difference. Bytearrays are mutable but also raw type of data. It can be very handy to use if you need to change a lot of little chunks in memory without a need to copy the data but to replace data in place like database engines and image libraries. The range bytes can display data is ASCII code format which means you can display integers from 0 to 256.


Lists are collections of sequential (ordered) data that do not have a limited number. They are one of the most commonly used data types and, and unlike strings, are mutable. Which means that every element of the list can be changed. List can contain any type of data that is dynamically typed which means that you can create list with different types (strings, integers, bytes, etc). Lists can be nested and can be used to create matrices with duplicated data.


Tuples are similar to lists expect they are immutable and cannot be dynamically changed.


Ranges are unordered sequence of integer numbers. Range has three parameters: start, end and step. For example range (1,10, 2) means even numbers from 1 to 10. Usually used as shortcut in for loops.

Mappings (Dictionaries)

Dictionaries are something completely different than lists. While lists are indexed by position, dictionaries are accessed by its key. They are unordered which means that cannot be indexed. Dictionaries always stores two values which are regularly called key-value pair, where all keys have their values. This is the reason why dictionaries reside in mapping category. Dictionaries share some characteristics with lists: they are mutable, dynamic and can be nested. Very useful when you want to describe properties of some objects.


Sets are a collection of unordered collection of data which can grow and shrink on demand. They differ from lists and dictionaries just because of its features: unordered and not mapping type. They hold unique collection of objects and usually used with mathematical operations like union and difference. Because sets are not ordered their elements cannot be accessed with index but major advantage of sets are their easy way to confirm if object is part of set because it maintains hash table of objects. Another type of immutable set is frozen set.

Frozen Set

Frozen Sets are immutable types of Sets.

Other types

Because everything in Python is object, there are several types included like objects, methods, functions, files and types.

Immutable vs Mutable

All these Python built-in data types are sharing or not sharing some common properties like: mutable, immutable, dynamic, ordered or unordered. Mutability is the reason why we have many more Python types. Built-in types (int, float, bool, str, tuple, unicode) are immutable. Built-in types (list, set, dict) are mutable. Mutable objects can be changed while immutable objects can’t. Best way to identify object in memory is to use id() functions which return integer number of object located in memory.

Use cases:

  • Access to Immutable objects is quicker than mutable
  • Mutable objects are used when you need to change size of the object
  • Immutable objects are used when you want to ensure that object is always the same
  • Changing the immutable objects involves much expensive operation because you have to create copy of existing object
Object Type Domain Mutable Ordered Dynamic
Int Number Z No N/A N/A
Float Number Z No N/A N/A
Complex Number Z No N/A N/A
String Text Text Yes N/A N/A
Byte Binary Unicode No N/A N/A
ByteArray Binary Unicode Yes N/A N/A
List Sequence Collection of things Yes Yes Yes
Tuple Sequence Collection of things No Yes No
Range Sequence Collection of numbers No Yes No
Set Sequence Collection of things Yes No Yes
Frozen Set Sequence Collection of things No No Yes
Dictionary Mapping Mapping between things Yes No Yes

Python operators

Python operators are divided into several major categories:

  • Arithmetic operators
  • Comparison operators
  • Logical operators
  • Bitwise operators
  • Assignment operators
  • Identity operators
  • Membership operators

Arithmetic operators

+ Addition x + y
Subtraction x – y
* Multiplication x * y
/ Division x / y
% Modulus x % y
** Exponentiation x ** y
// Floor division (integer division) x // y

Comparison operators

== If values of two operands are equal, result is true a == b is TRUE
!= If values of two operands are not equal, result is true a != b IS TRUE
<> If values of two operands are not equal, result is true a <> b IS TRUE
> If the value of left operand is greater than the value of right operand, then condition becomes true. a>b IS TRUE
< If the value of left operand is less than the value of right operand, then condition becomes true. a<b IS TRUE
>= If the value of left operand is greater than or equal to the value of right operand, then condition becomes true. a>=b IS TRUE
<= If the value of left operand is less than or equal to the value of right operand, then condition becomes true. a<=b IS TRUE

Logical operators

AND If both operands are TRUE, result is TRUE a AND b
OR If any of operands are TRUE, results is TRUE a OR b
NOT Used to reverse the logical state of its operands NOT (a AND b)

NOT (a OR b)

Bitwise operators

& Bitwise AND

Returns 1 if bits on same position are 1

x & y
| Bitwise OR

Returns 0 if bits on same position are 0

x | y
~ Bitwise NOT

Inverts all bits

^ Bitwise XOR

Returns 1 if any of bits on same position is 1

x ^ y
>> Bitwise right shift

Shifts 1 bit from left to right

<< Bitwise left shift

Shifts 1 bit from right to left


Assignment operators

Operator Syntax Eqivalent
= x = 1 x = 1
+= x += 2 x = x + 2
-= x -= 1 x = x – 1
*= x *= 2 x = x * 2
/= x /= 1 x = x / 1
%= x %= 2 x = x % 2
//= x //= 1 x = x // 1
**= x **= 2 x = x ** 2
&= x &= 1 x = x & 1
|= x |= 2 x = x | 2
^= x ^= 1 x = x ^ 1
>>= x >>= 2 x = x >> 2
//= x //= 1 x = x // 1

Identity operators

IS TRUE if operands are same X is TRUE
IS NOT TRUE if operands are not same X is NOT TRUE

Membership operators

IN Returns TRUE if specified value is present in object x in y
NOT IN Returns TRUE if specified value is not present in object x not in y