Introduction to Python I

1
Introduction to Python I

• CSE-391 Artificial IntelligenceUniversity of
  Pennsylvania
• Matt Huenerfauth
• January 2005

2
Todays Class

• Review Introduction, Installing Running.
• Sample Code from Homework 0.
• Names Assignment
• Containers Lists, Tuples, Dictionaries
• Mutability
• Hand out Homework 1.

3
What is Python?

• A programming language with strong similarities
  to PERL, but with powerful typing and object
  oriented features.
• Commonly used for producing HTML content on
  websites. Great for text files.
• Useful built-in types (lists, dictionaries).
• Clean syntax, powerful extensions.

4
Why Python for CSE-391?

• Textbook Code Very Object Oriented
• Python much less verbose than Java
• AI Processing Symbolic
• Pythons built-in datatypes for strings, lists,
  and more.
• Java or C require the use of special classes
  for this.
• AI Processing Statistical
• Python has strong numeric processing
  capabilities matrix operations, etc.
• Suitable for probability and machine learning
  code.

5
Technical Issues

• Installing Running Python

6
Installing Python

• Python is on eniac /pkg/bin/python
• Python for Win/Mac from www.python.org.
• GUI development environment IDLE.

Creditshttp//hkn.eecs.berkeley.edu/dyoo/python
/idle_intro/index.html
7
IDLE Development Environment

• Shell for interactive evaluation.
• Text editor with color-coding and smart indenting
  for creating python files.
• Menu commands for changing system settings and
  running files.
• Youll see me using IDLE in class.

8
Running Interactively on UNIX

• On Unix
• python
• 33
• 6
• The is the Python prompt. In Unix, when
  finished, you can use CONTROLD.

9
Running Programs on UNIX

• python filename.py
• You can create python files using emacs.
• (Theres a special Python editing mode.)
• You could even make the .py file executable and
  add the following text to top of the file to make
  it runable !/pkg/bin/python

10
Understanding the Basics
11
Look at a sample of code

• 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

12
Look at a sample of code

• 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

13
Enough to Understand the Code

• Assignment uses and comparison uses .
• For numbers -/ are as expected.
• Special use of for string concatenation.
• Special use of for string formatting.
• Logical operators are words (and, or, not) not
  symbols (, , !).
• The basic printing command is print.
• First assignment to a variable will create it.
• Variable types dont need to be declared.
• Python figures out the variable types on its own.
  

14
Basic Datatypes

• Integers (default for numbers)
• z 5 / 2 Answer is 2, integer division.
• Floats
• x 3.456
• Strings
• Can use or to specify. abc abc
  (Same thing.)
• Unmatched ones can occur within the string.
  matts
• Use triple double-quotes for multi-line strings
  or strings than contain both and inside of
  them abc

15
Whitespace

• Whitespace is meaningful in Python especially
  indentation and placement of newlines.
• Use a newline to end a line of code. (Not a
  semicolon like in C or Java.)(Use \ when must
  go to next line prematurely.)
• No braces to mark blocks of code in Python
  Use consistent indentation instead. The first
  line with a new indentation is considered outside
  of the block.
• Often a colon appears at the start of a new
  block. (Well see this later for function and
  class definitions.)

16
Comments

• Start comments with the rest of line is
  ignored.
• Can include a documentation string as the first
  line of any new function or class that you
  define.
• The development environment, debugger, and other
  tools use it its good style to include one.
• def my_function(x, y)
• This is the docstring. This function does
  blah blah blah. The code would go here...

17
Look at a sample of code

• 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

18
Understanding Assignment
19
Names and References 1

• Python has no pointers like C or C. Instead,
  it has names and references. (Works a lot
  like Lisp or Java.)
• You create a name the first time it appears on
  the left side of an assignment expression x
  3
• Names store references which are like pointers
  to locations in memory that store a constant or
  some object.
• Python determines the type of the reference
  automatically based on what data is assigned to
  it.
• It also decides when to delete it via garbage
  collection after any names for the reference have
  passed out of scope.

20
Names and References 2

• There is a lot going on when we typex 3
• First, an integer 3 is created and stored in
  memory.
• A name x is created.
• An reference to the memory location storing the 3
  is then assigned to the name x.

Type Integer Data 3
Name x Ref
memory
name list
21
Names and References 3

• The data 3 we created is of type integer. In
  Python, the basic datatypes integer, float, and
  string are immutable.
• This doesnt mean we cant change the value of x
  For example, we could increment x.
• x 3
• x x 1
• print x
• 4

22
Names and References 4

• If we increment x, then whats really happening
  is
• The reference of name x is looked up.
• The value at that reference is retrieved.
• The 31 calculation occurs, producing a new data
  element 4 which is assigned to a fresh memory
  location with a new reference.
• The name x is changed to point to this new
  reference.
• The old data 3 is garbage collected if no name
  still refers to it.

Type Integer Data 3
Name x Ref
23
Names and References 4

• If we increment x, then whats really happening
  is
• The reference of name x is looked up.
• The value at that reference is retrieved.
• The 31 calculation occurs, producing a new data
  element 4 which is assigned to a fresh memory
  location with a new reference.
• The name x is changed to point to this new
  reference.
• The old data 3 is garbage collected if no name
  still refers to it.

Type Integer Data 3
Name x Ref
Type Integer Data 4
24
Names and References 4

• If we increment x, then whats really happening
  is
• The reference of name x is looked up.
• The value at that reference is retrieved.
• The 31 calculation occurs, producing a new data
  element 4 which is assigned to a fresh memory
  location with a new reference.
• The name x is changed to point to this new
  reference.
• The old data 3 is garbage collected if no name
  still refers to it.

Type Integer Data 3
Name x Ref
Type Integer Data 4
25
Names and References 4

• If we increment x, then whats really happening
  is
• The reference of name x is looked up.
• The value at that reference is retrieved.
• The 31 calculation occurs, producing a new data
  element 4 which is assigned to a fresh memory
  location with a new reference.
• The name x is changed to point to this new
  reference.
• The old data 3 is garbage collected if no name
  still refers to it.

Name x Ref
Type Integer Data 4
26
Assignment 1

• So, for simple built-in datatypes (integers,
  floats, strings), assignment behaves as you would
  expect x 3 Creates 3, name x
  refers to 3 y x Creates name y,
  refers to 3. y 4 Creates ref for 4.
  Changes y. print x No effect on x,
  still ref 3.3

27
Assignment 1

• So, for simple built-in datatypes (integers,
  floats, strings), assignment behaves as you would
  expect x 3 Creates 3, name x
  refers to 3 y x Creates name y,
  refers to 3. y 4 Creates ref for 4.
  Changes y. print x No effect on x,
  still ref 3.3

Name x Ref
Type Integer Data 3
28
Assignment 1

• So, for simple built-in datatypes (integers,
  floats, strings), assignment behaves as you would
  expect x 3 Creates 3, name x
  refers to 3 y x Creates name y,
  refers to 3. y 4 Creates ref for 4.
  Changes y. print x No effect on x,
  still ref 3.3

Name x Ref
Type Integer Data 3
Name y Ref
29
Assignment 1

• So, for simple built-in datatypes (integers,
  floats, strings), assignment behaves as you would
  expect x 3 Creates 3, name x
  refers to 3 y x Creates name y,
  refers to 3. y 4 Creates ref for 4.
  Changes y. print x No effect on x,
  still ref 3.3

Name x Ref
Type Integer Data 3
Name y Ref
Type Integer Data 4
30
Assignment 1

• So, for simple built-in datatypes (integers,
  floats, strings), assignment behaves as you would
  expect x 3 Creates 3, name x
  refers to 3 y x Creates name y,
  refers to 3. y 4 Creates ref for 4.
  Changes y. print x No effect on x,
  still ref 3.3

Name x Ref
Type Integer Data 3
Name y Ref
Type Integer Data 4
31
Assignment 1

• So, for simple built-in datatypes (integers,
  floats, strings), assignment behaves as you would
  expect x 3 Creates 3, name x
  refers to 3 y x Creates name y,
  refers to 3. y 4 Creates ref for 4.
  Changes y. print x No effect on x,
  still ref 3.3

Name x Ref
Type Integer Data 3
Name y Ref
Type Integer Data 4
32
Assignment 2

• For other data types (lists, dictionaries,
  user-defined types), assignment works
  differently.
• These datatypes are mutable.
• When we change these data, we do it in place.
• We dont copy them into a new memory address each
  time.
• If we type yx and then modify y, both x and y
  are changed!
• Well talk more about mutability later.
• x 3 x some mutable object
• y x y x
• y 4 make a change to y
• print x look at x
• 3 x will be changed as well

immutable
mutable
33
Container Types in Python
34
Container Types

• Weve talked about integers, floats, and strings
• Containers are other built-in data types in
  Python.
• Can hold objects of any type (including their own
  type).
• There are three kinds of containers
• Tuples
• A simple immutable ordered sequence of items.
• Lists
• Sequence with more powerful manipulations
  possible.
• Dictionaries
• A look-up table of key-value pairs.

35
Tuples, Lists, and Strings Similarities
36
Similar Syntax

• Tuples and lists are sequential containers that
  share much of the same syntax and functionality.
• For conciseness, they will be introduced
  together.
• The operations shown in this section can be
  applied to both tuples and lists, but most
  examples will just show the operation performed
  on one or the other.
• While strings arent exactly a container data
  type, they also happen to share a lot of their
  syntax with lists and tuples so, the operations
  you see in this section can apply to them as well.

37
Tuples, Lists, and Strings 1

• Tuples are defined using parentheses (and
  commas).
• tu (23, abc, 4.56, (2,3), def)
• Lists are defined using square brackets (and
  commas).
• li abc, 34, 4.34, 23
• Strings are defined using quotes (, , or ).
• st Hello World
• st Hello World
• st This is a multi-line
• string that uses triple quotes.

38
Tuples, Lists, and Strings 2

• We can access individual members of a tuple,
  list, or string using square bracket array
  notation.
• tu1 Second item in the tuple.
• abc
• li1 Second item in the list.
• 34
• st1 Second character in string.
• e

39
Looking up an Item

• t (23, abc, 4.56, (2,3), def)
• Positive index count from the left, starting
  with 0.
• t1
• abc
• Negative lookup count from right, starting with
  1.
• t-3
• 4.56

40
Slicing Return Copy of a Subset 1

• 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 the second index.
• t14
• (abc, 4.56, (2,3))
• You can also use negative indices when slicing.
• t1-1
• (abc, 4.56, (2,3))

41
Slicing Return Copy of a Subset 2

• t (23, abc, 4.56, (2,3), def)
• Omit the first index to make a copy starting from
  the beginning of the container.
• t2
• (23, abc)
• Omit the second index to make a copy starting at
  the first index and going to the end of the
  container.
• t2
• (4.56, (2,3), def)

42
Copying the Whole Container

• You can make a copy of the whole tuple using .
• t
• (23, abc, 4.56, (2,3), def)
• So, theres a difference between these two lines
• list2 list1 2 names refer to 1 ref
• Changing one affects both
• list2 list1 Two copies, two refs
• Theyre independent

43
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
• Be careful the in keyword is also used in the
  syntax of other unrelated Python constructions
  for loops and list comprehensions.

44
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

45
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

46
MutabilityTuples vs. Lists

• Whats the difference betweentuples and lists?

47
Tuples Immutable

