View All Pages

Book - 3.6) Python in BlockPy

Blocks vs. Text

Block-based programming has been used so far to construct and execute algorithms. Using block-based programming is a good first step to learn about programming for several reasons. First, block-based languages do not allow certain kinds of mistakes to be made that are possible in text-based languages. For example,  blocks can only be snapped together in certain ways and the "syntax" of blocks is simpler (in comparison with text languages). Certain mistakes due to putting incompatible elements together or expressing a statement incorrectly are not possible. Of course, no language can avoid all forms of errors (you likely made a number on the Blockly assignments), but avoiding these kinds of errors is an important advantage. Second, the BlockPy environment is designed to give feedback about and make reasonable attempts to execute the constructed algorithm even if the algorithm is incomplete. We will see that the environments for text-based languages are often less helpful and forgiving. Also, BlockPy hid a number of details that are necessary for the algorithm's execution but which, up to now, have not been important. We will see these details emerge in learning a text-based language.

Moving beyond a block-based language is motivated by the limitations of a block-based approach. First, a block-based language is usually more cumbersome to use for composing a large program. The time to locate a block, drag and drop it into the workspace, and snap it together with other blocks is often longer than the time it takes to type the characters that have the same meaning in a text-based language. Second, using the full power and capability of the components available to build programs is most easily done in a text based language. For example, the blocks for visualizations in BlockPy are just a few of the simpler kinds of visualizations that can be created using the underlying Matplotlib library. Also, the "big data" blocks in BlockPy are only a few of the data sets than can be accessed in the CORGIS framework. We will learn more about both Matplotlib library and the CORGIS data sets as we progress.

In moving to text-based programming it is necessary to be prepared for two challenges. First, additional details, often small and "picky", will need to be learned. Some of these are details of syntax (how to write a statement correctly in the text language) and some require understanding some things that BlockPy hid from view and must now be exposed. Second, the programming environments are more complicated and report errors in a way that is more difficult for learners to understand. There will undoubtedly be some frustration in becoming productive in the new environment.

Three final thoughts before proceeding to a first view of programming in Python, a text-based language. First, no new fundamental concepts will be learned, just a different way of expressing the same concepts. The basic ideas of iteration, decision, calculation, sequence, and state remain the same. These concepts will now be represent in text rather than as blocks. Second, Python - the language we will be learning - is only one of many text-based languages. Others you may have heard of are Java, C, and C++. There are many others. Having learned Python, learning any of these other languages will be easier (should you chose to pursue learning other languages). Third, we will learn a specific subset of Python - just the right part of Python to do a meaningful project with "big data". For now we want to see what we can do with this subset of Python - and it is a lot. However, there is much more to learn about Python.  If you want to know more about Python there are other courses to take and  there are many on-line tutorials available for self-directed learning.

Python in BlockPy

The first step in learning Python is to see the Python equivalent of a Blockly program. In BlockPy these two forms can be seen by toggling between the "Blocks" view and the "Text" view using the control at the top of the workspace. The figure below shows these two views side by side for a simple algorithm. We will use this example to explore the similarities and differences between Blockly and Python.

Blocks-VS-Text-Example.png

Comparing Text and Block Views

 

First, notice the many similarities between the text and block views. These include:

  • many lines of Python text correspond directly to a horizontal set of blocks,
  • the lines of text in Python and the corresponding blocks are organized in the same top to bottom sequence (reflecting the same order of execution),
  • the property names are the same in each case (while this is largely true in general, Python has a specific set of naming rules. BlockPy silently makes changes in the property names you use to be sure that they follow the Python rules),
  • the use and meaning of iteration and decision are the same,
  • the mathematical operators used in calculations (the "+" is the only one seen in this example) are the same, and
  • the comparison operations used in decisions are recognizably the same ("<" and ">=", the later being the text equivalent of "greater than or equal to").

It is also important to notice the differences between the text and block views. There are two major differences.

The first difference is indentation. In Blockly the  iteration and decision blocks wrap around the blocks that they "contain". In Python this is done by indentation. The indentation is necessary to be able to know what lines are "contained" in the iteration or decision. For example, the indentation in an iteration shows the lines to be repeated on each iteration. Those lines not indented come before or after the iteration is complete. The correspondence between the wrapping in Blockly and the indentation in Python is shown in the following figure. Notice that there are two levels of indentation of text corresponding to the same two levels of wrapping of blocks.

