Introduction to Data Types in Python

• Python is dynamically typed, meaning you don’t need to declare a variable’s type explicitly. The interpreter assigns a type at runtime based on the value.

x = 10       # x is an integer
x = "Hello"  # Now x is a string

Built-in Data Types in Python

• Numeric — int, float, complex
• Sequence — str, list, tuple, range
• Set — set, frozenset
• Mapping — dict
• Boolean — bool
• Binary — bytes, bytearray, memoryview
• NoneType — None

print(type(10))         # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type("hello"))    # <class 'str'>
print(type([1, 2, 3]))  # <class 'list'>
print(type(None))       # <class 'NoneType'>

Numeric Data Types

Integer (int)

• Represents whole numbers (positive, negative, or zero).
• No limit on size (except memory constraints).

Floating-Point (float)

• Represents decimal numbers or numbers with a fractional part.
• Uses IEEE 754 double-precision floating-point format internally.

Complex Numbers (complex)

• Represents numbers in the form a + bj, where j is the imaginary unit.
• Used in advanced mathematical computations.

# Integer (`int`) Methods
x = -10

print(abs(x))      # 10 (Absolute value)
print(bin(10))     # '0b1010' (Binary representation)
print(hex(255))    # '0xff' (Hexadecimal representation)
print(oct(8))      # '0o10' (Octal representation)
print(int("1001", 2))  # 9 (Convert binary string to integer)
# Floating-Point (`float`) Methods
y = 3.14159
print(round(y, 2))  # 3.14 (Round to 2 decimal places)
print(pow(2, 3))    # 8 (2^3, equivalent to 2**3)
print(float("10.5")) # 10.5 (Convert string to float)
print(int(4.7))     # 4 (Convert float to integer)
print(y.is_integer()) # False (Checks if float has no decimal part)

Sequence Data Types

String (str)

• A sequence of Unicode characters enclosed in single or double quotes.
• Immutable (cannot be modified after creation).

s = "hello world"
print(s.upper())       # "HELLO WORLD" (Convert to uppercase)
print(s.lower())       # "hello world" (Convert to lowercase)
print(s.title())       # "Hello World" (Title case)
print(s.strip())       # "hello world" (Removes leading/trailing spaces)
print(s.replace("world", "Python"))  # "hello Python" (Replace substring)
print(s.split())       # ['hello', 'world'] (Split string into list)
print("-".join(["Hello", "world"]))  # "Hello-world" (Join list elements)
print(s.find("world")) # 6 (Index of first occurrence of substring)
print(s.count("l"))    # 3 (Count occurrences of character)

List (list)

• A mutable ordered collection that can hold mixed data types.

# Creating a list with 2 items
my_list = [3, 1]

# Adding Elements
my_list.append(5)        # [3, 1, 5] (Adds 5 at the end)
my_list.insert(1, 10)    # [3, 10, 1, 5] (Inserts 10 at index 1)
my_list.extend([6, 7])   # [3, 10, 1, 5, 6, 7] (Concatenates another list)
# Removing Elements
my_list.pop()            # [3, 10, 1, 5, 6] (Removes last element)
my_list.pop(1)           # [3, 1, 5, 6] (Removes element at index 1)
my_list.remove(5)        # [3, 1, 6] (Removes first occurrence of 5)
my_list.clear()          # [] (Removes all elements)
# Rebuilding the list for further operations
my_list = [3, 1]
# Sorting & Reversing
my_list.sort()           # [1, 3] (Sorts the list in ascending order)
my_list.reverse()        # [3, 1] (Reverses the list)
sorted_list = sorted(my_list)  # Returns a new sorted list 
# Checking & Finding Elements
print(3 in my_list)      # True (Check existence)
print(my_list.count(1))  # 1 (Count occurrences of 1)
print(my_list.index(3))  # 0 (Find index of 3)
# Copying the List
copy_list = my_list.copy()  # Creates a shallow copy of the list
# List Length, Max, Min, and Sum
print(len(my_list))      # 2 (Number of elements)
print(max(my_list))      # 3 (Largest element)
print(min(my_list))      # 1 (Smallest element)
print(sum(my_list))      # 4 (Sum of all elements)
# List Comprehension (Generating a List of Squares)
squares = [x**2 for x in range(2)]  # [0, 1]

