To learn DSA in Python, start with lists, strings, dictionaries and sets. Learn Big O alongside them, then practise two pointers, sliding windows, stacks, queues and binary search. Move on to trees, heaps, graphs, backtracking and dynamic programming. For every solution, explain why it works, test edge cases and account for time and memory.

DSA means data structures and algorithms. Data structures organise information; algorithms describe the steps used to process it. Together, they help you choose a solution that remains understandable and efficient as the input grows.

This guide is for learners who can already write small Python functions. It gives you a practical order, examples you can run and checkpoints that show whether you understand a topic. The eight-week schedule is a suggested starting plan; adjust it to your experience and available time.

What should you know before starting DSA in Python?

You do not need to finish every Python topic before starting. You should be comfortable reading a function, following a loop and predicting how a collection changes. That foundation lets you focus on reasoning instead of fighting syntax.

• Write functions with parameters and return values; distinguish returning a value from printing it.

• Use loops, conditions, enumerate, range and basic comprehensions.

• Read and update lists and dictionaries; understand indexing, slicing and mutable objects.

• Read a traceback and write assertions for expected results.

• Understand simple classes before implementing linked-list or tree nodes.

If these ideas are still unfamiliar, begin with the Python Kickstarter and return when you can write and test a small function independently.

The DSA in Python roadmap at a glance

Study one topic, solve a few variations and revisit it later without your notes. A long list of completed problems is less useful if you cannot explain which constraint made a technique appropriate.

Big O: measure the work your solution does

Big O describes how a cost grows with input size. O(1) is constant growth; O(log n) repeatedly reduces the search space; O(n) processes input proportionally; O(n log n) often appears in comparison sorting; O(n²) commonly appears when every item is compared with every other item. It describes growth, not an exact time in milliseconds.

Count the operations inside a loop as well as the loop itself. A single loop containing a linear search can still be quadratic. Two separate passes over an input are O(n), because constants disappear from this growth model. Nested loops are not automatically quadratic: their total iteration count is what matters.

These costs describe ordinary CPython collections and standard algorithm assumptions. See the official built-in complexity reference, deque documentation, bisect performance notes and heapq documentation for implementation details.

Track auxiliary space too: a copied list, a visited set or a recursion stack uses memory. State whether your space bound excludes the input and includes the returned output. The examples below use ordinary fixed-size integer/key assumptions; very large integers and expensive custom comparisons can add costs.

Lists, dictionaries and sets: build your first useful patterns

Use hashing when you need fast repeated lookup

A list preserves a sequence of values. A dictionary associates keys with values; a set tracks distinct values. For a two-sum problem, a dictionary can store a previously seen number and its index, so you can check for the missing partner as you scan.

def two_sum(nums: list[int], target: int) -> list[int]:
    seen = {}
    for index, value in enumerate(nums):
        needed = target - value
        if needed in seen:
            return [seen[needed], index]
        seen[value] = index
    return []

assert two_sum([2, 7, 11, 15], 9) == [0, 1]
assert two_sum([3, 3], 6) == [0, 1]
assert two_sum([], 9) == []

def two_sum(nums: list[int], target: int) -> list[int]:
    seen = {}
    for index, value in enumerate(nums):
        needed = target - value
        if needed in seen:
            return [seen[needed], index]
        seen[value] = index
    return []

assert two_sum([2, 7, 11, 15], 9) == [0, 1]
assert two_sum([3, 3], 6) == [0, 1]
assert two_sum([], 9) == []

def two_sum(nums: list[int], target: int) -> list[int]:
    seen = {}
    for index, value in enumerate(nums):
        needed = target - value
        if needed in seen:
            return [seen[needed], index]
        seen[value] = index
    return []

assert two_sum([2, 7, 11, 15], 9) == [0, 1]
assert two_sum([3, 3], 6) == [0, 1]
assert two_sum([], 9) == []

The dictionary contains only indices already visited. Checking before inserting prevents using the same position twice. Expected time is O(n), with O(n) auxiliary space. The function returns one valid pair of distinct indices, or an empty list when no pair exists.

• Practise: frequency counts, first repeated item, duplicate detection and grouping anagrams.

• Watch for: assuming set iteration gives sorted order or confusing a dictionary key with a list index.

• Checkpoint: explain when the extra lookup structure is worth the memory.

Two pointers, sliding windows and prefix sums

Two pointers work when moving through a sequence lets you discard possibilities safely. In a sorted pair-sum problem, a total that is too small tells you to move the left pointer. Without sorted input, that decision is not justified.

A sliding window represents a contiguous region. Expand it to include a new item, then shrink or reposition it when the rule is broken. A useful example is the longest substring containing no repeated characters.

