Author Archives: kang & atul

What’s inside Python ‘for’ loop?

Have you ever wondered how ‘for’ loop is automatically able to iterate over iterable like lists, strings etc? What if I tell you that Python for loop is actually an infinite while loop. Most of us might not believe but as is this beautiful Python.

There must be something inside ‘for’ loop that helps it to iterate over any iterable. In this blog, we will see how the for loop is actually implemented in python. Let’s understand this with an example.

Suppose we want to sum the elements of a list [1,2,3,4]. This can be done as

for number in my_list:
    sum += number

1 2	for number in my_list: sum += number

Actually what happens inside for loop is this

iter_object = iter(my_list)
while True:
    try:
        number = next(iter_object)
    except StopIteration:
        break
    sum += number
print(sum)

iter_object = iter(my_list)

while True:

try:

number = next(iter_object)

except StopIteration:

break

sum += number

print(sum)

To understand this, we first need to know what iterable and iterators are

Iterable: It is anything that you are able to loop over like lists, tuples, strings etc.
Iterator: It is the object that does the actual iterating.

So, in order to iterate, you must first convert an iterable into an iterator. This is done by using built-in iter() function. To get the next item, use next() function on that iterator (not on iterable). If there are 100 elements in an iterable then we need to call next() 100 times. To avoid this, we use an infinite while loop. next() function raises a StopIteration exception when there are no more elements in that iterable. So, to avoid this exception, we have used try-except statement and in this way, we break out from the infinite loop.

This is how the for loop actually works in python.

Now, you might have got some feeling about the Python for loop, iterator and iterable. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Read, Write and Display Videos with OpenCV Python

Leave a reply

In this blog, we will see how to Read, Write and Display Videos using OpenCV. Since a video is made up of images, most of the commands we learned in the previous blog also applies here.

Let’s see by an example how to capture video from the camera and display it.

import numpy as np
import cv2

cap = cv2.VideoCapture(0)

while(True):
    ret, frame = cap.read()
    
    cv2.imshow('frame',frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import numpy as np

import cv2

cap = cv2.VideoCapture(0)

while(True):

ret, frame = cap.read()

cv2.imshow('frame',frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

cv2.destroyAllWindows()

cv2.VideoCapture(0) will open the default camera. You can select the second camera by passing 1, third by passing 2 and so on. This creates a VideoCapture object (“cap” here).

cap.read() capture frame by frame. This returns two values, frame and ret. If the frame is read correctly, ret will be True otherwise False.

cv2.waitKey(1) & 0xFF == ord(‘q’) will exit the video when ‘q’ is pressed.

cap.release() closes video file or capturing device.

If you want to play a video from a file, just change the cv2.VideoCapture(0) function in the above code by giving the file path as cv2.VideoCapture(‘F:/downloads/Python.mp4’). Also, use the appropriate time for cv2.waitKey() function (25 will be OK).

Saving a Video:

First, create a VideoWriter object with cv2.VideoWriter(output filename, fourcc, fps, frameSize). fourcc(4-character code of codec) is used to compress the frames. After creating this object, use object.write() to save the video. Let’s see an example

import numpy as np
import cv2

cap = cv2.VideoCapture(0)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))
while(True):
    ret, frame = cap.read()
    cv2.imshow('frame',frame)
    out.write(frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import numpy as np

import cv2

cap = cv2.VideoCapture(0)

fourcc = cv2.VideoWriter_fourcc(*'XVID')

out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))

while(True):

ret, frame = cap.read()

cv2.imshow('frame',frame)

