1.2. Text Editors

A text editor is one of the most fundamental tools of computer programming. It's possible to compose text on the computer using a word processing program like Microsoft Word or Google Docs—being able to produce nicely formatted documents is important.

Text editors, however, work with pure text, and have no ability to "make things look pretty" like a word processor does. There are no superscripts or subscripts, no underlining, no bold, and no italics. The unformatted plain text is easier for both computers and programmers to work with.

There are two basic types of text editor that you might want to use.

1.2.1. Using a text editor in the terminal

We've just seen how you can use nano to edit a text file. You can also use emacs or vim, powerful programs that work in the terminal, and you'll probably see me using vim at some point in here.

These programs take a long time to learn, however, and we've got a better option available to us.

1.2.2. Using a Text Editor application on your local machine

We're going to install Microsoft's Visual Studio Code on your computer. It takes about five minutes to get it up and running. Follow along with this video, pausing it as needed so you can complete each step.

Written instructions (Summary)

You can also read a step-by-step guide on how to install VS Code for our class here.

1.2.3. Development set-up

You'll typically want to have two windows open simultaneously on your screen: one for the code that you're writing, and one for running/debugging that code. You'll switch back and forth between the two windows as you work, writing code in the window on the left, and then running the code in the window on the right to see how your program is coming along.

1.3. More Python

We've got a lot more to cover as we learn the Python programming language...

1.3.1. Comments

Real programs have additional components, some of which we're going to introduce right away.

You could reasonably wonder why we should include in our program several blank lines and comments that don’t make the program run any differently.

Experienced coders already know the answers to these questions. Briefly:

• The blank lines make the program easier to read, for you and anyone else who’s looking at your work.
• The comments identify important parts of the program and why you wrote them the way you did, useful to you and anyone else who’s looking at your work.

1.3.2. Code blocks, or Suites

Programs include logical sections of code blocks, which in Python are called suites.

Let's begin right away with setting up a suite that you'll use in practically every program that you write in the class: a main function that comprises the body of your program.

Here, the def instruction in Python defines a function called "main", which contains a bit of code that won't be run until the name is used later on in the program.

Down below, then, we "call the function" by writing main(), which tells the interpreter to execute the instructions that we'd described earlier on in the function definition.

Again, you might wonder why we've made our straightforward program a little more complex by defining a function.

• The function definitions provide a modularity to your program that will be extremely important to us in the near future. We want to get comfortable as quickly as possible with the idea of modular programs.

From this point on, you'll always be writing your programs with at least one function—main()—and then calling that function to execute it.

1.4. Developing and Debugging

Whether you're using Python or some other language, you'll need to know this.

1.4.1. Debugging

You should know right away that programs very rarely work the first time that one writes them. Writing a program has a lot in common with writing an essay or paper:

1.4.2. The Development Process

Writing good software is challenging, but rewarding, and usually even fun.

The process of writing a program involves quite a bit more than simply sitting down at the computer and entering code. A typical problem will require that you:

1. Analyze the problem
2. Determine the specifications
3. Design the program's overall structure
4. Write the program (lots of testing and debugging here)
5. Deliver the program
6. Maintain the program (updating it as required, repairing it as needed)

In this course, you'll often be provided with the first 2 items, and #6 won't typically be something you'll have to worry about.

1.4.3. Types of Errors

There are three specific types of errors that you'll need to keep an eye out for, and fixing errors is what we spend a good amount of time doing.

