theburningmonk.com

Fore­words

A while back I decided to try and learn Python for the hell of it as it seems like an inter­est­ing lan­guage and has some of the most con­cise and user-friendly syn­tax. Hav­ing spent some time going through a num­ber of dif­fer­ent learn­ing sources and mate­ri­als (like the offi­cial site python.org which has a very help­ful tuto­r­ial sec­tion) I have put together a set of notes I made as I was learn­ing and hope­fully they can be use­ful to you as a quick list of how-to code snippets.

All the code snap­shots I’m show­ing here are taken from the IDLE Python shell.

Lists

To cre­ate a new list:

 

Lists are NOT immutable:

 

Use the in key­word to check whether an ele­ment is in the spec­i­fied list:

 

Nest­ing lists:

 

The min and max func­tions:

 

The list func­tion – you can use the list() func­tion to con­vert a tuple to a list:

 

Ele­ment val­ues of a tuple can­not be changed and tuple ele­ments are put between paren­the­sis instead of square bracket:

 

Delet­ing an item from list:

or you can use the remove() function:

 

Replace por­tion of list with slicing:

 

Insert a list into another list with slicing:

 

Delete a por­tion of list with slicing:

 

Append­ing to a list by using sim­ple concatenation:

or use append or extend, the dif­fer­ence being append adds a sin­gle ele­ment to the list where as extend works like the con­cate­na­tion above.

now com­pare 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:

 

Sort­ing a list:

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

 

To con­struct an empty tuple:

To con­struct a tuple with a sin­gle item:

 

You can unpack a tuple or list (like the pat­tern match­ing in F#):

 

There must be the same num­ber of ele­ments on the left as the tuple on the right:

 

Use the range() func­tion to gen­er­ate a range of integers:

 

Use the fil­ter() func­tion to fil­ter a list:

 

Use the map() func­tion to project a sequence’s items to some­thing else:

you can also use it like the zip() method in F# by pass­ing in mul­ti­ple sequences:

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

 

Use the reduce() func­tion to return a sin­gle value from a list of ele­ment, e.g. to sum the num­bers 1–4:

you can also pass in a third argu­ment to indi­cate the start­ing value of the accumulator:

 

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

note that del state­ment doesn’t return any values.

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

or to delete the vari­able itself:

 

List com­pre­hen­sions (sim­i­lar to those in F#):

 

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

 

You can add addi­tional filters:

 

Or you can have a loop inside another loop:

 

Nested List Com­pre­hen­sions, e.g. to turn the columns of a matrix into rows:

remem­ber, read nested com­pre­hen­sions from right to left!

Nested com­pre­hen­sions is a pow­er­ful tool but adds com­plex­ity, where pos­si­ble, use built-in func­tions. E.g. the above can be done using zip():

 

When loop­ing through a sequence, the posi­tion index and cor­re­spond­ing value can be retrieved at the same time using the enu­mer­ate() function:

 

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

Fore­words

A while back I decided to try and learn Python for the hell of it as it seems like an inter­est­ing lan­guage and has some of the most con­cise and user-friendly syn­tax. Hav­ing spent some time going through a num­ber of dif­fer­ent learn­ing sources and mate­ri­als (like the offi­cial site python.org which has a very help­ful tuto­r­ial sec­tion) I have put together a set of notes I made as I was learn­ing and hope­fully they can be use­ful to you as a quick list of how-to code snippets.

All the code snap­shots I’m show­ing here are taken from the IDLE Python shell.

Basics

Com­ments:

 

Vari­able assignment:

 

Arith­metic:

 

Power:

 

Absolute value:

 

Get­ting user input:

 

raw_input vs input:

raw_input always con­tains string, input can con­tain any object, even a calculation:

 

Import mod­ules:

 

Func­tions as first class objects:

 

If-elseif-else:

 

The is oper­a­tor checks if two vari­ables refers to the SAME object:

on the other hand:

The is not oper­a­tor does the reverse.

 

The and and or log­i­cal oper­a­tors, same as && and || in C# respec­tively. You can use the not oper­a­tor to negate the out­come of a boolean comparison.

 

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

 

You may com­pare sequence objects of the same type, which uses lex­i­co­graph­i­cal order­ing — com­pare the first two, and if they dif­fer then that’s the out­come of the com­par­i­son, else com­pare the next two, and so on:

 

Strings

Strings can use dou­ble or sin­gle quotes interchangeably:

Escape char­ac­ter:

Span­ning across mul­ti­ple lines – a back­slash (\) as the last char­ac­ter on the line indi­cates that the next time is a log­i­cal con­tin­u­a­tion of this line:

or you can sur­round them in a pair of match­ing triple quotes: “”” or ”’:

 

String con­ver­sion using the str() function:

The repr func­tion – the repr func­tion returns a canon­i­cal string rep­re­sen­ta­tion of the object, back-ticks (‘) do the same thing (they are sim­i­lar to the ToString() method on C#‘s objects:

 

String con­cate­na­tion:

 

Slic­ing a string:

You can also use neg­a­tive index, in which case it starts count­ing from the right:

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

you can also set up steps in the slicing:

sim­i­larly to before, you can slice back­wards too:

 

Get length of string:

 

Strings are IMMUTABLE!

 

For­mat­ting strings:

 

Find­ing sub­string (returns the index of the start of the first match):

 

Join­ing strings:

 

Chang­ing the case of strings:

 

Replac­ing por­tions of a string: