Learn Python

Getting started with Flask: Hello World

noreply@blogger.com (Shyama Sankar) — Mon, 01 Apr 2019 07:50:00 +0000

In this post, we will learn how to create a very basic "Hello World" web application using Flask and run it locally.

Installation and setup

In this section, we will install Flask and set up our project environment.

Note: The commands I am providing are for setting it up on a MacBook. If you use a different OS, refer to Flask's installation guide: http://flask.pocoo.org/docs/1.0/installation/#installation. But the steps basically remain the same.

Install Python. I am using Python3.
Create a directory for your project, say, "hello" and go inside the directory.

mkdir hello
cd hello

Now create a virtual environment and activate it.

python3 -m venv venv
. venv/bin/activate

Then install Flask within the virtual environment.

pip3 install flask

Create the Hello World application

Now let us create our Hello World application.

Within the project directory, 'hello', create a file, 'hello.py'. This is where we are going to write the code for our application.
First, we need to import the module flask and create an instance of class Flask.
```
from flask import Flask
app = Flask(__name__)
```
The Flask class implements a WSGI (Web Server Gateway Interface) application. We should pass the name of the Python module or package of our application to it. In this case, we are not creating a package. We are simply creating a module 'hello.py'. Note that __name__ here refers to the name of the module.
Next, we will define our hello world method.
This method returns whatever we want to show in our app.

def hello_world():
  return "Hello World!"

Finally, we should link this method with a URL. In Flask, we can use the route() decorator to define which URL should trigger a function.

@app.route('/')
def hello_world():
  return "Hello World!"

So, now we have a file hello.py with the following content:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
  return "Hello World!"

Run the application locally

In this section we will see how to run our application locally on our device.

First, tell the terminal which flask application to run. In our case, the application is defined by the 'hello.py' module. Flask uses the environment variable 'FLASK_APP' while looking for the application. So let us set its value.

export FLASK_APP=hello.py

Now run the application. We have two options for running a flask application.

Using flask run

flask run

Using python -m flask

python -m flask run

Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Let it run and go to a browser and enter the URL "http://127.0.0.1:5000/" in it. You should see our application in action.

Useful tips

Development environment

Earlier, when we ran our flask application, you would have seen an output like:

flask run                      
 * Serving Flask app "hello.py"
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

This basically means that we were using "production" environment with "debug" mode turned on for our development purposes. One issue with this during development is that, whenever we make a code change, we would have to restart the application.

Flask provides a "development" environment for dev purposes and this can be very helpful. In "development" environment, the application is reloaded automatically whenever we make a code change. Also, the debug mode gets enabled and the debugger gets activated. You can change the environment by using the "FLASK_ENV" variable:

export FLASK_ENV=development
flask run
 * Serving Flask app "hello.py" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 299-503-654

You may also choose to just enable the debug mode by using environment variable "FLASK_DEBUG":

flask run                  
 * Serving Flask app "hello.py" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 299-503-654

Logging

Logging is another important feature that is useful while getting started. Flask provides a preconfigured logger(since version 0.3). This is a standard Python logger. Sample usage:

app.logger.info('Info message...')
app.logger.debug('Debug message...')
app.logger.warning('Warning message...')
app.logger.error('Error message...')

Conclusion

We discussed how to create a very basic "Hello World" app using Flask and run it in our local environments.

Monkey Patching in Python: Explained with Examples

noreply@blogger.com (Shyama Sankar) — Sat, 30 Mar 2019 11:43:00 +0000

In this post, we will learn about monkey patching, i.e., how to dynamically update code behavior at runtime. We will also see some useful examples of monkey patching in Python.

Monkey patching

What is monkey patching?
Why use monkey patching?
When is monkey patching used?
Cautionary note: Why monkey patching should be used carefully

Monkey patching in Python

Example 1: Monkey patching the value of a module's attribute
Example 2: Monkey patching to extend the behavior of a method
Example 3: Monkey patching to change the behavior of a method
Example 4: Monkey patching class attributes
Example 5: Monkey patching a specific instance's attributes
Example 6: Monkey patching a class
Example 7: Monkey patching a module

Conclusion

Monkey patching

What is monkey patching?

Monkey patching is a technique used to dynamically update the behavior of a piece of code at run-time.

Why use monkey patching?

It allows us to modify or extend the behavior of libraries, modules, classes or methods at runtime without actually modifying the source code.

When is monkey patching used?

Some common applications of monkey patching are:

To extend or modify the behavior of third-party or built-in libraries or methods at runtime without touching the original code.
During testing to mock the behavior of libraries, modules, classes or any objects.
To quickly fix some issues if we do not have the time or resources to roll-out a proper fix to the original software.

Cautionary note: Why monkey patching should be used carefully

Monkey patching should be used very carefully, especially if used in production software (would not recommend unless absolutely necessary). Some of the reasons are:

If we change the behavior of a method by monkey patching, it no longer behaves the way it was documented. So unless every client or user is aware of this change, it could cause their code to behave unexpectedly.
It makes it harder to troubleshoot issues.
If we are monkey patching a method in one module and another module is using that same method after the patch is applied, then the second module will also end up seeing the monkey patched method instead of its original version. This can lead to unwanted bugs.

Monkey patching in Python

In Python, modules or classes are just like any other mutable objects like lists, i.e., we can modify them or their attributes including functions or methods at runtime. Let us go through some examples to understand this clearly and learn how to monkey patch in Python.

Example 1: Monkey patching the value of a module's attribute

As a basic example, let us see how we could update a module's attribute. We will be updating the value of "pi" in the "math" module so that its precision is reduced to 3.14.

Note how we took a backup of the original value before our computation and then removed the patch at the end. This is a good practice, especially in tests, to avoid messing up the whole test suite.

Example 2: Monkey patching to extend the behavior of a method

In this example, we will see how to extend the behavior of a method using monkey patching. We will take a look at how to update the builtin print method in Python3 to include a timestamp.

Example 3: Monkey patching to change the behavior of a method

Now let us see how to completely change the behavior of a method. This can be particularly useful in unit tests to mock complex methods, with external dependencies (network, database, etc). Here, we will take a look at how to replace a method with another.

Example 4: Monkey patching class attributes

So far, we have been updating attributes or methods at the module level. Now let us take a look at how to monkey patch a class attribute. Note that this modifies the attribute for the class itself, all of its instances will see the patched attribute.

Example 5: Monkey patching a specific instance's attributes

The previous example showed how to monkey patch a class attribute. Here we will see how to patch just a specific instance's attribute.

Note that we made use of the MethodType method from types module in Python to bind the patched method to just one instance. This assures that other instances of the class are not affected.

Example 6: Monkey patching a class

Now let us see how we would monkey patch a class. Since a class is also just an object, we can monkey patch it with any other object. Here we will see an example of patching it with another class.

Example 7: Monkey patching a module

As the last example, let us see how we can patch an entire module. This works the same way as any other Python object.

Conclusion

Monkey patching is a cool technique and now we have learned how to do that in Python. However, as we discussed, it has its own drawbacks and should be used carefully.

Iteration in Python: The for, while, break, and continue statements

noreply@blogger.com (Shyama Sankar) — Fri, 29 Mar 2019 07:44:00 +0000

In this post, we will discuss iterations in Python. We will go over what iteration is, the two types of iterations (definite and indefinite), and the Python statements used for implementing iterations- for and while. We will also discuss the break and continue statements and see how they are used to alter the flow of an iteration.

What is an iteration?

Iteration is defined as the repetition of a process.

Let's say, we have a set of files on our computer and we wanted to append their names with a serial number. What would we do? We would rename every file one by one. So basically, we are iterating over every file and renaming them.

In programming, iteration or looping is the act of repeatedly executing a block of code.

Types of iteration

Depending on the way in which the number of iterations is determined, there are two types of iterations or loops:

Definite iteration or loop
If the number of iterations is predetermined when we start the loop, then it is called definite. For example, repeat renaming a file for 10 files in a directory.
Indefinite iteration or loop
If the number of iterations is not known when we start the loop, then it is called indefinite. For example, repeat moving the first file in a directory to another while it is not empty.

Now let us see how we can implement iteration in Python.

The while statement: Indefinite iteration in Python

The while statement is used to execute a set of statements as long as an expression evaluates to true. In Python, the while statement comes with an optional else condition which allows us to execute another set of statements if the expression evaluates to false. Let's take a look at the syntax.

Syntax

The expression is repeatedly evaluated and set_of_statements_1 is executed as long as the expression evaluates to true. Once the expression evaluates to false, then set_of_statements_2 is executed. Note that the else clause is optional. If the else block is not there, we just break out of the loop once the expression becomes false.

As you can see, we do not specify the exact number of times the loop would execute. Hence, the while statement is suited for implementing indefinite loops.

Examples

1. Basic while loop

The following example shows a basic while loop used to pop elements from a list and print them.

2. while loop with else

Now let us see how we can modify the previous example to print some message when the list becomes empty. Note that if the expression never evaluates to true, then only the code block associated with else will get executed.

3. Infinite while loop

We would end up with an infinite loop (a loop that would never end) if the expression always evaluates to true. Let us see an example.

4. Nested while loop

Loops can be nested. Let us see an example for nested-while loops.

The for statement: Definite iteration in Python

In Python, the for statement is used to iterate over the elements of an iterable object. A set of statements is executed for every item in the iterable. Similar to the while statement, the for statement also has an optional else clause. Let's see the syntax.

Syntax

The expression is evaluated once. It is expected to yield an iterable, i.e., an object that can give us an iterator when called using the built-in iter() function. The set_of_statements_1 is executed once for every element obtained from the iterator. Once the iterator raises the StopIteration exception or once it becomes empty, the loop terminates. If the else clause is provided, then set_of_statements_2 is executed before terminating the loop.

As you can see, the for loop would do a definite number of iterations, depending on how many elements are present in the iterator. So for loops are suited for implementing definite loops in Python.

Examples

1. Basic for loop

The following code snippet shows a basic for loop that iterates over a list.

2. for loop with else

The following example shows a basic for loop with an else clause.

3. Nested for loop

Now let us see an example for nested-for loops.

The break statement: Break out of a loop

The break statement can be used to terminate the execution of a loop. It can only appear within a for or while loop. It allows us to break out of the nearest enclosing loop. If the loop has an else clause, then the code block associated with it will not be executed if we use the break statement. Let us see some examples.

1. break within a while loop

Let us see how to break out of a while loop if and when a certain condition is met. We will also see how a while loop with an else behaves when a break statement is added to it. Note that the statements within the else condition are not executed if we break out of the while loop.

2. break within an infinite while loop

Now let us see how we can modify an infinite while loop to break on a certain condition.

3. break within a for loop

Now we will see how to use break within a basic for loop. Similar to while loops, we will see that the statements within else condition do not get executed if we break out of the for loop.

4. break within nested loops

Now we will see an example of nested for and while loops. Let us see how break behaves with nested loops. Note that break statement only breaks out of the nearest enclosing for or while loop.

The continue statement: Continue with the next iteration

The continue statement allows us to skip the rest of the statements within one cycle of the loop and forces it to continue to the next cycle. Let's take a look at some examples.

1. continue within a while loop

Let us see how the continue statement works in a while loop. Note that when continue is encountered in a while loop, it forces the loop to jump to the expression.

2. continue within a for loop

Now let us see how it works in a for loop. Note that if continue is encountered when we are at the last element of the iterable, then the loop is terminated or we move on to the else block if it is present.

3. continue within nested loops

The following code samples show how continue works within nested loops. Note that the continue statement causes the nearest enclosing for or while loop to continue with its next cycle.

Useful Resources and Reference

List, Set and Dictionary Comprehensions in Python

noreply@blogger.com (Shyama Sankar) — Sun, 24 Mar 2019 06:22:00 +0000

In this post, we will discuss the three Python comprehensions, i.e., list, set and dictionary comprehensions, with examples.

Introduction
Advantages
List comprehension
Set comprehension
Dictionary comprehension
Related posts

Introduction

Python comprehensions are essentially syntactic sugar used to create sequences from other sequences. They are commonly used to:

create new sequences which are obtained by applying some operation on elements of a sequence.
create a subsequence containing elements of a sequence which satisfy certain conditions.

List comprehensions were introduced in Python 2.0. Later in Python 3, set and dictionary comprehensions were added. Here, we will discuss these comprehensions with examples.

Advantages:

Concise
They need fewer lines of code than a for-loop with or without conditions.
More readable
If you understand comprehensions, it is more readable. Also, this depends. Sometimes, it is better to go for a traditional for-loop if the conditions are too complicated.
Faster
Memory is pre-allocated, instead of performing an append every time.
More Pythonic

List Comprehensions

List comprehension provides a concise way to create a new list from an iterable.
List comprehensions are created using enclosing square brackets []. Syntactically, it has an expression on elements from the original sequence, followed by zero or more for and if statements.
The following code snippet shows examples for list comprehensions.

If you are having difficulty with understanding any of the examples, then Python List Comprehension: Explained with Examples will be a good reference. There, I explain list comprehensions with 10 examples of increasing complexity. I have used similar or the same examples as those present here. Each example shows how to implement something using a for-loop and then how to re-write it using list comprehensions. The list comprehension syntax for each conversion and a screen recording for how it is done is also included in there.

Set Comprehensions

Similar to list comprehensions, set comprehensions are used to create sets from an iterable. Syntactically, the only difference is that curly braces are used instead of square brackets.
All examples from list comprehension are applicable here, the only difference is that you need to replace the enclosing '[]' with '{}' to get a set comprehension.
The following code snippet shows examples for set comprehensions and how it differs from list comprehension.

Dictionary Comprehensions

Dictionary comprehensions are used to create dictionaries from arbitrary key and value expressions. Similar to set comprehensions, curly braces are used in this case as well. The only difference from set comprehensions is that, instead of providing a single expression, we provide two expressions, one for the key and one for the value separated by a colon(:). All examples from list comprehension can be extended to dictionary comprehensions as well.
The following code snippet shows examples for dictionary comprehensions and how it differs from list and set comprehensions.

Python Dictionaries: Cheat Sheet

noreply@blogger.com (Shyama Sankar) — Sat, 23 Mar 2019 19:20:00 +0000

A cheat sheet for dictionaries in Python.
What is the dictionary datatype in Python? How to use it? Some key points and several examples of its usage.

Jump to the cheat sheet

Key points