1. Syntax errors are caught during compilation of your source code and represent incorrect use of the Python language. Typical syntax errors including
   • mispelling a variable name
   • incorrectly indenting a line
   • incorrect use of parentheses
   • incorrect use of a Python instruction

   The compiler will try to find as many errors as possible at one time, but realize that:

   • an error indicated for one line might have occurred on the previous line, and
   • a whole series of errors may be reported as a result of a single error earlier in the program.
   $ python hello_world.py File "hello_world.py", line 1 print("Hello, world!) ^ SyntaxError: EOL while scanning string literal $
2. Run-time errors occur while a program is able to run, but doesn't do what it was designed or expected to do. Some examples of run-time errors will cause the program to stop running include:
   • trying to divide by 0
   • the user enters text when a number is expected
   • the user enters a float (decimal point) value when an integer is expected
   $ python test.py Enter a number: 0 Traceback (most recent call last): File "test.py", line 2, in print (100/val) ZeroDivisionError: division by zero $
3. Logic errors are a specific type of error that occurs during runtime. The program will appear to run correctly, but the results produced are incorrect: a program that adds the numbers 1-10 and produces a result of 45 when the correct answer is 55, for example. The only way to catch these types of errors is with testing.
   $ python sum1to10 The sum of the integers 1 to 10 is 45 Expected result: 55

One thing that helps with avoiding errors is defensive programming: writing well-structured code with comments, and progressively testing the code so that errors in one part don't end up cascading down into other areas of the program.

One three-part "error management" strategy:

1. learn about common errors and how to avoid them
2. learn defensive strategies for minimizing likelihood and impact of errors
3. learn debugging strategies to find and correct errors.

1.4.4. Using scp to transfer files

You can use the scp command to transfer files from one computer to another.

In order to make this command work, you'll need to provide username and server information as part of the command.

To securely copy a file from the Desktop of my local computer to my Documents directory on the server I'd use this:

To securely copy a file from your local computer to a directory on the server where I'll look for your assignments, you'll use this:

To securely copy a file from the instructor's Public directory down to your machine, you'll use this:

1.5. Programming Basics

Let's write some programs! Get your development environment set up: a coding window on the left and a running/debugging window on the right. Also, create a standard Python document on the left coding window that we'll use when we're ready to start writing.

1.5.0. Overview

In this session we'll be learning how to assign values to variables, how to perform numeric calculations, how to get input, and how to write a simple program.

1.5.1. Assigning values to variables

The fundamental thing that computers do is calculate the answers to mathematical problems. To do that, we need to be able to take numbers and store them in the computer's memory.

Let's try writing a program that allows us to convert temperatures from one system to another.

1.5.2. Assigning values to a variable via user input

Although that temp_converter.py isn't bad, it requires that we rewrite the program every time we want to convert a different temperature.

We can improve the program quite a bit if we write it so that the user can enter their own initial temperature (degrees Fahrenheit) each time the program runs. Let's see how to get user input into one of our programs.

1.6. Numeric Data Types

In this session we'll be looking at the two different types of numeric data types in Python, seeing how you can import a module to give Python additional capabilities, and looking at local text editor applications.

1.6.0. Overview

Programming languages represent different types of data differently, and it's important for you to be aware of what data type one is working with. Data types in Python include int (integers), float numbers (floating point, or decimals), str (strings, of text), list (for lists of things), tuple (kind of like lists, but immutable), dictionary...

To begin, let's look at several of the numeric data types, operations that can be performed on those numbers, and some of the ways we can work with those numbers using functions in the math module.

1.6.1. Integers and Floating Point numbers

Why does a computer need to distinguish between the two? It's all about speed. It's far easier for computers to deal with integers, and therefore far faster for them to perform operations with integers. Differences in speed won't be apparent in most programs that we write, but for any program that performs the same operation thousands, million, or billions of times, working with integers where possible produces a significant increase in speed.

Of course, if you need to work with decimals (floats), then you'll have to use them where appropriate.

You can use Python's built-in functions to convert from one data type to another:

1.7. Functions, Parameters, and Return Values

1.7.0. Overview

In this session we'll be taking our first steps toward writing larger, more complex programs. We'll look at how writing procedural functions can help us better organize our code and make it less redundant, and how to write functions that uses parameters and return values to communicate with the programs that call them.

1.7.1. Functions and Parameters

1.7.1.0. Definition and Uses of Functions

In fact, a popular acronym among software engineers is DRY: Don't Repeat Yourself. If you do find yourself rewriting lots of segments of code, you should probably try to find a way to write the code more efficiently.

One way of reducing the amount of repeated code that we have to write is by using loops, which we'll learn about soon. Another very important strategy is to organize code into functions.

1.7.1.1. Standalone functions

I'm welcoming guests to my party and I find myself saying the same thing over and over again as each guest shows up at the door. I've written a program to print what I'm saying:

This program works just great, but you can see that I've had to repeat my little speech quite a few times. We can make the program a little more efficient by writing a function to print out the parts that are repeated.

This program produces exactly the same output:

This is quite a bit more efficient than what I did before. Each time I "call" the welcome() function in the main, the instructions in that welcome() function are performed.

1.7.1.2. Functions with parameters

We can make our function even more efficient by moving that print("Welcome,",name) instruction side the function, but when we first do that, we run into a problem:

The issue here is that although the main() program knows who the guest is, the function doesn't. We need to send that bit of information in via a parameter.

The working version of the program looks like this:

This works just as it should!

We're going to look at some other ways one can use functions, but first let's look at the random module.

1.7.2. The random Module

We've already discussed the math module, and how you can import that module to use various methods that will allow your Python program to perform mathematical calculations.

Now let's look at another useful module, and learn how to get help using that module.

#!/usr/bin/env python3
"""
Using the random module to simulate rolling a die.
"""

import random

def main():
    roll = random.randrange(6) + 1      
    # randrange randomly gets an integer from 0-5 inclusive.
    # Adding one gives us a value from 1-7, inclusive.
    print(roll)

if __name__ == "__main__":
    main()

What if you wanted to simulate playing Craps, which requires rolling two dice and adding them together? How would you do that?

Show/hide solution

That's still not bad, especially for a short little operation like this. But you can see that we're starting to repeat some of our coding, and if we had to do very much more here, we'd definitely want to come up with a different strategy for coding this.

1.7.4. Parameters and Scope

Here's a more formal development of how we can write functions that can be used in three different ways:

• stand-alone functions
• functions that need to get information from the main program (via parameters)
• functions that need to return information to the main program (via return statements)

Let's see how to write each type of function with a few examples.

1.7.4.1. Stand-alone functions

A stand-alone function doesn't need to interact with the main program in any serious way; it doesn't require any information from the main program, and it doesn't need to return any information to the main program. In this case, the function's sole purpose is to keep your code organized so that it's easier to read and manage.

Let's say that you're writing a program that allows the user to play Blackjack on the computer. If you want to print out the instructions for the user, you could certainly put a bunch of print() statements in the main() body of your program.

But it's better to move that block of print statements to someplace else—to a function—and then we'll just call that function if needed.

In most cases, the function definition is placed before the main() defintion. The code, then, looks like this:

When Python executes this code, it:

1. takes note of the print_instructions function definition and checks it for syntax, but doesn't actually execute that code yet.
2. takes note of the main() function definition and checks it for syntax, but doesn't actually execute that code yet.
3. falls through to the bottom of the code to see what it should do. If we're running this program from the command line, then __name__ == "__main__" so the main() function (program) is executed line by line.
4. encounters the print_instructions() line, causing execution to jump up to that function, and lines there are executed until the function is done.
5. returns to the line after the function was called in the main() where it continues to execute instructions.

Notice that the main() program now is much less cluttered and easier to read now that I'm using it to call other functions. If all the jumping around from the bottom of the program to the main() to the print_instructions() seems a little awkward, you'll get used to it very soon!

1.7.4.2. Sending in information with parameters

In the last example, we didn't need to pass any information back and forth between the main program and the function, but most programs DO need some way of doing that. How do you pass information into the function so that it can actually do something useful? You use parameters.

Let's take a look at a complete program that actually uses parameters.

You can probably guess exactly how this program works. At run time, the main program is called, which asks the user to input two numbers, after which the add_them procedure is called, with those two variables as parameters. In the add_them function, the formal parameters (variables) number1 and number2 refer to the actual parameters n1 and n2. Printing number1 refers to whatever value was referred to when the function was called... and that was n1. The function takes n1 and n2 and prints their sum. Pretty straightforward to this point.

We need to talk about scope for a minute, though.

1.7.4.3. Scope

In our Calculator Program, n1 and n2 are local to main(), and global to add_them. number1 and number2 are local to add_them, and undefined outside of that function.

The program doesn't print out the answer that we were hoping for; the variable answer is defined in the add_them() function, but not in the main program. We'll see how to solve that issue in the next section.

1.7.4.4. Getting information back out of a function

We've learned that you can pass information into a function using parameters. But how do you get information back out?

Let's take a look at our calculator program again. What if we'd written this:

This program won't work as we need it to, because the variable answer is "local to add_them", and undefined in our main program. We need to get the answer back out of the function somehow.

Our programming solution is to return a value.

Here's a version of our program, then, that does work:

One common use for functions is to gather user input. Writing separate functions for "initializing" a program (setting initial values for data) and actually processing that data is very common.

Now try this one:

As you're writing this program, you want to be able to trace exactly what values each variable has as the information is passed to and from the functions.

Here's another program to emphasize the importance of functions: