Introduction to

Programming
with Python

Python Review. Modified slides

 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.

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

 Python is instead directly interpreted into machine instructions.

interpret
source code outpu
Hello.py t

3
Best Python IDE
 Best Python IDE
1. Full-featured IDEs: These are comprehensive environments with debugging, code
completion, project management, and testing tools.

 PyCharm (by JetBrains)

o ✔️Advanced features, best for professional development
o 🔸 Community (Free) & Professional (Paid) editions
Supports Django, Flask, and web development.
- Database integration, scientific tools, and remote development.

-Best For: Professional developers, large projects.

Spyder
- Platforms: Cross-platform (bundled with Anaconda).
- Key Features:
- Built for data science (integrates with NumPy, Pandas, Matplotlib).
- Variable explorer, IPython console, and debugging tools.
- Best For: Data scientists, researchers.

5
 Best Python IDE
Wing IDE
- Platforms: Windows, macOS, Linux
- Key Features:
- Advanced debugging (watch expressions, conditional breakpoints).
- Remote development and test-driven development (TDD) support.
- Editions: Free Personal Edition vs. Paid Pro.
- Best For: Debugging-heavy workflows.
Komodo IDE
- Platforms: Cross-platform
- Key Features
- Multi-language support (Python, PHP, Ruby, etc.).
- Docker integration and unit testing.
- Editions: Paid (with free Komodo Edit for basic use).
- Best For: Multi-language developers.

6
 Best Python IDE
These are code editors enhanced with Python
2. Lightweight Editors with Python Support
extensions
Visual Studio Code (VS Code)
- Platforms: Cross-platform
-Key Features:
- Extensions for Python (IntelliSense, debugging, Jupyter notebooks).
- Git integration, terminal, and customizable workflows.
- **Best For**: General-purpose coding, flexibility.
Sublime Text
- Platforms: Cross-platform
- Key Features:
- Speed and simplicity with plugins (Anaconda, SublimeREPL).
- Multiple cursors, regex find/replace.
- Best For: Minimalists needing speed.

Atom (Discontinued)
- Platforms: Cross-platform (no longer maintained)
- Key Features:
- Hackable with packages (e.g., Hydrogen for Jupyter).
 Best Python IDE
3. Online IDEs / Cloud-based Platforms

Useful for beginners or those without a local setup.

 Google Colab
o ✔️Free GPU, ideal for ML & data science
o 💡 Jupyter Notebook style

 Replit
o ✔️Easy to use, great for beginners
o 💡 Real-time collaboration

 Jupyter Notebook / JupyterLab

o ✔️Interactive coding, used in data science
o 💡 Not an IDE in the classic sense, but very popular

8
 Expressions
 expression: is a combination of values, variables, and operators that result in 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

1
 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

1
 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:
7 / 3 * 1.2 + 3 /1 2/ 2.0 is 0.5
2 * 1.2 + 3 / 2
 The conversion
2.4
occurs on a per-operator basis.
+ 3 / 2
2.4 + 1
3.4

1
 Math commands
 Python has useful commands (or called functions) for
performing calculations.
Constant Description
Command name Description
e 2.7182818...
abs(value) absolute value
pi 3.1415926...
ceil(value) rounds up
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:
from math import * 8
 Keywords
Keywords are reserved words in Python with special meanings. You **cannot** use them
as variable names.

Code
import keyword
# Print all Python keywords
print("Python Keywords:")
print(keyword.kwlist)

Output:

['False', 'None', 'True', 'and', 'as', 'assert', ...]

 Numbers: Floating
Point
 int(x) converts x to >>> 1.23232
1.2323200000000001
an integer
>>> print 1.23232
 float(x) converts x
1.23232
to a floating >>> 1.3E7
point 13000000.0
 The interpreter >>> int(2.0)
2
shows >>> float(2)
a lot of digits 2.0
 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:
Python has no explicit variable declaration—just assign values.
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.

10
 Example