out.write(frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

cv2.destroyAllWindows()

Now, you might have got some feeling about the basic video commands in OpenCV. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Creating a Snake Game with pygame

7 Replies

In this tutorial, we will create a snake game with python and pygame. You can find full code here.

What is pygame?

It is a free and open source Python programming language library used for making a multimedia application like games. It is great for beginners as it’s simple and easy to use.

Installing pygame in Python:

There are two ways to do this.

You can directly use pip install pygame in the command window or
Download whl file from this link python extension packages according to your python version. Then use pip install whl_file_name.

Let’s create a snake game using pygame library. To Start with this, we first need to initialize pygame modules as shown below.

pygame.init()

1	pygame.init()

pygame.init() will attempt to initialize all the pygame modules for you. Not all pygame modules need to be initialized, but this will automatically initialize the ones that do.

Displaying Game Objects:

After initializing pygame modules, it’s time to display the game window. For that, we need to initialize its dimensions(width and height). Here I have used 500 x 500, but you can choose yours.

display_width = 500 
display_height = 500    
display = pygame.display.set_mode((display_width,display_height))
window_color= (200,200,200)
display.fill(window_color)
pygame.display.update()

display_width = 500

display_height = 500

display = pygame.display.set_mode((display_width,display_height))

window_color= (200,200,200)

display.fill(window_color)

pygame.display.update()

display.fill(window_color) will fill white color into game window and pygame.display.update() allows only a portion of the screen to be updated, instead of the entire area. If no argument is passed, it updates the entire Surface area.

This will create a game window as shown below.

Now it’s time to display snake and apple. Here I have used red color for snake and an image for apple. At the start of each game, we want snake’s starting position to be fixed while apple can take any random location. Starting length of the snake is 3 units where each unit is a 10×10 block.

red = (255,0,0)  
black = (0,0,0)
apple_image = pygame.image.load('apple.jpg') 
snake_head = [250,250] 
snake_position = [[250,250],[240,250],[230,250]] 
apple_position = [random.randrange(1,50)*10,random.randrange(1,50)*10]<strong>

def display_snake(snake_position):
    for position in snake_position:
        pygame.draw.rect(display,red,pygame.Rect(position[0],position[1],10,10))

def display_apple(display,apple_position, apple):
    display.blit(apple,(apple_position[0], apple_position[1]))
</strong>

red = (255,0,0)

black = (0,0,0)

apple_image = pygame.image.load('apple.jpg')

snake_head = [250,250]

snake_position = [[250,250],[240,250],[230,250]]

apple_position = [random.randrange(1,50)*10,random.randrange(1,50)*10]<strong>

def display_snake(snake_position):

for position in snake_position:

pygame.draw.rect(display,red,pygame.Rect(position[0],position[1],10,10))

def display_apple(display,apple_position, apple):

display.blit(apple,(apple_position[0], apple_position[1]))

</strong>

pygame.draw.rect() will draw a rectangle corresponding to given arguments which will represent our snake and display.blit() will show the image of an apple.

This will create a game window as shown below.

The next thing is to decide at what frame rate we want to play our game. This is done using pygame.time.Clock() that creates a “clock” object. Now whenever clock.tick() is called and passed with some number, then it will limit the run time speed of the game. As an example, if clock.tick(20) is called, then the program will never run at more than 20 frames per second.

clock = pygame.time.Clock()
clock.tick(20)

1 2	clock = pygame.time.Clock() clock.tick(20)

Game Logic:

Now it’s time to define game rules. As you know, there must be some rules which makes a game playable.

Rule 1: If the snake collapses with itself or with boundaries, game over.

def collision_with_boundaries(snake_head):
    if snake_head[0]>=500 or snake_head[0]<0 or snake_head[1]>=500 or snake_head[1]<0 :
        return 1
    else:
        return 0

def collision_with_self(snake_position):
    snake_head = snake_position[0]
    if snake_head in snake_position[1:]:
        return 1
    else:
        return 0

def collision_with_boundaries(snake_head):

if snake_head[0]>=500 or snake_head[0]<0 or snake_head[1]>=500 or snake_head[1]<0 :

return 1

else:

return 0

def collision_with_self(snake_position):

snake_head = snake_position[0]

if snake_head in snake_position[1:]:

return 1

else:

return 0

Rule 2: Moving the snake to a new position

In our game, the snake will continue to move in one direction until a button is pressed. To move the snake, we need to add one unit to the head and remove one unit from the tail.

 snake_position.insert(0,list(snake_head))
 snake_position.pop()

1 2	snake_position.insert(0,list(snake_head)) snake_position.pop()

Another case is when a button is pressed to move in a direction(left, right, up or down). Also, the Snake cannot move backward.

 if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_LEFT and prev_button_direction != 1:
        button_direction = 0
    elif event.key == pygame.K_RIGHT and prev_button_direction != 0:
        button_direction = 1
    elif event.key == pygame.K_UP and prev_button_direction != 2:
        button_direction = 3
    elif event.key == pygame.K_DOWN and prev_button_direction != 3:
        button_direction = 2
    else:
        button_direction = button_direction

if event.type == pygame.KEYDOWN:

if event.key == pygame.K_LEFT and prev_button_direction != 1:

button_direction = 0

elif event.key == pygame.K_RIGHT and prev_button_direction != 0:

button_direction = 1

elif event.key == pygame.K_UP and prev_button_direction != 2:

button_direction = 3

elif event.key == pygame.K_DOWN and prev_button_direction != 3:

button_direction = 2

else:

button_direction = button_direction

After seeing which direction button is pressed, we need to change our snakes head position.

if button_direction == 1:
    snake_head[0] += 10
elif button_direction == 0:
    snake_head[0] -= 10
elif button_direction == 2:
    snake_head[1] += 10
elif button_direction == 3:
    snake_head[1] -= 10
else:
    pass

snake_position.insert(0,list(snake_head))
snake_position.pop()

if button_direction == 1:

snake_head[0] += 10

elif button_direction == 0:

snake_head[0] -= 10

elif button_direction == 2:

snake_head[1] += 10

elif button_direction == 3:

snake_head[1] -= 10

else:

pass

snake_position.insert(0,list(snake_head))

snake_position.pop()

Rule 3. If the snake eats an apple, the apple moves to a new position and snake length increases.

When the snake eats an apple, we increase our snake’s length and improve the score. To increase snake size, we add one unit at snake’s head. Also, we need to create another apple at random location to proceed the game.

def collision_with_apple(apple_position, score):
    apple_position = [random.randrange(1,50)*10,random.randrange(1,50)*10]
    score += 1
    return apple_position, score

if snake_head == apple_position:
    apple_position, score = collision_with_apple(apple_position, score)
    snake_position.insert(0,list(snake_head))

def collision_with_apple(apple_position, score):

apple_position = [random.randrange(1,50)*10,random.randrange(1,50)*10]

score += 1

return apple_position, score

if snake_head == apple_position:

apple_position, score = collision_with_apple(apple_position, score)

snake_position.insert(0,list(snake_head))

Displaying Final Score:

After the game is over, we want to display the final score. Here, I have defined a function ‘display_final_score’, which takes final score and text to be displayed as its arguments to display in the game window.

def display_final_score(display_text, final_score):
    largeText = pygame.font.Font('freesansbold.ttf',35)
    TextSurf = largeText.render(display_text, True, black)
    TextRect = TextSurf.get_rect()
    TextRect.center = ((display_width/2),(display_height/2))
    display.blit(TextSurf, TextRect)
    pygame.display.update()
    time.sleep(2)

def display_final_score(display_text, final_score):

largeText = pygame.font.Font('freesansbold.ttf',35)

TextSurf = largeText.render(display_text, True, black)

TextRect = TextSurf.get_rect()

TextRect.center = ((display_width/2),(display_height/2))

display.blit(TextSurf, TextRect)

pygame.display.update()

time.sleep(2)

This will display our final score as shown below.

Finally, our snake game is created, now it’s time to play it.

Now, you might have got some feeling about creating games using pygame. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Read, Write and Display Images with OpenCV

Leave a reply

In this blog, we will see how to Read, Write and Display Images using OpenCV. I hope you have installed OpenCV, numpy, and matplotlib libraries, if not, please refer to this blog.

Read an image:

To read an image, use the function cv2.imread(filename[, flags]) where filename is the full path of image and flags specifies the way image should be read (>0 for color, =0 for greyscale, and <0 for loading image as is (with alpha channel)).

import numpy as np
import cv2
# Load an image in grayscale
img = cv2.imread('F:/downloads/Python.png',0)

import numpy as np

import cv2

# Load an image in grayscale

img = cv2.imread('F:/downloads/Python.png',0)

If the image cannot be read (because of missing file, improper permissions, unsupported or invalid format), the function returns an empty matrix, not an error.

Display an image:

To display an image in a window, use the function cv2.imshow(winname, image) where the first argument is the Name of the window and second is the Image to be shown. So, this will first create a window named as image and displays the image in that window.

Note: This function must be followed by cv2.waitkey(delay) function otherwise the image wouldn’t be displayed.

cv2.imshow('image',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.imshow('image',img)

cv2.waitKey(0)

cv2.destroyAllWindows()

cv2.waitKey(delay) decides for how long the image will be displayed. Its argument delay is the time in milliseconds. If the delay is <=0, the image will be shown forever otherwise destroyed after delay milliseconds.

cv2.destroyAllWindows() simply destroys all the windows we created.

Special Case: We can create a window first and load the image to it later. Just write the below code line before the cv2.imshow() function.

cv2.namedWindow('image', cv2.WINDOW_NORMAL)

1	cv2.namedWindow('image', cv2.WINDOW_NORMAL)

Write an image:

To save an image, use the function cv2.imwrite(filename, image) where the first argument is the file name with which we want to save the image file, the second argument is the image you want to save.

cv2.imwrite('pythongray.jpg',img)

1	cv2.imwrite('pythongray.jpg',img)

This will save the image in JPEG format in the working directory.

Now, you might have got some feeling about the basic image commands in OpenCV. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

What is a Digital Image?

3 Replies

In this blog, we will try to understand what is a digital image and how it is formed. We will also learn about image sensors and pixels in this blog.

What is a Digital Image?

A Digital Image is a numeric representation of a two-dimensional image and is made of picture elements called pixels, arranged in rows and columns. These numeric values are the intensity or brightness values that are associated with the pixels.

Now, let’s understand what is a pixel and how the intensity value is calculated?

The concept of pixel is closely related with image sensors. So, by understanding image sensors I hope you will get a feel of what a pixel is.

Image Sensor: It is a device that converts the light energy into an electric signal. The figure below shows a single image sensor.

source: R. C. Gonzalez, R. E. Woods, Digital Image Processing

In digital cameras, these sensors are arranged in the form of a 2D array on a chip. Mostly there is a 1-to-1 correspondence between a pixel and a sensor meaning each sensor produces 1 pixel. Thus, the total number of pixels in an image = total number of sensors on a chip. Sometimes, multiple sensors are used to produce a pixel of information.

8MP camera means there are 8×10⁶ image sensors in the camera chip and if there is a 1-to-1 correspondence between a pixel and a sensor then the image contains 8×10⁶ pixels.

Note: Larger the pixel, better will be the image quality.

How the Digital Image is formed?

There are basically two types of image sensors used in digital cameras: CCD or CMOS. The CCD sensor is a silicon chip that contains a 2D array of photosensitive sites or sensors. Each sensor has a PN diode and a storage cell. Each sensor outputs a pixel value through these steps

Light energy or photons(>1.2eV) falls on the silicon layer of the sensor and electrons are released(stored in potential well until the shutter is open).
After the camera shutter closes, these electrons are moved to the storage cell (by applying +ve voltage on vertical shift register).
These electrons are then transferred to the serial shift register.
These electrons are converted into the analog voltage that is amplified using an amplifier.
The output voltage signal is immediately converted to a digital signal by means of an analog-to-digital converter (ADC) in digital cameras, either on or off-chip. This digital quantity obtained is the intensity value of a pixel.

These steps are for the CCD sensor. For CMOS sensor, step 3 is not performed and voltage conversion and amplification (Step 4) is done in the sensor itself. This voltage is sent to ADC with the help of switch from each sensor and outputs the intensity value of a pixel.

Repeat these steps for all the sensors on a chip to get the intensity values corresponding to each pixel and thus we get a digital image.

Now, you might have got some feeling about the image sensors, pixel, and digital image. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Installing Python OpenCV and other libraries

1 Reply

Here, we will be installing the libraries that are required to perform image processing operations. We will be using the following Python libraries

OpenCV
Numpy
Matplotlib

Why we are using OpenCV, not Matlab or any other?

Because it is open source, fast(written in C/C++), memory efficient and easy to install (can run on any device that can run C).
if you really want to learn about how computer vision works from the initial steps to the last, I suggest you learn OpenCV first then use any deep learning library like Tensorflow, pytorch etc when you’re ready to train a deep learning algorithm for better performance/accuracy results.

Installing Numpy, OpenCV or any library (For WINDOWS)

There are two ways to install any library in Python IDLE,

using pip command: In the installed Python folder, go to Scripts folder and open command prompt(press and hold Shift + Right Click and select Open command window here). Then write pip install library name to get it installed. For example

Python

pip install numpy

1

pip install numpy
using .whl file: First download .whl file of any library (version corresponding to your Python) from here. Then open the command prompt where you have downloaded this file and write pip install filename.whl. For example

Python

pip install numpy‑1.14.2+mkl‑cp36‑cp36m‑win32.whl

1

pip install numpy‑1.14.2+mkl‑cp36‑cp36m‑win32.whl

Installing Numpy, OpenCV or any library (For UBUNTU)

First, install pip using apt-get, then you can install any library as shown below

sudo apt-get install python-pip  
sudo pip install numpy

1 2	sudo apt-get install python-pip sudo pip install numpy

Anaconda: open the Anaconda prompt and write pip install numpy or any other library name which you want to install.

Now, you might have got some feeling about how to install Python libraries. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Python If name == “main”

1 Reply

There are two things which we can do with our script/program, either we run it directly or import it into another program. Suppose we have a my_module.py file, as shown below

# my_module.py file

def function():
    print ('Hello World')

function()

# my_module.py file

def function():

print ('Hello World')

function()

To run the my_module.py file directly we write python my_module.py on the command line. But if we want to import this file, then we have to comment out the function() calling statement. Import file means we only want functions, classes etc. and no code execution statements like a function call from that file. Just let the user call these at his own will.

For example, import math only imports functions from the math.py file. It is up to us whether we call math.sin() or math.cos(). That’s why we should remove code execution statements before importing a file.

Problem: “Commenting out function call from the file which we want to import”. For large modules, this is seriously a headache.

Question: Can’t we do something to automate the above problem, meaning writing import should automatically comment out or remove the function call.

Solution: Python if __name__ == “__main__” statement.

Concept: Before executing the code, Python defines a few special variables. For example, if the Python interpreter is running that module (the source file) directly, it sets the special __name__ variable to have a value “__main__”. If this file is being imported from another module, __name__ will be set to the module’s or file’s name.

So, what we do is write all the code execution statements inside if __name__ == “__main__” statement. When we run the file directly this condition is satisfied and the code is executed. While importing __name__ == file_name and not __main__ so the code is not executed. Let’s see an example

# file hello.py
def func():
    print("func() in hello.py")

print("Hello World")

if __name__ == "__main__":
    print("run directly")
    func()
else:
    print("imported")

# file hello.py

def func():

print("func() in hello.py")

print("Hello World")

if __name__ == "__main__":

print("run directly")

func()

else:

print("imported")

Running the above hello.py file directly (F5 in shell or by command line), we get this output

Hello World
run directly
func() in hello.py

Hello World

run directly

func() in hello.py

Now, import this hello.py into another file say hi.py like as shown below

# hi.py file
import hello

1 2	# hi.py file import hello

Running the above code gives the output shown below

Hello World
imported

1 2	Hello World imported

Clearly, the func() is not executed while importing and this is what we want.

Now, you might have got some feeling about the Python if __name__ == “__main__” statement. Always use this. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Python Variables and Scope

1 Reply

To understand what is happening in the code, you should know what the “scope” of variable means. The scope of a variable refers to the places from where we can see or access a variable. To understand this more clearly, we should first know what “variable” actually means.

A variable is a reference to a memory address that contains the value. Let’s see the figure below.

Suppose, we have x=5. There are two ways of reading this line.

‘x’ is a variable name that references to a memory location in which 5 is stored.
variable x equals 5

Saying the humungous first line every time may be frustrating, so we usually use the second way. Here comes the confusion. Let’s see by an example

x = 5
def number():
    x = 3
def numb():
    x = 6
number()
numb()    
print x

x = 5

def number():

x = 3

def numb():

x = 6

number()

numb()

print x

Question: How many variables are there in the above code?

If we use the definition x equals 5, we might think that it is the same variable x with different values. But if we use the actual definition of the variable, we can argue that there are 3 variables as they refer to different memory locations and thus are different. We can always check the identity of the location of the object in memory using the python id() function. Just write id(variable_name) which outputs a number that refers to some memory location(same number means the same variable). So, use the shortcut definition but always remember the actual meaning.

This means we can define a number of variables with the same name(say x) in a program without having a relation between them. This sometimes creates confusion. Let’s understand this by an example

x = 5
def number():
    x = 3
number()    
print x

x = 5

def number():

x = 3

number()

print x

Now, which value should this x prints? This is where the scope comes into the picture. Scope tells us which variable we can access and from where.

LEGB Rule: LEGB stands for Local, Enclosing, Global and Built-in. This tells us the order in which python accesses the variable in a program. First, python will check if the variable is present in the local scope, if not then checks in enclosing scope and so on till the builtin scope is checked.

Let’s understand the LEGB terms one by one:

Local: Python first tries to search for an identifier(variable) in Local scope. The local variable exists only within the block/function that it is declared in. When that block/function ends, the local variable has no significance, it gets destroyed. We cannot use it outside the function where it is declared. For example in the code below, x=3 is local to the number() function means we cannot access that variable outside this function. So, the output of the last print(x) will be an error saying name ‘x’ is not defined.

Python

def number(): x=3 print x number() # 3 print x # name 'x' is not defined

1
2
3
4
5

def number():
    x=3
    print x
number()         # 3
print x          # name 'x' is not defined

Enclosing: Enclosing refers to the nested functions where one encloses the other. If Python does not find an identifier(variable) within the local scope, it will examine the Enclosing scope to see if it can find the variable there. Let’s understand this by an example

def outer():
    x=4
    def inner():
        print x           #----- 1
    inner()
    print x               #----- 2

outer()

def outer():

x=4

def inner():

print x #----- 1

inner()

print x #----- 2

outer()

For the print x —1, inner() is Local and outer is Enclosing while for the print x—2, outer() is Local. So, print x—1 will first search for x in the inner(). Since there is no x in the inner() so we go to outer()/Enclosing and check if x is there or not. So, print x—1 outputs 4. For print x–2, we have x in the Local scope of outer() so this will output 4.

Global: Global variable means that it is accessible from anywhere in your script, including from within a function. It is usually defined at the top of the script or outside of the function. If Python fails to find the variable in both above scopes, then it will check the global scope. Let’s see an example

x=4
def outer():
    def inner():
        print x           #----- 1
    inner()
    print x               #----- 2

outer()

x=4

def outer():

def inner():

print x #----- 1

inner()

print x #----- 2

outer()

As we have no x in the local and enclosing scope, so Python checks the global scope and outputs 4 for both print x statements.
Note: using too many global variables will generally lead to name conflicts and will likely lead to unwanted side effects.

Built-in: Built-in means the function and variables that are already defined in python. If an identifier is not found in any of the above scopes within a module, then Python will examine the built-in identifiers to see if it is defined there. For example

Python

x = len ( 'PANKAJ' ) print x # 6

1
2

x = len ( 'PANKAJ' )
print x                          # 6

If len is not found in any of the scopes, then Python would consult the Built-In scope, where it will find the len function and outputs 6. But if we create our own len function then it will have precedence over Built-in len function. Let’s see by an example

Python

def len(x): return (1) x = len ( 'PANKAJ' ) print x # 1

1
2
3
4

def len(x):
    return (1)
x = len ( 'PANKAJ' )
print x                          # 1

Since our len function precedes over built-in len and thus the output of print x statement equals 1.

Now, I hope that you might have understood the Python variable and scope, Let’s look at some of the keywords that are useful regarding this

Global Keyword: With this, we tell the Python to use the globally defined variable instead of locally defining it. This is useful when we want to change the value of a variable through a function. To use it, simply type global followed by the variable name. Let’s see an example

Python

x=4 def change(y): global x x = y change(10) print (x) # 10

1
2
3
4
5
6
7

x=4
def change(y):
    global x
    x = y

change(10)
print (x)                  # 10

NonLocal Keyword: This is useful in nested functions. It causes the variable to refer to the previously bound variable in the closest enclosing scope. Let’s see by an example

def outer():
    x=4
    def inner():
        nonlocal x
        x = 10
        print (x)
    inner()
    print (x)

outer()             # output 10,10

def outer():

x=4

def inner():

nonlocal x

x = 10

print (x)

inner()

print (x)

outer() # output 10,10

By nonlocal, we tell Python that this x is same as defined in the enclosing outer() function.

Now, you might have got some feeling about the Python variable and scope. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Side Effects in programming

Leave a reply

According to Wikipedia, a function or expression is said to have a side effect if it modifies some state outside its local environment. Let’s understand this in depth by examples.

To understand side effects, first, we should know what “state” is. In layman terms, the state refers to the value of the variable at any given point in the program like x=2.

Now, the above Wikipedia definition might have started to make some sense. If not, don’t worry, see the figure below.

In this figure, we have a variable x that is outside the scope of two functions. Clearly, after the Function_2 call, the value of x changes which means that Function_2, other than returning value(if any), is interacting with variables outside its local environment and thus has a side effect.

In general, any lasting effect that occurs in a function, not through its return value, is called a side effect. Not through its return value means if we assign x=Function_1(), this will clearly change the value of x but this is not a side effect. For side effect, the change should occur inside a function.

Common ways to have side effects:

Modifying a non-local variable: Let’s understand by an example

x=3
def square(x):
    x=x*x
    return x
def square_side_effect():
    global x
    x=x*x
    return x
print(x)                 # 3
print(square(x))         # 9
print(x)                 # 3 
print(square_side_effect())     # 9
print(x)                 # 9

x=3

def square(x):

x=x*x

return x

def square_side_effect():

global x

x=x*x

return x

print(x) # 3

print(square(x)) # 9

print(x) # 3

print(square_side_effect()) # 9

print(x) # 9

The x in the square() function is local to its scope so no change in outside x. Global in square_side_effect() makes x global so any change in x will change it in whole code (outside function scope) so the square_side_effect function() is not pure(has side effects).

Changing the value of a mutable object: Let’s take Lists which is a mutable object.

lst = [1,2,'Pankaj']
def list_side_effect(lst):
    lst[1] = 1
    lst[2] = 'Kang'
    return lst
print(lst)             # [1,2,'Pankaj']
list_side_effect(lst)
print(lst)             # [1,1,'Kang']

lst = [1,2,'Pankaj']

def list_side_effect(lst):

lst[1] = 1

lst[2] = 'Kang'

return lst

print(lst) # [1,2,'Pankaj']

list_side_effect(lst)

print(lst) # [1,1,'Kang']

Clearly, after calling list_side_effect(), the value of lst changes so, list_side has side effects.

Performing Input/Output operations: This doesn’t change any objects or variable value, but it does have a potential lasting effect outside the function call because a person might see the output and be influenced by it.
Calling other side-effect functions

Now, you might have got some feeling about the side effects. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Expressions vs Statements

Leave a reply

Statement and expression are two important terms which are commonly misunderstood. Let’s start the explanation from the expression term.

Expression:

An expression is a combination of values, variables, and operators including function call operator (), subscription operator [ ] etc. I guess that it is not clear, so let’s see an example.

>>> 1+1
2
>>> sum(range(2*3))
15

>>> 1+1

>>> sum(range(2*3))

In simple terms, an expression produces a value (1+1 is an expression as it produces a value 2) and can be written wherever a value is expected, for example as an argument in a function call, for example, 2*3 is expression given as an argument to range function in the code above.

Note: If you type an expression on the command line, the interpreter evaluates it and displays the result. While in a script an expression all by itself is a statement. You have to write print(expression) in order to display the result.

A value or variable is considered an expression as the interpreter returns the result(See example below). Functions that do not return anything is not an expression.

>>> 4
4
>>> x
2

>>> 4

>>> x

Note: Expressions can be reduced to any kind of value, which can be any integer, string or even a Python object like

>>> map(lambda x: x/2 , range(6))
<map object at 0x0000006242848588>

1 2	>>> map(lambda x: x/2 , range(6)) <map object at 0x0000006242848588>

Note: Evaluating an expression is not quite the same thing as printing a value. Expressions are displayed by the interpreter in the same format we enter, but print statement only shows the content (See example below)

>>> name= 'Pankaj'
>>> name            #  expression
'Pankaj'
>>> print(name)     #  statement
Pankaj

>>> name= 'Pankaj'

>>> name # expression

'Pankaj'

>>> print(name) # statement

Pankaj

Statements:

A statement is an instruction that the Python interpreter can execute. In short, every line of python code is a statement. Note that expressions are statements as well. Below is an example of print and assignment statements.

>>> x = 2        #  assignment (Do not display result)
>>> print(x)     #  print
2

>>> x = 2 # assignment (Do not display result)

>>> print(x) # print

Expression Statements: In this, first the expression is evaluated then the statement is executed. In the example below, the 2*3 expression is evaluated first, then the print statement is executed.

>>> print(2*3)
6

1 2	>>> print(2*3) 6

Now, you might have got some feeling about the difference between expression and statement. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

TheAILearner

Mastering Artificial Intelligence

Author Archives: kang & atul

What’s inside Python ‘for’ loop?

Read, Write and Display Videos with OpenCV Python

Creating a Snake Game with pygame

Read, Write and Display Images with OpenCV

Read an image:

Display an image:

Write an image:

What is a Digital Image?

Installing Python OpenCV and other libraries

Python If name == “main”

Python Variables and Scope

Like this:

Side Effects in programming

Like this:

Expressions vs Statements

Expression:

Statements: