== A Python limit I never expected to run into I've known for a while that the Python interpreter has a few little internal limits and [[implementation quirks ALengthGotcha]]. I can accept that; limits on the sizes of internal objects are not unexpected, and you have to draw the line somewhere. But I was surprised to discover that the Python interpreter has a limit on how many arguments you can write in a function call; 255, as it happens. (The limitation is on explicit arguments in the source code; you can call functions with many more arguments if you build a list and then use '_func(*lst)_' notation.) You might ask how anyone writes a function call with 255 arguments. In my case, one argument at a time; the function in question compiles a bunch of IP netblocks and ranges, in string form, into a set type object that other IP addresses get matched against. When I was only putting a few netblocks in the set, having them be function arguments made sense. (In fact I think that it still makes sense; I have to list them *somehow*, unless I exile them to a separate data file, so I might just do it directly as function arguments.) I probably should have noticed that something was wrong earlier, but I'm bad at noticing my programs growing unless they do it in large jumps. If they just grow by a function here and some entries in a list there, without forcing me to step back for an overall view, a few hundred lines can transform into a two thousand line hulk without me really noticing. === The nitty gritty details Because I got curious and looked it up in the CPython source: the actual limit is 255 positional arguments plus an additional 255 keyword arguments. It exists because of how the argument counts are encoded into the Python bytecode; each one is effectively restricted to a byte. Explicit _func(*lst)_ style function invocation sidesteps this. Some quick experimentation with _compile()_ suggests that there is no limit on how many parameters a function can be declared with.