T-Th 9:05
or
T-Th 11:15
in Olin 155

CS 1110: Introduction to Computing Using Python

Fall 2015

Lecture Summaries

This page lists a summary of the activities of each week, in reverse chronological order. This is your go-to page for downloading in-class handouts and getting caught back up if you get behind. This page is updated dynamically all semester long, with new material added as we get there.

If you want to see what future lectures in this class will be, you should look at the syllabus page.


Week 17


Week 16


Week 15

3 December (Thursday): Course Wrap-Up

[Presentation]

Hopefully you have enjoyed this course. Assuming that you have, today we discuss your options about what to do next in computer science.



Lab 13: Sequence Algorithms

[Instructions]

This lab is completely optional. However, if you can do all of the problems on this lab, you should do well on the final. Hence it serves as a study guide for the invariant question.


1 December (Tuesday): Searching and Sorting

[Handout]      [Presentation]
Demos
algorithms.py


Today we complete our discussion of loop invariants and show how to use them to implement sorting. This is the last lecture covering material on the exam.



Week 14

24 November (Tuesday): Sequence Algorithms (cont)

[Handout]      [Presentation]
Demos
algorithms.py


Today we continue our discussion of invariants and algorithms from last Tuesday. We review the Dutch National Flag algorithm and talk about how changing invariants can change your algorithm.



Week 13

19 November (Thursday): GUI Applications

[Handout]      [Presentation]
Demos
game2d.py
animation.py
arrows.py
touch.py
state.py
subcontroller.py
pyro.py


Today we return to classes one last time, and show how classes and while-loops fit together. By the end of the lecture, we will see that class invariants and loop invariants are really the same thing in practice. Today's lecture will provide you all that you need to know to get started on the last assignment.

Reading: Chapter 19



Lab 12: Loop Invariants

[Instructions]

This is the last required lab of the course. It covers the major topics with sequence algorithms that will appear on the final. Therefore, you should complete the lab as a way of studying for the final exam.


17 November (Tuesday): Sequence Algorithms

[Handout]      [Presentation]
Demos
algorithms.py


Originally, we wanted to talk about GUI applications today. However, we had to reorder things a bit to cover the material for the last lab.

Instead, today we start on the last major topic in the course: sorting. Before we get to sorting, we have start with the framework for building complex algorithms on sequences (strings, lists, etc.). This lecture covers advanced loop-invariants, and is a very important lecture for the final exam.

Reading: Chapter 13



Week 12

12 November (Thursday): Loop Invariants

[Handout]      [Presentation]
Demos
pairs.py
loop_invariants.py


Today we discuss how to design algorithms for while-loops. We introduce the notion of a loop-invariant, and show how to use that to write a program with a loop. Invariants are an important topic on the final exam, and are covered in the final labs.

Reading: Loop Invariants



Lab 11: Loop Exercises

[Instructions]

This is the first of several labs involving loops. It includes while-loops over both ranges integers and over more complicated conditions. Given both the exam and the assignment, we have tried to make this lab reasonable.


10 November (Tuesday): While Loops

[Handout]      [Presentation]
Demos
flow.py
comparison.py
numerical.py


Today we introduce while-loops, which are an alternate form of iteration. They are trickier to use than for-loops, and will be an important part of the last part of the course.

Reading: Chapter 7



Week 11

5 November (Thursday): Programming with Subclasses

[Handout]      [Presentation]
Demos
newfraction.py
read.py
trying.py


Now that we have subclasses, there is quite a bit we can do with them. To understand how to program with subclasses, we need to understand how to make type more explicit in our programs. We do that in this lecture, including a review of the try-except statement that we saw earlier in the course.

Reading: Exceptions in Python



Lab 10: Shapes

[Instructions]

This is a short(ish), but fun, lab that gives you experience with subclasses. In particular, you can see how subclasses can be very useful in graphics applications. We have also added some additional exercises with methods, particularly with getters and setters.


3 November (Tuesday): Inheritance

[Handout]      [Presentation]
Demos
employee.py
app.py
initialize.py
resolve.py
override.py


Subclasses and inheritance are integral part of object oriented programming. It allows us to take classes that someone else created (such as the GUI classes that Kivy provides) and add functionality to them. Today we show how these features are used in Python.

Reading: Chapter 18



Week 10

29 October (Thursday): Using Classes Effectively

[Handout]      [Presentation]
Demos
time.py
rectangle.py
card.py
hand.py
betterfraction.py
bestfraction.py