name = "Alice" # String variable
age = 25 # Integer variable
height = 5.6 # Float variable
is_student = True # Boolean variable

# Print variables
print("Name:", name)
print("Age:", age)
print("Height:", height)
print("Is Student?", is_student)
 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 1
Example: print Statement

•
Elements separated by
commas print with a space
between them >>> print 'hello'
•
A comma at the end of the hello
statement (print ‘hello’,) >>> print
will not print a newline 'hello', 'there'
character hello there
 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

 Exercise: Write a Python program that prompts the user for

his/her amount of money, then reports how many Nintendo Wiis
the person can afford, and how much more money he/she will
need to afford an additional Wii.

1
 Input: Example
print "What's your name?"
name = raw_input("> ")

print "What year were you born?"

birthyear = int(raw_input("> "))

print "Hi “, name, “!”, “You are “,

2016 – birthyear
% python input.py
What's your name?
> Michael
What year were
you born?
>1980
Hi Michael! You are
 Repetition
(loops) and
Selection (if/else)
 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

23
 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? 24
 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.

25
 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:
Example:
for x in range(1, 6): for i in range(5):
print x, "squared is", x * x print("Loop number:", i)

Output:
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25

26
 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."

27
 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 21
Example of If Statements

import math
x = 30
if x <= 15 : y >>> import ifstatement
= x + 15 y = 0.999911860107
>>>
elif x <= 30
In interpreter
:
y = x + 30
else :
y=x
print ‘y = ‘,
Inprint
file ifstatement.py
math.sin(y)
Example of If Statements

>>> import ifstatement

y = 0.999911860107
>>>

In interpreter

In file ifstatement.py
Example of If Statements

age = int(input("Enter your age: "))

if age >= 18:

print("You are an adult.")
elif age > 12:
print("You are a teenager.")
else:
print("You are a child.")
 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

2
 While Loops
>>> import whileloop
x=1 1
while x < 10 : 2
print x 3
x=x+1 4
5
6

In whileloop.py
7
8
9
>>>

In interpreter
 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
not not 7 > 0 False

 Exercise: Write code to display and count the factors of a number.

25
Loop Control Statements

break Jumps out of the closest

enclosing loop

continue Jumps to the top of the closest

enclosing loop

pass Does nothing, empty statement

placeholder
 More Examples For
Loops
 Similar to perl for loops, iterating through a
list of values
for x in [1,7,13,2]: for x in range(5) :
forloop1.py print x forloop2.py print x

%python forloop1.py
% python forloop2.py
1
0
7
1
13
2
2
3
4 [0,1, …, n-1]
range(N) generates a list of numbers
More Data Types
 Everything is an object

 Everything means
>>> x = 7
everything, >>> x
including 7
functions and >>>
classes (more on x=
'hello'
this later!) >>>
 Data type is a x
property of the 'hello'
>>>
object and not
of the variable
 Numbers: Integers

 Integer – the
equivalent of a C long >>> 132224
 Long Integer – an 132224
unbounded >>> 132323 **
2
integer value. 17509376329L
>>>
 Numbers: Floating
Point
 int(x) converts x to >>> 1.23232
1.2323200000000001
an integer
>>> print 1.23232
 float(x) converts x
1.23232
to a floating >>> 1.3E7
point 13000000.0
 The interpreter >>> int(2.0)
2
shows >>> float(2)
a lot of digits 2.0
 Numbers: Complex

 Built into Python

 Same operations are >>> x = 3 + 2j
>>> y = -1j
supported as
>>> x +y
integer and float (3+1j)
>>> x *y
(2-3j)
 String Literals

 + is overloaded to do
concatenation >>> x = 'hello'
>>> x = x + ' there'
>>> x
'hello there'
 String Literals
 Can use single or double quotes, and
three double quotes for a multi-line
string

>>> 'I am a string'

'I am a string'
>>> "So am I!"
'So am I!'
Substrings and Methods

•len(String) – returns the

>>> s = '012345' number of characters in
>>> s[3] the String
'3'
>>> s[1:4] •str(Object) – returns a
'123' String representation of
>>> s[2:] the Object
'2345'
>>> s[:4] >>> len(x)
'0123' 6
>>>
>>> s[-2]
str(10.3)
'4'
'10.3'
 String Formatting
 Similar to C’s printf
 <formatted string> % <elements to

insert>
 Can usually just use %s for everything,

it will convert the object to its String

representation.
>>> "One, %d, three" % 2
'One, 2, three'
>>> "%d, two, %s" % (1,3)
'1, two, 3'
>>> "%s two %s" % (1, 'three')
'1 two three'
>>>
 Types for Data
Collection List, Set,
and Dictionary

List


Ordered Pairs of values

Unordered list
 Lists
 Ordered collection of
data
>>> x = [1,'hello', (3 + 2j)]
 Data can be of
>>> x
different [1, 'hello', (3+2j)]
types >>> x[2]
 Lists are (3+2j)
>>>
mutable x[0:2]
 Issues with shared [1,
'hello']
references and
mutability
 Same subset
 List Functions
 list.append(x)
 Add item at the end of the list.

 list.insert(i,x)
 Insert item at a given position.

 Similar to a[i:i]=[x]

 list.remove(x)
 Removes first item from the list with value x

 list.pop(i)
 Remove item at position I and return it. If no index I is given then

remove the first item in the list.

 list.index(x)
 Return the index in the list of the first item with value x.

 list.count(x)
 Return the number of time x appears in the list

 list.sort()
 Sorts items in the list in ascending order

 list.reverse()
 Reverses items in the list
 List

List (Mutable):
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")

print(fruits[0]) # First item

print(len(fruits))
 Lists: Modifying Content

 x[i] = a reassigns >>> x = [1,2,3]

the ith element to >>> y = x
the value a >>> x[1] = 15
 Since x and y point to >>> x
[1, 15, 3]
the same list object,
>>> y
both are changed [1, 15, 3]
 The method append >>>
x.append
also modifies the list (12)
>>> y
[1, 15, 3,
12]
 Lists: Modifying
Contents >>> x = [1,2,3]
 The method >>> y = x
append >>> z = x.append(12)
modifies the list >>> z == None
and returns True
None >>> y
 List addition [1, 2, 3, 12]
>>> x = x +
(+) returns [9,10]
a new list >>> x
[1, 2, 3, 12, 9,
10]
>>> y
[1, 2, 3, 12]
 Using Lists as Stacks
 You can use a list as a stack
