Python basics

Python can be run in one of two modes. It can either be used?interactively, via an interpreter, or it can be called from the command line to execute a?script. We will first use the Python interpreter interactively.

The Python interpreter can be used to evaluate expressions, for example simple arithmetic expressions. If you enter such expressions at the prompt (>>>) they will be evaluated and the result will be returned on the next line.

>>> 1 + 1?
2?
>>> 2 * 3?
6

Boolean operators also exist in Python to manipulate the primitive?True?and?False?values.

>>> 1==0?
False?
>>> not (1==0)?
True?

?

Like Java, Python has a built in string type. The?+?operator is overloaded to do string concatenation on string values.

>>> ‘artificial‘ + "intelligence"?
‘artificialintelligence‘

There are many built-in methods which allow you to manipulate strings.

>>> ‘artificial‘.upper()
‘ARTIFICIAL‘

?

Notice that we can use either single quotes?‘ ‘?or double quotes?" "?to surround string. This allows for easy nesting of strings.

We can also store expressions into variables.

>>> s = ‘hello world‘?
>>> print s?
hello world?
>>> s.upper()
‘HELLO WORLD‘

?

In Python, you do not have declare variables before you assign to them.

Learn about the methods Python provides for strings. To see what methods Python provides for a datatype, use the?dir?and?help?commands:

>>> s = ‘abc‘?

>>> dir(s)

[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__doc__‘, ‘__eq__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__getslice__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘,‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘,‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__str__‘, ‘capitalize‘, ‘center‘, ‘count‘, ‘decode‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘, ‘find‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdigit‘, ‘islower‘, ‘isspace‘, ‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘replace‘, ‘rfind‘,‘rindex‘, ‘rjust‘, ‘rsplit‘, ‘rstrip‘, ‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]

>>> help(s.find)

Help on built-in function find:

find(...)

S.find(sub [,start [,end]]) -> int

?

Return the lowest index in S where substring sub is found,

such that sub is contained within s[start,end]. Optional

arguments start and end are interpreted as in slice notation.

?

Return -1 on failure.

?

>> s.find(‘b‘)
1

Try out some of the string functions listed in?dir?(ignore those with underscores ‘_‘ around the method name).

?

Python comes equipped with some useful built-in data structures, broadly similar to Java‘s collections package.

Lists?store a sequence of mutable items:

>>> fruits = [‘apple‘,‘orange‘,‘pear‘,‘banana‘]
>>> fruits[0]?
‘apple‘

We can use the?+?operator to do list concatenation:

>>> otherFruits = [‘kiwi‘,‘strawberry‘]
>>> fruits + otherFruits
>>> [‘apple‘, ‘orange‘, ‘pear‘, ‘banana‘, ‘kiwi‘, ‘strawberry‘]

Python also allows negative-indexing from the back of the list. For instance,?fruits[-1]?will access the last element?‘banana‘:

>>> fruits[-2]
‘pear‘
>>> fruits.pop()
‘banana‘
>>> fruits
[‘apple‘, ‘orange‘, ‘pear‘]
>>> fruits.append(‘grapefruit‘)?
>>> fruits?
[‘apple‘, ‘orange‘, ‘pear‘, ‘grapefruit‘]?
>>> fruits[-1] = ‘pineapple‘?
>>> fruits?
[‘apple‘, ‘orange‘, ‘pear‘, ‘pineapple‘]

We can also index multiple adjacent elements using the slice operator. For instance,?fruits[1:3], returns a list containing the elements at position 1 and 2. In general?fruits[start:stop]?will get the elements in?start, start+1, ..., stop-1. We can also do?fruits[start:]?which returns all elements starting from the?start?index. Also?fruits[:end]?will return all elements before the element at position?end:

>>> fruits[0:2]?
[‘apple‘, ‘orange‘]?
>>> fruits[:3]
[‘apple‘, ‘orange‘, ‘pear‘]?
>>> fruits[2:]
[‘pear‘, ‘pineapple‘]?
>>> len(fruits)?
4

?

The items stored in lists can be any Python data type. So for instance we can have lists of lists:

>>> lstOfLsts = [[‘a‘,‘b‘,‘c‘],[1,2,3],[‘one‘,‘two‘,‘three‘]]?
>>> lstOfLsts[1][2]?
3
>>> lstOfLsts[0].pop()
‘c‘
>>> lstOfLsts
[[‘a‘, ‘b‘],[1, 2, 3],[‘one‘, ‘two‘, ‘three‘]]

?

Exercise: Lists

Play with some of the list functions. You can find the methods you can call on an object via thedir?and get information about them via the?help?command:

>>> dir(list)

?

>>> help(list.reverse)

>>> lst = [‘a‘,‘b‘,‘c‘]
>>> lst.reverse()
>>> [‘c‘,‘b‘,‘a‘]

?

Note: Ignore functions with underscores "_" around the names; these are private helper methods. Press ‘q‘ to back out of a help screen.

A data structure similar to the list is the?tuple, which is like a list except that it is immutable once it is created (i.e. you cannot change its content once created). Note that tuples are surrounded with parentheses while lists have square brackets.

