Python I

Some material adapted

from Upenn cmpe391
slides and other sources
 Overview

 Names & Assignment

 Data types
 Sequences types: Lists, Tuples, and
Strings
 Mutability
 Understanding Reference Semantics in
Python
 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 meaning the code
• Block structure indicated by indentation
 The first assignment to a variable creates it
• Dynamic typing: no declarations, names don’t have
types, objects do
 Assignment uses = and comparison uses ==
 For numbers + - * / % are as expected.
• Use of + for string concatenation.
• Use of % for string formatting (like printf in C)
 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, "foo" == 'foo’
• Unmatched can occur within the string
“John’s” or ‘John said “foo!”.’
• 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 don’t have an intrinsic type,
objects have types
Python determines type of the reference auto-
matically 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
 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
recommended 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
 Python PEPs
 Where do such conventions come from?
• The community of users
• Codified in PEPs
 Python's development is done via the Python
Enhancement Proposal (PEP) process
 PEP: a standardized design document, e.g.
proposals, descriptions, design rationales,
and explanations for language features
• Similar to IETF RFCs
• See the PEP index
 PEP 8: Style Guide for Python Code
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
Python’s data types
 Everything is an object
 Python data is represented by objects or by
relations between objects
 Every object has an identity, a type and a value
 Identity never changes once created Location
or address in memory
 Type (e.g., integer, list) is unchangeable and
determines the possible values it could have
and operations that can be applied
 Value of some objects is fixed (e.g., an integer)
and can change for others (e.g., list)
Python’s built-in type hierarchy
Sequence types:
Tuples, Lists, and
Strings
 Sequence Types
 Sequences are containers that hold objects
 Finite, ordered, indexed by integers
 Tuple: (1, “a”, [100], “foo”)
 An immutable ordered sequence of items
 Items can be of mixed types, including collection types
 Strings: “foo bar”
 An immutable ordered sequence of chars
• Conceptually very much like a tuple
 List: [“one”, “two”, 3]
 A 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’)

Returns copy of container with subset of original

members. Start copying at first index, and stop
copying before the second index
>>> t[1:4]
(‘abc’, 4.56, (2,3))
You can also use negative indices
>>> 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 a copy starting from the
beginning of container
>>> t[:2]
(23, ‘abc’)
Omit second index to make a copy starting at
1st index and going to end of the container
>>> 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 same 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
 Careful: the in keyword is also used in the syntax of
for loops and list comprehensions
 + Operator is Concatenation
 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’
 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 are

faster than lists
 Functions vs. methods
 Some operations are functions and others methods
• Remember that (almost) everything is an object
• You just have to learn (and remember or lookup) which
operations are functions and which are methods

len() is a function on collec- index() is a method on col-

tions that returns the num- lections that returns the
ber of things they contain index of the 1st occurrence
of its arg
>>> len(['a', 'b', 'c'])
3 >>> ['a’,'b’,'c'].index('a')
>>> len(('a','b','c')) 0
3 >>> ('a','b','c').index('b')
>>> len("abc") 1
3 >>> "abc".index('c')
2
 Lists methods
 Lists have many methods, including index,
count, append, remove, reverse, sort, etc.
 Many of these modify the list
>>> l = [1,3,4]
>>> l.append(0) # adds a new element to the end of the list
>>> l
[1, 3, 4, 0]
>>> l.insert(1,200) # insert 200 just before index position 1
>>> l
[1, 200, 3, 4, 0]
>>> l.reverse() # reverse the list in place
>>> l
[0, 4, 3, 200, 1]
>>> l.sort() # sort the elements. Optional arguments can give
>>> l # the sorting function and direction
[0, 1, 3, 4, 200]
>>> l.remove(3) # remove first occurence of element from list
>>> l
[0, 1, 4, 200]
 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()
()
 Tuples vs. Lists
 Lists slower but more powerful than tuples
• Lists can be modified and they have many handy
operations and methods
 Tuples are immutable & have fewer features
• Sometimes an immutable collection is required (e.g.,
as a hash key)
• Tuples used for multiple return values and parallel
assignments
x,y,z = 100,200,300
old,new = new,old
 Convert tuples and lists using list() and tuple():
mylst = list(mytup); mytup = tuple(mylst)