>>> a = ["a", "b", "c“,”d”]
>>> a
['a', 'b', 'c', 'd']
>>> a.append("e")
>>> a
['a', 'b', 'c', 'd', 'e']
>>> a.pop()
'e'
>>> a.pop()
'd'
>>> a =
["a", "b",
"c"]
>>>
 Tuples
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
 Tuples

colors = ("red",
"green", "blue")

print(colors[1])
# Second
item
 Sets
 A set is another python data structure that is an unordered
collection with no duplicates.
>>> setA=set(["a","b","c","d"])
>>> setB=set(["c","d","e","f"])
>>> "a" in setA
True
>>> "a" in setB
False
 Sets
>>> setA - setB
numbers = {1, 2, 2, 3}
{'a', 'b'} print(numbers) # Output:
>>> setA | setB {1, 2, 3}
numbers.add(4)
{'a', 'c', 'b', 'e', 'd', 'f'}
>>> setA & setB
{'c', 'd'}
>>> setA ^ setB
{'a', 'b', 'e', 'f'}
>>>
 Dictionaries
🔹 Dictionary (key-value pairs):
 A set of key-value pairs
 Dictionaries are mutable

>>> d= {‘one’ : 1, 'two' : 2, ‘three’ : 3}

>>> d[‘three’]
3

person = {"name": "Ali", "age": 25}

print(person["name"])

person["age"] = 26
 Dictionaries:
Add/Modify
 Entries can be changed by assigning to

that entry
>>> d
{1: 'hello', 'two': 42, 'blah': [1, 2, 3]}
>>> d['two'] = 99
>>> d
{1: 'hello', 'two': 99, 'blah': [1, 2, 3]}
•
Assigning to a key that does not exist
adds an entry
>>> d[7] = 'new entry'
>>> d
{1: 'hello', 7: 'new entry', 'two': 99, 'blah': [1, 2, 3]}
 Dictionaries: Deleting
Elements
 The del method deletes an element from a
dictionary

>>> d
{1: 'hello', 2: 'there', 10: 'world'}
>>> del(d[2])
>>> d
{1: 'hello', 10: 'world'}
 Iterating over a dictionary
>>>address={'Wayne': 'Young 678', 'John': 'Oakwood 345',
'Mary': 'Kingston 564'}
>>>for k in address.keys():
print(k,":", address[k])

Wayne : Young 678

John : Oakwood 345
Mary : Kingston 564
>>>

>>> for k in sorted(address.keys()):

print(k,":", address[k])

John : Oakwood 345

Mary : Kingston 564
Wayne : Young 678
>>>
Copying Dictionaries and
Lists
 The built-in >>> l1 = [1] >>> d = {1 : 10}
list function >>> l2 = list(l1) >>> d2 = d.copy()
>>> l1[0] = 22 >>> d[1] = 22
will copy a
>>> l1 >>> d
list [22] {1: 22}
 The dictionary >>> l2 >>> d2
has a [1] {1: 10}
method
called copy
 Similar Syntax
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
 Sequence Types 1
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 2

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 “““).
Sequence
>>> st
= “Hello World”
>>> st
= ‘Hello World’
Types 1
>>> 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
 Comparision Dictionaries and
Lists
Feature List (list) Tuple (tuple)
✅ Mutable (can be ❌ Immutable (cannot
Mutability
changed) be changed)
Syntax [1, 2, 3] (1, 2, 3)
Many methods
Few methods
Methods available like .append(), .remove
like .count(), .index()
()
Slightly slower (more
Performance Faster (fixed structure)
flexible)
When data should
Use case When data can change
remain constant
Memory usage Higher Lower (more compact)
Can be a dictionary ❌ No (because it's ✅ Yes (if it contains
key mutable) only immutables)
 Comparision Dictionaries and
Lists
Feature Set (set) Dictionary (dict)
Unordered collection of Unordered collection of
Structure
unique values key-value pairs
Syntax {1, 2, 3} {'a': 1, 'b': 2}
✅ Mutable (can
✅ Mutable (can add/remove
Mutability add/change/remove key-
items)
values)

❌ No (all values must be ❌ No duplicate keys (values

Duplicates allowed?
unique) can be duplicated)

✅ Via keys (e.g.,

Indexing ❌ Not supported
my_dict['a'])
Membership testing, Storing and retrieving data
Common use case
removing duplicates using keys
.get(), .keys(), .values(), .ite
Methods .add(), .remove(), .union() etc.
ms()
 Data Type Summary
Integers: 2323, 3234L
Floating Point: 32.3, 3.1E2
Complex: 3 + 2j, 1j
Lists: l = [ 1,2,3]
Tuples: t = (1,2,3)
Dictionaries: d = {‘hello’ :
‘there’, 2 : 15}

 Lists, Tuples, and Dictionaries can store

any type (including other lists,
tuples, and dictionaries!)
 Only lists and dictionaries are mutable

 All variables are references

Functions
● The name of your variable (myInt etc.) is placed on the left of the
“=“ operator.

Basic Syntax Rules