• t (23, abc, 4.56, (2,3), def)
• t2 3.14
• Traceback (most recent call last)
• File "", line 1, in -toplevel-
• tu2 3.14
• TypeError object doesn't support item assignment
• Youre not allowed to change a tuple in place in
  memory so, you cant just change one element of
  it.
• But its always OK to make a fresh tuple and
  assign its reference to a previously used name.
• t (1, 2, 3, 4, 5)

48
Lists Mutable

• li abc, 23, 4.34, 23
• li1 45
• liabc, 45, 4.34, 23
• We can change lists in place. So, its ok to
  change just one element of a list. Name li still
  points to the same memory reference when were
  done.

49
Operations on Lists Only 1

• Since lists are mutable (they can be changed in
  place in memory), there are many more operations
  we can perform on lists than on tuples.
• The mutability of lists also makes managing them
  in memory more complicated So, they arent as
  fast as tuples. Its a tradeoff.

50
Operations on Lists Only 2

• li 1, 2, 3, 4, 5
• li.append(a)
• li
• 1, 2, 3, 4, 5, a
• li.insert(2, i)
• li
• 1, 2, i, 3, 4, 5, a

51
Operations on Lists Only 3

• The extend operation is similar to
  concatenation with the operator. But while the
  creates a fresh list (with a new memory
  reference) containing copies of the members from
  the two inputs, the extend operates on list li in
  place.
• li.extend(9, 8, 7)
• li
• 1, 2, i, 3, 4, 5, a, 9, 8, 7
• Extend takes a list as an argument. Append takes
  a singleton.
• li.append(9, 8, 7)
• li
• 1, 2, i, 3, 4, 5, a, 9, 8, 7, 9, 8, 7

52
Operations on Lists Only 4

• li a, b, c, b
• li.index(b) index of first occurrence
• 1
• li.count(b) number of occurrences
• 2
• li.remove(b) remove first occurrence
• li
• a, c, b

53
Operations on Lists Only 5

• 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

54
Tuples vs. Lists

• Lists slower but more powerful than tuples.
• Lists can be modified, and they have lots of
  handy operations we can perform on them.
• Tuples are immutable and have fewer features.
• We can always convert between tuples and lists
  using the list() and tuple() functions.
• li list(tu)
• tu tuple(li)

55
More About Assignment

• Classes, Functions, Naming Rules

56
Assignment Mutability 1

• Remember that assignment works differently for
  mutable vs. immutable datatypes.
• If you type yx, then changing y will change
  x if they are mutable. wont change x if they
  are immutable.
• x 3 x 1, 2, 3
• y x y x
• y y 1 y.reverse()
• print x print x
• 3 3, 2, 1

immutable
mutable
57
Assignment Mutability 2

• Python is object-oriented, and user-defined
  classes are mutable.
• Lets say that the name x refers to an object of
  some class. This class has a set and a get
  function for some value.
• x.getSomeValue() 4
• What happens if we create a new name y and set
  yx ?
• y x
• This creates a new name y which points to the
  same memory reference as the name x. Now, if we
  make some change to y, then x will be affected as
  well.
• y.setSomeValue(3) y.getSomeValue() 3
  x.getSomeValue() 3

58
Assignment Mutability 3

• When passing parameters to functions
• Immutable data types are call by value.
• Mutable data types are call by reference.
• If you pass mutable data to a function, and you
  change it inside that function, the changes will
  persist after the function returns.
• Immutable data appear unchanged inside of
  functions to which they are passed.

59
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

60
Accessing Non-Existent Name

• If you try to access a name before its been
  properly created (by placing it on the left side
  of an assignment), youll get an error.
• y
• Traceback (most recent call last)
• File "", line 1, in -toplevel-
• y
• NameError name y' is not defined
• y 3
• y
• 3

61
Multiple Assignment

• You can also assign to multiple names at the same
  time.
• x, y 2, 3
• x
• 2
• y
• 3

62
Homework 1