What is the common pitfall with Confusing `strftime` (Format) and `strptime` (Parse)?

strftime formats datetime objects into strings; strptime parses strings into datetime objects. Exam trap note: Remember: strftime = "string Format time", strptime = "string Parse time".

What are the core concepts of Python Dates & Math?

Provides C-standard mathematical functions: `math.sqrt`, `math.pow`, `math.sin`, `math.cos`, `math.log`, `math.gcd`. Rounding utilities: `math.floor` (rounds down to -∞), `math.ceil` (rounds up to +∞), `math.trunc` (truncates decimals toward zero). Mathematical constants: `math.pi`, `math.e`, `math.inf`, `math.nan`.

← Previous: Python Modules & Packages All Modules Next: Python JSON & Regular Expressions →

MOD-23 · Sequence #23 · Standard Library

Python Dates & Math

Python includes powerful batteries-included libraries: `math` for floating-point mathematical functions, and `datetime` for date, time, and timedelta calculations. Mastering ISO parsing and strftime formatting is essential for data processing.

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

import datetime
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d"))

Core Principles & Mental Models

1. The math Module

Trigonometry, Logarithms, Constants

Provides C-standard mathematical functions: `math.sqrt`, `math.pow`, `math.sin`, `math.cos`, `math.log`, `math.gcd`.
Rounding utilities: `math.floor` (rounds down to -∞), `math.ceil` (rounds up to +∞), `math.trunc` (truncates decimals toward zero).
Mathematical constants: `math.pi`, `math.e`, `math.inf`, `math.nan`.

import math
print("math.ceil(4.1):", math.ceil(4.1))    # 5
print("math.floor(4.9):", math.floor(4.9))  # 4
print("math.gcd(24, 36):", math.gcd(24, 36)) # 12

💡 Key Takeaway: Use math functions for high-speed floating point computations.

2. The datetime and timedelta Objects

Date Arithmetic and String Formatting

`datetime.date` (year, month, day) and `datetime.datetime` (includes hours, minutes, seconds).
`datetime.timedelta` represents durations between two dates and enables arithmetic: `future = now + timedelta(days=7)`.
`strftime()` converts dates to formatted strings (%Y, %m, %d, %H, %M, %S).
`strptime()` parses strings into datetime objects.

import datetime
start = datetime.date(2026, 1, 1)
duration = datetime.timedelta(days=45)
end = start + duration
print("Calculated date:", end.strftime("%B %d, %Y"))

💡 Key Takeaway: Use timedelta objects for calendar arithmetic to correctly account for leap years and month lengths.

Interactive Walkthrough Examples

Parsing and Formatting Dates with strptime/strftime (Basic)

Converting raw log timestamps into formatted human-readable strings.

from datetime import datetime
raw_timestamp = "2026-10-08 14:30:00"
dt = datetime.strptime(raw_timestamp, "%Y-%m-%d %H:%M:%S")
formatted = dt.strftime("%A, %d %b %Y at %I:%M %p")
print("Formatted date:", formatted)

Explanation: strptime parses string -> datetime; strftime formats datetime -> string.

Common Misconceptions & Exam Traps

Common Pitfall: Confusing `strftime` (Format) and `strptime` (Parse)

strftime formats datetime objects into strings; strptime parses strings into datetime objects.

Buggy Code

# Trying to parse with strftime:
# dt = datetime.strftime("2026-01-01", "%Y-%m-%d") -> TypeError!

Correct Solution

from datetime import datetime
# Memory tip: 'f' = Format (to string), 'p' = Parse (from string)
dt = datetime.strptime("2026-01-01", "%Y-%m-%d")

Exam Trap Note: Remember: strftime = "string Format time", strptime = "string Parse time".

Conceptual Knowledge Self-Check Quiz

Q1: Which method parses a string timestamp into a Python datetime object?

datetime.strftime()
datetime.strptime()
datetime.parse()
datetime.from_string()

`datetime.strptime()` (Parse) converts string data into datetime objects.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Store dates in ISO 8601 format (YYYY-MM-DDTHH:MM:SS) for consistent database interoperability.
✅ Always consider timezone awareness (timezone.utc) in distributed systems.

← Python Modules & Packages Take Assessed Test → Python JSON & Regular Expressions →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.