○ Most variable names are in camel case where the first word
begins with a lowercase letter and any subsequent words are
capitalized
○ Variable names may also appear in snake case where all words
are lowercase, with underscores between words
● The assignment operator (“=“) sets the variable name equal to the
memory location where your value is found.
● The value of your variable (“Hello, World”) is placed on the right
of the “=“ operator.
○ The type of this value does NOT need to be stated but its
format must abide by a given object type (as shown).
myString = “Hello, World”
myInt = 7
myFloat = 7.0
myList = [7, 8, 9]
myBoolean = true
●Function Syntax
Basic
○ def...:Syntax
indicates that youRules
are defining a new function.
○ function() refers to the name of your function. By convention,
this name is typically lowercase and represents a verb/action.
○ a,b refers to parameters (values or variables) that can be
used within the statements of your function’s definition (......). If
your function has no parameters, an empty parenthetical () is
used.
○ The return statement is an optional statement that will return a
value for your function to your original call.

def function(a, b):

......
return a + b
● Calling a function

Basic
○ Call Syntax
the functionRules (cont.)
by referring to its name
(function()) and by placing
any necessary arguments (1, 2) within
the parenthesis separated by
commas. myValue = function(1, 2)
○ If you wish, you can set your function call
equal to a variable (myValue). The value
returned by the function will be assigned
to your variable name.

myValue = function(1, 2)
 Function Basics

def max(x,y) : >>> import functionbasics

if x < y : >>> max(3,5)
return x 5
else : >>>
max('hello',
retur
'there')
ny
'there'
functionbasics.py >>> max(3, 'hello')
'hello'
 Functions are objects
 Can be assigned to a variable
 Can be passed as a parameter

 Can be returned from a function

• Functions are treated like any other

variable in Python, the def statement

simply assigns a function to a variable
 Function names are like
any variab
le >>> x = 10
>>> x
10
 Functions are >>>
objects def x
() :
 The same
...
reference rules print
hold for them 'hello'
>>>
as for other x
objects <funct
ion x
at
0x619
Functions as Parameters

def foo(f, a) : >>> from funcasparam import *

return f(a) >>> foo(bar, 3)
9
def bar(x) :
return x * x

funcasparam.py 
Note that the function foo takes two
parameters and applies the first as a
function with the second as its
parameter
 Higher-Order Functions


map(func,seq) – for all i, applies func(seq[i]) and returns the
corresponding sequence of the calculated results.

>>> from highorder import *

def double(x): >>> lst = range(10)
return 2*x >>> lst
[0,1,2,3,4,5,6,7,8,9]
highorder.py >>> map(double,lst)
[0,2,4,6,8,10,12,14,16,18]
 Higher-Order Functions


filter(boolfunc,seq) – returns a sequence containing all those
items in seq for which boolfunc is True.

>>> from highorder import *

