T-Th 9:05 |
CS 1110: Introduction to Computing Using Python Fall 2014 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Main
About: Announcements Staff Consultants Times & Places Calendar Materials: Texts Python Command Shell Terminology VideoNote Handouts: Lectures Assignments Labs Assessment: Grading Exams Resources: CMS Piazza AEWs FAQ Python API Python Tutor Style Guide Academic Integrity |
Lecture SummariesThis 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 17Week 16Week 154 December (Thursday): Course Wrap-Up
[Presentation]
Lab 13: More Loop Invariants
[Instructions]
2 December (Tuesday): Searching and Sorting[Handout] [Presentation]
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 1427 November (Thursday): THANKSGIVING
25 November (Tuesday): Sequence Algorithms (cont)[Handout] [Presentation]
Today is a bit of catch-up lecture to get us back on track for the last week of class. We finish up the final controller example from the previous lecture. We also continue the discussion of sequence algorithms from last Tuesday. Week 1320 November (Thursday): Stateful Controllers[Handout] [Presentation]
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]
18 November (Tuesday): Sequence Algorithms[Handout] [Presentation]
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 1213 November (Thursday): Loop Invariants[Handout] [Presentation]
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]
11 November (Tuesday): While Loops[Handout] [Presentation]
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 116 November (Thursday): Classes and Types[Handout] [Presentation]
Types are an important part of any programming language, even Python (despite what some internet blogs may say to the contrary). In this lecture we show how types affect the outcome of certain commands and operations. Reading: Errors and Exceptions Lab 10: Subclasses and Encapsulation
[Instructions]
4 November (Tuesday): Inheritance[Handout] [Presentation]
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 1030 October (Thursday): Using Classes Effectively[Handout] [Presentation]
In the previous lectures, we have learned the syntax for define classes. Today we look at the design philosophy for constructing classes. This lecture is very similar to Lecture 9 (Algorithm Design), except that it is for classes instead of functions. Lab 9: Blackjack
[Instructions]
28 October (Tuesday): Methods and Encapsulation[Handout] [Presentation]
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 also introduce the notion of encapsulation and how it relates to the class invariant. Reading: Chapter 17 Week 923 October (Thursday): Classes[Handout] [Presentation]
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]
21 October (Tuesday): More on Recursion[Handout] [Presentation]
Today we continue talking about recursion, with several examples. We look at the different ways that we can break up a recursive method. We also look at how recursion is used in Assignment 4. Reading: Sections 6.5-6.8 Week 716 October (Thursday): Recursion[Handout] [Presentation]
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 14 October (Tuesday): FALL BREAK
9 October (Thursday): Exam Review
Lab 7: For-Loops
[Instructions]
7 October (Tuesday): More with Sequences[Handout] [Presentation]
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 Week 62 October (Thursday): For-Loops[Handout] [Presentation]
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. Reading: Sections 8.4, 8.7, Chapter 10 Lab 6: Lists and Asserts
[Instructions]
30 September (Tuesday): Lists (and Sequences)
[Handout]
[Presentation]
Reading: Sections 10.0-10.2 and 10.4-10.6 Week 5Lab 5: Objects and Conditionals
[Instructions]
23 September (Tuesday): Algorithm Design[Handout] [Presentation]
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 418 September (Thursday): Conditionals and Control Flow[Handout] [Presentation]
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]
With that said, this lab does include some optional exercises, should you want extra practice. 16 September (Tuesday): Memory in Python[Handout] [Presentation]
One of the problems with the new calendar is that the labs and the lectures do not match up as nicely. So I think people have been getting confused about all these memory representation issues (e.g. call frames, objects). Today, we are going to try to ease your confusion with an overview lecture that reviews all of these concepts and puts them together. Week 311 September (Thursday): Objects[Handout] [Presentation]
We got a little rushed last time. To help you with Assignment 1, we will finish off with Tuesday's lecture, so that you can better understand testing and debuggging. Once that is done, we will introduce the notion of Objects. Objects are a new type of value, beyond the basic four that we have seen already. They require a new conceptual model for us to understand them. Lab 3: Functions and Testing
[Instructions]
9 September (Tuesday): Visualizing Functions[Handout] [Presentation]
Today we go into much more depth about functions. We talk about how they work, and present a formal model of execution. We also learn how to test functions and make sure that they are working properly. After this lecture, you should be able to get started with Assignment 1. Reading: Sections 6.1-6.4 Week 24 September (Thursday): Functions[Handout] [Presentation]
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 Lab 2: Assignments and Strings
[Instructions]
2 September (Tuesday): Strings and Modules
[Handout]
[Presentation]
Reading: Chapter 8 (not 8.6, 8.11) Week 128 August (Thursday): Variables and Assignments
[Handout]
[Presentation]
Reading: Sections 2.2-2.9 Lab 1: Getting Started
[Instructions]
26 August (Tuesday): Types and Expressions[Handout] [Presentation]
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) |