Get an introduction to programming with one of the hottest languages, Python.

# Principles of Computation with Python

$25

- Description
- What students will learn
- Learning objectives by module
- Course assessments, activities, and outline
- Other course details
- System requirements
- Included instructor tools

### Description

This course provides an introduction to Python and elementary principles of computing, including iteration, recursion, and binary representation of data. Additional topics on cellular automata, encryption, and the limits of computation are also introduced. The main goal of this course is to teach the fundamental principles used in computer science to a general audience so that they understand how computer scientists use these principles to solve complex problems to improve their daily lives. The first four modules employ Python to introduce and illustrate conditionals and iteration. The remaining modules do not use Python and can be used to can be incorporated into classes that do not use Python. Used together, these materials **show students that there is much more to computer science than learning to write code**.

##### Topics Covered:

- Programming with Python (Introduction, Conditionals, Loops)
- Iterative Processes
- Recursive Thinking
- Representation of Data and Instructions in Binary
- Cellular Automata as a Means of Generating Random Behavior
- Encryption Methods
- Limits of Computability.

##### Changes in this Update Include:

- Additional Python activities and additions to quiz questions.

The initial four modules introduce students to the Python programming language using an embedded programming environment. The modules explore if-statements and loops to illustrate concepts of flow-control and iteration, finally combining these constructs for more sophisticated programs.

Modules 5, 6 and 7 are traditionally some of the harder topics to comprehend for students who tend to shy away from technical courses, especially in computing.

The last three modules were chosen because they illustrate some deeper discoveries in computing that will show how computational thinking affects our lives. For example, principles in cellular automata can be used to create simple simulations that illustrate complex behavior (e.g. forest fire simulations). Encryption methods showcase how number theory is used to create an encryption method that is very hard to crack, so it can be used to support commerce today on the Internet.

The Limits of Computability module illustrates to students that not every problem is computable by computers…some require far more time than our lifespans, and some just can’t be solved regardless of the power of the computer, the amount of memory it has, or the amount of time we give the computer to solve the problem.

## What students will learn

**Topics Covered:**

- Programming with Python (Introduction, Conditionals, Loops)
- Iterative Processes
- Recursive Thinking
- Representation of Data and Instructions in Binary
- Cellular Automata as a Means of Generating Random Behavior
- Encryption Methods
- Limits of Computability.

## Learning objectives by module

**Unit 1: Introduction to Programming with Python**

**Module 1: Introduction to Programming with Python**- Evaluate expressions and execute basic statements (also known as commands) using a Python interpreter.
- Predict the meaning of code before interacting with the interpreter.
- Recognize what is a computer program, a programming language, and a programming language interpreter.
- Use user-defined and built-in Python functions.
- Write and run Python.

**Module 2: Iteration**- Create and access elements in a Python list.
- Design and code simple algorithms using iteration.
- Design and code simple algorithms with nested iteration.
- Identify an iterative algorithm and express it using a loop structure.
- Trace iterative algorithms.

**Module 3: Making Decisions**- Apply relational and logical operators and functions to form Boolean-valued expressions
- Design and code algorithms involving decisions
- Determine the value of a given Boolean-valued expression
- Trace Python code containing conditional statements (if-else statements)

**Module 4: Putting Iterations and Decisions Together**- Design and code simple algorithms that require conditionals and loops for processing a collection (list) of data items
- Trace Python code containing conditionals and loops
- Translate a given algorithm to Python code using conditionals and loops

**Unit 2: Principles of Computation**

**Module 5: Recursion**- Be able to trace simple recursion algorithms.
- Identify a recursion algorithm.

**Module 6: Data Structures**- Given a problem that requires storage and retrieval of information, determine which data structure is most appropriate.
- Identify some basic data structures commonly used in description of algorithms and in programming with a focus on arrays, singly linked lists, stacks, queues, and binary trees.
- Identify the distinguishing features of each data structure to reason about their advantages and disadvantages with respect to memory usage and running time.

**Module 7: Data Representation**- Be able to convert between integers represented in decimal and integers represented in binary.
- Be able to convertbetween integers represented in decimal and integers represented in binary.
- Define binary representation.
- Describe how different data types can be represented in binary.

**Module 8: Encryption**- Be able to identify one-way functions.
- Define what is meant by encryption and identify application areas where encryption is critical to our everyday way of life.
- Explain the basic principles of encryption and decryption using a substitution cipher.
- Trace the RSA algorithm to show how modern encryption and decryption is performed.

**Module 9: Computability**- Determine the orderof complexity for the exhaustive search algorithms for several decisionproblems.
- Explain why computing the solutions for intractable problems will take a huge amount of time unless the size ofthe problem is small.

**Module 10: Cellular Automata**- Create future generations of a cellular automaton by applying a given rule correctly.
- Define cellular automata and identify one dimensional automaton.
- Demonstrate the relationship between a rule number, its description and its pictorial form.
- Explain the binary nature of these rules and calculate the maximum number of rules that this system allows.
- Look at a result of a cellular automata and determine if the output could be used as a random number generator.

## Course assessments, activities, and outline

UNIT 1: Introduction to Programming with Python

Module 1: Introduction to Programming with Python

**Quiz: **Introduction to Python

Module 2: Iteration

**Quiz: **Iteration

Module 3: Making Decisions

**Quiz: **Making Decisions

Module 4: Putting Iterations and Decisions Together

**Quiz: **Putting Iterations and Decisions Together

UNIT 2: Principles of Computation

Module 5: Recursion

Module 6: Data Structures

Module 7: Data Representation

Module 8: Encryption

Module 9: Computability

Module 10: Cellular Automata

## Other course details

## System requirements

OLI system requirements, regardless of course:

- internet access
- an operating system that supports the latest browser update
- the latest browser update (Chrome recommended; Firefox, Safari supported; Edge and Internet Explorer are supported but not recommended)
- pop-ups enabled
- cookies enabled

Some courses include exercises with exceptions to these requirements, such as technology that cannot be used on mobile devices.

This course’s system requirements:

- None. A Python environment is embedded in the course materials; learners will benefit from access to a Python interpreter, however.

## Included instructor tools

Instructors who teach with OLI courses benefit from a suite of free tools, technologies, and pedagogical approaches. Together they equip teachers with insights into real-time student learning states; they provide more effective instruction in less time; and they’ve been proven to boost student success.