IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 17

Microphone

Graded Quiz

You can connect to Gradescope to take weekly graded quiz today during the last 15 minutes of the class.

Once you start the quiz you have 15 minutes to finish it.

You can only take this quiz today.

There is not makeup for the weekly quiz because Gradescope does not permit it.

Readings

If you have the textbook read Chapter 10, Classes and Object-Oriented Programming, sections 10.1 and 10.2, Classes and Object-Oriented Programming and Procedural and Object-Oriented Programming.

Solution to Homework 6

I have posted a solution to homework 6 here.

Let's take a look.

Homework 8

I have posted homework 8 here.

It is due this coming Sunday at 11:59 PM.

Midterm Scores

If you believe I have scored one of your Midterm answers incorrectly you can request a rescore for that question on Gradescope.

If your score on the Final is significantly better than your score on the Midterm, I will replace your Midterm grade with that of the Final when calculating your grade for the course.

If you want to discuss how you can improve your grade in this course, come see me during Office Hours.

You do not have to make an appointment to see me during Office Hours, but you may have to wait your turn if I am helping another student.

I want students to pass this course, and will do what I reasonably can to make that happen.

Your Current Standing in This Course

If you want to know your grade as of this moment, send me an email.

In performing this calculation, I will assume that your score on the final exam will be the same as that of you Midterm score.

I can do this only for your grade as of the Midterm.

I can't do this for your grade later in the semester.

Final Exam

The final for this course will take place in this room on Thursday, May 16, from 3:00PM - 6:00PM.

You will also find this information at the top of the class web page.

Questions

Are there any questions before I begin?

Tips and Examples

Common Exam Mistake - Creating a File Object When You Don't Need To

Some exam questions ask you to write a function with a file object as a parameter
In this case you should not create a file object
If you do you will lose points

Review

The SQLite Command Line

All SQL database products have a command line
You can use this run SQL statements

On our systems you get a SQLite command line like this

$ sqlite3 
SQLite version 3.16.0 2016-11-04 19:09:39
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite>

sqlite> is the SQLite prompt
This tells you the program is ready to receive you next command

Database Structure

All the data in a database are stored in tables
The rows of a database are individual records
And the columns are fields within that record

Here is a table whose records contain student data

sqlite> select * from students;
student_id  first_name  last_name   umb_email              user_name   college   
----------  ----------  ----------  ---------------------  ----------  ----------
09329034    Jane        Adams       Jane.Adams001@umb.edu  jadams      CSM       
03687480    Alexander   Smith       Alexander.Smith001@um  bigboy      CM        
05431692    Christophe  Cannon      Christopher.Cannon001  ccannon     CSM       
07511379    Joseph      Malloney    Joseph.Malloney001@um  jmal        CSM       
07518979    Fatih       Jones       Fatih.Jones001@umb.ed  fjones      CM        
04175276    James       Reynolds    James.Reynolds001@umb  jr          CSM

Tables usually have one column where the values are unique
This column is called the primary key
Often, the values in this column are integers
They are usuallly assigned automatically by the database

Data Checking

Every column in a database has certain restrictions on the values it can contain
The database will prevent entry of data that violates these restrictions
The most elementary restriction is the data type of the value

Here is the definition for the student table

create table students 
(   student_id  text primary key unique,  
    first_name  text not null,
    last_name   text not null,
    umb_email   text not null unique,
    email       text unique,
    user_name   text unique,
    college     text
);

Queries

To get information from a table you write a SQL query

A SQL query often has the following form

select COLUMN_LIST from TABLE_NAME where RESTRICTIONS;

To get the student ID, first name and last name of all students in the College of Management I would write

sqlite> select student_id, first_name, last_name from students where college = "CM";
student_id  first_name  last_name
----------  ----------  ----------
03687480    Alexander   Smith
07518979    Fatih       Jones

All SQL statements MUST have a semicolon, ; , at the end

Changing Data in a Table

There are special SQL commands for changing data in a table
There are three ways you can change what is in a table
- Add a record
- Delete a record
- Change the values in a record
Each of these operations has its own SQL command

Adding a Record to a Table

To add a record to a table you must use the SQL insert command which has the following syntax
```
insert into TABLE_NAME (COLUMN_LIST) values (VALUE_LIST);
```

Changing the Values in a Record

To change the value stored in a table you use an SQL update command

It has the following format

update TABLE_NAME set COLUMN_VALUE_PAIRS where CONDITION

COLUMN_VALUE_PAIRS are a column name and equal sign and a value

Deleting Records

An SQL delete command is used to remove a record from a table
It has the format
```
delete from TABLE_NAME where CONDITION
```
If I wanted to delete all students registered for IT 244 in Fall 2017 I would write
```
sqlite> delete from enrollments where course_id = "it244" and semester_id = "f18";
```
If no error message appears, the statement succeeded

Using SQLite in Python

sqlite3 is a Python module
It has functions that allow a Python script to talk to a SQLite database
This module is contained in the Python standard library
That means you should be able to find it in all Python installations

All Python scripts that use a SQLite database must import this module

>>> import sqlite3 
>>> sqlite3 
<module 'sqlite3' from '/usr/lib/python3.5/sqlite3/__init__.py'>

Connecting to a SQLite Database

To use a SQLite database in Python you need to create a connection object
You create this object using the connect function of the of sqlite3 module
The function takes the filename of the SQLite database as its argument
It creates a connection object to the database ...
and returns a pointer to it

The format for using this function is

CONNECTION_OBJECT_VARIABLE = sqlite3.connect(DATABASE_FILENAME)

If I have a SQLite database contained in the file umb.db ...
in my current directory ...

I would create a connection object to it like this

>>> import sqlite3 
>>> con = sqlite3.connect("umb.db")

The SQLite Cursor Object

To run a SQLite command you need to create a cursor object
You then use the execute method of this object run a SQL command
You create a cursor object using the cursor method ...
of the connection object
This method creates the cursor object ...
and returns a pointer to it

The format is

CURSOR_OBJECT_VARIABLE = CONNECTION_OBJECT_VARIALE.cursor()

If I had a variable named con pointing to a connection object ...
I would create a cursor object object like this
```
>>> cur = con.cursor()
```

Running a SQLite Query in Python

You run an SQL query in SQLite using execute
The argument to execute is the text of your SQL query

To get the contents of the students table I would write

>>> import sqlite3 
>>> con = sqlite3.connect("umb.db")
>>> cur = con.cursor()
>>> cur.execute("select * from students")

The results of this query are stored in the cursor object

I can use the variable that points to the cursor object in in a for loop

>>> for row in cur:
...     print(row)
... 
('09329034', 'Jane', 'Adams', 'Jane.Adams001@umb.edu', 'jadams', 'CSM')
('03687480', 'Alexander', 'Smith', 'Alexander.Smith001@umb.edu', 'bigboy', 'CM')
('05431692', 'Christopher', 'Cannon', 'Christopher.Cannon001@umb.edu', 'ccannon', 'CSM')
('07511379', 'Joseph', 'Malloney', 'Joseph.Malloney001@umb.edu', 'jmal', 'CSM')
('07518979', 'Fatih', 'Jones', 'Fatih.Jones001@umb.edu', 'fjones', 'CM')
('04175276', 'James', 'Reynolds', 'James.Reynolds001@umb.edu', 'jr', 'CSM')

Adding a Record Using SQLite

To add a record you again use the execute method
The argument is the text of an SQL insert command

Here is an example

>>> cur.execute("insert into enrollments values(null, "it244", 1, "f18", "05431692")")
<sqlite3.Cursor object at 0x7febd141aab0>

The result marked in red means the that the insertion succeeded

Committing Changes to a Table

If we get no error message after running a SQL insert command
A row has been added to the table
But only to the copy of the table in RAM
The table on disk will not be changed ...
until we run the commit method on the cursor object
Like this
```
con.commit()
```

Changing a Record Using SQLite

To change an record we give an update command to execute

Like this