def even(x): >>> lst = range(10)
return ((x%2 == >>> lst
0)
[0,1,2,3,4,5,6,7,8,9]
highorder.py >>> filter(even,lst)
[0,2,4,6,8]
 Higher-Order Functions


reduce(func,seq) – applies func to the items of seq, from left
to right, two-at-time, to reduce the seq to a single value.


>>> from highorder import *
def plus(x,y): 
>>> lst = [‘h’,’e’,’l’,’l’,’o’]
return (x + y) 
>>> reduce(plus,lst)

‘hello’
highorder.py
Functions Inside Functions

 Since they are like any other object, you

can have functions inside functions

def foo (x,y) : >>> from funcinfunc import *

def bar (z) : >>> foo(2,3)
return z * 2 7
return bar(x) + y

funcinfunc.py
Functions Returning
Functions
def foo (x) :
def bar(y) :
return x + y % python funcreturnfunc.py
return bar <function bar at 0x612b0>
# main 5
f=
foo(3)
print f
print f(2)
funcreturnfunc.py
 Parameters: Defaults

 Parameters can be
assigned default 
>>> def foo(x = 3) :
values 
... print x
 They are

...

>>> foo()
overridden if a 3

parameter is given 
>>> foo(10)
for them 
10
 The type of the 
>>> foo('hello')

hello
default doesn’t
limit the type of
a parameter
 Parameters: Named

 Call by name >>> def foo (a,b,c) :

 Any positional ... print a, b, c
arguments ...

must come >>> foo(c = 10, a = 2, b = 14)

2 14 10
before
>>> foo(3, c = 2, b = 19)
named 3 19 2
ones in a call
 Anonymous Functions

 A lambda
expression >>> f = lambda x,y : x + y
returns a >>> f(2,3)
function 5
object >>> lst =
 The body can ['one',
lambda x :
only be a simple x * x, 3]
expression, >>> lst[1](4)
not complex 16
statements
 Modules

 The highest level structure of Python

 Each file with the py suffix is a module

 Each module has its own namespace

 Modules: Imports

import mymodule Brings all elements

of mymodule in, but
must refer to as
mymodule.<elem>
from mymodule import x Imports x from
mymodule right into
this namespace
from mymodule import * Imports all elements
of mymodule into
this namespace
Text and File
Processing
 Strings
 string: A sequence of text characters in a program.

Strings start and end with quotation mark " or apostrophe ' characters.

Examples:
"hello"
"This is a string"
"This, too, is a string. It can be very long!"
 A string may not span across multiple lines or contain a " character.
"This is not
a legal String."
"This is not a "legal" String either."
 A string can represent characters by preceding them with a backslash.

\t tab character

\n new line character

\" quotation mark character

\\ backslash character

Example: "Hello\tthere\nHow are
you?"

89
 Indexes
 Characters in a string are numbered with indexes starting at 0:
 Example:
name = "P. Diddy"

index 0 1 2 3 4 5 6 7
character P . D i d d y

 Accessing an individual character of a string:

variableName [ index ]
 Example:
print name, "starts with", name[0]

Output:
P. Diddy starts with P

90
 String properties
 len(string) - number of characters in a
string (including spaces)
 str.lower(string) - lowercase version of a string
 str.upper(string) - uppercase version of a string

 Example:
name = "Martin Douglas Stepp"
length = len(name)
big_name = str.upper(name)
print big_name, "has",
length, "characters"

Output:
MARTIN DOUGLAS STEPP has 20
characters

91
 raw_input
 raw_input : Reads a string of text from user input.
 Example:
name = raw_input("Howdy, pardner. What's yer name?
")
print name, "... what a silly name!"
Output:
Howdy, pardner. What's yer name? Paris Hilton
Paris Hilton ... what a silly name!

92
 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
h

93
 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"

94
 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()

95
 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.

96
 Objects, and Classes

● A class is a collection of
objects who share the same
Instance #1
set of variables/methods. Color: Pink
Name: Polo
○ The definition of the class Instance #2
provides a blueprint for all the Color: Red
Name: Mini
objects within it (instances).
Instance #3
Color: Blue
○ Instances may share the same Name: Beetle
variables (color, size, shape, etc.),
but they do NOT share the same
values for each variable
(blue/red/pink, small/large,
square/circular etc.)
Object
 Defining a Class
 Python program may own many objects
 An object is an item with fields supported by a set of method functions.

An object can have several fields (or called attribute variables) describing
such an object

These fields can be accessed or modified by object methods
 A class defines what objects look like and what functions can operate
on these object.

 Declaring a class:
class name:
statements
 Example:
class UCSBstudent:
age = 21
schoolname=‘UCSB’
 Fields
name = value
 Example:
class Point: point.py
x = 0
1 class Point:
y = 0 2 x = 0
3 y = 0
# main
p1 = Point()
p1.x = 2
p1.y = -5
 can be declared directly inside class (as shown here)
or in constructors (more common)
 Python does not really have encapsulation or private
fields

relies on caller to "be nice" and not mess with
objects' contents
 Using a Class
import class
 client programs must import the classes they use

point_main.py
1 from Point import *
2
3 # main
4 p1 = Point()
5 p1.x = 7
6 p1.y = -3
7
8 p2 = Point()
9 p2.x = 7
10 p2.y = 1

# Python objects are dynamic (can add fields any time!)

p1.name = "Tyler Durden"
 Object Methods
def name(self, parameter, ...,
parameter): statements

 self must be the first parameter to any object

method

represents the "implicit parameter" (this in Java)

 must access the object's fields through the self

reference
class Point:
def move(self, dx, dy):
self.x += dx
self.y += dy
 Exercise Answer
point.py
1 from math import *
2
3 class Point:
4 x = 0
5 y = 0
6
7 def set_location(self, x, y):
8 self.x = x
9 self.y = y
10
11 def distance_from_origin(self):
12 return sqrt(self.x * self.x + self.y * self.y)
13
14 def distance(self, other):
15 dx = self.x - other.x
16 dy = self.y - other.y
17 return sqrt(dx * dx + dy * dy)
 Calling Methods
 A client can call the methods of an object in two ways:
 (the value of self can be an implicit or explicit parameter)

1) object.method(parameters)
or
2) Class.method(object,
parameters)
 Example:
