Python provides a rich set of built-in data types that allow you to efficiently store, access, and manipulate various kinds of data in your programs. This comprehensive guide explores Python’s core data types in depth, providing clear explanations and practical examples to help you understand and utilize them effectively.

## Table of Contents

## Open Table of Contents

## Overview of Built-in Data Types

Python’s main built-in types can be categorized as follows:

**Numeric types**(`int`

,`float`

,`complex`

): Represent numbers and support mathematical operations.**Strings**(`str`

): Represent textual data and provide powerful text processing capabilities.**Sequence types**(`list`

,`tuple`

,`range`

): Represent ordered collections of objects.**Set types**(`set`

,`frozenset`

): Represent unordered collections of unique objects.**Mappings**(`dict`

): Represent key-value stores or associative arrays.**Boolean**(`bool`

): Represent truth values and are used for logical operations.**Binary types**(`bytes`

,`bytearray`

,`memoryview`

): Represent byte data and provide efficient storage and manipulation.**NoneType**(`None`

): Represents the absence of a value or a null value.

Understanding these core data types is essential for writing effective Python code. Let’s dive into each type in more detail.

## Numeric Types

Python provides three main numeric data types: integers, floating-point numbers, and complex numbers.

### Integers

The `int`

type represents integer values of unlimited magnitude. Integers support all standard mathematical operations, such as addition, subtraction, multiplication, division, exponentiation, and more.

```
x = 10
y = x + 5 * 2 # Arithmetic operations can be performed on integers
print(y) # Output: 20
```

Integers can be specified in decimal (base 10), binary (base 2), octal (base 8), or hexadecimal (base 16) notation. Useful functions for working with integers include `abs()`

, `divmod()`

, `pow()`

, and `round()`

.

### Floating Point Numbers

The `float`

type represents real numbers or values with fractional components. Floats provide greater precision than integers but may have some limitations, such as floating-point rounding errors.

```
y = 10.5
z = 2.5
print(y + z) # Output: 13.0
```

Useful `float`

functions include `is_integer()`

, `hex()`

, `as_integer_ratio()`

, and more.

### Complex Numbers

The `complex`

type represents complex numbers with real and imaginary parts. Complex numbers are useful for many scientific and mathematical applications.

```
z = 2 + 3j # j represents the imaginary component
print(z.real) # Output: 2.0
print(z.imag) # Output: 3.0
```

Key functions for complex numbers include `conjugate()`

and `phase()`

.

## Strings

The `str`

type represents textual data in Python as immutable sequences of Unicode characters.

```
text = "Hello, world!"
print(text) # Output: Hello, world!
```

Strings can be enclosed using single quotes (`'...'`

) or double quotes (`"..."`

). Useful string methods include `lower()`

, `upper()`

, `split()`

, `replace()`

, and many more.

Strings support indexing and slicing for accessing subsections and individual characters:

```
print(text[7]) # Output: w
print(text[7:12]) # Output: world
```

Some other helpful string functions include `len()`

to get the length and `in`

to check for substrings.

## Sequence Types

Python includes several built-in sequence types that allow you to store ordered collections of data.

### Lists

The `list`

type represents mutable ordered sequences. Lists can contain elements of different types and can be modified after creation.

```
numbers = [1, 5, 2, 8] # Create a list
numbers.append(7) # Append a new element
print(numbers) # Output: [1, 5, 2, 8, 7]
```

Useful list methods include `append()`

, `insert()`

, `pop()`

, `remove()`

, `sort()`

, and more. Lists can be indexed and sliced like strings.

### Tuples

The `tuple`

type represents immutable ordered sequences of objects. Tuples are similar to lists but cannot be modified after creation.

```
point = (10, 5) # Tuples use parentheses
print(point[1]) # Output: 5
```

Useful tuple methods include `count()`

and `index()`

.

### Range

The `range`

type represents an immutable sequence of integers commonly used for iteration.

```
for i in range(10): # Prints numbers 0 to 9
print(i)
```

The `range()`

function accepts start, stop, and step arguments. Range objects generate values lazily, making them very efficient.

## Set Types

Python includes two built-in set types: `set`

and `frozenset`

, which represent unordered collections of distinct objects.

### Sets

The `set`

type represents mutable unordered collections of unique elements.

