Python Data Types: A Beginner Guide.

Python’s built-in data types form the backbone of programming in the language. In this guide, we will examine the key data types: Numeric, Sequence, Mapping, and Set. Each section covers the attributes, built-in methods, and practical use cases to give you a solid foundation for teaching these concepts.

1. Numeric Data Types

Numeric types represent numbers in Python. There are three main numeric types:

a. Integers (int)

Integers are whole numbers without a fractional component. They support arbitrary precision, meaning you can work with very large numbers.

Attributes & Characteristics:

• Immutable
• Supports arithmetic operations (+, -, *, /, //, % and **)
• Can be converted to other numeric types using built-in functions (e.g., float())

Example:

# Integer Example
a = 100
b = -45
print("a:", a, "b:", b)
print("Type of a:", type(a))
    

b. Floating Point Numbers (float)

Floats represent real numbers and include a decimal point. They use double-precision (usually 64-bit) internally.

Attributes & Characteristics:

• Immutable
• Can represent fractional parts
• May introduce rounding errors due to binary representation

Example:

# Float Example
pi = 3.14159
negative_float = -0.001
print("pi:", pi)
print("Type of pi:", type(pi))
    

c. Complex Numbers (complex)

Complex numbers consist of a real part and an imaginary part. They are written in the format real + imagj.

Attributes & Characteristics:

• Immutable
• Access real and imaginary parts using .real and .imag
• Used in scientific and engineering calculations

Example:

# Complex Number Example
c = 3 + 4j
print("Complex number:", c)
print("Real part:", c.real, "Imaginary part:", c.imag)
print("Type of c:", type(c))
    

2. Sequence Data Types

Sequences are ordered collections that allow you to store a series of items. They include strings, lists, and tuples. We’ll explore each in detail.

a. Strings (str)

Strings are immutable sequences of Unicode characters. Every method that appears to modify a string returns a new string.

Key Attributes & Methods:

• Indexing & Slicing: Access individual characters (text[0]) or substrings (text[1:5]).
• Concatenation & Repetition: Use + to join strings and * to repeat them.
• Built-in Methods: upper(), lower(), strip(), find(), replace(), split(), and join().

Example:

text = "Python is fun!"
print("First character:", text[0])
print("Slice 'Python':", text[0:6])
print("Uppercase:", text.upper())
print("Count of 'n':", text.count('n'))
    

b. Lists (list)

Lists are ordered, mutable collections. They can store elements of different types and are ideal for collections that need to be modified.

Key Attributes & Methods:

• Indexing & Slicing: Similar to strings for accessing and extracting elements.
• Mutability: Change, add, or remove elements via indexing or methods.
• Built-in Methods:
  • append(), extend(), insert()
  • remove(), pop(), clear()
  • index(), count(), sort(), reverse()

Example:

fruits = ["apple", "banana", "cherry"]
print("First fruit:", fruits[0])
fruits.append("date")
print("After append:", fruits)
fruits[1] = "blueberry"
print("After modification:", fruits)
    

c. Tuples (tuple)

Tuples are ordered, immutable collections. They are similar to lists but cannot be modified once created, which makes them useful for fixed collections of data.

Key Attributes & Methods:

• Indexing & Slicing: Access elements in the same way as lists and strings.
• Immutability: Cannot add, remove, or change elements after creation.
• Built-in Methods: Limited to count() and index().

Example:

dimensions = (1920, 1080)
print("First dimension:", dimensions[0])
print("Slice of tuple:", dimensions[1:])
    

d. The range Object

Although not a container that holds all values, a range object is an immutable sequence that represents a sequence of numbers. It is frequently used in loops.

Key Attributes:

• Indexing & Slicing: Supports accessing values without storing the entire sequence.
• Immutability: Cannot be changed once created.
• Efficiency: Generates numbers on-demand, saving memory.

Example:

r = range(0, 20, 2)
print("Elements in range:")
for num in r:
    print(num, end=" ")
    

Tip: Highlight how similar operations like indexing and slicing are consistent across sequences. Stress that mutability is key: use lists when you need to modify data and tuples for fixed collections.

3. Mapping Data Type: Dictionaries (dict)

Dictionaries store data as key-value pairs and are ideal for fast lookups. They are mutable and, starting with Python 3.7, maintain insertion order.

Key Attributes & Methods:

• Key-Value Pairs: Keys must be immutable types (like strings, numbers, or tuples) while values can be any type.
• Mutable: Can add, remove, or modify key-value pairs.
• Built-in Methods:
  • keys(), values(), and items() for iterating.
  • get() for safe key access.
  • pop() and popitem() for removal.
  • update() to merge dictionaries.

Example:

student = {
  "name": "Alice",
  "age": 23,
  "course": "Computer Science"
}
print("Student Name:", student["name"])
student["grade"] = "A"
print("Updated Dictionary:", student)
    

4. Set Data Types

Sets are unordered collections of unique elements. They are useful for operations like membership testing and eliminating duplicates.

a. Sets (set)

Key Attributes & Methods:

• Unordered and Unique: Automatically removes duplicate elements.
• Mutable: Elements can be added or removed.
• Built-in Methods:
  • add() to insert a new element.
  • remove() and discard() to remove elements.
  • union(), intersection(), difference(), and symmetric_difference() for set operations.

Example:

unique_numbers = {1, 2, 3, 2, 1}
print("Unique numbers:", unique_numbers)
unique_numbers.add(4)
print("After adding 4:", unique_numbers)
    

b. Frozen Sets (frozenset)

Frozen sets are the immutable version of sets. Once created, they cannot be altered.

Key Attributes:

• Immutable and hashable, which allows them to be used as keys in dictionaries.
• Support most set operations except those that modify the set.

Example:

immutable_set = frozenset([1, 2, 3, 2, 1])
print("Immutable set:", immutable_set)
    

Conclusion

This guide has provided a detailed look at Python’s core data types. Understanding numeric types, sequences, dictionaries, and sets—not only their syntax but also their attributes and methods—is essential for writing effective and efficient Python code. Use these examples to reinforce best practices and help others grasp these concepts.

Happy Teaching and Coding!

© 2025 Python Data Types Guide | All Rights Reserved

SHARE

Milan Tomic

Hi. I’m Designer of Blog Magic. I’m CEO/Founder of ThemeXpose. I’m Creative Art Director, Web Designer, UI/UX Designer, Interaction Designer, Industrial Designer, Web Developer, Business Enthusiast, StartUp Enthusiast, Speaker, Writer and Photographer. Inspired to make things looks better.

• 
• 
• 
• 
•