当我在函数中传递一个完全不同的参数名称时会发生什么？

Question

Let's say I have this function:

def print_a_line(line_count, f):
    print line_count, f.readline()

I call it by:

current_line = 3
print_a_line(current_line, current_file)

What happens now? line_count = 3 or will it be line_count= current_line = 3?

Also, is it a bad thing if I pass different argument names(like I did here with current_line instead of line_count?)

Answer 1

What happens now? line_count = 3 or will it be line_count= current_line = 3?

line_count is bound to 3 inside the call to print_a_line . The variable current_line is unaffected by the call.

Also, is it a bad thing if I pass different argument names(like I did here with current_line instead of line_count?)

It's not a bad thing at all. You are using positional arguments rather than named arguments.

In Python, there are two kinds of arguments: positional arguments and named arguments. A function declared like your print_a_line function above is using only positional arguments. A function with only named arguments might look like

def print_a_line_2(line_count=3, f=None):
    if f is not None:
        print line_count, f.readline()

A function with both positional and named arguments might look like

def print_a_line_2(line_count, f, append_newline=True):
    if append_newline:
        print line_count, f.readline()
    else:
        print line_count, f.readline(),

The reason that positional arguments are called positional is that only the position of the arguments you pass matters. So you can write any two expression you like as the arguments to print_a_line , and whichever argument is passed first will be bound to line_count , and whichever argument is passed second will be bound to f during the execution of print_a_line .

That's not the case for named arguments , but the syntax is different there. To pass a named argument, you write name=expression instead of simply writing expression . So, to call print_a_line_2 , you could write

print_a_line_2(line_count=3, f=current_file)

and the names of the arguments come from what is before the equals sign, not what is after the equals sign.

For more on named and positional arguments, I would recommend checking out the Python tutorial .

EDIT : What happens under the hood whenever you call line_count(current_line, current_file)

The Python interpreter maintains several pieces of information about your program, and some of the important things it maintains are a symbol table, which binds names (variables) to their values, and a current statement pointer. Whenever the current statement pointer reaches the line

print_a_line(current_line, current_file)

the Python interpreter looks up print_a_line , current_line , and current_file in the symbol table. It finds that print_a_line is bound to the function that you defined in your question, that current_line is bound to 3, and that current_file is bound to a file object (this is a big implementation-defined data structure, which for ease of notation I'll call F, with the uppercase F distinguished from the lowercase f we will meet in a bit). Since print_a_line is a function, the interpreter calls the function with arguments 3 and F. To accomplish this, it saves the current state of execution, binds variable line_count to 3 and f to F in the symbol table, and moves the current statement pointer to the first line of the print_a_line function, which is

print line_count, f.readline()

It then executes the built-in print statement in much the same way as it executed the original function call, looking up all variables in the symbol table and making a function call to f.readline() in the same way as the overall function call to print_a_line . Then, when the print_a_line function returns, the Python interpreter removes line_count and f from the symbol table, and moves the statement pointer back to the location it saved earlier. It then continues execution with the line of code after the call to print_a_line .

Answer 2

You're confusing scopes. Let's assume your file looks like this:

def print_a_line(line_count, f):
    print line_count, f.readline()

def main():
    current_line = 3
    print_a_line(current_line, current_file)

if __name__ == "__main__":
    current_file = open('file.txt')
    main()

In main , you have current_line=3 , and current_line is a local variable. The method print_a_line and the variable current_file are global, which is why main can use them. In print_a_line , you have the local variables line_count and f , which are the same as current_line and current_file , respectively. But, because current_line is local to main and line_count is local to print_a_line , there is no scope where current_line == line_count would evaluate to True .

It is definitely not a bad thing to do this - the same value might mean different things in different scopes, and the names of the variables should reflect this.

Answer 3

Read up in the places the others have recommended. Using different names when you define and when you call a function is not a bad thing; in fact I would recommend it until you have a good grasp of scopes and all that.