>>> pair = (3,5)
>>> pair[0]
3
>>> x,y = pair
>>> x
3
>>> y
5?
>>> pair[1] = 6
TypeError: object does not support item assignment

The attempt to modify an immutable structure raised an exception. Exceptions indicate errors: index out of bounds errors, type errors, and so on will all report exceptions in this way.

A?set?is another data structure that serves as an unordered list with no duplicate items. Below, we show how to create a set, add things to the set, test if an item is in the set, and perform common set operations (difference, intersection, union):

>>> shapes = [‘circle‘,‘square‘,‘triangle‘,‘circle‘]
>>> setOfShapes = set(shapes)
>>> setOfShapes?
set([‘circle‘,‘square‘,‘triangle‘])?
>>> setOfShapes.add(‘polygon‘)?
>>> setOfShapes?
set([‘circle‘,‘square‘,‘triangle‘,‘polygon‘])?
>>> ‘circle‘ in setOfShapes?
True?
>>> ‘rhombus‘ in setOfShapes?
False?
>>> favoriteShapes = [‘circle‘,‘triangle‘,‘hexagon‘]
>>> setOfFavoriteShapes = set(favoriteShapes)
>>> setOfShapes - setOfFavoriteShapes?
set([‘square‘,‘polyon‘])?
>>> setOfShapes & setOfFavoriteShapes?
set([‘circle‘,‘triangle‘])
>>> setOfShapes | setOfFavoriteShapes?
set([‘circle‘,‘square‘,‘triangle‘,‘polygon‘,‘hexagon‘])

Note that the objects in the set are unordered; you cannot assume that their traversal or print order will be the same across machines!

The last built-in data structure is the?dictionary?which stores a map from one type of object (the key) to another (the value). The key must be an immutable type (string, number, or tuple). The value can be any Python data type.

Note: In the example below, the printed order of the keys returned by Python could be different than shown below. The reason is that unlike lists which have a fixed ordering, a dictionary is simply a hash table for which there is no fixed ordering of the keys (like HashMaps in Java). The order of the keys depends on how exactly the hashing algorithm maps keys to buckets, and will usually seem arbitrary. Your code should not rely on key ordering, and you should not be surprised if even a small modification to how your code uses a dictionary results in a new key ordering.

>>> studentIds = {‘knuth‘: 42.0, ‘turing‘: 56.0, ‘nash‘: 92.0 }
>>> studentIds[‘turing‘]
56.0
>>> studentIds[‘nash‘] = ‘ninety-two‘
>>> studentIds
{‘knuth‘: 42.0, ‘turing‘: 56.0, ‘nash‘: ‘ninety-two‘}
>>> del studentIds[‘knuth‘]
>>> studentIds
{‘turing‘: 56.0, ‘nash‘: ‘ninety-two‘}
>>> studentIds[‘knuth‘] = [42.0,‘forty-two‘]
>>> studentIds
{‘knuth‘: [42.0, ‘forty-two‘], ‘turing‘: 56.0, ‘nash‘: ‘ninety-two‘}
>>> studentIds.keys()
[‘knuth‘, ‘turing‘, ‘nash‘]
>>> studentIds.values()
[[42.0, ‘forty-two‘], 56.0, ‘ninety-two‘]
>>> studentIds.items()
[(‘knuth‘,[42.0, ‘forty-two‘]), (‘turing‘,56.0), (‘nash‘,‘ninety-two‘)]
>>> len(studentIds)?
3

As with nested lists, you can also create dictionaries of dictionaries.

Exercise: Dictionaries

Use?dir?and?help?to learn about the functions you can call on dictionaries.

Now that you‘ve got a handle on using Python interactively, let‘s write a simple Python script that demonstrates Python‘s?for?loop. Open the file called?foreach.py?and update it with the following code:

control structures (e.g.,?if?and?else) in Python

?

If you like functional programming you might also like?map?and?filter:

>>> map(lambda x: x * x, [1,2,3])
[1, 4, 9]
>>> filter(lambda x: x > 3, [1,2,3,4,5,4,3,2,1])
[4, 5, 4]

?

The next snippet of code demonstrates Python‘s?list comprehension?construction:

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

plusOneNums = [x+1 for x in nums]

oddNums = [x for x in nums if x % 2 == 1]

print oddNums

Exercise: List Comprehensions

Write a list comprehension which, from a list, generates a lowercased version of each string that has length greater than five. You can find the solution in?listcomp2.py.

strings = [‘Some string‘,‘Art‘,‘Music‘,‘Artificial Intelligence‘]

print [x.lower() for x in strings if len(x) > 5]

Unlike many other languages, Python uses the indentation in the source code for interpretation. So for instance, for the following script:

if 0 == 1:

    print ‘We are in a world of arithmetic pain‘

print ‘Thank you for playing‘

will output

Thank you for playing

But if we had written the script as

if 0 == 1:

    print ‘We are in a world of arithmetic pain‘

    print ‘Thank you for playing‘

there would be no output. The moral of the story: be careful how you indent! It‘s best to use four spaces for indentation -- that‘s what the course code uses.

?

