# .css-4zleql{display:block;}Data Science Rocks  # Python Notes [N°2] - Datatypes

Davide Camera

Published on Nov 3, 2020

Subscribe to my newsletter and never miss my upcoming articles

# Hello Data Lovers👋

Another article for Pythonic, Pythonist, Pythoneer and Pythonista. Python is a widely used high-level programming language for general-purpose programming, created by Guido van Rossum and first released in 1991.

Hope you find them educational!

## Article outline

• Booleans

• Numbers

• Strings

• Sequences and collections

• Built-in constants

• Testing the type of variables

• Converting between datatypes

• Mutable and Immutable Data Types

## Datatypes

Booleans

Bool: a boolean value of either True or False. Logical operations like and, or, not can be performed on booleans.

``````x or y    #  if x is False then y otherwise  x
x and y    #  if x is False then x otherwise  y
not x    # if x is True then False, otherwise True
``````

In Python 2.x and in Python 3.x, a boolean is also an int. The bool type is a subclass of the int type and True and False are its only instances:

``````issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True
``````

If boolean values are used in arithmetic operations, their integer values (1 and 0 for True and False) will be used to return an integer result:

``````True + False == 1 #  1  +  0  ==  1
True * True    == 1 #  1  *  1  == 1
``````

Numbers

• int: Integer number
``````a = 2
b = 100
c = 123456789
d = 38563846326424324
``````

Integers in Python are of arbitrary sizes.

Note: in older versions of Python, a long type was available and this was distinct from int. The two have been uniﬁed.

• float: Floating point number; precision depends on the implementation and system architecture, for CPython the float datatype corresponds to a C double.
``````a = 2.0
b = 100.e0
c = 123456789.e1
``````
• complex: Complex numbers
``````a = 2 + 1j
b = 100 + 10j
``````

The <, <=, > and >= operators will raise a TypeError exception when any operand is a complex number.

Strings

Python 3.x Version ≥ 3.0

• str: a unicode string. The type of 'hello'

• bytes: a byte string. The type of b'hello'

Python 2.x Version ≤ 2.7

• str: a byte string. The type of 'hello'

• bytes: synonym for str

• unicode: a unicode string. The type of u'hello'

Sequences and collections

Python diﬀerentiates between ordered sequences and unordered collections (such as set and dict).

• strings (str, bytes, unicode) are sequences
• reversed: A reversed order of str with reversed function
``````a = reversed('hello')
``````
• tuple: An ordered collection of n values of any type (n >= 0).
``````a = (1, 2, 3)
b = ('a', 1, 'python', (1, 2))
b = 'something else' # returns a TypeError
``````

Supports indexing; immutable; hashable if all its members are hashable.

• list: An ordered collection of n values (n >= 0)
``````a = [1, 2, 3]
b = ['a', 1, 'python', (1, 2), [1, 2]]
b = 'something else' # allowed
``````

Not hashable; mutable.

• set: An unordered collection of unique values. Items must be hashable.
``````a = {1, 2, 'a'}
``````
• dict: An unordered collection of unique key-value pairs; keys must be hashable.
``````a = {1: 'one',
2: 'two'}

b = {'a': [1, 2, 3],
'b': 'a string'}
``````

Built-in constants

In conjunction with the built-in datatypes there are a small number of built-in constants in the built-in namespace:

• True: The true value of the built-in type bool

• False: The false value of the built-in type bool

• None: A singleton object used to signal that a value is absent.

• Ellipsis or ...: used in core Python3+ anywhere and limited usage in Python2.7+ as part of array notation. NumPy and related packages use this as a 'include everything' reference in arrays.

• NotImplemented: a singleton used to indicate to Python that a special method doesn't support the speciﬁc arguments, and Python will try alternatives if available.

``````a = None # No value will be assigned. Any valid datatype can be assigned later
``````

Testing the type of variables

In python, we can check the datatype of an object using the built-in function type.

``````a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>
``````

In conditional statements, it is possible to test the datatype with isinstance. However, it is usually not encouraged to rely on the type of the variable.

``````i = 7
if isinstance(i, int): i += 1
elif isinstance(i, str): i = int(i)
i += 1
``````

To test if something is of NoneType:

``````x = None
if x is None:
print('Not a surprise, I just defined x as None.')
``````

Converting between datatypes

You can perform explicit datatype conversion.

For example, '123' is of str type and it can be converted to integer using int function.

``````a = '123'
b = int(a)
``````

Converting from a ﬂoat string such as '123.456' can be done using float function.

``````a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123
``````

You can also convert sequence or collection types:

``````a = 'hello'
list(a)    # ['h', 'e', 'l', 'l', 'o']
set(a)    # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')
``````

Mutable and Immutable Data Types

An object is called mutable if it can be changed. For example, when you pass a list to some function, the list can be changed:

``````def f(m):
m.append(3)    # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]    # False now, since an item was added to the list
``````

An object is called immutable if it cannot be changed in any way. For example, integers are immutable, since there's no way to change them:

``````def bar():
x = (1, 2)
g(x)
x == (1, 2)    # Will always be True, since no function can change the object (1, 2)
``````

Note that variables themselves are mutable, so we can reassign the variable x, but this does not change the object that x had previously pointed to. It only made x point to a new object.

Data types whose instances are mutable are called mutable data types, and similarly for immutable objects and datatypes.

Examples of immutable Data Types:

• int, long, float, complex

• str

• bytes

• tuple

• frozenset

Examples of mutable Data Types:

• bytearray

• list

• set

• dict

### Thanks for reading! If it was useful to you, please Like/Share so that, it reaches others as well.

To get e-mail notification on my latest posts, please subscribe to my blog by hitting the Subscribe button at the top of the page.

Stay Tuned.

``````In the next article we will analyze:
✅ IDLE Python GUI
`````` 