Understanding data types is fundamental to programming in Python. This guide provides hands-on coding exercises to help reinforce your knowledge of Python’s basic data structures like numbers, strings, lists, dictionaries etc. Working through concrete examples can deepen comprehension and retention of key programming concepts.
Table of Contents
Open Table of Contents
Prerequisites
The exercises assume basic Python syntax knowledge and experience running scripts. For Python beginners, an introductory tutorial is recommended first.
Numeric Types
Python provides various numeric data types including integers, floats, complex numbers etc. Let’s explore some exercises for numeric types.
Integers
Integers represent whole numbers. Let’s try some integer arithmetic:
print(100 + 200) # 300
print(10 / 3) # 3, truncated integer division
Key points about integer arithmetic:
- Operations between integers return integers
- Division truncates fractional part
- Exponentiation raises to power
Floating-Point Numbers
Floats represent real numbers with fractional precision:
print(10.0 / 3) # 3.3333333333333335
print(2.5 ** 3) # 15.625
Observations about floats:
- Division produces fractional results
- Supports exponentiation
- Mixed types lead to float outputs
Complex Numbers
Complex numbers have real and imaginary parts.
c1 = 2 + 3j
print(c1.real) # 2.0
print(c1.imag) # 3.0
- Imaginary unit represented by
j - Access real and imaginary parts via attributes
- Support arithmetic operations
Exercise 1: Type Conversions and Mixed Operands
Let’s illustrate type conversions and mixed arithmetic:
x = 100 # int
print(float(x)) # 100.0
print(str(x)) # '100'
print(complex(x)) # (100+0j)
y = 3.14 # float
print(int(y)) # 3
z = 2 + 1j # complex
print(int(z)) # TypeError
print(x + y) # 103.14, mixed int and float
This demonstrates:
- Type conversions between numeric types
- Arithmetic with mixed operand types
Exercise 2: Testing Numeric Limits
Let’s test the limits of numeric types:
import sys
print(sys.maxsize) # Max int value before overflow
print(2**1024) # Float max exponent before infinity
c = 1000 + 1000j
print(c) # (1000+1000j)
c = 1000000000000 + 1000000000000j # Formats as exponential
print(c) # (1e+12+1e+12j)
Key takeaways:
- Integers have maximum range before overflow
- Floats can represent very large/small numbers
- Complex format changes at magnitudes
This reveals precision and range limits of numeric types.
Booleans
Booleans represent truth values True and False in Python.
print(5 > 2) # True
x = True
y = False
print(x and y) # Logical AND
print(x or y) # Logical OR
Some exercises to apply Boolean operations:
Exercise 3: Short-Circuit Evaluation
Short-circuit evaluation prevents unnecessary code execution:
# With short-circuiting no exception raised
print(False and raise Exception())
print(True or raise Exception())
# Without short-circuiting exception raised
print(False & raise Exception())
print(True | raise Exception())
This demonstrates short-circuiting behavior in Boolean expressions.
Exercise 4: Truth Value Testing
Different objects have inherent truth values:
print(bool(0)) # False
print(bool("hello")) # True
class MyClass:
def __init__(self):
self.att = "Hello"
def __len__(self):
return 0
obj = MyClass()
print(bool(obj)) # False, __len__ is 0
This shows how truth testing works in Python:
- Numbers: Zero is False, non-zero is True
- Strings: Empty is False, non-empty is True
- Custom classes use
__bool__or__len__
Strings
Strings represent textual data in Python. Some key operations:
s = "Hello"
print(s[0]) # 'H'
s2 = "World"
print(s + " " + s2) # 'Hello World'
print(s.upper()) # 'HELLO'
Properties of Python strings:
- Immutable sequenced type
- Support indexing, slicing, methods
- Useful for text processing
Some exercises to apply strings:
Exercise 5: Formatted Printing
Formatted printing injects values into strings:
name = "Eric"
age = 25
print(f"Name: {name}, Age: {age}")
print("My name is {}, I am {} years old".format(name, age))
- f-strings provide concise formatted strings
- str.format() method offers flexible substitutions
Exercise 6: Input Parsing and Validation
We can validate formatted string input:
import re
phone = input("Phone number: ")
if not re.match(r"\d{10}", phone):
print("Invalid phone format")
email = input("Email: ")
if not re.match(r"\w+@\w+\.com", email):
print("Invalid email")
This shows string validation:
- Regular expressions match text patterns
- Can sanitize free-form string input
Lists
Lists represent ordered, mutable sequences in Python.
nums = [1, 2, 3]
nums.append(4)
for n in nums:
print(n) # Prints 1, 2, 3, 4
Key characteristics of Python lists:
- Ordered collections allowing duplicates
- Mutable sequences, can modify in-place
- Flexible for data wrangling tasks
Some hands-on list exercises:
Exercise 7: List Comprehensions
List comprehensions provide a concise syntax for list operations:
squares = [x**2 for x in range(10)]
even_nums = [i for i in range(30) if i % 2 == 0]
List comprehensions allow:
- Transforming and filtering lists
- Generating lists from scratch
- More efficient than for loops
Exercise 8: Multidimensional Lists
Lists can represent multidimensional structures:
grid = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
print(grid[1][2]) # 6, nested index
cube = [[[1, 2], [3, 4]],
[[5, 6], [7, 8]]]
print(cube[0][1][0]) # 3, 3D index
- Lists can be nested to arbitrary depth
- Useful for matrices, cubes etc.
Tuples
Tuples are immutable ordered sequences in Python.
point = (10, 20)
x, y = point # Unpack tuple
print(x) # 10
Properties of tuples:
- Immutable sequences, cannot modify after creation
- Support indexing, slicing, iteration like lists
- Useful for fixed data
Exercise 9: Swapping Values
Tuple unpacking provides an easy way to swap values:
x, y = 10, 20
print(x, y) # 10, 20
x, y = y, x # Swap
print(x, y) # 20, 10
Sets
Sets represent unordered collections of unique elements in Python.
numbers = {1, 2, 3}
numbers.add(4)
print(3 in numbers) # Membership test
Key set properties:
- Unordered collection of distinct elements
- Support unions, intersections, diffs
- Efficient membership testing
Exercise 10: Set Operations
We can perform set operations like:
set1 = {1, 2, 3, 4}
set2 = {2, 4, 6, 8}
print(set1.union(set2))
print(set1.intersection(set2))
print(set1.difference(set2))
# More complex set logic
set3 = {1, 3, 5, 7, 9}
print(set1.union(set2).difference(set3))
This demonstrates:
- Unions, intersections, differences
- Chaining multiple set operations
Dictionaries
Dictionaries map keys to values in Python.
ages = {"Alice": 25, "Bob": 27}
print(ages["Alice"]) # 25
ages["Charlie"] = 30 # Insert
for name in ages:
print(name, ages[name]) # Iteration
Key dictionary properties:
- Unordered mappings of key-value pairs
- Keys must be immutable types
- Efficient lookup by key
- Nesting provides flexibility
Exercise 11: Group By
We can group data in a dictionary:
categories = ["Zero", "One", "Two"]
nums = [1, 2, 3, 4, 5, 6]
grouped = {}
for n in nums:
mod = n % 3
if mod not in grouped:
grouped[mod] = []
grouped[mod].append(n)
print(grouped)
# {0: [3, 6], 1: [1, 4], 2: [2, 5]}
This demonstrates:
- Creating a grouping based on keys
- Appending values to nested list
- Useful for aggregation scenarios
Summary
Mastering Python’s core data types provides a solid foundation for programmatically working with real-world data. This guide covered practical hands-on exercises focused on numbers, strings, lists, tuples, sets and dictionaries to help reinforce key concepts through concrete examples and live coding.
Some suggestions for extending your learning:
- Apply data types to math, science, game, web development projects
- Process different file formats like CSV, JSON, HTML using Python types
- Develop classes encapsulating multiple data structures
- Utilize Python’s extensive modules for specialized data types
With fluency in Python’s core data representations, programmers can effectively tackle a wide range of programming problems.