def longest_unique_length(text: str) -> int:
    last_seen = {}
    left = 0
    best = 0
    for right, char in enumerate(text):
        left = max(left, last_seen.get(char, -1) + 1)
        last_seen[char] = right
        best = max(best, right - left + 1)
    return best

assert longest_unique_length("abcabcbb") == 3
assert longest_unique_length("abba") == 2
assert longest_unique_length("") == 0

def longest_unique_length(text: str) -> int:
    last_seen = {}
    left = 0
    best = 0
    for right, char in enumerate(text):
        left = max(left, last_seen.get(char, -1) + 1)
        last_seen[char] = right
        best = max(best, right - left + 1)
    return best

assert longest_unique_length("abcabcbb") == 3
assert longest_unique_length("abba") == 2
assert longest_unique_length("") == 0

def longest_unique_length(text: str) -> int:
    last_seen = {}
    left = 0
    best = 0
    for right, char in enumerate(text):
        left = max(left, last_seen.get(char, -1) + 1)
        last_seen[char] = right
        best = max(best, right - left + 1)
    return best

assert longest_unique_length("abcabcbb") == 3
assert longest_unique_length("abba") == 2
assert longest_unique_length("") == 0

The window from left through right contains no repeated characters. The max prevents left from moving backwards when an older duplicate is already outside the window. Expected time is O(n), and auxiliary space is O(u), where u is the number of distinct characters encountered. This treats Python string elements as characters, not user-perceived grapheme clusters.

Prefix sums store cumulative totals so a range sum can be answered by subtraction. For nums = [2, 4, 1], build prefix = [0, 2, 6, 7]. The sum over the half-open range [1, 3) is prefix[3] - prefix[1], or 5. Building the prefix array takes O(n) time and space; each subsequent range query is O(1).

• Practise: sorted pair sum, maximum sum of a fixed-size window and repeated range-sum queries.

• Watch for: mixing inclusive and exclusive boundaries.

• Checkpoint: state the window rule before writing the loop. A variable-size sum window may fail when negative values break the monotonic behaviour you rely on.

Stacks, queues and linked lists

A stack processes the most recently added item first. Use list.append and list.pop for bracket matching, undo histories or an iterative depth-first traversal. A queue processes the oldest pending item first, which is useful for breadth-first exploration.

For a Python queue, use collections.deque with append and popleft. Repeated list.pop(0) shifts the remaining entries and can turn a traversal into unnecessary quadratic work.

A linked list stores values in nodes connected by references. Practise reversing a list and using slow/fast pointers to detect a cycle. Keep track of the next reference before overwriting a link. Finding a position still requires traversal; constant-time insertion assumes you already have the relevant node reference.

• Practise: valid brackets, a queue simulation, reversing a linked list and cycle detection.

• Watch for: popping an empty stack and losing access to the remaining linked-list nodes.

• Checkpoint: draw each reference change on paper before running the code.

Binary search, sorting and heaps

Binary search needs an ordered search space and a rule that safely eliminates part of it. Begin with a sorted list, then learn how to search for a boundary or the first value satisfying a monotonic condition.

from bisect import bisect_left

def find_sorted(nums: list[int], target: int) -> int:
    index = bisect_left(nums, target)
    if index < len(nums) and nums[index] == target:
        return index
    return -1

assert find_sorted([1, 3, 3, 7], 3) == 1
assert find_sorted([1, 3, 7], 5) == -1
assert find_sorted([], 3) == -1

from bisect import bisect_left

def find_sorted(nums: list[int], target: int) -> int:
    index = bisect_left(nums, target)
    if index < len(nums) and nums[index] == target:
        return index
    return -1

assert find_sorted([1, 3, 3, 7], 3) == 1
assert find_sorted([1, 3, 7], 5) == -1
assert find_sorted([], 3) == -1

from bisect import bisect_left

def find_sorted(nums: list[int], target: int) -> int:
    index = bisect_left(nums, target)
    if index < len(nums) and nums[index] == target:
        return index
    return -1

assert find_sorted([1, 3, 3, 7], 3) == 1
assert find_sorted([1, 3, 7], 5) == -1
assert find_sorted([], 3) == -1

This returns the leftmost matching index, or -1. Search takes O(log n) time and O(1) auxiliary space for a list of ordinary comparable values. Sorting beforehand costs extra, so include that work when analysing an unsorted-input solution.

The bisect reference distinguishes a logarithmic search from insort, whose list insertion is O(n). A fast search does not make moving list elements free.

Use sorted when you need a new ordered list and list.sort when changing the original list is acceptable. Understand merge sort as an example of divide and conquer. Learn why quicksort performance depends on partitioning, and why a binary search tree is not automatically balanced.

A heap keeps a priority item accessible without maintaining a completely sorted sequence. Use a min-heap for repeatedly selecting the smallest pending value; practise keeping only the largest k items with a heap of size k.

• Practise: first/last occurrence, merging intervals, kth-largest values and scheduling by priority.

• Watch for: reading heap storage as sorted output; only the heap ordering invariant is guaranteed.

• Checkpoint: explain why you need a sorted sequence, a boundary search or just the next priority item.

Trees and graphs: learn BFS and DFS

A tree connects nodes hierarchically without cycles. A graph can represent routes, dependencies or relationships, including cycles and disconnected components. Use an adjacency list to describe each vertex’s neighbours.

Breadth-first search, or BFS, visits vertices by increasing number of edges from the start. It can find the shortest distance in an unweighted graph. Depth-first search, or DFS, follows a branch before returning and is useful for exploring components and dependencies.

from collections import deque

def shortest_hops(graph, start, target):
    queue = deque([(start, 0)])
    visited = {start}
    while queue:
        node, distance = queue.popleft()
        if node == target:
            return distance
        for neighbour in graph.get(node, ()):
            if neighbour not in visited:
                visited.add(neighbour)
                queue.append((neighbour, distance + 1))
    return None

graph = {"A": ["B", "C"], "B": ["D"],
         "C": ["D"], "D": []}
assert shortest_hops(graph, "A", "D") == 2
assert shortest_hops(graph, "D", "A") is None
assert shortest_hops(graph, "A", "A") == 0

from collections import deque

def shortest_hops(graph, start, target):
    queue = deque([(start, 0)])
    visited = {start}
    while queue:
        node, distance = queue.popleft()
        if node == target:
            return distance
        for neighbour in graph.get(node, ()):
            if neighbour not in visited:
                visited.add(neighbour)
                queue.append((neighbour, distance + 1))
    return None

graph = {"A": ["B", "C"], "B": ["D"],
         "C": ["D"], "D": []}
assert shortest_hops(graph, "A", "D") == 2
assert shortest_hops(graph, "D", "A") is None
assert shortest_hops(graph, "A", "A") == 0

from collections import deque

def shortest_hops(graph, start, target):
    queue = deque([(start, 0)])
    visited = {start}
    while queue:
        node, distance = queue.popleft()
        if node == target:
            return distance
        for neighbour in graph.get(node, ()):
            if neighbour not in visited:
                visited.add(neighbour)
                queue.append((neighbour, distance + 1))
    return None

graph = {"A": ["B", "C"], "B": ["D"],
         "C": ["D"], "D": []}
assert shortest_hops(graph, "A", "D") == 2
assert shortest_hops(graph, "D", "A") is None
assert shortest_hops(graph, "A", "A") == 0

Marking a vertex when it enters the queue prevents repeated enqueuing. For the reachable part of an adjacency-list graph, expected time is O(V + E) and auxiliary space is O(V), assuming constant-cost vertex hashing. Missing adjacency entries are treated as vertices with no outgoing edges. The function returns a distance, not the route itself.

BFS does not solve arbitrary weighted shortest-path problems. Learn Dijkstra’s algorithm when edge weights are nonnegative, and learn its assumptions before using it. For deep trees or graphs, an explicit stack can avoid the recursion-depth problem of a recursive DFS.

• Practise: tree traversals, maximum tree depth, counting connected components and shortest unweighted routes.

• Watch for: missing a visited set, assuming every graph is connected or treating a directed edge as bidirectional.

• Checkpoint: explain what is stored in the frontier and why the next removed node is safe to process.

Backtracking, greedy algorithms and dynamic programming

Backtracking explores choices, then undoes a choice before trying another branch. Use it for subsets, permutations and constrained searches. Draw a small decision tree and identify when a partial answer can be rejected early. Producing all subsets already requires exponential-size output; no implementation trick removes that output cost.

A greedy algorithm commits to a local choice. It needs a reason that this choice can still lead to an optimal complete answer. Test the proposed rule on counterexamples before trusting it. Choosing the largest coin first, for example, fails for some coin systems.

Dynamic programming stores answers to states that would otherwise be solved repeatedly. Define the state, transition, base cases and evaluation order before optimising storage. Counting ways to climb stairs with steps of one or two gives a compact first example.

def count_stair_ways(n: int) -> int:
    if n < 0:
        raise ValueError("n must be nonnegative")
    previous, current = 1, 1
    for _ in range(n):
        previous, current = current, previous + current
    return previous

assert count_stair_ways(0) == 1
assert count_stair_ways(1) == 1
assert count_stair_ways(5) == 8

def count_stair_ways(n: int) -> int:
    if n < 0:
        raise ValueError("n must be nonnegative")
    previous, current = 1, 1
    for _ in range(n):
        previous, current = current, previous + current
    return previous