>>> cur.execute("update students set user_name = "alex" where student_id = "03687480")
<sqlite3.Cursor object at 0x7f15373ffb20>

Deleting a Record Using SQLite

To delete a record, give execute a SQL delete statement

Like this

cur.execute("delete from enrollments  where course_id = "it244", section_no = 1, semester = "f18", student_id = "05431692")
<sqlite3.Cursor object at 0x7f15373ffb20>>

Then call commit

A Python Function to Add an Entry to the enrollment Table

The SQL statement to add a student to the enrollments table

Would have this format

insert into enrollments values (null, COURSE_ID, SECTION_NO, SEMESTER_ID, STUDENT_ID)

So the function to add an must do the following
- Create a string containing the SQLinsert statement
- Create a cursor
- Call the execute method on the using the statement as an argument

Here is the code

def enrollment_add(con, course_id, section_no, semester_id, student_id):
    stmnt = "insert into enrollments values(null, " + course_id + ", "   + str(section_no) +\
                 ", "  +  semester_id + ", " + student_id + ")"
    cur = con.cursor()
    cur.execute(stmnt)
    cur.close()

Attendance

New Material

Writing Better Programs

The academic discipline of computer science studies many things
One field of study is how to design the look and feel of a program
The goal is to make programs intuitive and easy to use
Another field of study is software engineering
It studies the best way to design, develop and maintain software
In the early days of programming the organization of code was left to individual programmers
The programs did not have much structure and were hard to read
Researchers in software engineering began to think of better approaches
One technique was to break up a big program into a individual functions
This is sometimes called procedural programming
This made programs easier to read
It also made the programs easier to debug
Because all the code that did a particular thing was is one place
The first part of debugging is finding where the error occurs
Well designed functions make it easier to narrow the search for the problem

Demonstrating Different Approaches to Programming

I want to contrast the different ways a program can be written
To do this I will pick a problem
And then solve it with three different programming approaches
The first approach does not try to order the code
The next approach will use procedural programming
Finally we will use an object oriented approach

An Example Problem

Let's say I needed to read in a date from a text file
where it appeared in the following format
```
YYYY-MM-DD
```
YYYY represents a 4 digit year
MM is a two digit month number
And DD is a two digit day of the month
So the date January 1, 1970 would be written
```
1970-01-01
```
Let's assume the program needs to print the date in the following format
```
MONTH_NAME DAY_OF_MONTH, YEAR
```
In other words, a date like January 1, 1970
Assume that the date is on the first line of a file
And the filename is stored in the variable DATA_FILENAME

First Approach

The first thing we need to do is read in the date
This is stored in the first line of a the file

The date string can be read in with two lines of code

data_file = open(DATA_FILENAME, "r")
date_string = data_file.readline()

Now we have a string with three pieces of information
- Year
- Month number
- Day of month
We can use the string method split to extract these values
This method will take a string like this
```
>>> test_string = "foo bar bletch"
```

And return a list

>>> test_string.split()
['foo', 'bar', 'bletch']

The string used to separate different substrings is called the delimiter
By default, split uses a space as a delimiter ...

but we have to use -

>>> date_string.split("-")
['2016', '09', '06\n']

It seems we have a problem with the last value
It has the newline character \n at the end of the string
We can eliminate this using the string method strip
```
date_string = date_string.strip()
```

Now when we run split we get

>>> date_string.split("-")
['2016', '09', '06']

We can use multiple assignment to assign three different variables ...

in one statement

>>> year, month, day = date_string.split("-")

But the values for month and day each have a leading zero
The easiest way to deal with this is to convert both month and day to integers
We could leave year as a string

But it's better to be consistent and convert it too

>>> year = int(year)
>>> month = int(month)
>>> day = int(day)
>>> year
2016
>>> month
9
>>> day
6

A better way to do this is to use multiple assignment

>>> year, month, day = int(year), int(month), int(day)
>>> year
2016
>>> month
9
>>> day
6

Now we need a way to convert a month number into a month name

The easiest way to do this is with a dictionary

>>> month_names = {1:"January",    2:"February", 3:"March",     4:"April",
...                5:"May",        6:"June",     7:"July",      8:"August",
...                9:"September", 10:"October", 11:"November", 12:"December"}

To get the month name, we use the month number as a key to the dictionary
```
>>> month_names[month]
'September'
```

We now have all we need to create date string in the format we want

>>> new_date_string = month_names[month] + " " + str(day) + ", " + str(year)
>>> new_date_string
'September 6, 2016'

Putting all the code together we get

#! /usr/bin/python3

# code to convert a date in the format 
#    YYYY_MM_DD
# stored as the first line in a file whose name
# is stored in the variable DATA_FILENAME
# into a string in the format
#    MONTH_NAME DAY_OF_MONTH, YEAR

DATA_FILENAME = "data.txt"
data_file = open(DATA_FILENAME, "r") # open the file for reading
date_string = data_file.readline()
date_string = date_string.strip()
year, month, day = date_string.split("-")
year, month, day = int(year), int(month), int(day) 

month_names = {1:"January",    2:"February", 3:"March",     4:"April",
               5:"May",        6:"June",     7:"July",      8:"August",
               9:"September", 10:"October", 11:"November", 12:"December"}

new_date_string = month_names[month] + " " + str(day) + ", " + str(year)
print(new_date_string)

Procedural Programming Approach

Let's rewrite this code using the procedural programming approach
I will do this using a technique called refactoring
The basic ideas is to make small changes to the code ...
testing after each change ...
and making sure that that the overall behavior of the code does not change
We can refactor this code into a new program with four functions
- get_first_line
- get_date
- get_month_name
- format_date
We will also need three global variables
- year
- month
- day
Why did I decide to create four functions?
I could instead create two functions
- get_date_from_file
- format_date_with_month_name
get_date_from_file would do the work of both get_first_line ...
and get_date
And format_date_with_month_name does the work of both get_month_name ...
and format_date
But this is not a good idea
A function should to one thing and do it well
A function like get_date_from_file would only be useful ...
for this particular kind of problem
One where the date string is stored in the first line of the file
It would not be useful in other situations
I might want to use get_month_name and format_date in other scripts
So I am going to put them in a separate module, date_functions.py
I will leave get_first_line in the original script
Because it has nothing to do with dates
get_first_line accepts a filename as a parameter ...

and returns the first line as a string with the newline removed

# opens a file and returns the first line in
# that file without the newline
def get_first_line(filename):
    data_file = open(filename, "r")
    date_string = data_file.readline()
    data_file.close()
    return date_string.strip()

get_date accepts a date string as a parameter ...

and returns integer values for year, month and day

# turns a string with a date in the format
# YYYY-MM-DD
# into integer values for year, month and date
def get_date(date_string):
    year, month, day = date_string.split("-")
    return int(year), int(month), int(day)

get_month_name accepts a month number as a parameter ...

and returns the month name

# converts a month number into a month name
def get_month_name(month_number):
    month_names = {1:"January",    2:"February", 3:"March",     4:"April",
                   5:"May",        6:"June",     7:"July",      8:"August",
                   9:"September", 10:"October", 11:"November", 12:"December"}
    return month_names[month_number]

format_date takes the three integer values year, month and day as parameters ...

and returns a string in the proper format

# returns a date in standard format
def format_date(year, month, day):
    return get_month_name(month) + " " + str(day) + ", " + str(year)

To make use of these functions we rewrite the script as follows

#! /usr/bin/python3

# code to convert a date in the format 
#    YYYY_MM_DD
# stored as the first line in a file whose name
# is stored in the variable DATA_FILENAME
# into a string in the format
#    MONTH_NAME DAY_OF_MONTH, YEAR

import date_functions

# opens a file and returns the first line in
# that file without the newline
def get_first_line(filename):
    data_file = open(filename, "r")
    date_string = data_file.readline()
    data_file.close()
    return date_string.strip()

DATA_FILENAME = "data.txt"

date_string = get_first_line(DATA_FILENAME)
year, month, day = date_functions.get_date(date_string)
print(date_functions.format_date(year, month, day))

Notice that I had to import the date_functions module

Object Oriented Programming

Certain variables go naturally together
And certain functions are needed to operate on these variables
This is one of the key idea behind object oriented programming
To create an object you need to define a class
A class is a template that Python uses to create individual objects
The objects are the things in memory
But the class is the blueprint used to create the objects of that class
The class defines all variables and methods inside the object
Functions defined inside a class are called methods
Every class must have a special method ...
which must be named __init__
The name has two underscore characters, _
Before and after "init"
This special method is called a constructor or an initializer ...
and is used to create objects of the class
An actual object of a given class is called an instance
So you can have many instances of a particular class

Object Oriented Approach

Let's rewrite the program using objects
To do this I will define a Date class
It will be stored in the module date.py
I have to move the functions from the date_functions.py module ...
into the Date class ...
and move the variables year, month and day into the class as well
This will involve modifying the code
So it is in the proper format for a class
I'm not going explain these changes in depth today
I will save that for the next class
The first thing I have to do is create the constructor ...
which must be named __init__
I will change get_date so it can serve as the constructor for this class
Instead of returning a list of integer values ...
__init__ will set three internal variables
These variables can be accessed directly by the other methods in the class

Here is the code for __init__

def __init__(self, date_string):
    self.year, self.month, self.day = date_string.split("-")
    self.year  = int(self.year) 
    self.month = int(self.month)
    self.day   = int(self.day)

Every method in a class takes the self parameter
This represents the object that the constructor creates
We use the self parameter to access the variables and methods in a class
We do this using dot notation
self.year, self.month and self.day are the internal variables of the object
__init__ still takes the date string as its parameter
But it has no return statement
Constructors always return a new instance of an object in their class
But they don't use a return statement to do this
Although the code looks a little different
It does the same thing as get_date

Here is the class version of get_month_name

# converts a month number into a month name
def get_month_name(self):
    month_names = {1:"January",    2:"February", 3:"March",     4:"April",
                   5:"May",        6:"June",     7:"July",      8:"August",
                   9:"September", 10:"October", 11:"November", 12:"December"}
    return month_names[self.month]

It takes only one parameter, self
It uses this parameter to access the month variable using dot notation
```
self.month
```
Otherwise the code is the same

format_date undergoes similar changes

# returns a date in standard format
def format_date(self):
    return self.get_month_name() + " " + str(self.day) + ", " + str(self.year)

In the program itself we have to import the Date class definition
Then we create a Date object like this
```
date_object = Date(date_string)
```
date_object is a local variable
It points to the object created by the constructor
The name of the constructor inside the class is __init__
Outside the class we call it using the name of the class
Inside the class __init__ takes two parameters
But we only use one parameter in the function call
This is true for all methods
Methods must take self as a parameter
But we leave this out when calling them outside the class

Here is the code for the latest version of our script

#! /usr/bin/python3

# code to convert a date in the format 
#     YYYY_MM_DD
# stored as the first line in a file whose name
# is stored in the variable DATA_FILENAME
# into a string in the format
#     MONTH_NAME DAY_OF_MONTH, YEAR
# Uses the Date class

from date import Date

# opens a file and returns the first line in
# that file without the newline
def get_first_line(filename):
    data_file = open(filename, "r")
    date_string = data_file.readline()
    data_file.close()
    return date_string.strip()

DATA_FILENAME = "data.txt"

date_string = get_first_line(DATA_FILENAME)
date_object = Date(date_string)
print(date_object.format_date())

We'll go into more detail in our next class

Ethics and Technology

The Spiderman Principle

Tips and Examples

Review

New Material

Graded Quiz

Readings

Solution to Homework 6

Homework 8

Midterm Scores

Your Current Standing in This Course

Final Exam

Questions

Tips and Examples

Common Exam Mistake - Creating a File Object When You Don't Need To

Review

The SQLite Command Line

Database Structure

Data Checking

Queries

Changing Data in a Table

Adding a Record to a Table

Changing the Values in a Record

Deleting Records

Using SQLite in Python

Connecting to a SQLite Database

The SQLite Cursor Object

Running a SQLite Query in Python

Adding a Record Using SQLite

Committing Changes to a Table

Changing a Record Using SQLite

Deleting a Record Using SQLite

A Python Function to Add an Entry to the enrollment Table

Attendance

New Material

Writing Better Programs

Demonstrating Different Approaches to Programming

An Example Problem

First Approach

Procedural Programming Approach

Object Oriented Programming

Object Oriented Approach

Class Exercise

Class Quiz