Introduction

Last week, we were looking at search strategies for problem solving agents -- goal-based agents in unfactored domain setting.
We looked at uninformed (BFS, DFS, UCS, IDS) and informed search strategies (greedy BestFS, `A^{\star}`).
We then started to give a quick intro to Python, so that everyone is on roughly the same page with regard to this language.
We gave some reasons why Python is a good choice of language for AI programming: interpreted, good string processing, higher-order functions, good built-in libraries, lots of projects in, used outside of AI...
We said there were two commonly used variants of Python: Python 2.x and Python 3.x.
We said for this class will use Python 3.x.
We wrote hello world in Python.
Today, we continue our Python Tutorial.

Python as Calculator; Programs in Files

You can use the command prompt as a quick calculator of python expressions. For example,
```
>>>2 / 3 + 7.9
```
outputs 8.566666666666666 (notice converts to a float).
You can refer to the last result by using an underscore similar to Perl. So after the last expression _ + 1 would give 9.566666666666666.
Python programs are put into files with the .py extension. For example, we might have the file: hello.py with the following in it:
```
#!/usr/bin/env python
# The above would mean don't have to type python when run under *nix
# Comments begin with #
print("Hello World")
```
If we didn't have the first line or on Windows we would need to type "python3 hello.py" to run the program.
Aside: As I have multiple python installations on my machine, I am using python3 as an alias to a copy of Python 3. For many people, where I am writing python3, they could get away with python.

Variables and Arithmetic Expressions

Variables are bound to values by assignments. We don't have to declare variables before using them.

So we can do things like:

x = 7
x += 1 #note there are no ++ and -- operators
x *= 3
y = 5
z = x - y
print(z)

which would print 19

Notice we don't have to terminate statements with ';' although we can. If we want several statements of the same line we use ';'
Python supports a formatted string operator %:
```
print("%3d %0.2f" % (10, .9799))
```
prints 10 with a leading space followed by 0.98
There is also a format() function which outputs a string. So format(0.979, "0.2f") outputs the string 0.98 .

Conditionals

Python supports if elif else conditionals with the syntax:

a = 5
if a > 4:
    print("a is bigger than 4")

b = 99
if  b < 50:
    print("b is too little")
else:
    print("b is big enough")

if a > 4 and  b < 50:
    print("1")
elif not a == 6:
    print("2")
else:
    print("3")

The bodies of these statements are denoted using indentation.
To create an empty clause, you can use the pass statement.
Python has boolean connectives and, or, and not.
Python uses the Boolean literal True and False.
Python does not have switch/case

File I/O

One could read in a file using a program like:

f = open("hello.py")
line = f.readline()
while line:
   print (line, end='') #print without newline
   #in Python 2, would write print line, 
   line = f.readline()
f.close()

open() returns a file object
We can invoke methods of this object just as in Java (in this case, readline())

We could have also written:

for line in open("hello.py"):
    print(line, end='')

to achieve the same affect

To write a file we can do things like:

f = open("somefile.txt", "w")
print("%0.2f" % 0.7999, file=f) #we are redirecting output to file f here
#In Python 2, for above, could have done print >>f, "%02f" % 0.7999 
f.write("hello") #normal way of doing a write
f.close()

To get the command line arguments, get input from the terminal or write to the terminal we can use the sys.argv, sys.stdout and sys.stdin objects:

import sys

print("\n".join(sys.argv)) # print the command line arguments, each on their own line
sys.stdout.write("Type something\n");
name = sys.stdin.readline()
print("You wrote:" +name)

Example Files in a Folder as a List

import glob
path = './*'
files = glob.glob(path) 
for name in files:
   print(name)

In-Class Exercise

Write a Python program which takes its first command line argument and prints out all the files in the current folder whose name begins with that argument's value and that ends with .txt.
Post your solutions to the Sep 7 In-Class Exercise Thread.

Strings

String literals can be enclosed in either single, double, or triple quotes:

a = "Hello"
b = 'Good "bye"'
c = """ Triple quotes one can
go over multiple lines
"""
d = ''' this one
works as well
'''

It is relatively easy to extract characters out of a string:

a = "Hello World"
b = a[4] # b is 'o'
c = a[:5] # c is 'Hello'
d = a[6:] # d is 'World'
e = a[3:8] # e is "lo Wo"

Strings are concatenated using + .
A string can be converted to a integer using int() and a float using float(). For example, int("79")
The command str (for base types) and repr (for objects) can be used to convert other types into strings. For example, str(3.4).

Lists

Lists can be declared using square brackets like:

my_list = ['YO', 1.2, 7, "HI", ["scary nested list", "watch out!"]]
my_empty_list = [] # or list()

We can access parts of a list in a variety of ways:

b = my_list[0] # b is now: 'YO'
c = my_list[4][1] # c is now: 'watch out!'
d = my_list[1:3] # d is [1.2, 7]
e = my_list[2:] # e is [7, 'HI', ['scary nested list', 'watch out!']]

Lists can also be easily manipulated to make new lists:

my_list.append("an end") #my_list now 
    #['YO', 1.2, 7, 'HI', ['scary nested list', 'watch out!'], 'an end']
my_list.insert(2, 3) # my_list now
    #['YO', 1.2, 3, 7, 'HI', ['scary nested list', 'watch out!'], 'an end']
a = [1, 2, 3] + [4, 5] #a is [1, 2, 3, 4, 5]

Example Using Lists and Command Line

import sys
if(len(sys.argv)) != 2: 
   #notice sys.argv is a list of command-line args and we found its length
   print("Please supply a filename")
   raise(SystemExit(1)) # throw an error and exit
f = open(sys.argv[1]) #program name is argv[0]
lines = f.readlines() # reads all lines into list one go
f.close()

#convert inputs to list of ints
ivalues = [int(line) for line in lines]

# print min and max
print("The min is ", min(ivalues))
print("The max is", max(ivalues))

Tuples

You can pack a collection of objects into a single object in Python using a tuple

a = ( 1, "hello", 3)
b = ( some, where)
c = "6 scared of 7", "as 7 8 9" #notice can omit paren's
d = () # 0-tuple
e = 'yo', #one tuple 
f = ('yo',) #same one tuple
g = (d,) # g is ((),)

Can access parts of tuple with the same notation as lists a[1] gives 'hello' for instance. Or we can do things like:
```
c = (4, 5)
a, b = c
```
Tuples cannot be appended or inserted to, but save memory. Tuples are immutable.

Sets

A set is used to contain an unordered collection of objects.

Sets can be created, viewed, and checked for membership using statements like:

my_set = set([3, 9, 2, 6])
another_set = set("goodness") # set of unique chars
print (another_set) # set(['e', 'd', 'g', 'o', 'n', 's'])
if 'e' in another_set:
    print("it's in there")

Sets support various operations:

a = my_set; b = another_set;
c = a | b # union of sets
c = a & b # intersection of sets
c = a - b # difference of sets
c = a ^ b # symmetric difference of sets
another_set.add('y') # adds a single element to set
another_set.update([6,7,8]) # add multiple elements
my_set.remove(3) # removes the number 3 from my_set

A frozenset is like a set but cannot be changed

Python Tutorial

Outline