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.
A set is an unordered collection with no duplicate elements. To create a set:
notice how the duplicate was removed?
You can also use a string as a sequence of char objects and turn it into a set:
Now, let’s use this two simple sets to illustrate some basic set operations:
Exclusive (in one or the other but not both):
Dictionaries are key value pairs indexed by keys, which can be any immutable type. To create an empty dictionary:
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:
You can also use the del statement to delete a key value pair:
You can create a dictionary using the dict() method and pass in a sequence of tuples:
if the keys are all strings, you can even do this:
To loop through dictionaries, the key and corresponding value can be retrieved at the same time using the iteritems() method:
Use a while loops to generate the Finobacci sequence:
Mutable sequences like lists should not be modified at the same time as looping through it, and instead should be done on a copy:
what would happen if we don’t use a copy here? This code will get stuck in an infinite loop:
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:
The continue statement:
The pass statement:
It does nothing, often used to create a minimal class..
Use the def keyword to define a function:
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:
Use the return keyword to return values from a function:
Default argument values:
The default values are evaluated once and once only, at the point of function definition:
however, it works differently with mutable objects such as lists, dictionaries etc.
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:
note that keyword arguments cannot be provided twice.
You can define an arbitrary argument list which takes in a tuple:
Similarly, you can take in a dictionary:
Interestingly, the reserve of the above is true too! You can take a tuple and unpacking it with the * operator:
Or take a dictionary and unpacking it with the ** operator:
I specialise in rapidly transitioning teams to serverless and building production-ready services on AWS.
Are you struggling with serverless or need guidance on best practices? Do you want someone to review your architecture and help you avoid costly mistakes down the line? Whatever the case, I’m here to help.
Check out my new course, Complete Guide to AWS Step Functions. In this course, we’ll cover everything you need to know to use AWS Step Functions service effectively. Including basic concepts, HTTP and event triggers, activities, callbacks, nested workflows, design patterns and best practices.
Here is a complete list of all my posts on serverless and AWS Lambda. In the meantime, here are a few of my most popular blog posts.
- Lambda optimization tip – enable HTTP keep-alive
- You are thinking about serverless costs all wrong
- Many faced threats to Serverless security
- We can do better than percentile latencies
- I’m afraid you’re thinking about AWS Lambda cold starts all wrong
- Yubl’s road to Serverless
- AWS Lambda – should you have few monolithic functions or many single-purposed functions?
- AWS Lambda – compare coldstart time with different languages, memory and code sizes
- Guys, we’re doing pagination wrong