```
numbers = {1, 5, 2, 4} # Create a set
numbers.add(3) # Add a new element
print(len(numbers)) # Output: 4 (sets cannot contain duplicates)
```

Useful set methods include `add()`

, `remove()`

, `pop()`

, `clear()`

, `union()`

, `intersection()`

, and more. Sets are useful for removing duplicates and checking membership.

### Frozensets

`frozenset`

represents immutable forms of sets.

```
numbers = frozenset([1, 5, 2, 4])
print(5 in numbers) # Output: True (membership can be tested)
```

Frozensets are like regular sets but cannot be changed after creation. Sets provide high performance and uniqueness checks.

## Mappings

The `dict`

type represents mutable mappings of unique keys to values.

```
ages = {'Alice': 25, 'Bob': 27} # Dictionary with string keys
ages['Charlie'] = 30 # Add a new entry
print(ages['Alice']) # Output: 25 (get the value for a key)
```

Dictionaries implement extremely fast key lookups using hash tables. Useful dictionary methods include `get()`

, `pop()`

, `update()`

, `keys()`

, `values()`

, `items()`

, and more. Dictionaries are commonly used for data storage and lookups in Python programs.

You can also create dictionaries using dictionary comprehensions:

```
squares = {x: x**2 for x in range(10)} # Dictionary comprehension
```

## Boolean Type

The `bool`

type represents boolean or logical values `True`

and `False`

in Python.

```
done = True # Assign a boolean value
print(bool(5)) # Output: True (bool() converts to boolean)
```

Booleans represent truth values and are very useful for control flow, conditional tests, and logical operations. They can be combined using logical operators like `and`

, `or`

, and `not`

.

## Binary Types

Python contains built-in types for working with binary data, such as bytestrings and byte arrays.

### Bytes and Bytearrays

The `bytes`

type represents immutable sequences of bytes.

```
data = b'Hello' # Bytes literal
print(len(data)) # Output: 5
```

The `bytearray`

type provides a mutable sequence of bytes.

```
data = bytearray(b'Hello')
data[0] = 106 # Modify bytes
print(data) # Output: bytearray(b'jello')
```

Both `bytes`

and `bytearray`

support methods like `decode()`

, `join()`

, `split()`

, `replace()`

, and more. Binary data types provide efficient storage for multimedia, network streams, and other binary data.

### Memory Views

`memoryview`

allows accessing slices of data from another binary sequence, such as `bytes`

, without copying.

```
data = memoryview(b'Hello')
print(data[1:4]) # Output: <memory at 0x...> (prints a slice of the bytes)
```

Memory views are useful for efficient access to binary buffers.

## None Type

The `None`

type represents the absence of a value.

```
x = None # Assign None
print(x is None) # Output: True (only one None value exists)
```

`None`

is commonly used as a placeholder or to represent null values in Python. It evaluates as false in conditionals and is equivalent to `null`

in other languages.

## Type Conversions

Python enables easy conversion between its built-in types using functions like `int()`

, `float()`

, `str()`

, `bool()`

, `list()`

, and more.

```
x = 5 # int
y = float(x) # Convert to float
print(list('hello')) # Convert string to list
```

You can also convert types using constructors like `bool()`

, `dict()`

, `set()`

. Explicit type conversions allow you to transform data correctly.

## Summary

- Python provides robust built-in types for numbers, strings, sequences, mappings, sets, booleans, binary data, and null values.
- Numeric types like
`int`

,`float`

, and`complex`

support mathematical operations. `str`

represents textual data and supports powerful text processing methods.- Sequence types like
`list`

,`tuple`

, and`range`

store ordered collections of data. - Set types like
`set`

and`frozenset`

represent unordered collections of unique elements. - Mappings like
`dict`

allow fast lookups using key-value pairs. `bool`

represents boolean or logical values.- Binary types like
`bytes`

and`bytearray`

provide efficient storage of byte data. `None`

represents null values.- Conversions between types can be performed using functions like
`int()`

and`float()`

.

Python’s robust built-in data types provide the fundamental building blocks for working with all kinds of data in your programs. By understanding the key attributes and usage patterns of each type, you can write more effective and efficient Python code.

This comprehensive guide has explored the major built-in types in Python, providing clear explanations and practical examples. With this knowledge, you are well-equipped to leverage Python’s data types to solve a wide range of programming problems.