Introduction to

Computer
Programming using
Python
University of Mines and Technology
Faculty of Computing and Mathematical Sciences
Computer Science and Engineering Department
Prepared by Engr Mensah Sitti
 Overview

• History
• Installing & Running Python
• Names & Assignment
• Sequences types: Lists, Tuples, and
Strings
• Mutability
 Brief History of Python
• Invented in the Netherlands, early 90s
by Guido van Rossum
• Named after Monty Python
• Open sourced from the beginning
• Considered a scripting language, but is
much more
• Scalable, object oriented and functional
from the beginning
• Used by Google from the beginning
• Increasingly popular
 Python’s Benevolent Dictator For Life

“Python is an experiment in
how much freedom program-
mers need. Too much freedom
and nobody can read another's
code; too little and expressive-
ness is endangered.”
- Guido van Rossum
http://docs.python.org/
The Python tutorial is good!
 Features of Python
Programming language
Running
Python
 The Python Interpreter
• Typical Python implementations offer
both an interpreter and compiler
• Interactive interface to Python with a
read-eval-print loop
[finin@linux2 ~]$ python
Python 2.4.3 (#1, Jan 14 2008, 18:32:40)
[GCC 4.1.2 20070626 (Red Hat 4.1.2-14)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def square(x):
... return x * x
...
>>> map(square, [1, 2, 3, 4])
[1, 4, 9, 16]
>>>
 Installing
• Python is pre-installed on most Unix systems,
including Linux and MAC OS X
• The pre-installed version may not be the most
recent one (2.6.2 and 3.1.1 as of Sept 09)
• Download from http://python.org/download/
• Python comes with a large library of standard
modules
• There are several options for an IDE
• IDLE – works well with Windows
• Emacs with python-mode or your favorite text editor
• Eclipse with Pydev (http://pydev.sourceforge.net/)
IDLE Development Environment
• IDLE is an Integrated DeveLopment Environ-
ment for Python, typically used on Windows
• Multi-window text editor with syntax
highlighting, auto-completion, smart indent
and other.
• Python shell with syntax highlighting.
• Integrated debugger
with stepping, persis-
tent breakpoints,
and call stack visi-
bility
 Editing Python in Emacs
• Emacs python-mode has good support for editing
Python, enabled enabled by default for .py files
• Features: completion, symbol help, eldoc, and inferior
interpreter shell, etc.
 Languages
• Some influential ones:
• FORTRAN
—science / engineering

• COBOL
—business data

• LISP
—logic and AI

• BASIC
—a simple language
13
 Programming basics
• code or source code: The sequence of instructions in a program.

• syntax: The set of legal structures and commands that can be

used in a particular programming language.

• output: The messages printed to the user by a program.

• console: The text box onto which output is printed.

• Some source code editors pop up the console as an external
window, and others contain their own console window.

14
 Compiling and interpreting
• Many languages require you to compile
(translate) your program into a form that the
machine understands.
compile execute
source code byte code output
Hello.java Hello.class

• Python is instead directly interpreted into

machine instructions.
interpret
source code output
Hello.py

15
Running Interactively on UNIX
On Unix…
% python
>>> 3+3
6
• Python prompts with ‘>>>’.
• To exit Python (not Idle):
• In Unix, type CONTROL-D
• In Windows, type CONTROL-Z + <Enter>
• Evaluate exit()
 Running Programs on UNIX
• Call python program via the python interpreter
% python fact.py
• Make a python file directly executable by
• Adding the appropriate path to your python
interpreter as the first line of your file
#!/usr/bin/python
• Making the file executable
% chmod a+x fact.py
• Invoking file from Unix command line
% fact.py
 Example ‘script’: fact.py
#! /usr/bin/python
def fact(x):
"""Returns the factorial of its argument, assumed to be a posint"""
if x == 0:
return 1
return x * fact(x - 1)
print
print ’N fact(N)’
print "---------"
for n in range(10):
print n, fact(n)
 Python Scripts
• When you call a python program from the
command line the interpreter evaluates each
expression in the file
• Familiar mechanisms are used to provide
command line arguments and/or redirect
input and output
• Python also has mechanisms to allow a
python program to act both as a script and as
a module to be imported and used by another
python program
 Example of a Script
#! /usr/bin/python
""" reads text from standard input and outputs any email
addresses it finds, one to a line.
"""
import re
from sys import stdin
# a regular expression ~ for a valid email address
pat = re.compile(r'[-\w][-.\w]*@[-\w][-\w.]+[a-zA-Z]{2,4}')
for line in stdin.readlines():
for address in pat.findall(line):
print address
 results

python> python email0.py <email.txt

[email protected]
[email protected]
[email protected]
[email protected]
python>
 Expressions
• expression: A data value or set of operations to compute a value.
Examples: 1 + 4 * 3
42

• Arithmetic operators we will use:

• + - * / addition, subtraction/negation, multiplication, division
• % modulus, a.k.a. remainder
• ** exponentiation

• precedence: Order in which operations are computed.

• * / % ** have a higher precedence than + -
1 + 3 * 4 is 13

• Parentheses can be used to force a certain order of evaluation.

(1 + 3) * 4 is 16

22
 Integer division
• When we divide integers with / , the quotient is also an integer.
3 52
4 ) 14 27 ) 1425
12 135
2 75
54
21
• More examples:
— 35 / 5 is 7
— 84 / 10 is 8
— 156 / 100 is 1

• The % operator computes the remainder from a division of

integers.
3 43
4 ) 14 5 ) 218
12 20
2 18
15
3

23
 Real numbers
• Python can also manipulate real numbers.
• Examples: 6.022 -15.9997 42.0
2.143e17
• The operators + - * / % ** ( ) all work for real numbers.
• The / produces an exact answer: 15.0 / 2.0 is 7.5
• The same rules of precedence also apply to real numbers:
Evaluate ( ) before * / % before + -
• When integers and reals are mixed, the result is a real
number.
• Example: 1 / 2.0 is 0.5
• The conversion occurs on a per-operator basis.
• 7 / 3 * 1.2 + 3 / 2
• 2 * 1.2 + 3 / 2
• 2.4 + 3 / 2
• 2.4 + 1
• 3.4

24
 Math commands
• Python has useful commands for performing calculations.
Command name Description Constant Description
abs(value) absolute value e 2.7182818...
ceil(value) rounds up pi 3.1415926...
cos(value) cosine, in radians
floor(value) rounds down
log(value) logarithm, base e
log10(value) logarithm, base 10
max(value1, value2) larger of two values
min(value1, value2) smaller of two values
round(value) nearest whole number
sin(value) sine, in radians
sqrt(value) square root

• To use many of these commands, you must write the

following at the top of your Python program:
25 from math import *
 Variables
• variable: A named piece of memory that can store a value.
• Usage:
—Compute an expression's result,
—store that result into a variable,
—and use that variable later in the program.

• assignment statement: Stores a value into a variable.

• Syntax:
name = value

• Examples: x = 5
gpa = 3.14

x 5 gpa 3.14

• A variable that has been given a value can be used in expressions.

x + 4 is 9

• Exercise: Evaluate the quadratic equation for a given a, b, and c.

26
 print
• print : Produces text output on the console.

• Syntax:
print "Message"
print Expression
• Prints the given text message or expression value on the console, and moves the
cursor down to the next line.
print Item1, Item2, ..., ItemN
• Prints several messages and/or expressions on the same line.

• Examples:
print "Hello, world!"
age = 45
print "You have", 65 - age, "years until retirement"
Output:
Hello, world!
You have 20 years until retirement
27
 input
• input : Reads a number from user input.
• You can assign (store) the result of input into a variable.
• Example:
age = input("How old are you? ")
print "Your age is", age
print "You have", 65 - age, "years until retirement"
Output:
How old are you? 53
Your age is 53
You have 12 years until retirement
• Try Exercise:
Write a Python program that prompts the user for his/her
amount of money, then creates a budget for the user for a
semester based on the needs of a first year student, and
inform the user how to spend his/her money for the semester.
28
 Getting a unique, sorted list
import re
from sys import stdin

