DEV Community

Cover image for Python Notes #2 - Data types
Elvin Seyidov
Elvin Seyidov

Posted on • Edited on • Originally published at elvinseyidov.Medium

Python Notes #2 - Data types

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 
Enter fullscreen mode Exit fullscreen mode

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'> 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

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] 
Enter fullscreen mode Exit fullscreen mode

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)] 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

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 
Enter fullscreen mode Exit fullscreen mode

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'} 
Enter fullscreen mode Exit fullscreen mode

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() # {} 
Enter fullscreen mode Exit fullscreen mode

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} 
Enter fullscreen mode Exit fullscreen mode
  • 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 
Enter fullscreen mode Exit fullscreen mode

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 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

bytearray (Mutable)

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

memoryview (Efficient Slicing)

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

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'> 
Enter fullscreen mode Exit fullscreen mode

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} 
Enter fullscreen mode Exit fullscreen mode

Boolean Conversion

print(bool(0)) # False print(bool(10)) # True print(bool("")) # False print(bool("Python")) # True 
Enter fullscreen mode Exit fullscreen mode

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 
Enter fullscreen mode Exit fullscreen mode

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"] 
Enter fullscreen mode Exit fullscreen mode

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 
Enter fullscreen mode Exit fullscreen mode

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) 
Enter fullscreen mode Exit fullscreen mode

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. 
Enter fullscreen mode Exit fullscreen mode

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. 
Enter fullscreen mode Exit fullscreen mode

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}) 
Enter fullscreen mode Exit fullscreen mode

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 
Enter fullscreen mode Exit fullscreen mode

Top comments (0)