Dictionary is a commonly used collection datatype in Python; the others being lists, sets, and tuples.
A dictionary is essentially a set of key-value pairs, where, the keys should be unique and immutable.
A dictionary is mutable, i.e., it can be modified in place after it is created. We can add, remove or update items in a dictionary.
Keys could be of any immutable data type, i.e., string, number, or even a tuple of immutable objects. [Note: Immutable objects are objects which cannot be modified in place once they are created. Python's built-in immutable objects include numbers, strings, and tuples].
Dictionaries are indexed using their keys.
Dictionaries are created using a pair of curly braces, i.e., {}, or by using the dict() constructor.
We can create and initialize a dictionary with items by adding a comma-separated list of key-value pairs within the curly braces. The 'dict' constructor also takes an optional iterable, mapping, or keyword arguments as input.
For examples on how to create a dictionary, add elements, update elements, remove elements, etc, see the cheat sheet.

Cheat sheet

Useful resources and references

Python Sets: Cheat Sheet

noreply@blogger.com (Shyama Sankar) — Wed, 20 Mar 2019 07:19:00 +0000

A cheat sheet for sets in Python. What is the 'set' datatype in Python? How is it used?

Jump to the cheat sheet

Key points

Unlike lists and tuples, a set is an unordered collection of unique elements.
A set can be created using the set() constructor. It takes an optional iterable as input.
Sets with some elements can also be initialized using the curly braces (e.g., {1, 2, 3}).
However, curly braces cannot be used to create an empty set. Using empty curly braces, i.e., {}, creates a dictionary datatype in Python.
'in' operator can be used to check the presence of an element in a set.
Sets support the mathematical set operations like union, intersection, difference, symmetric difference, etc.
Sets are mutable, we can add or remove elements from them.

Cheat sheet

Useful resources and references

Python documentation for sets

Python Tuples: Cheat Sheet

noreply@blogger.com (Shyama Sankar) — Tue, 19 Mar 2019 06:56:00 +0000

A cheat sheet for tuples in Python. What are tuples? How are they used in Python?

Jump to the cheat sheet

Similar to lists, tuples are another example of a 'sequence' datatype in Python. Some key points:

A tuple contains an ordered collection of values or items.
Tuples are defined as a comma-separated list of items (usually enclosed within parenthesis).
They can also be constructed using the tuple() constructor. It takes any sequence as its input.
They can contain elements of the same or different data types.
Items in a tuple can be accessed by unpacking or indexing.
Elements of a tuple are indexed from 0 to length-1.
Tuples are immutable, i.e., once the tuple is created, we cannot change its contents.
We cannot assign values to elements of tuples by indexing them. Neither does it support methods like append(), insert(), delete(), etc. which are typically used for mutating collections.
Tuples support sequence unpacking, i.e., its elements can be unpacked to individual variables.

Tuples: Cheatsheet

Useful Resources and References

Python documentation for tuples

Python Lists: Cheat Sheet

noreply@blogger.com (Shyama Sankar) — Mon, 18 Mar 2019 06:50:00 +0000

A cheat sheet for Python lists.

Jump to the cheat sheet

Lists are one of the most commonly used 'sequence' data types in Python. Following are some of the key things to know about Python lists.

A list contains an ordered group of values or items. These items can be of the same or different data types.
Lists are initialized using square brackets '[]' or by using list() constructor method.
We can get the length of a list using the len() method.
Lists can be indexed, i.e., we can access the elements of a list using their position in the list. The first index is '0' and the last index is 'len(list_object) - 1'.
Lists are mutable, i.e., we can change their content.
We can append items to a list using the append() method.

Lists: Cheatsheet

Reference

Python List Comprehensions: Explained with Examples

noreply@blogger.com (Shyama Sankar) — Sun, 17 Mar 2019 10:07:00 +0000

In this post, we will go through a set of examples for list comprehensions in Python. We will start with a very basic example and gradually work our way up to more complex ones.

Python lists
List Comprehensions

1. Create a list using a list comprehension
2. List comprehension with an expression
3. List comprehension with an if condition
4. List comprehension with an if-else condition
5. List comprehension with an if-elif-else ladder
6. Using methods within list comprehension
7. List comprehension with nested-if conditions
8. List comprehension equivalent of nested for loops
9. List comprehension to flatten a list of lists
10. Nested list comprehension

Related Posts
Useful Resources and References

Python lists

Before starting with the list comprehension examples, let us take a look at what lists look like and how they are created in Python. The following code snippet should help to set the basic pre-requisites before we dive into the examples.

List Comprehensions

If you are not familiar with list comprehensions, now may be a good time to take a look at my post on Understanding the basics of List Comprehension in Python. We will be following the same pattern of introducing the problem we are trying to solve, seeing how it is done with a traditional for loop and then see how we can convert that for loop into a list comprehension. I will include a screen recording of the transformation of for loop to list comprehension so that you can understand it clearly.

1. Create a list using a list comprehension

This example shows the most basic form of list comprehension. Here we will be creating a list of numbers in a specific range. We will see how it is done using a for loop and then rewrite it using a list comprehension.

Code snippet

Screen recording

2. List comprehension with an expression

Now let us build on the previous example by applying an operation on each of the list items. We will be creating a new list where each number is the double of the numbers in the original list.

Code snippet

Screen recording

3. List comprehension with an if condition

Next, let us introduce if conditions to our list comprehension. In this case, we will create a new list which contains the squares of all the odd numbers in the original list.

Code snippet

Code snippet

Screen recording

Useful Resources and References

Python3 documentation for List Comprehension

List Comprehension in Python: Understanding the Basics

noreply@blogger.com (Shyama Sankar) — Sat, 16 Mar 2019 09:49:00 +0000

A list comprehension is a concise way of creating a new list from an iterable. It may seem a bit tricky in the beginning, but it can be your new best friend once you understand and get used to it! In this tutorial, we will look at a very basic example of list comprehension.

Creating a filtered list

One of the most basic examples of a list comprehension would be filtering out elements of a list into a new list.
To illustrate it, let us take a look at how we would write a simple loop to filter out all even numbers from a list of numbers.
Using list comprehension, we would rewrite this as follows.
Let us take a look at what we actually did here:

Now let us get into the step by step details of how we converted the for loop into the list comprehension:

Just as we did initially, we create a new list object even_numbers using the square brackets.

even_numbers = []

Then we define the elements of this new list as the expression which we used within 'even_numbers.append()'. In this case, since we are just filtering out certain numbers, the variable number itself is the expression.

even_numbers = [number]

As you can see we have not yet defined the variable number. This is done by the for loop.

even_numbers = [number for number in numbers]

Now all that is left to do is adding the conditional.

even_numbers = [number for number in numbers if number % 2 == 0]

That was not so difficult, was it! 😊

To summarize, we can use a list comprehension instead of a traditional for loop if the loop follows the following syntax.

# For loop
new_items_list = []
for item in items_list:
  if condition(item):
    new_items_list.append(expression(item))

# Equivalent list comprehension
new_items_list = [expression(item) for item in items_list if condition(item)]

Note that we could have zero or more for loops and if conditions following the initial for loop. My next blog post will discuss more complex list comprehensions.

Thank you for visiting my blog! Feel free to comment with any corrections, suggestions, questions or feedback!

Learn Python

Getting started with Flask: Hello World

Installation and setup

Create the Hello World application

Run the application locally

Useful tips

Development environment

Logging

Conclusion

Monkey Patching in Python: Explained with Examples

Table of contents

Monkey patching

What is monkey patching?

Why use monkey patching?

When is monkey patching used?

Cautionary note: Why monkey patching should be used carefully

Monkey patching in Python

Example 1: Monkey patching the value of a module's attribute

Example 2: Monkey patching to extend the behavior of a method

Example 3: Monkey patching to change the behavior of a method

Example 4: Monkey patching class attributes

Example 5: Monkey patching a specific instance's attributes

Example 6: Monkey patching a class

Example 7: Monkey patching a module

Conclusion

Iteration in Python: The for, while, break, and continue statements

What is an iteration?

Types of iteration

The while statement: Indefinite iteration in Python

Syntax

Examples

1. Basic while loop

2. while loop with else

3. Infinite while loop

4. Nested while loop

The for statement: Definite iteration in Python

Syntax

Examples

1. Basic for loop

The following code snippet shows a basic for loop that iterates over a list.

2. for loop with else

The following example shows a basic for loop with an else clause.

3. Nested for loop

Now let us see an example for nested-for loops.

The break statement: Break out of a loop

1. break within a while loop

2. break within an infinite while loop

3. break within a for loop

4. break within nested loops

The continue statement: Continue with the next iteration

1. continue within a while loop

2. continue within a for loop

3. continue within nested loops

Useful Resources and Reference

List, Set and Dictionary Comprehensions in Python

Table of Contents

Introduction

Advantages:

List Comprehensions

Set Comprehensions

Dictionary Comprehensions

Related Posts

Python Dictionaries: Cheat Sheet

Key points

Cheat sheet

Related Posts

Useful resources and references

Python Sets: Cheat Sheet

Key points

Cheat sheet

Related Posts

Useful resources and references

Python Tuples: Cheat Sheet

Tuples: Cheatsheet

Related Posts

Useful Resources and References

Python Lists: Cheat Sheet

Lists: Cheatsheet

Related Posts

Reference