List Comprehension (list)

# Creating a list of squares
squares = [x**2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# Filtering even numbers
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8]
# Creating a list of tuples
pairs = [(x, x**2) for x in range(5)]
print(pairs)  # [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]

Tuple (tuple)

• Similar to a list but immutable (cannot be modified).

t = (1, 2, 3, 2, 4)

print(t.count(2))  # 2 (Count occurrences of 2)
print(t.index(3))  # 2 (Find index of value 3)

Tuple Comprehension (tuple)

# Creating a tuple of squares
squares_tuple = tuple(x**2 for x in range(1, 6))
print(squares_tuple)  # (1, 4, 9, 16, 25)

Range (range)

r = range(1, 10, 2)  # Creates range from 1 to 9 with step 2

print(list(r))   # [1, 3, 5, 7, 9] (Convert range to list)
print(r.start)   # 1 (Start value)
print(r.stop)    # 10 (Stop value)
print(r.step)    # 2 (Step value)

Set Data Types

Set (set)

• Stores only unique elements (duplicates are removed automatically).
• Supports set operations like union, intersection, difference.
• Unordered (no indexing or slicing).
• Mutable (can add or remove elements).

Frozenset (frozenset)

• Similar to a set but immutable (cannot be modified after creation).
• Useful when you need a hashable set (e.g., as a dictionary key).

s = {1, 2, 3}

# Adding and Removing Elements
s.add(4)      # {1, 2, 3, 4}
s.remove(2)   # {1, 3, 4} (Error if not found)
s.discard(5)  # No error if element doesn't exist
s.clear()     # {} (Removes all elements)
# Set Operations
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.union(s2))        # {1, 2, 3, 4, 5} (Combine sets)
print(s1.intersection(s2)) # {3} (Common elements)
print(s1.difference(s2))   # {1, 2} (Elements in s1 but not in s2)
print(s1.symmetric_difference(s2))  # {1, 2, 4, 5} (Elements in one set)
# Membership Testing
print(2 in s1)  # True
print(5 in s1)  # False

Set Comprehension (set)

# Creating a set of squares
squares_set = {x**2 for x in range(1, 6)}
print(squares_set)  # {1, 4, 9, 16, 25}

# Extracting unique vowels from a string
vowels = {char for char in "hello world" if char in "aeiou"}
print(vowels)  # {'o', 'e'}

Mapping Data Type

Dictionary (dict)

# Dictionary Keys, Values, and Items
print(person.keys())   # dict_keys(['name', 'age'])
print(person.values()) # dict_values(['Alice', 26])
print(person.items())  # dict_items([('name', 'Alice'), ('age', 26)])

# Checking if a Key Exists
print("name" in person)  # True
print("email" in person)  # False
# Merging Dictionaries
person.update({"country": "USA", "age": 27})
print(person)  # {'name': 'Alice', 'age': 27, 'country': 'USA'}
# Clearing a Dictionary
person.clear()  # {}

Dictionary Comprehension

# Creating a dictionary with squares of numbers
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

• A dictionary in Python is a collection of key-value pairs where each key is unique. It is mutable and allows fast lookups.

Boolean Data Type

Boolean Data Type (bool)

• The Boolean (bool) data type represents True or False values. It is a subclass of int, where: True is equivalent to 1 False is equivalent to 0

x = True
y = False
print(type(x))  # <class 'bool'>
print(int(x), int(y))  # 1 0

Truthy and Falsy Values

• Falsy values (Evaluates to False): 0, “”, [], {}, set(), None, False
• Truthy values (Evaluates to True): Everything else

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(100))    # True
print(bool("Hello")) # True