In previous lectures, we have learned the syntax for defining classes. Today we look at the design philosophy for making classes. This lecture is very similar to Lecture 9 (Algorithm Design), except that it is for classes instead of functions.



Lab 9: Blackjack

[Instructions]

This is a straight-forward lab that gives you some experience working with classes. And when you are done, you can play a nice game of blackjack.


27 October (Tuesday): Methods and Operations

[Handout]      [Presentation]
Demos
simplefrac.py
fraction.py
point.py


There is a lot going on with classes in Python. There are all these mysterious methods that start with an underscore. Today we talk these mysterious methods. We show how to use these methods to create classes for mathematical types like fractions or complex numbers.

Reading: Chapter 17



Week 9

22 October (Thursday): Classes

[Handout]      [Presentation]
Demos
example.py
worker.py
worker_tutor.py
point.py
person.py
test_person.py


Up until now, if we wanted to use objects, we had to import a module that provided them for us. Today we finally learn how to create our own classes. Not only can we make our own class types now, but we can even add them to the Python visualizer.

Reading: Chapters 15, 16



Lab 8: Recursion Exercises

[Instructions]

This lab gives you experience with writing recursive functions. This is a very different lab from previous ones, as we would like you to work entirely in the Python Tutor. There are a lot files to download, so get them from the main Labs webpage.


20 October (Tuesday): More on Recursion

[Handout]      [Presentation]
Demos
palindrome.py
morefun.py
person.py
person_tutor.py
test_palindrome.py
test_morefun.py
test_person.py
hilbert.py


Today we continue to talk about recursion. We look at the different ways that we can break up a recursive function, and how recursion (potentially) differs from iteration. We also look at how recursion is used in Assignment 4.

Reading: Sections 6.5-6.8



Week 7

15 October (Thursday): Recursion

[Handout]      [Presentation]
Demos
factorial_tutor.py
fibonacci_tutor.py
deblank_tutor.py
memory.py
stringfun.py
test_stringfun.py


Today we talk about recursion, a powerful computing tool and one of the harder concepts in the course. Recursion is one of the fundamental principles of computer science, and used for a lot of advanced algorithms. We will see many applications as the course progresses.

Reading: Section 5.8-5.10



13 October (Tuesday): FALL BREAK



There is no class today.



8 October (Thursday): More with Sequences

[Handout]      [Presentation]
Demos
transpose.py
grades.py


This lecture covers several advanced topics on sequences. In particular, we will look at the topic of multi-dimensional lists, and why we would want to use them. We also introduce dictionaries, which are similar to a sequence, but have several important differences.

Reading: Chapter 11



Lab 7: Lists & For-Loops

[Instructions]

This lab has you work with lists and write several functions using for-loops. There is no lab the week of Fall Break, so you technically have two weeks to do this lab. However, the material from this lab may be on the exam; therefore, you may want to complete it as soon as possible.


6 October (Tuesday): For-Loops

[Handout]      [Presentation]
Demos
loops.py
ranges.py


Lists (and sequences) come with their own special control structure: the for-loop. In this lecture we see what for-loops can (and cannot) do to make more interesting programs.

The material in this lecture is the last material that will be on the first prelim.

Reading: Sections 8.4, 8.7, Chapter 10



Week 6

1 October (Thursday): Lists (and Sequences)

[Handout]      [Presentation]

Now that you are an expert of string slicing, we introduce another sliceable data type: lists. Lists behave just like strings, except that they can contain data other than text. They are also mutable, which means we need to use folders to represent them.

Reading: Sections 10.0-10.2 and 10.4-10.6



Lab 6: Asserts & Debugging

[Instructions]

We have talked a lot about errors and debugging in the last few weeks. This week you will get hands-on experience finding errors in some rather complex functions. In addition, you will learn how to add asserts to better stop errors before they appear.


29 September (Tuesday): Asserts and Error Handling

[Handout]      [Presentation]
Demos
anglicize.py
error.py
recover.py
try.py


We have talked about how preconditions are a promise that indicate what your function will and will not do. Today we will show how to make them more than a promise. We will also show how error reporting relates to the call stack.



Week 5

24 September (Thursday): Memory in Python

[Handout]      [Presentation]
Demos
reorder.py
anglicize.py
globals.py


Today we revisit call frames again. We put them in the context of the put call stack, which is the collection of frames for all currently executing functions. We also show the big picture of memory in Python, including global space and heap space.



