Learning Python – Part 2

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.

Lists

To create a new list:

 

Lists are NOT immutable:

 

Use the in keyword to check whether an element is in the specified list:

 

Nesting lists:

 

The min and max functions:

 

The list function – you can use the list() function to convert a tuple to a list:

 

Element values of a tuple cannot be changed and tuple elements are put between parenthesis instead of square bracket:

 

Deleting an item from list:

or you can use the remove() function:

 

Replace portion of list with slicing:

 

Insert a list into another list with slicing:

 

Delete a portion of list with slicing:

 

Appending to a list by using simple concatenation:

or use append or extend, the difference being append adds a single element to the list where as extend works like the concatenation above.

now compare this to extend:

 

Like in Javascript, you can use a list like a stack (FILO) too:

 

You can also use a list as a queue (FIFO) using the collections.deque function:

 

Sorting a list:

you can do the same to a string too using the sorted function:

 

To construct an empty tuple:

To construct a tuple with a single item:

 

You can unpack a tuple or list (like the pattern matching in F#):

 

There must be the same number of elements on the left as the tuple on the right:

 

Use the range() function to generate a range of integers:

 

Use the filter() function to filter a list:

 

Use the map() function to project a sequence’s items to something else:

you can also use it like the zip() method in F# by passing in multiple sequences:

if the lists are not of equal length, None is used to fill in the gap:

 

Use the reduce() function to return a single value from a list of element, e.g. to sum the numbers 1-4:

you can also pass in a third argument to indicate the starting value of the accumulator:

 

You can remove an item from a list using its index with the del statement:

note that del statement doesn’t return any values.

You can also use it to delete the entire list or part of the list:

or to delete the variable itself:

 

List comprehensions (similar to those in F#):

 

If the result is a tuple, then it must be parenthesized:

 

You can add additional filters:

 

Or you can have a loop inside another loop:

 

Nested List Comprehensions, e.g. to turn the columns of a matrix into rows:

remember, read nested comprehensions from right to left!

Nested comprehensions is a powerful tool but adds complexity, where possible, use built-in functions. E.g. the above can be done using zip():

 

When looping through a sequence, the position index and corresponding value can be retrieved at the same time using the enumerate() function:

 

You can also use zip() function to loop over two or more sequences at the same time: