Learning Python – Part 3

Forewords

A while back I decided to try and learn Python for the hell of it as it seems like an interesting language and has some of the most concise and user-friendly syntax. Having spent some time going through a number of different learning sources and materials (like the official site python.org which has a very helpful tutorial section) I have put together a set of notes I made as I was learning and hopefully they can be useful to you as a quick list of how-to code snippets.

All the code snapshots I’m showing here are taken from the IDLE Python shell.

Sets

A set is an unordered collection with no duplicate elements. To create a set:

clip_image001

notice how the duplicate was removed?

 

You can also use a string as a sequence of char objects and turn it into a set:

clip_image002

 

Now, let’s use this two simple sets to illustrate some basic set operations:

clip_image003

Set difference:

clip_image004

Set union:

clip_image005

Set intersect:

clip_image006

Exclusive (in one or the other but not both):

clip_image007

 

Dictionaries

Dictionaries are key value pairs indexed by keys, which can be any immutable type. To create an empty dictionary:

clip_image008

 

You access the elements in a dictionary using square brackets [], you can find out all the keys and values in a dictionary using the keys and values methods:

clip_image009

 

You can also use the del statement to delete a key value pair:

clip_image010

 

You can create a dictionary using the dict() method and pass in a sequence of tuples:

clip_image011

if the keys are all strings, you can even do this:

clip_image012

 

To loop through dictionaries, the key and corresponding value can be retrieved at the same time using the iteritems() method:

clip_image013

 

Loops

Use a while loops to generate the Finobacci sequence:

clip_image001[10]

 

For loops:

clip_image002[10]

 

Mutable sequences like lists should not be modified at the same time as looping through it, and instead should be done on a copy:

clip_image003[6]

what would happen if we don’t use a copy here? This code will get stuck in an infinite loop:

clip_image004[6]

 

The else and break statement:

Loops in Python can have an else clause which is executed when the loop terminates through exhaustion of the list (for for loops) or when the loop condition becomes false (for while loops), but it won’t execute if the loop is terminated with the break statement:

clip_image005[10]

 

The continue statement:

clip_image006[10]

 

The pass statement:

It does nothing, often used to create a minimal class..

clip_image007[6]

 

Functions

Use the def keyword to define a function:

clip_image001[12]

Note that the first string is a docstring that can be used by some tools to generate documentations.

 

Arguments are passed using call by reference, as the argument is always an object reference not the value of the object.

Every function has a return value, if nothing is returned then a special None value is returned. Writing of the None value is usually suppressed by the interpreter, but you can see it using print:

clip_image002[12]

 

Use the return keyword to return values from a function:

clip_image003[8]

 

Default argument values:

clip_image004[8]

 

The default values are evaluated once and once only, at the point of function definition:

clip_image005[12]

however, it works differently with mutable objects such as lists, dictionaries etc.

clip_image006[12]

notice how the second function call didn’t use the default empty list? That’s because the object referenced by the variable l is mutable and its state was mutated by the first add_item call.

 

You can also call the function using keyword arguments if they appear AFTER the regular parameters have been passed in:

clip_image007[8]

note that keyword arguments cannot be provided twice.

 

You can define an arbitrary argument list which takes in a tuple:

clip_image008[10]

 

Similarly, you can take in a dictionary:

clip_image009[6]

 

Interestingly, the reserve of the above is true too! You can take a tuple and unpacking it with the * operator:

clip_image010[6]

 

Or take a dictionary and unpacking it with the ** operator:

clip_image011[6]

 

Lambdas:

clip_image012[6]