pat = re.compile(r'[-\w][-.\w]*@[-\w][-\w.]+[a-zA-Z]{2,4}’)
# found is an initially empty set (a list w/o duplicates)
found = set( )
for line in stdin.readlines():
for address in pat.findall(line):
found.add(address)
# sorted() takes a sequence, returns a sorted list of its elements
for address in sorted(found):
print address
 results

python> python email2.py <email.txt

[email protected]
[email protected]
[email protected]
python>
 Simple functions: ex.py
"""factorial done recursively and iteratively"""

def fact1(n):
ans = 1
for i in range(2,n):
ans = ans * n
return ans

def fact2(n):
if n < 1:
return 1
else:
return n * fact2(n - 1)
 Simple functions: ex.py
671> python
Python 2.5.2 …
>>> import ex
>>> ex.fact1(6)
1296
>>> ex.fact2(200)
78865786736479050355236321393218507…000000L
>>> ex.fact1
<function fact1 at 0x902470>
>>> fact1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'fact1' is not defined
>>>
The Basics
 A Code Sample (in IDLE)
x = 34 - 23 # A comment.
y = “Hello” # Another one.
z = 3.45
if z == 3.45 or y == “Hello”:
x = x + 1
y = y + “ World” # String concat.
print x
print y
 Enough to Understand the Code
• Indentation matters to code meaning
• Block structure indicated by indentation
• First assignment to a variable creates it
• Variable types don’t need to be declared.
• Python figures out the variable types on its own.
• Assignment is = and comparison is ==
• For numbers + - * / % are as expected
• Special use of + for string concatenation and % for
string formatting (as in C’s printf)
• Logical operators are words (and, or,
not) not symbols
• The basic printing command is print
 Basic Datatypes
• Integers (default for numbers)
z = 5 / 2 # Answer 2, integer division
• Floats
x = 3.456
• Strings
• Can use “” or ‘’ to specify with “abc” ==
‘abc’
• Unmatched can occur within the string:
“matt’s”
• Use triple double-quotes for multi-line strings or
strings than contain both ‘ and “ inside of them:
“““a‘b“c”””
 Whitespace
Whitespace is meaningful in Python: especially
indentation and placement of newlines
•Use a newline to end a line of code
Use \ when must go to next line prematurely
•No braces {} to mark blocks of code, use
consistent indentation instead
• First line with less indentation is outside of the block
• First line with more indentation starts a nested block
•Colons start of a new block in many constructs,
e.g. function definitions, then clauses
 Comments
• Start comments with #, rest of line is ignored
• Can include a “documentation string” as the
first line of a new function or class you define
• Development environments, debugger, and
other tools use it: it’s good style to include one
def fact(n):
“““fact(n) assumes n is a positive
integer and returns facorial of n.”””
assert(n>0)
return 1 if n==1 else n*fact(n-1)
 Assignment
• Binding a variable in Python means setting a name to
hold a reference to some object
• Assignment creates references, not copies
• Names in Python do not have an intrinsic type,
objects have types
• Python determines the type of the reference automatically
based on what data is assigned to it
• You create a name the first time it appears on the left
side of an assignment expression:
x = 3
• A reference is deleted via garbage collection after
any names bound to it have passed out of scope
• Python uses reference semantics (more later)
 Naming Rules
• Names are case sensitive and cannot start
with a number. They can contain letters,
numbers, and underscores.
bob Bob _bob _2_bob_ bob_2 BoB
• There are some reserved words:
and, assert, break, class, continue,
def, del, elif, else, except, exec,
finally, for, from, global, if,
import, in, is, lambda, not, or,
pass, print, raise, return, try,
while
 Naming conventions
The Python community has these recommend-
ed naming conventions
•joined_lower for functions, methods and,
attributes
•joined_lower or ALL_CAPS for constants
•StudlyCaps for classes
•camelCase only to conform to pre-existing
conventions
•Attributes: interface, _internal, __private
 Assignment
• You can assign to multiple names at the
same time
>>> x, y = 2, 3
>>> x
2
>>> y
3
This makes it easy to swap values
>>> x, y = y, x
• Assignments can be chained
>>> a = b = x = 2
Accessing Non-Existent Name
Accessing a name before it’s been properly
created (by placing it on the left side of an
assignment), raises an error
>>> y

Traceback (most recent call last):

File "<pyshell#16>", line 1, in -toplevel-
y
NameError: name ‘y' is not defined
>>> y = 3
>>> y
3
Sequence types:
Tuples, Lists, and
Strings
 Sequence Types
1. Tuple: (‘john’, 32, [CMSC])
• A simple immutable ordered sequence of
items
• Items can be of mixed types, including
collection types
2. Strings: “John Smith”
• Immutable
• Conceptually very much like a tuple
3. List: [1, 2, ‘john’, (‘up’, ‘down’)]
• Mutable ordered sequence of items of
mixed types
 Similar Syntax
• All three sequence types (tuples,
strings, and lists) share much of the
same syntax and functionality.
• Key difference:
• Tuples and strings are immutable
• Lists are mutable
• The operations shown in this section
can be applied to all sequence types
• most examples will just show the
operation performed on one
 Sequence Types 1

• Define tuples using parentheses and commas

>>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)

• Define lists are using square brackets and

commas
>>> li = [“abc”, 34, 4.34, 23]
• Define strings using quotes (“, ‘, or “““).
>>> st = “Hello World”
>>> st = ‘Hello World’
>>> st = “““This is a multi-line
string that uses triple quotes.”””
 Sequence Types 2
• Access individual members of a tuple, list, or
string using square bracket “array” notation
• Note that all are 0 based…
>>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’)
>>> tu[1] # Second item in the tuple.
‘abc’
>>> li = [“abc”, 34, 4.34, 23]
>>> li[1] # Second item in the list.
34
>>> st = “Hello World”
>>> st[1] # Second character in string.
‘e’
 Positive and negative indices

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)

Positive index: count from the left, starting with 0
>>> t[1]
‘abc’
Negative index: count from right, starting with –1
>>> t[-3]
4.56
 Slicing: return copy of a subset

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)

Return a copy of the container with a subset of

the original members. Start copying at the first
index, and stop copying before second.
>>> t[1:4]
(‘abc’, 4.56, (2,3))
Negative indices count from end
>>> t[1:-1]
(‘abc’, 4.56, (2,3))
 Slicing: return copy of a =subset

>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)

Omit first index to make copy starting from
beginning of the container
>>> t[:2]
(23, ‘abc’)
Omit second index to make copy starting at first
index and going to end
>>> t[2:]
(4.56, (2,3), ‘def’)
 Copying the Whole Sequence

• [ : ] makes a copy of an entire sequence

>>> t[:]
(23, ‘abc’, 4.56, (2,3), ‘def’)
• Note the difference between these two lines
for mutable sequences
>>> l2 = l1 # Both refer to 1 ref,
# changing one affects both
>>> l2 = l1[:] # Independent copies, two
refs
 The ‘in’ Operator
• Boolean test whether a value is inside a container:
>>> t = [1, 2, 4, 5]
>>> 3 in t
False
>>> 4 in t
True
>>> 4 not in t
False
• For strings, tests for substrings
>>> a = 'abcde'
>>> 'c' in a
True
>>> 'cd' in a
True
>>> 'ac' in a
False
• Be careful: the in keyword is also used in the syntax
of for loops and list comprehensions
 The + Operator
The + operator produces a new tuple, list, or
string whose value is the concatenation of its
arguments.

>>> (1, 2, 3) + (4, 5, 6)

(1, 2, 3, 4, 5, 6)

>>> [1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

>>> “Hello” + “ ” + “World”

‘Hello World’
 The * Operator
• The * operator produces a new tuple, list, or
string that “repeats” the original content.
>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> “Hello” * 3
‘HelloHelloHello’
 Repetition (loops)
and Selection (if/else)

5
 The for loop
• for loop: Repeats a set of statements over a group of values.
• Syntax:
for variableName in groupOfValues:
statements
— We indent the statements to be repeated with tabs or spaces.
— variableName gives a name to each value, so you can refer to it in the
statements.
— groupOfValues can be a range of integers, specified with the range function.

• Example:
for x in range(1, 6):
print x, "squared is", x * x

Output:
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25
57
 range
• The range function specifies a range of integers:
— range(start, stop) - the integers between start (inclusive)
and stop (exclusive)
• It can also accept a third value specifying the change between values.
— range(start, stop, step) - the integers between start
(inclusive)
and stop (exclusive) by step
• Example:
for x in range(5, 0, -1):
print x
print "Blastoff!"
Output:
5
4
3
2
1
Blastoff!
• Exercise: How would we print the "99 Bottles of Beer" song?
58
 Cumulative loops
• Some loops incrementally compute a value that is
initialized outside the loop. This is sometimes
called a cumulative sum.
sum = 0
for i in range(1, 11):
sum = sum + (i * i)
print "sum of first 10 squares is", sum

Output:
sum of first 10 squares is 385

• Exercise: Write a Python program that computes

the factorial of an integer.

59
 if
• if statement: Executes a group of
statements only if a certain condition is
true. Otherwise, the statements are
skipped.
• Syntax:
if condition:
statements

• Example:
gpa = 3.4
if gpa > 2.0:
print "Your application is accepted."

60
 if/else
• if/else statement: Executes one block of statements if a certain
condition is True, and a second block of statements if it is False.
• Syntax:
if condition:
statements
else:
statements
• Example:
gpa = 1.4
if gpa > 2.0:
print "Welcome to Mars University!"
else:
print "Your application is denied."

• Multiple conditions can be chained with elif ("else if"):

if condition:
statements
elif condition:
statements
else:
statements
61
 while
• while loop: Executes a group of statements as long as a condition is
True.
• good for indefinite loops (repeat an unknown number of times)

• Syntax:
while condition:
statements

• Example:
number = 1
while number < 200:
print number,
number = number * 2

• Output:
1 2 4 8 16 32 64 128

62
 Logic
• Many logical expressions use relational
operators:
Operator Meaning Example Result
== equals 1 + 1 == 2 True
!= does not equal 3.2 != 2.5 True
< less than 10 < 5 False
> greater than 10 > 5 True
<= less than or equal to 126 <= 100 False
>= greater than or equal to 5.0 >= 5.0 True

• Logical expressions can be combined with logical

operators: Operator Example Result
and 9 != 6 and 2 < 3 True
or 2 == 3 or -1 < 5 True
63 not not 7 > 0 False
 Mutability:
Tuples vs. Lists
 Lists are mutable

>>> li = [‘abc’, 23, 4.34, 23]

>>> li[1] = 45
>>> li
[‘abc’, 45, 4.34, 23]
• We can change lists in place.
• Name li still points to the same memory
reference when we’re done.
 Tuples are immutable
>>> t = (23, ‘abc’, 4.56, (2,3), ‘def’)
>>> t[2] = 3.14
Traceback (most recent call last):
File "<pyshell#75>", line 1, in -toplevel-
tu[2] = 3.14
TypeError: object doesn't support item assignment

•You can’t change a tuple.

•You can make a fresh tuple and assign its
reference to a previously used name.
>>> t = (23, ‘abc’, 3.14, (2,3), ‘def’)
•The immutability of tuples means they’re faster
than lists.
 Operations on Lists Only

>>> li = [1, 11, 3, 4, 5]

>>> li.append(‘a’) # Note the method

syntax
>>> li
[1, 11, 3, 4, 5, ‘a’]

>>> li.insert(2, ‘i’)

>>>li
[1, 11, ‘i’, 3, 4, 5, ‘a’]
 The extend method vs +
• + creates a fresh list with a new memory ref
• extend operates on list li in place.
>>> li.extend([9, 8, 7])
>>> li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7]

• Potentially confusing:
• extend takes a list as an argument.
• append takes a singleton as an argument.
>>> li.append([10, 11, 12])
>>> li
[1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7, [10,
11, 12]]
 Operations on Lists Only
Lists have many methods, including index, count,
remove, reverse, sort
>>> li = [‘a’, ‘b’, ‘c’, ‘b’]
>>> li.index(‘b’) # index of 1st occurrence
1
>>> li.count(‘b’) # number of occurrences
2
>>> li.remove(‘b’) # remove 1st occurrence
>>> li
[‘a’, ‘c’, ‘b’]
 Operations on Lists Only
>>> li = [5, 2, 6, 8]

>>> li.reverse() # reverse the list *in place*

>>> li
[8, 6, 2, 5]

>>> li.sort() # sort the list *in place*

>>> li
[2, 5, 6, 8]

>>> li.sort(some_function)
# sort in place using user-defined comparison
 Tuple details
• The comma is the tuple creation operator, not parens
>>> 1,
(1,)

• Python shows parens for clarity (best practice)

>>> (1,)
(1,)

• Don't forget the comma!

>>> (1)
1

• Trailing comma only required for singletons others

• Empty tuples have a special syntactic form
>>> ()
()
>>> tuple()
()
 Summary: Tuples vs. Lists
• Lists slower but more powerful than tuples
• Lists can be modified, and they have lots of
handy operations and mehtods
• Tuples are immutable and have fewer
features
• To convert between tuples and lists use the
list() and tuple() functions:
li = list(tu)
tu = tuple(li)
 Text processing
• text processing: Examining, editing, formatting
text.
• often uses loops that examine the characters of a string one
by one

• A for loop can examine each character in a

string in sequence.
• Example:
for c in "booyah":
print c
Output:
b
o
o
y
a
73 h
 Strings and numbers
• ord(text) - converts a string into a number.
• Example: ord("a") is 97, ord("b") is 98, ...

• Characters map to numbers using standardized mappings

such as ASCII and Unicode.

• chr(number) - converts a number into a string.

• Example: chr(99) is "c"

• Exercise: Write a program that performs a

rotation cypher.
• e.g. "Attack" when rotated by 1 becomes "buubdl"

74
 File processing
• Many programs handle data, which often comes
from files.

• Reading the entire contents of a file:

variableName = open("filename").read()

Example:
file_text = open("bankaccount.txt").read()

75
 Line-by-line processing
• Reading a file line-by-line:
for line in open("filename").readlines():
statements
Example:
count = 0
for line in open("bankaccount.txt").readlines():
count = count + 1
print "The file contains", count, "lines."

• Exercise: Write a program to process a file of DNA text,

such as:
ATGCAATTGCTCGATTAG
• Count the percent of C+G present in the DNA.

76
Graphics

7
 DrawingPanel
• To create a window, create a drawingpanel and
its graphical pen, which we'll call g :
from drawingpanel import *
panel = drawingpanel(width, height)
g = panel.get_graphics()
... (draw shapes here) ...
panel.mainloop()

• The window has nothing on it, but we can draw

shapes and
lines on it by sending commands to g .
• Example:
g.create_rectangle(10, 30, 60, 35)
g.create_oval(80, 40, 50, 70)
g.create_line(50, 50, 90, 70)
78
 Graphical commands
Command Description
g.create_line(x1, y1, x2, y2) a line between (x1, y1), (x2, y2)
g.create_oval(x1, y1, x2, y2) the largest oval that fits in a box with
top-left corner at (x1, y1) and
bottom-left corner at (x2, y2)
g.create_rectangle(x1, y1, x2, y2) the rectangle with top-left corner at
(x1, y1), bottom-left at (x2, y2)
g.create_text(x, y, text="text") the given text at (x, y)

• The above commands can accept optional outline and fill colors.
g.create_rectangle(10, 40, 22, 65, fill="red", outline="blue")

• The coordinate system is y-inverted:

(0, 0)

(200, 100)
79
 Drawing with loops
• We can draw many repetitions of the same item at different
x/y positions with for loops.
• The x or y assignment expression contains the loop counter, i, so
that in each pass of the loop, when i changes, so does x or y.
from drawingpanel import *

window = drawingpanel(500, 400)

g = window.get_graphics()

for i in range(1, 11):

x = 100 + 20 * i
y = 5 + 20 * i
g.create_oval(x, y, x + 50, y + 50, fill="red")

window.mainloop()

• Exercise: Draw the figure at right.

80
What's Next?

8
 Further programming
• Lab exercises
• Weekly lab Exercise in computer labs!
• Mini Project Assignment to groups

• What next?
• Arrays, data structures
• Algorithms: searching, sorting, recursion, etc.
• Objects and object-oriented programming
• Graphical user interfaces, event-driven programming

82