In this step, we have our falling piece respond to left-arrow, right-arrow, and down-arrow key presses by moving in the given direction.  Also, for testing purposes, we will add temporary code that changes the falling piece whenever any other key is pressed.  This code will be removed after this step.
 

Actually, we only want to move in a given direction if it is legal to do so.  There are two reasons why it may not be legal:  the falling piece may wind up off of the board, or a part of the falling piece may collide with a non-empty cell on the board.  In either case, we should not move the falling piece.  Among other consequences, this means that for now, once pieces reach the bottom of the board, we will not be able to move them any lower, yet we will not place them on the board.  That comes later.  For now, the piece will stay there until we use the temporary test code to change the falling piece (which also places the new falling piece back at the top-center of the board).
 

One approach would be to test if a move is legal first, and if it is, then make the move.  That approach requires different code, however, to test for each type of move we might make (left, right, down, and, eventually, rotation), which is unnecessarily complicated.  An easier approach is to blindly make the move, then test if the result of the move is legal.  If it is not legal, then unmake the move.  In this way, a single legal move test can be used for any sort of move.  We will use this move-test-unmove design.
 

Explaining moveFallingPiece:
Next, we will write a function that will move the falling piece a given number of rows and columns:
 def moveFallingPiece(data, drow, dcol)
We use "drow" to signify a change in rows (the "d" in "drow" stands for the mathematical symbol "delta", meaning change).  Similarly, "dcol" is the change in columns.  Consider:  a move to the left would change our column by -1 (since columns go down to the left), and keep our row constant.  Thus, with this function, we can move to the left by calling moveFallingPiece(data,0,-1).  Similarly, we can move to the right with moveFallingPiece(data,0,+1).  And to move down, we hold our column constant and add one to our row:  moveFallingPiece(data,+1,0).
 

Writing moveFallingPiece:
As noted above, we proceed in three steps.  First, we simply make the move by modifying the data values storing the location of the left-top corner of the falling piece.  Next, we test if this new location of the falling piece is legal.  We do this using top-down design, so we assume the function fallingPieceIsLegal exists at this point, and we'll actually write it in a moment.  If the new location is not legal (because it was off the board or because it collided with a non-empty cell on the board), then we undo the move we just made, by resetting the data values to their original values prior to the call to moveFallingPiece.
 

Explaining fallingPieceIsLegal:
This function is similar to drawFallingPiece, though it only takes one parameter, data, and in particular does not take or use a canvas.  It iterates over every cell (every row and every column) in the fallingPiece, and for those cells which are part of the falling piece (that is, where the falling piece list has a True value), rather than draw the cell (as drawFallingPiece does), this method confirms that:  (1) the cell is in fact on the board; and (2) the color at that location on the board is the emptyColor.  If either of these checks fails, the function immediately returns False.  If all the checks succeed for every cell in the fallingPiece, the function returns True.
 

Writing keyPressed:
We modify the keyPressed handler to call moveFallingPiece to move left, right, or down in response to left-arrow, right-arrow, or down-arrow key presses (and to change the falling piece in response to any other key press for now).