I’d like to write a function to selectively modify lines read from a file handle and write it back. By default, lines are read as byte() objects that are immutable, so I converted it to bytearray() instead so it can be modified because only a few lines meeting certain criteria needs to be changed.
When I try to refactor similar operation into a function, I was hoping to pass the mutable bytearray() as an argument and directly modify the caller’s content like in C++, given Python variables works LIKE reference binding.
I know bytearray.replace() does not modify the data in place, but instead outputs the modified line to a new variable. Normally, I can simply do this:
line = line.replace(b'\tCLASS', b'')
and the code will work. However, it doesn’t do anything when I try to pass it as an argument to a Python function (unless I return
line as output). Although I am well aware that Python variables assignments to existing variables means orphaning the old data and re-purposing the label, the variable assignment behavior in Python requires careful thought when used in non-idiomatic situation.
In other words, I want this function to have side effects on the variable ‘
line‘, but I wasn’t doing it right. This is a tempting mistake for people with a C/C++ background: in C/C++, it is not possible to shadow an input parameter even if we were to explicitly declare it, so the innocent assignment I did above has to modify the object in the caller (passed as a reference to the function) in C/C++, as if I did this directly in the caller.
However, in Python, variables do not need to be declared (aka, dynamically typed). This opens up the possibility of unwittingly shadowing the input parameters, which is what happened here. Mutable arguments on the stack still can be modified through the function, but when you assign a variable using ‘=’ operator, a new local variable with the name on the LHS is created, which shadows the input parameter.
This means the connection to the caller objects is lost during shadowing.
The correct way to do this is use slice assignment (which the logic/concept is very different despite the syntax is similar) to replace all the contents of the input variable with the output of bytearray.replace():
def remove_from_header_token_CLASS(tokens, line): # line is expected to be byte array (mutable) try: column_CLASS = tokens.index(b'CLASS') except: column_CLASS = None else: line[:] = line.replace(b'\tCLASS', b'') return column_CLASS
Since Python has a clear distinct concept of parameter variable (from local variable), trying to apply nonlocal keyword over it (in hopes to broaden the scope) will not parse/compile.
This is actually the same behavior as in MATLAB (dynamic typing) for the same reason that variables does not have to be declared like in C/C++ (static typing). In MATLAB, if you choose to have a handle object (which works like references), you can shadow the input argument by creating a local variable of the same name:
classdef DemoHandleClass < handle properties x = 3; end end function demo_shadowing() C = DemoHandleClass(); f(C); disp(C.x) end function f(C) C = DemoHandleClass(); // Shadowing C.x = 14; end
The above MATLAB program will display 14 without shadowing and 3 with shadowing (C became a new local variable that has nothing to do with the input argument C). MATLAB users rarely run into this because the language design heavily discourage side-effects: we are supposed to return the changed local variable to the caller. The only way to do side-effects in MATLAB is through handles (which you need to establish a class, which is clumsy). Technically you can write the data to external resources (e.g. file) and read it back. But guess what? Resources are accessed through handles, so there’s no escape.
Of course, there’s a better way to do so (MATLAB’s preferred way): return the modified object back to the caller as if they are immutable:
def remove_from_header_token_CLASS(tokens, line): # line DOES NOT HAVE TO BE MUTABLE try: column_CLASS = tokens.index(b'CLASS') except: column_CLASS = None else: line = line.replace(b'\tCLASS', b'') return column_CLASS, line
This is what I ultimately used (so I ended up not converting the byte lines to bytearray), given that Python’s tuple syntax make it easy to return multiple outputs like MATLAB. The call ended up looking like this:
column_SPL_CLASS, line = remove_from_header_token_CLASS(tokens, line)
Nonetheless, I think there’s an important lesson to be learned for doing side-effects in dynamically typed languages. Maybe I’ll need this one day if I get an excuse to do something more complicated that genuinely requires side-effects.
In summary, variable assignments in most dynamically typed languages will shadow the input argument with a newly generated local variable instead of modifying the data in the original input argument. This implies that there function side-effects cannot be carried out through variable assignment.
The most common implication is: do not (equality) assign to a input variable to modify its contents in a dynamically typed language.
37 total views, no views today