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:

clip_image001

 

Lists are NOT immutable:

clip_image002

 

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

clip_image003

 

Nesting lists:

clip_image004

 

The min and max functions:

clip_image005

 

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

clip_image006

 

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

clip_image007

 

Deleting an item from list:

clip_image008

or you can use the remove() function:

clip_image009

 

Replace portion of list with slicing:

clip_image010

 

Insert a list into another list with slicing:

clip_image011

 

Delete a portion of list with slicing:

clip_image012

 

Appending to a list by using simple concatenation:

clip_image013

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

clip_image014

now compare this to extend:

clip_image015

 

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

clip_image016

 

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

clip_image017

 

Sorting a list:

clip_image018

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

clip_image019

 

To construct an empty tuple:

clip_image020

To construct a tuple with a single item:

clip_image021

 

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

clip_image022

clip_image023

 

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

clip_image024

 

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

clip_image025

 

Use the filter() function to filter a list:

clip_image026

 

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

clip_image027

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

clip_image028

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

clip_image029

 

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

clip_image030

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

clip_image031

 

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

clip_image032

note that del statement doesn’t return any values.

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

clip_image033

or to delete the variable itself:

clip_image034

 

List comprehensions (similar to those in F#):

clip_image035

 

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

clip_image036

 

You can add additional filters:

clip_image037

 

Or you can have a loop inside another loop:

clip_image038

 

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

clip_image039

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():

clip_image040

 

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

clip_image041

 

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

clip_image042

Learning Python – Part 1

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.

Basics

Comments:

clip_image001[10]

 

Variable assignment:

clip_image002[10]

 

Arithmetic:

clip_image003[10]

 

Power:

clip_image004[8]

 

Absolute value:

clip_image005[8]

 

Getting user input:

clip_image006[8]

 

raw_input vs input:

raw_input always contains string, input can contain any object, even a calculation:

clip_image007[8]

 

Import modules:

clip_image008[8]

 

Functions as first class objects:

clip_image009[8]

 

If-elseif-else:

clip_image028[8]

 

The is operator checks if two variables refers to the SAME object:

clip_image029[8]

on the other hand:

clip_image030[8]

The is not operator does the reverse.

 

The and and or logical operators, same as && and || in C# respectively. You can use the not operator to negate the outcome of a boolean comparison.

 

You can chain comparisons, e.g. is the value of x greater than or equal to 5 and less than or equal to 10?

clip_image031[8]

 

You may compare sequence objects of the same type, which uses lexicographical ordering – compare the first two, and if they differ then that’s the outcome of the comparison, else compare the next two, and so on:

clip_image032[8]

 

Strings

Strings can use double or single quotes interchangeably:

clip_image010[8]

Escape character:

clip_image011[8]

Spanning across multiple lines – a backslash (\) as the last character on the line indicates that the next time is a logical continuation of this line:

clip_image012[8]

or you can surround them in a pair of matching triple quotes: """ or ”’:

clip_image013[8]

 

String conversion using the str() function:

clip_image014[8]

The repr function – the repr function returns a canonical string representation of the object, back-ticks (`) do the same thing (they are similar to the ToString() method on C#’s objects:

clip_image015[8]

 

String concatenation:

clip_image016[8]

 

Slicing a string:

clip_image017[8]

You can also use negative index, in which case it starts counting from the right:

clip_image018[8]

note: message[0] = message[-0], see how the indices are mapped:

clip_image019[8]

you can also set up steps in the slicing:

clip_image020[8]

similarly to before, you can slice backwards too:

clip_image021[8]

 

Get length of string:

clip_image022[8]

 

Strings are IMMUTABLE!

 

Formatting strings:

clip_image023[8]

 

Finding substring (returns the index of the start of the first match):

clip_image024[8]

 

Joining strings:

clip_image025[8]

 

Changing the case of strings:

clip_image026[8]

 

Replacing portions of a string:

clip_image027[8]