assert count_stair_ways(0) == 1
assert count_stair_ways(1) == 1
assert count_stair_ways(5) == 8

def count_stair_ways(n: int) -> int:
    if n < 0:
        raise ValueError("n must be nonnegative")
    previous, current = 1, 1
    for _ in range(n):
        previous, current = current, previous + current
    return previous

assert count_stair_ways(0) == 1
assert count_stair_ways(1) == 1
assert count_stair_ways(5) == 8

ways(n) equals ways(n - 1) + ways(n - 2): the last move was either one or two steps. There is one way to climb zero steps: take no steps. This implementation performs O(n) additions and keeps O(1) integer variables. The integers themselves grow with n, so constant variable count does not imply constant bit-space for arbitrarily large inputs.

• Practise: subsets, combination searches, interval scheduling and minimum-cost grid paths.

• Watch for: memoizing a state that omits information needed for future decisions.

• Checkpoint: describe a state in one sentence and explain why each dependency has already been computed.

An eight-week DSA practice plan

Use this as an adjustable study schedule, not a promise of interview readiness. If you cannot solve a small variation without copying, repeat that stage. A suggested session is 10 minutes reviewing an earlier problem, 30 minutes solving and 15 minutes testing and writing notes.

Aim first for two or three carefully reviewed problems per topic, then add variations. Re-solve one the following day and again after a week. This is a suggested routine rather than a universal problem-count target. The useful signal is whether you recognise the structure and justify your choices.

How to solve a DSA problem without memorising the answer

1. Clarify the contract: input shape, output, duplicates, ordering, mutation and allowed values.

2. Work a tiny example by hand, including an empty input or a missing result.

3. Write a correct straightforward approach and estimate its cost.

4. Identify repeated work or an invariant that enables a better approach.

5. Implement the idea, explaining what each state variable represents.

6. Test boundaries and adversarial examples; compare small cases with the straightforward version.

7. Record the time and auxiliary-space bounds with their assumptions.

Use an AI assistant to request hints, counterexamples or a review of your complexity argument. Try the problem yourself before asking for a full solution. Then explain the result without the assistant and run it: a plausible explanation is not evidence that code handles duplicate values or boundary conditions.

For interviews, practise talking through decisions while writing readable code. Ask about constraints before optimising. There is no algorithm checklist or number of solved questions that guarantees a job offer.

Turn DSA practice into a small Python project

Choose one project and document the input contract, the structure you selected, the alternatives you rejected and the tests you ran. Measure representative inputs after you have a correct solution; small timings alone cannot establish an asymptotic complexity bound.

For project ideas beyond exercises, explore the Python Project Vault. The Python Bundle brings together broader Python learning resources; use the product page to check its current contents. This article’s DSA roadmap is a standalone study plan.

If your longer-term goal is AI development, continue with What to Learn in Python for AI in 2027 to connect Python fundamentals with APIs, data and application testing.

Frequently asked questions about DSA in Python

Is Python good for learning data structures and algorithms?

Yes. Python’s concise syntax lets you focus on the algorithm, while lists, dictionaries, sets, deque and heapq cover many common tasks. You still need to understand the costs of those operations and any restrictions of your interview or programming platform.

Should I learn Python or DSA first?

Learn enough Python to write functions, loops and collection operations, then study them together. Add classes when you reach linked structures. You do not need web frameworks, machine learning or advanced metaprogramming before beginning DSA.

How long does it take to learn DSA in Python?

The eight-week plan above is an introduction for someone with basic Python knowledge. Depth, retention and interview readiness take further practice and depend on your starting point. Advance when you can explain and test unfamiliar variations, rather than when a calendar says you should.

Do I need DSA for AI and automation?

Basic collection choice, complexity analysis, queues and search are useful when processing records or coordinating work. Advanced interview-style DSA is not a prerequisite for every AI application. Match your depth to the tasks and hiring expectations you actually face.

Do I have to implement every structure from scratch?

Implement a few to understand their behaviour, especially linked lists, tree traversal and a basic search. In ordinary projects, use well-tested built-ins and standard-library tools when they fit. Knowing how a structure works helps you use the existing implementation responsibly.

Your next step

Start with the two-sum example. Predict its behaviour on [3, 3] before running it, write a simple double-loop alternative and compare the two explanations. Then solve a different lookup problem without notes. That small cycle of reasoning, implementation and testing is the habit this roadmap is designed to build.

Browse Python resources when you want a structured foundation or a practical project to apply next.

Official Python references

Python data structures tutorial — lists, dictionaries, sets and collection operations.

Time complexity of built-in types — CPython operation costs and assumptions.

collections.deque — queues and efficient operations at both ends.

bisect — sorted search, insertion points and performance notes.

heapq — priority queues and heap operations.