Python-Indentation.png

Indentation in Python vs. Blockly 

The second major difference is the use of colons. The iteration line and the decision lines must end with a colons. Notice the colon at the end of the iteration line. Also notice that for decision a colon is needed at the end of the "if" line and the "elif" (meaning "else if" in Python) line. The use of colons are shown in the following figure.

 Python-Colons.png

Use of Colons in Python

 

There are a number of smaller differences between the "keywords" used in Python and Blockly. A "keyword" is a fixed descriptive word or phrase that identify the meaning of the block or text. For example, the keyword "if" is used to identify a decision. Generally, Python shortens or eliminates the keywords. Specifically:

  •  the  iteration keyword "for each item" in Blockly is "for" in Python; also in iteration the Blockly "in list" is expressed in Python as "in".
  • the decision keyword "else if" is shortened to "elif" in in Python,
  • the keyword "do" used in Blockly for both decisions and iteration has no Python equivalent,
  • in calculations statements that change (initialize or update) the value of a property Blockly uses a "set" keyword which is not used in Python.

One other difference between Blockly and Python that is not shown in the example above deals with calculation statements. Earlier a calculation was used to convert Fahrenheit temperatures to Celsius. The Blockly and Python forms of this calculation are shown in the figure below.
Python-Parenthesis-Calculation.png

Parenthesis in Python Calculations

 Because of the "nesting" in Blockly it is clear that the subtraction should be done before the division. The use of parenthesis in Python is the equivalent of the nesting of blocks. The meaning is that operations in parenthesis are performed first. The parenthesis in the Python text in the above figure means that the subtraction will be performed before the division. Without the parenthesis Python would do the reverse, performing the division (32/1.8) before subtracting this value from the Fahrenheit value. The order in which the operations are performed makes a difference. If the Fahrenheit temperature is 32 degrees the calculation with parenthesis would yield a value of 0 (zero) for the temperature in Celsius (which is correct). Without the parenthesis the calculation would result in 14.2 for the Celsius temperature (which is wrong). A simple rule is always to use as many parenthesis as need to make the steps in your calculation clear.

Import and Functions

One other difference between the Blockly and Python versions of the first example above (also shown in the BlockPy workspace below) involves the two ideas of import and functions. The goal at this point is to understand the very basics of these two programming ideas. They will be seen in more detail later. The figure below shows the blocks that set the value of temperatures to the list of temperatures forecast for "Blacksburg,VA". The two lines of Python equivalent to the blocks are also shown.

Python-Import-Figure.pngImport and Functions

A Python structure, called a package, contains the machinery to access the forecast temperatures. Python packages are used to keep together related items for easy handling (just as you put several small items in a physical package to make it easy to carry around or send through the postal system). Each package has a name to refer to it; the package used here is named weather. The import statement locates the package on your computer so that the contents of the package can then be accessed. Python gives an error message if you try to use the contents of a package without the corresponding import statement. As an experiment, in the BlockPy workspace below choose the Text view, delete the import statement and hit the Run button to execute the program. You should see an error message complaining that "weather" is not defined. Put the import statement back and see that the program not runs as expected.


 

The weather package contains a collection of functions. A function is an algorithm that has already been developed which you use by referring to the function's name. One of the functions in the weather package is named get_forecasts. To refer to this function we must be clear that the get_forecasts function we want to use is the one in the weather package. Thus, as shown above, the name weather.get_forecasts is used. We know from usage that the forecast can be obtained for a number of cities ("Blacksburg, VA", "Seattle, WA", etc.). Which city is intended is given by a parameter of the function. In this example, the parameter of the weather.get_forecasts function is "Blacksburg, VA". Notice that the parameter is enclosed in parenthesis. The parenthesis is a required part of the Python syntax.

It is reasonable to ask "How do I know what a package is named and what functions are in it?" The answer is that the developer of the package has written user documentation explaining the purpose of the package and how to use it. We will see later the user documentation for Matplotlib (for producing visualizations) and CORGIS (the collection of "big data" sets).

This very brief description of packages, functions, and parameters is intended only to give a high-level view of these programming elements. We will return later and explore them in more detail.