{"title":"min, max, sum","description":"","content":"`min`, `max`, and `sum` are three of Python's most-used built-ins. Each one collapses an iterable into a single number, and each one has a `key=` argument that turns it into something much more powerful than the basic definition suggests. This lesson covers the basic forms, the `key` and `default` arguments, what `sum` does with strings and custom objects, and the patterns where these built-ins beat writing the loop by hand.\n\n---\n\n# min and max: Two Calling Forms\n\nBoth `min` and `max` accept either an iterable or two-or-more positional arguments. Same function, two shapes.\n\n\n```python\nprices = [29.99, 14.99, 9.99, 49.99, 19.99]\n\nprint(min(prices))\nprint(max(prices))\n\nprint(min(29.99, 14.99, 9.99))\nprint(max(29.99, 14.99, 9.99))\n```\n\n\nThe iterable form is the common one: a list, tuple, set, generator, or anything else that can be iterated. The positional form is a shortcut for \"the smaller of these two or three values\", which shows up in clamping code like `min(quantity, stock_left)` to cap a cart quantity at the available stock.\n\nOne important rule: the two forms can't be mixed. `min([1, 2, 3], 4)` doesn't compare a list with a number element-wise; it compares the list and the number directly, which in Python 3 raises `TypeError`.\n\n\n```python\ntry:\n print(min([1, 2, 3], 4))\nexcept TypeError as e:\n print(f\"Error: {e}\")\n```\n\n\nTo take the smaller of \"everything in the list\" and \"some other value\", unpack the list: `min(*[1, 2, 3], 4)` works because it expands the list into separate positional arguments.\n\nBoth `min` and `max` are O(n) and single-pass. They walk the iterable once, holding onto the running extreme. For the top three or top ten, use `heapq.nsmallest` and `heapq.nlargest`, which are O(n log k) and avoid a full sort.\n\n---\n\n# The key Argument\n\nBy default, `min` and `max` compare items directly. That works for numbers and simple strings. With richer data, they need to be told what to compare, which is what `key` does. The mechanic is identical to `sorted`: `key` is a function that takes one item and returns the value to use for comparison.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"rating\": 4.2},\n {\"name\": \"Webcam\", \"price\": 49.99, \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"price\": 14.99, \"rating\": 3.9},\n]\n\ncheapest = min(products, key=lambda p: p[\"price\"])\ntop_rated = max(products, key=lambda p: p[\"rating\"])\n\nprint(f\"Cheapest: {cheapest['name']} at ${cheapest['price']}\")\nprint(f\"Top rated: {top_rated['name']} at {top_rated['rating']}\")\n```\n\n\nTwo structural points. The returned value is the whole product dict, not just the price or rating. The key is only used for comparison; the original item is what's returned. This is the \"argmax\" pattern: instead of finding the maximum value, the call finds the item that produced the maximum value. In other languages this is a separate function; in Python, `key` does the work.\n\nFor the common case of \"pull this field out of a dict\" or \"pull this attribute off an object\", the `operator` module helpers work just as well here:\n\n\n```python\nfrom operator import itemgetter, attrgetter\n\ncheapest = min(products, key=itemgetter(\"price\"))\nprint(cheapest[\"name\"])\n\nclass Product:\n def __init__(self, name, price):\n self.name = name\n self.price = price\n def __repr__(self):\n return f\"{self.name} (${self.price})\"\n\ncatalog = [Product(\"Mouse\", 29.99), Product(\"Cable\", 9.99), Product(\"Webcam\", 49.99)]\nprint(min(catalog, key=attrgetter(\"price\")))\n```\n\n\n`itemgetter(\"price\")` and `attrgetter(\"price\")` are both implemented in C, so they run a little faster than the equivalent lambda. The bigger win is readability: `key=itemgetter(\"price\")` states what it does without requiring the reader to parse a lambda body.\n\nA third helper, less common, is `operator.methodcaller`. It builds a function that calls a named method on each item.\n\n\n```python\nfrom operator import methodcaller\n\nnames = [\"wireless MOUSE\", \"USB cable\", \"Webcam\"]\nshortest = min(names, key=methodcaller(\"lower\"))\nprint(shortest)\n```\n\n\n`methodcaller(\"lower\")` returns a function equivalent to `lambda s: s.lower()`. For most code, the lambda or a plain `key=str.lower` reads as well.\n\n---\n\n# The argmax Pattern\n\nA common idiom: find the item that scores highest on some metric. This is \"argmax\" (argument of the max) in math, and `max` plus `key` does it directly.\n\n\n```python\ncarts = [\n {\"id\": 1, \"total\": 124.50, \"items\": 5},\n {\"id\": 2, \"total\": 38.99, \"items\": 2},\n {\"id\": 3, \"total\": 245.00, \"items\": 8},\n {\"id\": 4, \"total\": 89.00, \"items\": 3},\n]\n\nbiggest_cart = max(carts, key=lambda c: c[\"total\"])\nfullest_cart = max(carts, key=lambda c: c[\"items\"])\n\nprint(f\"Biggest: cart {biggest_cart['id']} at ${biggest_cart['total']}\")\nprint(f\"Fullest: cart {fullest_cart['id']} with {fullest_cart['items']} items\")\n```\n\n\nAny \"best by X\" query fits this pattern. Top customer by orders, cheapest in-stock item, longest review, highest-margin product, the cart closest to a free-shipping threshold. They're all `max(items, key=...)` or `min(items, key=...)` with the right key function.\n\nTo get the score alongside the item, pull it out after the fact, or use a tuple-returning generator:\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"stock\": 12},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"stock\": 50},\n {\"name\": \"Webcam\", \"price\": 49.99, \"stock\": 7},\n]\n\n# Highest inventory value (price * stock)\ntop = max(products, key=lambda p: p[\"price\"] * p[\"stock\"])\nprint(f\"{top['name']}: ${top['price'] * top['stock']:.2f} sitting in inventory\")\n```\n\n\nThe key function can be any expression. It doesn't have to read a single field. Here it multiplies two of them, which fits the case where \"best\" depends on a derived quantity.\n\nFor multi-key tie-breaking, return a tuple from the key function. Tuples compare element by element, exactly like in `sorted`:\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"rating\": 4.5},\n {\"name\": \"HDMI Cable\", \"price\": 14.99, \"rating\": 4.5},\n {\"name\": \"Webcam\", \"price\": 49.99, \"rating\": 4.8},\n]\n\n# Best rating, cheapest as a tiebreaker\nbest = max(products, key=lambda p: (p[\"rating\"], -p[\"price\"]))\nprint(best[\"name\"])\n```\n\n\nThe Webcam wins on rating. If two items tied on rating, the tuple comparison would fall to the second element, where the negated price means \"cheaper is better\" within a tie.\n\n---\n\n# The default Argument\n\n`min`, `max`, and `sum` differ on what they do with an empty iterable. `sum` returns its start value (defaulting to `0`). `min` and `max` raise `ValueError`.\n\n\n```python\ntry:\n print(max([]))\nexcept ValueError as e:\n print(f\"Error: {e}\")\n```\n\n\nPython 3.4 added a `default` argument to `min` and `max` for this case. Pass it and the empty iterable returns the default instead of raising.\n\n\n```python\nempty_cart = []\n\ncheapest = min(empty_cart, default=None)\nexpensive = max(empty_cart, default=0)\n\nprint(cheapest, expensive)\n```\n\n\nThis is the cleanest way to handle \"find the most expensive item, or zero if the cart is empty\" without a defensive `if`. It also works with a generator expression and a `key` function together, which is where the alternative (a try/except around the call) gets awkward.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"stock\": 0},\n {\"name\": \"USB Cable\", \"stock\": 0},\n]\n\nmost_in_stock = max(\n (p for p in products if p[\"stock\"] > 0),\n key=lambda p: p[\"stock\"],\n default=None,\n)\nprint(most_in_stock)\n```\n\n\nThe generator filters out the zero-stock items, leaving nothing. Without `default=None`, this would raise `ValueError`. With it, the call returns `None` and the rest of the code can handle it naturally.\n\n`default` is checked once, only when the iterable turns out to be empty. There's no per-element overhead. Use it liberally; it's the right pattern for any min/max call where an empty input is possible.\n\n---\n\n# sum: How It Actually Works\n\n`sum(iterable, start=0)` walks the iterable and accumulates a running total starting from `start`. The mechanic is `start + first + second + third + ...`, left to right.\n\n\n```python\nprices = [29.99, 14.99, 9.99, 49.99, 19.99]\n\ncart_total = sum(prices)\nwith_shipping = sum(prices, start=5.00)\n\nprint(f\"Cart total: ${cart_total:.2f}\")\nprint(f\"With shipping: ${with_shipping:.2f}\")\n```\n\n\n`start` is also positional, so `sum(prices, 5.00)` works the same way. It's the closest thing `sum` has to a `key` argument, except `start` controls the initial value, not how items are read. For \"sum after transforming\", combine `sum` with a generator expression:\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"quantity\": 2},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"quantity\": 5},\n {\"name\": \"Webcam\", \"price\": 49.99, \"quantity\": 1},\n]\n\ncart_total = sum(p[\"price\"] * p[\"quantity\"] for p in products)\nprint(f\"Cart total: ${cart_total:.2f}\")\n```\n\n\nThe generator yields one line total per product, and `sum` adds them up. This is the common pattern: a generator expression for the per-item math, `sum` to collapse the results. It reads in the same order as the spoken description of the calculation.\n\n`sum` works on any iterable of values that support `+`. That includes ints, floats, fractions, decimals, and any custom class that defines `__add__`. It does not include strings, by deliberate design.\n\n\n```python\ntry:\n print(sum([\"a\", \"b\", \"c\"]))\nexcept TypeError as e:\n print(f\"Error: {e}\")\n```\n\n\nThe error message is unusually helpful. `sum` would technically work on strings (because `\"a\" + \"b\"` is valid), but it would be quadratic: each `+` builds a new string by copying everything that came before, so summing N strings costs O(N²) time. The built-in catches the mistake early and points to `\"\".join(strings)`, which is O(N) and the right tool for joining.\n\n\n```python\nwords = [\"mouse\", \"cable\", \"webcam\"]\nprint(\"\".join(words))\nprint(\", \".join(words))\n```\n\n\n`join` is a string method, and the string it's called on becomes the separator. The argument is the iterable of strings to join. This is the canonical Pythonic way to build a string from pieces, and it's what `sum` would do if it didn't refuse on principle.\n\n`sum(strings)` is O(N²) when it works; `\"\".join(strings)` is O(N). The built-in refusing to sum strings exists specifically to push toward the linear-time alternative. The same advice applies to any \"concat in a loop\" pattern: build a list first, then join once at the end.\n\n---\n\n# sum with Non-Strings and Custom Objects\n\nLists and tuples can be summed, with a caveat about the `start` argument. The default `start=0` is an int, and `0 + [1, 2]` raises `TypeError`, so an empty list (or tuple) must be passed as the start when summing lists.\n\n\n```python\npairs = [[1, 2], [3, 4], [5, 6]]\nflat = sum(pairs, start=[])\nprint(flat)\n```\n\n\nThat works, but it's O(N²) for the same reason as strings: each `+` builds a new list by copying. For flattening a list of lists, use `itertools.chain.from_iterable(pairs)` and wrap in `list(...)`, which is linear.\n\nFor a custom class, define `__add__` and `sum` works on instances of the class automatically. Consider a `Money` class that tracks an amount and a currency:\n\n\n```python\nclass Money:\n def __init__(self, amount, currency=\"USD\"):\n self.amount = amount\n self.currency = currency\n\n def __add__(self, other):\n if isinstance(other, Money):\n if self.currency != other.currency:\n raise ValueError(f\"Cannot add {self.currency} and {other.currency}\")\n return Money(self.amount + other.amount, self.currency)\n if other == 0:\n return self # so sum() with default start=0 works\n return NotImplemented\n\n def __radd__(self, other):\n return self.__add__(other)\n\n def __repr__(self):\n return f\"Money({self.amount}, {self.currency!r})\"\n\ncart = [Money(29.99), Money(14.99), Money(9.99)]\ntotal = sum(cart)\nprint(total)\n```\n\n\nThe `__radd__` and the `other == 0` check are the two pieces that make `sum` work without forcing the caller to pass a starting `Money(0)`. The first iteration computes `0 + Money(29.99)`, which Python tries as `int.__add__(0, Money(29.99))` (fails, returns `NotImplemented`), then falls back to `Money.__radd__(Money(29.99), 0)`, which returns the `Money` instance directly. From then on, each step is `Money + Money`, which works normally. To skip the `__radd__` step, pass `start=Money(0)` and only define `__add__`.\n\nFor floats specifically, a sharper tool exists when accuracy matters.\n\n\n```python\nimport math\n\n# Classic floating-point trouble\nprint(sum([0.1] * 10))\nprint(math.fsum([0.1] * 10))\n```\n\n\n`math.fsum` (Python 3.0+) uses a tracking algorithm that compensates for floating-point rounding error. For sums of many floats where small errors would accumulate, `fsum` is the right choice. For cart totals with a handful of items, plain `sum` is fine. The cost of `fsum` is higher than `sum`, so use it only when the precision matters.\n\n`sum` over floats can accumulate small errors that grow with the input size. `math.fsum` is slower per item but produces the mathematically correct result regardless of input size. For money, the safest path is to store amounts as integer cents and sum those.\n\n---\n\n# Combining with Comprehensions and Generators\n\nThe three built-ins pair well with a generator expression. The generator does the per-item transformation; `min`, `max`, or `sum` collapses the result.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"stock\": 12, \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"stock\": 0, \"rating\": 4.2},\n {\"name\": \"Webcam\", \"price\": 49.99, \"stock\": 7, \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"price\": 14.99, \"stock\": 4, \"rating\": 3.9},\n]\n\n# Cheapest in-stock product's price\ncheapest_in_stock = min(p[\"price\"] for p in products if p[\"stock\"] > 0)\n\n# Total inventory value across the catalog\ninventory_value = sum(p[\"price\"] * p[\"stock\"] for p in products)\n\n# Highest-rated product\ntop_rated = max(products, key=lambda p: p[\"rating\"])\n\nprint(f\"Cheapest in-stock price: ${cheapest_in_stock}\")\nprint(f\"Total inventory value: ${inventory_value:.2f}\")\nprint(f\"Top rated product: {top_rated['name']}\")\n```\n\n\nThree different questions, three single-line answers, all reading in the order the questions would be asked. The generator expressions filter and transform; the built-ins reduce. This is the standard shape of Python data work.\n\nPrefer a generator expression to a list comprehension inside these built-ins. `sum([x * 2 for x in items])` builds an intermediate list first, then sums. `sum(x * 2 for x in items)` streams one value at a time, with no intermediate allocation. Same answer, less memory.\n\n\n```mermaid\nflowchart LR\n SRC[Source iterable]:::cyan --> GEN[Generator
transforms or filters]:::orange\n GEN --> RED{Reducer}:::teal\n RED -->|sum| TOTAL[Single total]:::green\n RED -->|min/max| EXTREME[Single extreme item]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe diagram shows the shape of the pipeline. Start with a source, pipe it through a generator that does the per-item work, then collapse with the right built-in. No intermediate lists, one pass over the data, and the intent is on a single line.\n\n---\n\n# Common Patterns\n\nA handful of patterns cover most uses of these three built-ins.\n\n**Pattern 1: Clamp a value between two limits**\n\n\n```python\ndef clamp(value, low, high):\n return max(low, min(value, high))\n\n# Cap requested quantity at available stock, but not below zero\nrequested = 50\nstock = 12\nprint(clamp(requested, 0, stock))\n```\n\n\nThe nested call reads \"the larger of `low` and (the smaller of `value` and `high`)\". It pins the value into the `[low, high]` range with no `if` statements.\n\n**Pattern 2: Weighted sum (price times quantity)**\n\n\n```python\ncart = [\n {\"name\": \"Mouse\", \"price\": 29.99, \"qty\": 2},\n {\"name\": \"Cable\", \"price\": 9.99, \"qty\": 5},\n {\"name\": \"Webcam\", \"price\": 49.99, \"qty\": 1},\n]\n\ntotal = sum(item[\"price\"] * item[\"qty\"] for item in cart)\nprint(f\"${total:.2f}\")\n```\n\n\nThe generator yields each line total; `sum` adds them. For a weighted average instead of a weighted sum, divide by `sum(item[\"qty\"] for item in cart)`.\n\n**Pattern 3: Find the item closest to a target**\n\n\n```python\nprices = [9.99, 14.99, 24.99, 49.99, 89.99]\ntarget = 30.00\n\nclosest = min(prices, key=lambda p: abs(p - target))\nprint(f\"Closest to ${target}: ${closest}\")\n```\n\n\nThe `key` is the distance from the target. `min` finds the item with the smallest distance, which is the closest match. This is also the building block for \"snap to nearest\" logic in pricing tiers, discount thresholds, or shipping bands.\n\n**Pattern 4: Top-K instead of top-1**\n\nFor the three best items instead of the single best, use `heapq` rather than calling `max` repeatedly:\n\n\n```python\nimport heapq\n\nproducts = [\n {\"name\": \"Wireless Mouse\", \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"rating\": 4.2},\n {\"name\": \"Webcam\", \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"rating\": 3.9},\n {\"name\": \"Charger\", \"rating\": 4.7},\n]\n\ntop_three = heapq.nlargest(3, products, key=lambda p: p[\"rating\"])\nfor product in top_three:\n print(f\"{product['name']:<16} {product['rating']}\")\n```\n\n\n`heapq.nlargest(k, items, key=...)` is O(n log k), which beats sorting the whole list when `k` is small. There's a matching `heapq.nsmallest` for the other direction.\n\n**Pattern 5: When NOT to use these built-ins**\n\nSome shapes look like a fit but aren't. The notable ones:\n\n\n| Shape | Don't use | Use instead |\n| --- | --- | --- |\n| Concatenating strings | `sum(strings, \"\")` | `\"\".join(strings)` |\n| Flattening a list of lists | `sum(lists, [])` | `list(itertools.chain.from_iterable(lists))` |\n| Finding the index of the max | `max(...)` | `max(range(len(items)), key=items.__getitem__)` or `items.index(max(items))` |\n| Adding many floats accurately | `sum(floats)` | `math.fsum(floats)` |\n| Counting occurrences | `sum(1 for x in items if cond)` | `sum(1 for x in items if cond)` is fine, or `collections.Counter` for multi-key |\n\n\nThe flattening and concatenation rows are about quadratic-time traps. The float row is about accuracy. The index row is because `max` returns the item, not its position; getting the position requires a different formulation.","pageType":"python"}

min, max, sum

Get Premium