p = Point(3, -4)
p.move(1, 5)
Point.move(p, 1, 5)
 Constructors
def init (self, parameter, ...,
parameter): statements
 a constructor is a special method with the name init

 Example:
class Point:
def init (self, x, y):
self.x = x
self.y = y
...


How would we make it possible to
construct a
Point() with no parameters to get (0,
0)?
 toString and str
def str (self):
return string
 equivalent to Java's
toString
(converts object to
a string)
 invoked
automatically when
str or print is
called

Exercise: Write a str method for Point objects that returns strings
like "(3, -14)"

def str (self):

return "(" + str(self.x) + ", " + str(self.y) + ")"
 Complete Point Class
point.p
y
1 from math import *
2
3 class Point:
4 def init (self, x, y):
5 self.x = x
6 self.y = y
7
8 def distance_from_origin(self):
9 return sqrt(self.x * self.x + self.y * self.y)
10
11 def distance(self, other):
12 dx = self.x - other.x
13 dy = self.y - other.y
14 return sqrt(dx * dx + dy *
15 dy)
16
17 def move(self, dx, dy):
18 self.x += dx
19 self.y += dy
20
21 def str (self):
return "(" +
str(self.x) + ", "
 Operator Overloading
 operator overloading: You can define functions so that Python's
built-in operators can be used with your class.

See also: http://docs.python.org/ref/customization.html

Operator Class Method Operator Class Method

- neg (self, other) == eq (self, other)
+ pos (self, other) != ne (self, other)
* mul (self, other) < lt (self, other)
/ truediv (self, other) > gt (self, other)

Unary Operators <= le (self, other)
- neg (self) >= ge (self, other)
+ pos (self)
 Generating Exceptions
raise ExceptionType("message")

 useful when the client uses your object improperly


types: ArithmeticError, AssertionError, IndexError,
NameError, SyntaxError, TypeError, ValueError

 Example:
class BankAccount:
...
def deposit(self, amount):
if amount < 0:
raise ValueError("negative amount")
...
 Inheritance
class name(superclass):
statements
 Example:
class Point3D(Point): # Point3D extends Point
z = 0
...

 Python also supports multiple inheritance

class name(superclass, ...,
superclass): statements

(if > 1 superclass has the same field/method, conflicts are resolved
in left-to-right order)
 Calling Superclass Methods
 methods: class.method(object,
 constructors: parameters) class. init
(parameters)
class Point3D(Point):
z = 0
def init (self, x, y, z):
Point. init (self, x, y)
self.z = z

def move(self, dx, dy, dz):

Point.move(self, dx, dy)
self.z += dz
Writing & Reading
Files
Writing to a File
Appending to a File
Reading to a File

-“r” must opens file for reading

Reading Lie by Line to a File
Reading lines into a list
Access Modes
Selected Text File Methods
Task
Task