Introduction

If by "one line" you mean a compact expression for binary search, it is possible in Python, but it is usually not the best implementation to keep. Binary search is easier to reason about when the boundaries are explicit, and in production Python code the bisect module is usually better than writing a code-golf version by hand.

A Practical Python Solution

The standard-library approach is bisect_left:

1from bisect import bisect_left
2
3def binary_search(arr, target):
4    i = bisect_left(arr, target)
5    return i if i < len(arr) and arr[i] == target else -1
6
7print(binary_search([1, 3, 5, 7, 9], 7))
8print(binary_search([1, 3, 5, 7, 9], 4))

This is short, correct, and easier to maintain than a compressed recursive expression.

The Classic Manual Version

If you want to understand the algorithm itself, write it out:

1def binary_search_manual(arr, target):
2    left, right = 0, len(arr) - 1
3
4    while left <= right:
5        mid = (left + right) // 2
6
7        if arr[mid] == target:
8            return mid
9        if arr[mid] < target:
10            left = mid + 1
11        else:
12            right = mid - 1
13
14    return -1

That version is clear about the search interval and much easier to debug.

A One-Liner Style Version

If you really want a compact expression, you can wrap bisect_left:

from bisect import bisect_left

binary_search = lambda a, x: (lambda i: i if i < len(a) and a[i] == x else -1)(bisect_left(a, x))

This technically satisfies the "one line" idea, but it is not more informative than the named function above.

Why One-Liners Are Usually the Wrong Goal

Binary search is famous for off-by-one mistakes. Compressing the logic into a single expression makes those mistakes harder to spot.

A one-liner also makes it harder to:

• Explain what left, right, and mid mean
• Handle first-occurrence or last-occurrence variants
• Add debugging output
• Teach the algorithm to someone else

So the compact version is fine as an exercise, but not usually as the version you want to maintain.

It also makes variant behavior harder. As soon as you want "first occurrence," "last occurrence," or "insertion point for duplicates," the clean one-liner usually turns into unreadable code faster than the normal loop version does.

When bisect Is Best

In Python, bisect is often the best answer because:

• It is part of the standard library
• It is well-tested
• It expresses intent clearly

If the real goal is "find the insertion point" rather than "return exact index or -1," then bisect is even more natural.

That is one more reason not to over-optimize for the one-line version. The standard library already gives you the compactness and correctness without turning the search logic into a puzzle.

Common Pitfalls

• Running binary search on an unsorted list.
• Using a one-liner and then struggling to modify it for duplicate-handling rules.
• Returning the insertion point as if it were a confirmed match.
• Optimizing for line count instead of clarity.

Summary

• You can write binary search in one line, but that is rarely the best version to keep.
• In Python, bisect_left is the cleanest practical tool.
• The classic manual loop is still the best way to learn and explain the algorithm.
• One-liners are acceptable for exercises, not usually for maintainable code.
• Binary search correctness matters more than compactness.

Readable search code wins in the long run. That matters more than line count.