Lab 5: Objects & Conditionals

[Instructions]

Now that you are an expert of writing functions, our labs can start involving more interesting challenges. In this lab, we show how to use conditionals in functions. Our functions will use strings (just like Assignment 1) as well as a new class called Time.


22 September (Tuesday): Algorithm Design

[Handout]      [Presentation]
Demos
reorder.py
anglicize.py
test_anglicize.py


Your first assignment was very much do-this/do-that. Today we step back and see how we would design a complex program from scratch. How do we take a complex task and break it up into manageable pieces?

Reading: Chapter 4



Week 4

17 September (Thursday): Conditionals and Control Flow

[Handout]      [Presentation]
Demos
name.py
test_name.py
bettertemp.py
debug_name.py
flow.py


Today we talk about the difference between program structure and program flow. We also introduce the conditional, which is our first program structure for controlling program flow. This will not be necessary for Assignment 1, but will be very important in later assignments.

Reading: Sections 5.1-5.7



Lab 4: Assignment 1

[Instructions]

In recognition of the length of the last lab and the looming assignment, today's lab is a chance for you to work on assignment 1. You do not have to show to lab, but consultants are available to give you help. You will get credit for the lab so long as you turn in Assignment 1 on time Thursday night.


15 September (Tuesday): Objects

[Handout]      [Presentation]
Demos
pointfuncs.py
geom_tutor.py


Today, we introduce the notion of objects. Objects are a new type of data. They require a new conceptual model for us to understand them. Objects are a minor part of Assignment 1, but will be a major part of Assignment 3.



Week 3

10 September (Thursday): Call Frames

[Handout]      [Presentation]

Today we go into much more depth about functions. We talk about how they work, and present a formal model of execution. The material in this lecture will be a major part of Assignment 2.

Note: We did not manage to cover all of the material on the provided slides. Do not worry. All of this material will be reviewed again in later lectures.

Reading: Sections 3.9-3.10



Lab 3: Functions & Testing

[Instructions]

This lab is bit longer than the previous ones. This is an intensive, hands-on lab to give you a lot of experience with writing functions and testing them. You should try very hard to complete this lab before you finish the first assignment; you will need these skills for that assignment.


8 September (Tuesday): Specifications and Testing

[Handout]      [Presentation]
Demos
greet.py
temp.py
name.py
test_name.py
bettertemp.py
debug_name.py


Last time we saw how to write functions. However, writing functions takes a lot of practice and you are likely make mistakes along the way. That is why it is extremely important to test your functions and make sure they are working properly. As part of testing, we will also see why comments are more important that just notes to yourself.

Reading: Docstrings in Python



Week 2

3 September (Thursday): Defining Functions

[Handout]      [Presentation]
Demos
module.py
greet.py
temp.py
commalist.py
print_return.py


Now that we know how to use modules, today we learn how to create our own modules. As part of this, we will learn a lot more about functions. In particular, we will learn the difference between a function call and a function definition.

Reading: Sections 3.1-3.8, Sections 6.1-6.4



Lab 2: Expressions

[Instructions]

The purpose of this lab is to get you comfortable with using the Python library. The Python library is a collection of modules built-in to the language.


1 September (Tuesday): Strings and Modules

[Handout]      [Presentation]

Today we go into more detail about the String type, and show just how powerful Python is at manipulating text. We also introduce the concept of modules and show how they provide Python with extra (optional) functionality.

Reading: Chapter 8 (not 8.6, 8.11)



Week 1

27 August (Thursday): Variables and Assignments

[Handout]      [Presentation]

While we got started with a little bit of Python last time, this time we will jump into it. We show how to use Python as a calculator, and introduce the notion of expressions and types. We also introduce the notion of a variable, and how an assignment statement works.
We will use the iClickers for the first time today.

Reading: Sections 2.2-2.9



Lab 1: Getting Started

[Instructions]

The purpose of this lab is two fold. First, it is designed to get you started with Python immediately. Second, gives you hands on experience with Python expressions, which we talked about on the first day of class.


25 August (Tuesday): Types and Expressions

[Handout]      [Presentation]
Additional
Course Overview
Why Python?


We give an overview of the course and its expectations. We show you how to get started with Python. Finally, we talk about types and expressions, which is the bare minimum that you need to do something "useful" in Python.

Reading: Chapter 1; Section 2.1



Course Material Authors: D. Gries, L. Lee, S. Marschner, & W. White (over the years)