# Data types in python

An exploration of various pythonic data types.

If you haven’t yet installed python and set up a development environment, I would suggest that you first read this post on getting started with python.

In this post, we will be looking broadly at the following data types:

• Numeric values
• Boolean values
• Sequential types
• Strings
• Dictionaries

This is by no means an exhaustive list, but is likely to be the data types you use most often when programming in python.

## Numerics

In python, numerical values can be stored in 3 distinct data types: integers, floating point numbers and complex numbers.

Integers

Integers in python are represented by the `int` class and can contain positive or negative whole numbers.

Floats

Decimal numbers in python are represented by the `float` class. These can be positive or negative real numbers specified by the presence of a decimal point .

Complex numbers

Complex numbers are are represented by the `complex` class. These are specified as (real part) + (imaginary part)j.

``````# integer
x = 3

# float
y = 2.0

# complex number - j represents the imaginary part of your complex number
z = 1 + 3j``````

When working with complex numbers you can access the real and imaginary parts of your complex number - in this case `z` - by using the `z.real` and `z.imag` attributes respectively.

Let’s look at how we can perform some basic operations with these data types.

``````# sum of x and y
x + y

# difference of x and y
x - y

# product of x and y
x * y

# quotient of x and y
x / y

# floored quotient of x and y
x // y

# remainder of x / y
x % y

# x to the power y
x ** y``````

In python, it is possible to convert data types into others using various built-in functions. Be sure to try out `int()`, `float()` and `complex()`.

## Booleans

Boolean data types can take on one of two built-in values: `True` or `False`. They are used to represent truth values. Other values can also be used as ‘truth’ values, for example, the integers 0 and 1 in a numerical context. The built-in function `bool()` can be also used to convert any value to a Boolean, if the value can be interpreted as a truth value (see section Truth Value Testing in the python docs). Take note of the capitalization as the usage of `true` and `false` will throw errors.

``````# boolean values
a = True
b = False

print("The type of a is: ", type(a))
print("The type of b is: ", type(b))``````

Boolean values are useful when checking if two variables have the same value or are of the same data type.

``````# let x be an integer
x = 5

# let y be a floating point number
y = 5.0

# check if the value of x is the same as the value of y - result is True
x == y

# check if x and y are of the same data type - result is False
type(x) == type(y)``````

Above we can see that `5` and `5.0` are seen to have the same value, but as we are aware, belong to the different data type classes `int` and `float`.

## Lists

In python, lists are synonymous with arrays declared in other languages. A key feature of a list that makes it super powerful is that it need not be homogeneous. This means that a single list may contain other data types like integers and strings or even other lists in your list.

``````# create an empty list
mylist = []

# a list with various data types
mylist = ['Text', 23, 3.14]

# a list within a list
mylist = ['Fruit', ['apples','oranges','bananas']]``````

Lists are also mutable, which means they can be altered after they have been created. The elements in a list are indexed according to a definite sequence and the indexing of a list is done with 0 being the first index. Elements in a list can easily be duplicated and/or re-ordered as needed. Lists are represented in python by the `list` class.

``````# create a list
mylist = ['Text', 23, 3.14]

# select items from the list
mylist
mylist
mylist

# append item to end of the list
mylist.append('New list item')

# select the last item in the list
last_item = mylist[-1]

# remove an item from a list - also try the .pop() method
mylist.remove('Text')``````

## Sets

A set in python, is very similar to a list with a few exceptions. The biggest difference being that a set only contains unique elements. Sets can be created using curly braces, with elements separated by commas. Alternatively an iterable object (such as a list, tuple or string) can be turned into a set using the `set()` function. Sets are represented by the `set` class.

``````# create an empty set
myset = {}

# convert a list into a set
mylist = ['Text', 23, 3.14]
myset = set(mylist)

# a set containing various elements
myset = {'a', 'b', 'c', 1, 2, 3}

# a set will only keep unique values
myset = {1, 1, 1, 2, 2, 3}``````

It is important to note that ordinary sets cannot be nested as seen above with lists as sets are not hashable.

## Tuples

Much like the list, a tuple is an ordered collection of python objects. The sequence of values stored in a tuple can be of any type, and they are indexed by integers. A notable difference that exists between a list and a tuple is that tuples are immutable. Tuples can be created using round brackets, with elements separated by commas or by using the `tuple()` function. It is represented by the `tuple` class.

``````# create an empty tuple
mytuple = ()

# convert a list into a set
mytuple = ('Text', 23, 3.14)
print(mytuple)

# convert a list into a tuple
mylist = ['Text', 23, 3.14]
mytuple = tuple(mylist)``````

### Strings

A string is also a sequential data type in python. It is an immutable sequence of Unicode characters or put simply - ordinary text. String literals are written by enclosing a sequence of characters in either single, double or triple quotes. It is represented by `str` class.

``````# an empty string
mystring = ""

# a string with single quotes
mystring = 'Hello, this is a string!'

# a string with double quotes
mystring = "It's useful if you need to use an apostrophe."

# a string with triple quotes
mystring = ''' These are useful for
creating strings that span
multiple lines!
'''``````

### Dictionaries

In python, a dictionary is an unordered collection of key-value pairs used to store data values. Dictionaries can be created by placing a comma-separated list of `key : value` pairs within curly braces. Dictionaries are represented by `dict` class.

``````# create an empty dictionary
mydict = {}

# create a dictionary
mydict = {'abc' : ['a','b','c'], 123 : 'One-two-three', 'eight' : 8 }

# create a dictionary using built-in function
mylist = [('abc', ['a','b','c']), (123, 'One-two-three'), ('eight', 8)]
mydict = dict(mylist)``````

We can access the values in a dictionary by making reference to it’s key name, used inside square brackets, similar to retrieving an item from a list. We can also add or remove items from a dictionary as seen below.

``````# create a dictionary
mydict = {'abc' : ['a','b','c'], 123 : 'One-two-three', 'eight' : 8 }

# get the value 8
myvalue = mydict['eight']

# delete a key:value pair
del mydict

# Deleting entire Dictionary
mydict.clear()