In Python, a data type communicates with the interpreter about how the programmer intends to use the data and information stored. The classification of data specifies the type of value a variable can hold.

In Python programming, you don't need to explicitly declare the data type of your variable. Instead, Python, as a dynamically typed language, determines the data type of your variable according to the assigned value.

A solid understanding of data types in Python is crucial as it allows programmers to write concise code. Python has several built-in data types like the sequence, numeric, mapping, set, none, and Boolean types of data.

This article will discuss the following topics:

- Numeric Data Types in Python
- Sequence Data Types in Python
- Mapping Data Type in Python
- Set Data Type in Python
- None Data Type in Python
- Boolean Data Type in Python
- Wrapping Up

## Numeric Data Types in Python

Have you ever thought about working with numerical values with Python? If yes, numeric data types are used to represent any numerical values.

There are three main numeric data types in Python: integers, floating-point numbers, and the complex numbers.

### Integer Data Type in Python

In Python, integers are known as `int`

. They are a built-in data type for whole numbers. `int`

can represent any size of integers without overflow errors because they can either be positive, zero, or negative.

```
# Python Integer
a = 7
y = -1
c = 0
print(a) # Output: 7
print(y) # Output: -1
print(c) # Output: 0
```

Numerous arithmetic calculations like addition, subtraction, multiplication, modulus, integer division, exponentiation, and division can be performed with integers.

```
# Addition Operation +
addition = 8 + 3
print("Addition:", addition) # Output: 11
# Subtraction operation -
subtraction = 9 - 4
print("Subtraction:", subtraction) # Output: 5
# Multiplication operation *
multiplication = 10 * 2
print("Multiplication:", multiplication) # Output: 20
# Division operation /
division = 10 / 6
print("Division:", division) # Output: 1.6666666666666667
# Integer Division operation //
integer_division = 10 // 2
print("Integer Division:", integer_division) # Output: 5
# Modulus operation %
modulus = 10 % 5
print("Modulus:", modulus) # Output: 0
# Exponentiation operation **
exponentiation = 2 ** 6
print("Exponentiation:", exponentiation) # Output: 64
```

### Floating-point Data Type in Python

In Python, `float`

can represent both whole numbers and fractions. They are used for approximating real numbers. Hence, they are not precise when dealing with a very small or a very large numbers.

```
# Python Float
b = 2.47
y = -0.1
k = 5.0
print(b) # Output: 2.47
print(y) # Output: -0.1
print(k) # Output: 5.0
```

Floating-point arithmetic calculations like addition, subtraction, multiplication, modulus, integer division, exponentiation, and division are performed using floating-point numbers. The float is any number with a decimal point.

```
# Addition Operation
a = 3.5
b = 2.1
print(a + b) # Output will be 5.3
# Subtraction Operation
c = 5.5
d = 2.2
print(c - d) # Output will be 3.3
# Multiplication operation
e = 4.0
f = 2.5
print(e * f) # Output will be 10.0
# Division Operation
g= 10.0
h = 7.0
print(g / h) # Output will be 1.4285714285714286
# Exponential Operation
i = 2.0
j = 3.0
print(i * j)# Output will be 6.0
# Modulus operation
k = 10.5
l = 4.0
print(k % l) # Output will be 2.5
# integer division Operation
m = 10.5
n = 3.0
print(k // l) # Output will be 2.0
```

**Note:** In Python 3, by default, dividing two integers returns a floating-point result.

### Complex Data Type in Python

`complex`

numbers are popularly used in engineering, physics, and mathematics to model the real and imaginary components. The numbers take the form of `a + bj`

, where `a`

and `b`

are real numbers, and `j`

represents the imaginary unit, defined as the square root of -1.

```
z1 = 8 + 2j # Creates a complex number 8 + 2j
z2 = -9 - 6j # Creates a complex number -9 - 6j
```

Python can perform various arithmetic calculations like addition, subtraction, multiplication, and division with complex number.

```
z2 = complex(3, 2)
z4 = complex(-1, 6)
# Addition Operation
sum_z = z2 + z4 # Result: 3 - 1 + (2 + 6)j = 2 + 8j
# Subtraction
diff_z = z2 - z4 # Result: 3 - (-1) + (2 - 6)j = 4 - 4j
# Multiplication
prod_z = z2 * z4
# Result: (3 * -1 - 2 * 6) + (3 * 6 + 2 * -1)j = (-15+16j)
# Division
div_z = z2 / z4
# Result:(0.24324324324324323-0.5405405405405406j)
```

## Sequence Data Types in Python

In Python, there are several sequence data types used to represent data collections in a specific order. They are as follows:

### List Data Type in Python

Lists are defined using square brackets `[]`

with comma-separated elements. They are a mutable, built-in data structure for storing item collections. The mutability feature of `[]`

means it's modifiable after creation.

Lists are a widely used data structures in Python because they support various operations and offer flexibility.

The element inside a list can be of any data type, list included.

```
# List creation
the_list = [1, 2, 4, 5]
# creating a mixed data list
multiple_data_list = [1, 'hi', 2.57, False]
print(the_list[0]) # Output: 1
print(multiple_data_list[2]) # Output:2.57
# Mutable feature of list
the_list[0] = 10 # Modify the first element
the_list.append(9) # Append a new element
the_list.extend([5, 4]) # Extend the list with another list
the_list.remove(2) # Remove an element by value
del the_list[0] # Remove an element by index
```

### Tuple Data Type in Python

In Python, a tuple is an immutable built-in data type for storing an ordered collection of elements.

Tuples are created using parentheses `()`

. Just like lists, Tuples have comma-separated elements.

A tuple requires a comma after the element to differentiate it from a parenthesized expression, even if it contains single element. The immutability feature of tuples implies that you cannot change them after creation.

```
# Empty tuple
zilch_tuple = ()
# Tuple with a single element
single_tuple = (1,)
# Tuple with multiple elements
multiple_tuple = (1,8,9,3, 5)
# Tuple immutability
single_slice[0] = 5
print(tuple_slice) # TypeError: 'tuple' object does not support item assignment
# Different elements tuples
mixed_tuple = (1, 'hello', 3.14, True)
# Nested tuple
nested_tuple = ('Orange', ('banana', 'Pineapple'), ["he", 'she', 'them'])
# Concatenate tuples
add_tuple = multiple_tuple + (6, 7, 8) # Output: (1, 8, 9, 4, 3, 5, 7, 8)
# Create a slice of the tuple
tuple_slice = add_tuple[1:3] # Output: (8, 9)
```

### String Data Type in Python

A string enclosed in either single `(')`

or a double quote `(")`

is an immutable sequence of characters used to represent textual data.

Python allows you to perform operations like, indexing, slicing, and concatenation on strings.

```
# Creaating a String with both single and double quote
single_string = 'Hello!'
double_string = "Python Programming!"
# Outputting the result
print(single_string[0]) # Output: 'H'
print(double_string[-1]) # Output: '!'
print(single_string[0:5]) # Output: 'Hello'
print(double_string[::2]) # Output: 'Pto rgamn!'
# Concatenate the two strings
concatenate_string = single_string + ' ' + double_string
print(concatenate_string) # Output: 'Hello! Python Programming'
# Some popular string methods like the upper,lower,find,replace, split and strip.
print(single_string.upper()) # Output: 'HELLO!'
print(double_string.lower()) # Output: 'python programming!'
print(single_string.find('World')) # Output: -1
print(double_string.replace('Python', 'Java')) # Output: 'Java Programming'
print(single_string.split(',')) # Output: ['Hello!']
print(double_string.strip()) # Output: 'Python Programming!'
```

### Range Data Type in Python

The `range`

function is used to iterate over elements in a list. By executing a task repeatedly, the `range`

generates indices for the data structure.

The syntax for a `range`

function is as follows:

```
range(start, stop, step)
```

The `start`

represents a starting value if, when omitted, the range starts from 0, while `stop`

is the number that indicates that the range should stop generating numbers.

The `step`

being the last value, specifies the increment or step between each different number in the sequence. The default value for this parameter is 1.

The `range`

function returns an immutable series of numbers.

```
# Generating a number from 0 to 10
for i in range(11):
print(i) # OUTPUT..... 0,1,2,3,4,5,6,7,8,9,10
# Generate a number from 1 to 19.
for i in range(1, 20):
print(i) # OUTPUT.....1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19
# Generating numbers from 0 to 10 with a step of 2:
for i in range(0, 21, 2):
print(i) # OUTPUT.... 0,2,4,6,8,10,12,14,16,18,20
# Generate a list of numbers using the list function in conjuction with range:
new_list = list(range(15))
print(new_list) # Output: [0, 1, 2, 3, 4,5,6,7,8,9,10,11,12,13,14]
```

## Mapping Data Type in Python

In Python, the dictionary `dict`

is the primary data type for storing a collection of key-value pairs.

The `dict`

is widely used in Python for different functions, such as mapping between related information, representing a set of data records, and storing configurations.

We can create a `dict`

in Python with either the curly braces `{}`

or the `dict()`

constructor.

Some of the characteristics of a dictionary are as follows:

**Key-Value Pairs**: A`dict`

consists of a key associated with a specific value in a key-value pair. The function of the key is to look up the corresponding value in the dictionary.**Uniqueness**: Duplicate keys are not allowed in`dict`

. Assigning a new value to an existing key will only replace the old value associated with that key.**Key Immutability**: The immutability nature of the keys ensures that keys remain "hashable" and consistent. Hence, keys in dictionary must be immutable. Some examples of immutable data types include integers, strings, and tuples.**Flexible Values**: Any data type including but not limited to lists, tuples, strings, numbers and even dictionaries can be associated with keys in a dictionary.

```
person = {
"name": "Kamaldeen",
"age": 32,
"city": "Nigeria"
}
```

In the code above, the keys are the `"name"`

, `"age"`

, and `"city"`

while their corresponding values are `"kamaldeen"`

, `32`

, and `"Nigeria"`

.

```
# Accessing values by key:
print(person["name"]) # Output: Kamaldeen
# Modifying values
person["age"] = 35 # Output: {'name': 'Kamaldeen', 'age': 35, 'city':
'Nigeria'}
# Adding a new key-value paie
person["job"] = "Engineer" # Output: {'name': 'Kamaldeen', 'age': 32, 'city': 'Nigeria', 'job': 'Engineer'}
# Check if name is in person dictionary
if "name" in person:
print("Name is present in the dictionary.") # Output:Name is present in the dictionary
```

## Set Data Type in Python

In Python, a `set`

is a built-in data type that represents a collection of unique elements with no particular order.

The elements in the `set`

are immutable, but the `set`

itself is mutable. Sets can be defined using curly braces `{}`

with comma-separated elements or by the `set()`

constructor. They gets used for mathematical operations like unions, intersections, and differences.

```
# Creating curly braces set
curly_set = {1, 2, 6, 4, 9}
# Creating set() function set
func_set = set([1, 2, 6, 9, 5])
```

Some of the characteristics are:

**No defined order**: In a`set`

, there's no defined order because the elements are unordered.**Uniqueness**: Sets are unique in nature, because they do not allow duplicate elements.**Mutability**: Sets allow you to update either by adding or removing elements after creation.**Elements Immutability**: Mutable elements like`lists`

cannot be an element of a set, because elements within a set must be immutable. Therefore, immutable data types like floats, integers , tuples and string can be used instead.

### Set Operation

Python supports mathematical operations like union, intersection, difference, and more for sets.

#### Union Operation Using Sets in Python

The union mathematical operation of two sets joins all unique elements from both sets.

```
first_set = {1, 2, 3}
second_set = {3, 4, 5}
union_set = first_set | second_set # Using the '|' operator
# Output: {1, 2, 3, 4, 5}
# or
union_method = first_set.union(second_set) # Using the union() method
# Output: {1, 2, 3, 4, 5}
```

The union can be created with either the `|`

or the `union()`

method.

#### Intersection Operation using Sets in Python

In Python, the intersection is a mathematical operation of two sets that prints the common elements only.

```
first_set = {1, 2, 3}
second_set = {3, 4, 5}
union_set = first_set & second_set # Using the '&' operator
# Output: {3}
# or
union_method = first_set.intersection(second_set) # Using the union() method
# Output: {3}
print(union_set)
print(union_method)
```

