Why does Python allow function calls with wrong number of arguments?
Question: Python is my first dynamic language. I recently coded a function call
incorrectly supplying a wrong number of arguments. This failed with an
exception at the time that function was called. I expected that even in a
dynamic language, this kind of error can be detected when the source file is
parsed.

I understand that the **type** of actual arguments is not known until the
function is called, because the same variable may contain values of any type
at different times. But the **number** of arguments is known as soon as the
source file is parsed. It is not going to change while the program is running.

### So that this is not a philosophical question

To keep this in scope of Stack Overflow, let me phrase the question like this.
Is there some feature, that Python offers, that requires it to delay checking
the number of arguments in a function call until the code actually executes?


Answer: Python cannot know up-front what object you'll end up calling, because being
dynamic, you can _swap out the function object_. At any time. And each of
these objects can have a different number of arguments.

Here is an extreme example:

    
    
    import random
    
    def foo(): pass
    def bar(arg1): pass
    def baz(arg1, arg2): pass
    
    the_function = random.choice([foo, bar, baz])
    print(the_function())
    

The above code has a 2 in 3 chance of raising an exception. But Python cannot
know a-priori if that'll be the case or not!

And I haven't even started with dynamic module imports, dynamic function
generation, other callable objects (any object with a `__call__` method can be
called), or catch-all arguments (`*args` and `**kwargs`).

But to make this extra clear, you state in your question:

> It is not going to change while the program is running.

This is not the case, not in Python, once the module is loaded you can delete,
add or replace any object in the module namespace, including function objects.

