function parameter typing

[dineshbvadhia]

In the contrived example below, when the function do_bee() is called are the parameters typed or not?

p: str  = 'pestil'
f: str = 'flower'

honey: list[str] = do_bee(p, f)  # or, do_bee(p: str, f: str)

def do_bee(p: str, f: str):
        return list[f, p]

[JelleZijlstra]

I'm not clear on what you're asking. Your example won't run because pestil and flower are undefined names, and because there is a mismatch in the name of the function. Also, list[flower, pestil] isn't meaningful.

[dineshbvadhia]

Apologies, question re-framed.

[erictraut]

It's not clear from your question what you mean by "typed".

Let's consider the following function:

def do_bee(p, f):
    print(f'The type of p is {type(p)}')
    print(f'The type of f is {type(f)}')

do_bee("pestil", "flower")

If you run this code, you will see the following output:

The type of p is <class 'str'>
The type of f is <class 'str'>

At runtime, all values have a type, and if a value has been assigned to ("bound to") a symbol, then that symbol has a type. Parameters (like p and f in this example) are symbols whose values are assigned when you call the function.

So the general answer to your question is "yes, all parameters have types" because every parameter has a value, and every value has a type.

In your code sample, you have also specified static type annotations for parameters p and f. The Python interpreter largely ignores these annotations, so they don't really mean anything at runtime. You can think of these as comments that are understood by your editor (assuming it has language server support). They allow you to declare your intent as a programmer, effectively saying "I am assuming that these parameters will be assigned only values that are of type str".

Consider this code, which has a comment. This comment is useful to a human who is reading your code, but tools won't be able to do much with this text.

def do_bee(p, f):
    """
    This function prints two strings. It requires that
    both parameters are `str` instances.
    """
    print(p.lower() + ": " + f.lower())

do_bee(1, 2) # This will crash at runtime

Now consider this version, which has type annotations that can be understood by a language server or type checker.

def do_bee(p: str, f: str):
    print(p.lower() + ": " + f.lower())

do_bee(1, 2) # Your editor will now tell you about the error before you run the code!

(Note: if you're using VS Code and the Pylance language server, you will need to enable basic type checking to receive the above error. You can do this by opening your settings and setting "python.analysis.typeCheckingMode" to "basic".)