Binary Data Types

bytes (Immutable)

b = bytes([65, 66, 67])  # ASCII values for 'A', 'B', 'C'
print(b)  # b'ABC'
print(b[0])  # 65 (Accessing byte value)

bytearray (Mutable)

ba = bytearray([65, 66, 67])
ba[1] = 68  # Modifying byte value
print(ba)  # bytearray(b'ADC')

memoryview (Efficient Slicing)

bv = memoryview(b"Hello")
print(bv[1:4].tobytes())  # b'ell' (Slicing without copying data)

Use Cases

• Handling binary files (images, audio, video)
• Efficient data transfer in networking
• Working with low-level operations (e.g., encryption, compression)

Type Conversion and Type Casting

Implicit Type Conversion (Automatic)

x = 10   # int
y = 2.5  # float
result = x + y  # int + float → float
print(result, type(result))  # 12.5 <class 'float'>

Explicit Type Conversion (Casting)

# Convert to Integer
print(int(3.7))   # 3 (float → int)
print(int("10"))  # 10 (str → int)

# Convert to Float
print(float(5))   # 5.0 (int → float)
# Convert to String
print(str(100))   # "100" (int → str)
# Convert to List, Tuple, Set
print(list("abc"))  # ['a', 'b', 'c']
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2, 3]))  # {1, 2, 3}

Boolean Conversion

print(bool(0))    # False
print(bool(10))   # True
print(bool(""))   # False
print(bool("Python"))  # True

Mutable vs. Immutable Data Types

Mutable Data Types (Can be Modified)

• Lists (list)
• Dictionaries (dict)
• Sets (set)
• Bytearrays (bytearray)

Immutable Data Types (Cannot be Modified)

• Integers (int)
• Floats (float)
• Strings (str)
• Tuples (tuple)
• Frozen Sets (frozenset)
• Bytes (bytes)

Special Data Type: NoneType

• Python has a special data type called NoneType, which has only one value: None. It represents the absence of a value or a null value in Python.

x = None
print(x)  # None
print(type(x))  # <class 'NoneType'>

def example():
    pass  # No return statement
print(example())  # None
value = None  # Assign None until a real value is provided
x = None
if x is None:
    print("x has no value")  # This runs

Advanced Topics

Type Hints and Static Typing (typing module)
Python supports optional type hints for better code readability and static analysis.

from typing import List, Dict

def add_numbers(a: int, b: int) -> int:
    return a + b
def get_names() -> List[str]:
    return ["Alice", "Bob"]

Custom Data Types with Classes
You can define custom data types using Python classes.

class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

p = Person("Alice", 25)
print(p.name)  # Alice

dataclass for Structured Data
Python’s dataclass provides a simple way to create data objects.

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    salary: float
e = Employee("Bob", 50000)
print(e)  # Employee(name='Bob', salary=50000)

Memory Optimization with __slots__
Using __slots__ reduces memory usage by preventing dynamic attribute creation.

class Person:
    __slots__ = ['name', 'age']
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 30)
# p.address = "New York"  # ❌ Error! `address` is not allowed.

Immutable Data with NamedTuple
NamedTuple is an immutable, lightweight alternative to classes.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int
p = Point(3, 4)
print(p.x)  # 3
# p.x = 5  # ❌ Error! NamedTuple is immutable.

Using collections for Specialized Data Types
The collections module provides enhanced data structures.

from collections import defaultdict, Counter

# defaultdict (Default value for missing keys)
d = defaultdict(int)
d["a"] += 1
print(d)  # {'a': 1}
# Counter (Counts occurrences in an iterable)
c = Counter("banana")
print(c)  # Counter({'a': 3, 'n': 2, 'b': 1})

enum for Defining Constant Values
Enum is used to define named constant values.

from enum import Enum

class Status(Enum):
    PENDING = 1
    COMPLETED = 2
    FAILED = 3
print(Status.PENDING)  # Status.PENDING
print(Status.PENDING.value)  # 1