The intersection can be created with either the `&`

or the `intersection()`

method.

#### Difference Operation using Sets in Python

In Python, the difference mathematical operation between two sets occurs when an element is present in the first, but not in the second.

```
first_set = {1, 2, 3}
second_set = {3, 4, 5}
union_set = first_set - second_set # Using the '-' operator
# or
union_method = first_set.difference(second_set) # Using the difference() method
print(union_set)
print(union_method)
```

The difference can be created with either by the `-`

or the `difference()`

method.

#### Add Operation using Sets in Python

The `add()`

method of sets is used to add a single element to the set collection, while the `update()`

method is for adding multiple element.

```
first_set = {1, 2, 3}
second_set = {3, 4, 5}
# Add with add method
first_set.add(4)
# Update with update method
second_set.update({4,8,9,7})
print(first_set) # Output: {1, 2, 3, 4}
print(second_set) # OUtput: {3, 4, 5, 7, 8, 9}
```

#### Remove Operation using Sets in Python

In Python, the function of the `remove()`

method in sets is to remove a specific element if it exists. The `discard()`

method is also used for removing an element if it exists.

The only difference is that `discard()`

won't raise an error if the element doesn't exist, but `remove()`

will raise a `KeyError`

.

```
first_set = {1, 2, 3}
second_set = {3, 4, 5}
first_set.remove(5) # Output:KeyError: 5
second_set.discard(4) # Output:KeyError: {3, 5}
print(first_set)
print(second_set)
```

#### Frozenset Operation using Sets in Python

The `frozenset`

is a built-in immutable set. It gets defined like a regular set with `{}`

, but its element cannot be changed or modified after creation.

```
# Creating a frozenset
frozen_set = frozenset([7, 2, 3, 1, 5])
# Frozensets are immutable.
frozen_set.add(6) # An AttributeError will be raised
# Elements of a frozenset cannot be changed once it's created
frozen_set[0] = 10 # TypeError will be raised
# You can perform set operations like union, intersection, and difference on the frozenset
```

## None Data Type in Python

In Python, the `None`

data type represents the absence of a value or a null value.

It indicates the function does not a have a return value or the expression lacks a meaningful value.

Some key takeaways from the None data type:

**Type**:`None`

is called the`NoneType`

data type in Python.**Return Value**:`None`

is the default return value for a function without a value.**Default Value**: We can use`None`

as a default argument in the function definition.

```
# Initializing z with None, indicating that it does not currently hold any meaningful value.
z = None
print(z) # Output: None
y = None
if y is None:
print("The Value of y is:" "x is None")
# Output: The Value of y is :y is None
def pair(y=None):
if y is None:
print("y is None")
pair() # Output: y is None
# The greeting() function prints a message if a name is provided, otherwise it greets a stranger, but since the function does not return any value explicitly, it returns None by default.
def greeting(name):
if name:
print("Hi, " + name)
else:
print("Hi, Stranger")
result = greeting("Kamaldeen") # Output: Hello, Kamaldeen
print(result) # Output: None
```

## Boolean Data Type in Python

In Python, there are only two values used for comparisons and logical operation when using the `boolean`

data type. They are the `True`

and `False`

values.

The `boolean`

values are the result that arises from the comparison operators such as the equal (`==`

), the not equal (`!=`

), the greater than (`>`

), the less than (`<`

), the greater than or equal to (`>=`

), and the less than or equal to (`<=`

).

```
a = 10
b = 15
# Comparison operators
print(a == b) # False
print(a < b) # True
# Logical operators
print(a < 10 and b > 5) # False
print(a < 3 or b> 20) # False
print(not(a == b)) # True
# Control Flow
age = 75
if age >= 18:
print("You are an adult.")
else:
print("You are a minor.")
# Functions return
def is_even(number):
return number % 2 == 0
print(is_even(10)) # True
print(is_even(7)) # False
```

## Wrapping Up

In this tutorial, you learned about the various data types in Python.

We talked about several built-in data types like the sequence, mapping, set, none, and Boolean types.

Happy reading!