Because Python uses indentation for code evaluation, it needs to keep track of the level of indentation across code blocks. This means that if your Python file switches from using tabs as indentation to spaces as indentation, the Python interpreter will not be able to resolve the ambiguity of the indentation level and throw an exception. Even though the code can be lined up visually in your text editor, Python "sees" a change in indentation and most likely will throw an exception (or rarely, produce unexpected behavior).

As in Java, in Python you can define your own functions:

fruitPrices = {‘apples‘:2.00, ‘oranges‘: 1.50, ‘pears‘: 1.75}

?

def buyFruit(fruit, numPounds):
						

    if fruit not in fruitPrices:

        print "Sorry we don‘t have %s" % (fruit)

    else:

        cost = fruitPrices[fruit] * numPounds

        print "That‘ll be %f please" % (cost)

?

# Main Function

if __name__ == ‘__main__‘:
						

    buyFruit(‘apples‘,2.4)

    buyFruit(‘coconuts‘,2)

Rather than having a?main?function as in Java, the?__name__ == ‘__main__‘?check is used to delimit expressions which are executed when the file is called as a script from the command line. The code after the main check is thus the same sort of code you would put in a?main?function in Java.

attention：two_

Although this isn‘t a class in object-oriented programming, you‘ll have to use some objects in the programming projects, and so it‘s worth covering the basics of objects in Python. An object encapsulates data and provides functions for interacting with that data.

Here‘s an example of defining a class named?FruitShop:

class FruitShop:

?

							def
							__init__(self, name, fruitPrices):

        """

            name: Name of the fruit shop

?

            fruitPrices: Dictionary with keys as fruit

            strings and prices for values e.g.

            {‘apples‘:2.00, ‘oranges‘: 1.50, ‘pears‘: 1.75}

        """

        self.fruitPrices = fruitPrices

        self.name = name

        print ‘Welcome to the %s fruit shop‘ % (name)

?

    def getCostPerPound(self, fruit):

							"""
						

            fruit: Fruit string

        Returns cost of ‘fruit‘, assuming ‘fruit‘

        is in our inventory or None otherwise

							"""
						

        if fruit not in self.fruitPrices:

            print "Sorry we don‘t have %s" % (fruit)

            return None

        return self.fruitPrices[fruit]

?

    def getPriceOfOrder(self, orderList):

        """

            orderList: List of (fruit, numPounds) tuples

?

        Returns cost of orderList. If any of the fruit are

        """

        totalCost = 0.0

        for fruit, numPounds in orderList:

            costPerPound = self.getCostPerPound(fruit)

            if costPerPound != None:

                totalCost += numPounds * costPerPound

        return totalCost

?

    def getName(self):

        return self.name

The?FruitShop?class has some data, the name of the shop and the prices per pound of some fruit, and it provides functions, or methods, on this data. What advantage is there to wrapping this data in a class?

?

So how do we make an object and use it? Make sure you have the?FruitShop?implementation inshop.py. We then import the code from this file (making it accessible to other scripts) using?import shop, since?shop.py?is the name of the file. Then, we can create?FruitShop?objects as follows:

import shop

?

shopName = ‘the Berkeley Bowl‘

fruitPrices = {‘apples‘: 1.00, ‘oranges‘: 1.50, ‘pears‘: 1.75}

berkeleyShop = shop.FruitShop(shopName, fruitPrices)

applePrice = berkeleyShop.getCostPerPound(‘apples‘)

print applePrice

print(‘Apples cost $%.2f at %s.‘ % (applePrice, shopName))

?

otherName = ‘the Stanford Mall‘

otherFruitPrices = {‘kiwis‘:6.00, ‘apples‘: 4.50, ‘peaches‘: 8.75}

otherFruitShop = shop.FruitShop(otherName, otherFruitPrices)

otherPrice = otherFruitShop.getCostPerPound(‘apples‘)

print otherPrice

print(‘Apples cost $%.2f at %s.‘ % (otherPrice, otherName))

print("My, that‘s expensive!")

This code is in?shopTest.py; you can run it like this:

[[email protected] ~]$ python shopTest.py

Welcome to the Berkeley Bowl fruit shop

1.0

Apples cost $1.00 at the Berkeley Bowl.

Welcome to the Stanford Mall fruit shop

4.5

Apples cost $4.50 at the Stanford Mall.

My, that‘s expensive!

The following example illustrates how to use static and instance
variables in Python.

Create the?person_class.py?containing the following code:

class Person:

							population = 0

    def __init__(self, myAge):

							self.age = myAge

        Person.population += 1

    def get_population(self):

        return Person.population

    def get_age(self):

        return self.age

We first compile the script:

[[email protected] ~]$ python person_class.py

Now use the class as follows:

>>> import person_class
>>> p1 = person_class.Person(12)
>>> p1.get_population()
1?
>>> p2 = person_class.Person(63)
>>> p1.get_population()
2?
>>> p2.get_population()
2?
>>> p1.get_age()
12?
>>> p2.get_age()
63

In the code above,?age?is an instance variable and?population?is a static variable.?population?is shared by all instances of the?Person?class whereas each instance has its own?age?variable.

These are some problems (and their solutions) that new Python learners commonly encounter.