DEV Community: Arnab Dey

Music Player App GUI using Python

Arnab Dey — Mon, 31 May 2021 07:12:41 +0000

Here, we will create a Music Player Application in Python using Pygame and Tkinter module.

In our daily life, we see every person has a hobby and that is listening to music. So in order to listen to music, they all need a Music player(hardware or software) where they can play their favorite songs. And we have to install this music player on our computer, based the Operating system i.e Windows, Macintosh, Android, Linux, etc. Then we can listen to our favorite songs.

Now we will help you to code and create a Music Player from scratch.

Libraries used for Music Player Application:
Now we will tell you about the Libraries we will use in our code :

1.Tkinter

We had already told you in the title of this page that we are going to use the Tkinter library, which is a standard library for GUI creation. The Tkinter library is most popular and very easy to use and it comes with many widgets (these widgets helps in the creation of nice-looking GUI Applications).

Also, Tkinter is a very light-weight module and it is helpful in creating cross-platform applications(so the same code can easily work on Windows, macOS, and Linux)

To use all the functions of Tkinter you need to import it in your code and the command for the same is:

from tkinter import *

2.Pygame module

Pygame is a Python module that works with computer graphics and sound libraries and designed with the power of playing with different multimedia formats like audio, video, etc. While creating our Music Player application, we will be using Pygame's mixer.music module for providing different functionality to our music player application that is usually related to the manipulation of the song tracks.

Command used to install pygame is:

pip install pygame

Click and drag to moveTo use this module into your code you need to write this:

import pygame

OS module

There is no need to install this module explicitly, as it comes with the standard library of Python. This module provides different functions for interaction with the Operating System. In this tutorial, we are going to use the OS module for fetching the playlist of songs from the specified directory and make it available to the music player application.

To use this module in your code you need to import its and command for the same is as follows:

import OS

After importing Libraries and modules, now it's time to create a basic window where we will add our UI elements or Tkinter widgets. You can add this code either after importing libraries or also at the end just before the looping of the root window and the code is as follows:

root = Tk() # In order to create an empty window

Passing Root to MusicPlayer Class

MusicPlayer(root)
MusicPlayer Class
Here we have the constructor and the other functions defined in the MusicPlayer class.

init Constructor With the help of this constructor, we will set the title for the window and geometry for the window. We will initiate pygame and pygame mixer and then declare track variable and status variable.

We will then Create the Track Frames for Song label & status label and then after Insert the Song Track Label and Status Label.

After that, we will create the Button Frame and insert play, pause, unpause, and stop buttons into it.

Then we will create the playlist frame and add the scrollbar to it and we will add songs into playlist.

The code snippet is as follows:

def init(self,root):
self.root = root
# Title of the window
self.root.title("MusicPlayer")
# Window Geometry
self.root.geometry("1000x200+200+200")
# Initiating Pygame
pygame.init()
# Initiating Pygame Mixer
pygame.mixer.init()
# Declaring track Variable
self.track = StringVar()
# Declaring Status Variable
self.status = StringVar()

# Creating the Track Frames for Song label & status label
trackframe = LabelFrame(self.root,text="Song Track",font=("times new roman",15,"bold"),bg="Navyblue",fg="white",bd=5,relief=GROOVE)
trackframe.place(x=0,y=0,width=600,height=100)
# Inserting Song Track Label
songtrack = Label(trackframe,textvariable=self.track,width=20,font=("times new roman",24,"bold"),bg="Orange",fg="gold").grid(row=0,column=0,padx=10,pady=5)
# Inserting Status Label
trackstatus = Label(trackframe,textvariable=self.status,font=("times new roman",24,"bold"),bg="orange",fg="gold").grid(row=0,column=1,padx=10,pady=5)

# Creating Button Frame
buttonframe = LabelFrame(self.root,text="Control Panel",font=("times new roman",15,"bold"),bg="grey",fg="white",bd=5,relief=GROOVE)
buttonframe.place(x=0,y=100,width=600,height=100)
# Inserting Play Button
playbtn = Button(buttonframe,text="PLAYSONG",command=self.playsong,width=10,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=0,padx=10,pady=5)
# Inserting Pause Button
playbtn = Button(buttonframe,text="PAUSE",command=self.pausesong,width=8,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=1,padx=10,pady=5)
# Inserting Unpause Button
playbtn = Button(buttonframe,text="UNPAUSE",command=self.unpausesong,width=10,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=2,padx=10,pady=5)
# Inserting Stop Button
playbtn = Button(buttonframe,text="STOPSONG",command=self.stopsong,width=10,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=3,padx=10,pady=5)

# Creating Playlist Frame
songsframe = LabelFrame(self.root,text="Song Playlist",font=("times new roman",15,"bold"),bg="grey",fg="white",bd=5,relief=GROOVE)
songsframe.place(x=600,y=0,width=400,height=200)
# Inserting scrollbar
scrol_y = Scrollbar(songsframe,orient=VERTICAL)
# Inserting Playlist listbox
self.playlist = Listbox(songsframe,yscrollcommand=scrol_y.set,selectbackground="gold",selectmode=SINGLE,font=("times new roman",12,"bold"),bg="silver",fg="navyblue",bd=5,relief=GROOVE)
# Applying Scrollbar to listbox
scrol_y.pack(side=RIGHT,fill=Y)
scrol_y.config(command=self.playlist.yview)
self.playlist.pack(fill=BOTH)
# Changing Directory for fetching Songs
os.chdir("PATH/OF/DIRECTORY")
# Fetching Songs
songtracks = os.listdir()
# Inserting Songs into Playlist
for track in songtracks:
  self.playlist.insert(END,track)

In the code above, change the PATH/OF/DIRECTORY with appropriate path where the song files are stored.

The playsong() Function Now we will define the Play Song Function and the code is:

def playsong(self):
# Displaying Selected Song title
self.track.set(self.playlist.get(ACTIVE))
# Displaying Status
self.status.set("-Playing")
# Loading Selected Song
pygame.mixer.music.load(self.playlist.get(ACTIVE))
# Playing Selected Song
pygame.mixer.music.play()

The stopsong() Function The code snippet to stop the song:

def stopsong(self):
# Displaying Status
self.status.set("-Stopped")
# Stopped Song
pygame.mixer.music.stop()

The pausesong() Function The code snippet to pause the song:

def pausesong(self):
# Displaying Status
self.status.set("-Paused")
# Paused Song
pygame.mixer.music.pause()

The unpausesong() Function The code snippet to unpause the song:

def unpausesong(self):
# It will Display the Status
self.status.set("-Playing")
# Playing back Song
pygame.mixer.music.unpause()

Root Window Looping The command will be:

root.mainloop()
Now here are some of the screenshots of our application:

We will provide the path of the songs folder in our code where all songs are placed in order to access them.

Now the following screenshot is to show you how the application will look like:

whenever you made a click on the song it will look like:

On clicking the PLAYSONG Button:

On clicking the PAUSE Button:

On clicking the STOP Button:

So this was all about building the Music Player Application using Tkinter. Hope you all like this application.

Calculator Application GUI using Python

Arnab Dey — Mon, 31 May 2021 06:46:28 +0000

What is a Calculator?

For those who do not know, a calculator is basically a program on a computer that simulates the behavior of any hand-held calculator useful for performing Mathematical Calculations. It is a very basic device used in our every day lives. Now all the smartphones also have a Calculator application in them.

While creating any GUI Application there are mainly two steps:

The first step is to create a User Interface.

The second step is the most important one and in this, to add functionalities to the GUI

Now let's begin with creating a simple calculator app using Tkinter in Python which is used for basic arithmetic calculations.

Calculator App Code

Now it's time to take a look at the code to create a Calculator App using Tkinter.

Here is how our calculator will look, which is made by using the input field, buttons and for the calculation purpose we will use logic in our code defined in functions, like if you want to add two numbers then behind this there must be a logic for addition purpose, similarly for substraction, multiplication, etc, we have created functions whose task is to perform these operations.

Now we will show you a snapshot as the output of the above code. And yes you can implement it on your system for more clear.

Understanding of Calculator App Using Tkinter:

We have an Input Field in which the user input will be shown and the final result of the calculation will be displayed.

And the buttons are like 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, -, *, /, =, ., and C(clear button)

There are a variety of functions in Tkinter with the help of them it becomes easy and convenient to make a simple calculator just with this little code.

Calcular Application GUI using Python Code

from tkinter import *

win = Tk() # This is to create a basic window
win.geometry("312x324") # this is for the size of the window
win.resizable(0, 0) # this is to prevent from resizing the window
win.title("Calculator")

#############Starting with functions

'btn_click' function :

This Function continuously updates the

input field whenever you enters a number

def btn_click(item):
global expression
expression = expression + str(item)
input_text.set(expression)

'bt_clear' function :This is used to clear

the input field

def bt_clear():
global expression
expression = ""
input_text.set("")

'bt_equal':This method calculates the expression

present in input field

def bt_equal():
global expression
result = str(eval(expression)) # 'eval':This function is used to evaluates the string expression directly
input_text.set(result)
expression = ""

expression = ""

'StringVar()' :It is used to get the instance of input field

input_text = StringVar()

Let us creating a frame for the input field

input_frame = Frame(win, width=312, height=50, bd=0, highlightbackground="black", highlightcolor="black", highlightthickness=2)

input_frame.pack(side=TOP)

Let us create a input field inside the 'Frame'

input_field = Entry(input_frame, font=('arial', 18, 'bold'), textvariable=input_text, width=50, bg="#eee", bd=0, justify=RIGHT)

input_field.grid(row=0, column=0)

input_field.pack(ipady=10) # 'ipady' is internal padding to increase the height of input field

Let us creating another 'Frame' for the button below the 'input_frame'

btns_frame = Frame(win, width=312, height=272.5, bg="grey")

btns_frame.pack()

first row

clear = Button(btns_frame, text = "C", fg = "black", width = 32, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: bt_clear()).grid(row = 0, column = 0, columnspan = 3, padx = 1, pady = 1)

divide = Button(btns_frame, text = "/", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("/")).grid(row = 0, column = 3, padx = 1, pady = 1)

second row

seven = Button(btns_frame, text = "7", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(7)).grid(row = 1, column = 0, padx = 1, pady = 1)

eight = Button(btns_frame, text = "8", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(8)).grid(row = 1, column = 1, padx = 1, pady = 1)

nine = Button(btns_frame, text = "9", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(9)).grid(row = 1, column = 2, padx = 1, pady = 1)

multiply = Button(btns_frame, text = "", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("")).grid(row = 1, column = 3, padx = 1, pady = 1)

third row

four = Button(btns_frame, text = "4", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(4)).grid(row = 2, column = 0, padx = 1, pady = 1)

five = Button(btns_frame, text = "5", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(5)).grid(row = 2, column = 1, padx = 1, pady = 1)

six = Button(btns_frame, text = "6", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(6)).grid(row = 2, column = 2, padx = 1, pady = 1)

minus = Button(btns_frame, text = "-", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("-")).grid(row = 2, column = 3, padx = 1, pady = 1)

fourth row

one = Button(btns_frame, text = "1", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(1)).grid(row = 3, column = 0, padx = 1, pady = 1)

two = Button(btns_frame, text = "2", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(2)).grid(row = 3, column = 1, padx = 1, pady = 1)

three = Button(btns_frame, text = "3", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(3)).grid(row = 3, column = 2, padx = 1, pady = 1)

plus = Button(btns_frame, text = "+", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("+")).grid(row = 3, column = 3, padx = 1, pady = 1)

fourth row

zero = Button(btns_frame, text = "0", fg = "black", width = 21, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(0)).grid(row = 4, column = 0, columnspan = 2, padx = 1, pady = 1)

point = Button(btns_frame, text = ".", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click(".")).grid(row = 4, column = 2, padx = 1, pady = 1)

equals = Button(btns_frame, text = "=", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: bt_equal()).grid(row = 4, column = 3, padx = 1, pady = 1)

win.mainloop()

Github Link: https://github.com/arnab132/Calculator-Application-GUI-Python

JavaScript Cookies

Arnab Dey — Mon, 31 May 2021 02:48:05 +0000

Cookies let you store user information in web pages.

What are Cookies?
Cookies are data, stored in small text files, on your computer.

When a web server has sent a web page to a browser, the connection is shut down, and the server forgets everything about the user.

Cookies were invented to solve the problem "how to remember information about the user":

When a user visits a web page, his/her name can be stored in a cookie.
Next time the user visits the page, the cookie "remembers" his/her name.
Cookies are saved in name-value pairs like:

username = John Doe
When a browser requests a web page from a server, cookies belonging to the page are added to the request. This way the server gets the necessary data to "remember" information about users.

Note: None of the examples below will work if your browser has local cookies support turned off.

Create a Cookie with JavaScript

JavaScript can create, read, and delete cookies with the document.cookie property.

With JavaScript, a cookie can be created like this:

document.cookie = "username=John Doe";

You can also add an expiry date (in UTC time). By default, the cookie is deleted when the browser is closed:

document.cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC";
With a path parameter, you can tell the browser what path the cookie belongs to. By default, the cookie belongs to the current page.

document.cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/";
Read a Cookie with JavaScript
With JavaScript, cookies can be read like this:

var x = document.cookie;
document.cookie will return all cookies in one string much like: cookie1=value; cookie2=value; cookie3=value;

Change a Cookie with JavaScript

With JavaScript, you can change a cookie the same way as you create it:

document.cookie = "username=John Smith; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/";
The old cookie is overwritten.

Delete a Cookie with JavaScript

Deleting a cookie is very simple.

You don't have to specify a cookie value when you delete a cookie.

Just set the expires parameter to a past date:

document.cookie = "username=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
You should define the cookie path to ensure that you delete the right cookie.

Some browsers will not let you delete a cookie if you don't specify the path.

The Cookie String

The document.cookie property looks like a normal text string. But it is not.

Even if you write a whole cookie string to document.cookie, when you read it out again, you can only see the name-value pair of it.

If you set a new cookie, older cookies are not overwritten. The new cookie is added to document.cookie, so if you read document.cookie again you will get something like:

cookie1 = value; cookie2 = value;

Display All Cookies Create Cookie 1 Create Cookie 2 Delete Cookie 1 Delete Cookie 2

If you want to find the value of one specified cookie, you must write a JavaScript function that searches for the cookie value in the cookie string.

JavaScript Cookie Example

In the example to follow, we will create a cookie that stores the name of a visitor.

The first time a visitor arrives to the web page, he/she will be asked to fill in his/her name. The name is then stored in a cookie.

The next time the visitor arrives at the same page, he/she will get a welcome message.

For the example we will create 3 JavaScript functions:

A function to set a cookie value
A function to get a cookie value
A function to check a cookie value
A Function to Set a Cookie

First, we create a function that stores the name of the visitor in a cookie variable:

Example
function setCookie(cname, cvalue, exdays) {
var d = new Date();
d.setTime(d.getTime() + (exdays*24*60*60*1000));
var expires = "expires="+ d.toUTCString();
document.cookie = cname + "=" + cvalue + ";" + expires + ";path=/";
}
Example explained:

The parameters of the function above are the name of the cookie (cname), the value of the cookie (cvalue), and the number of days until the cookie should expire (exdays).

The function sets a cookie by adding together the cookiename, the cookie value, and the expires string.

A Function to Get a Cookie
Then, we create a function that returns the value of a specified cookie:

Example
function getCookie(cname) {
var name = cname + "=";
var decodedCookie = decodeURIComponent(document.cookie);
var ca = decodedCookie.split(';');
for(var i = 0; i <ca.length; i++) {
var c = ca[i];
while (c.charAt(0) == ' ') {
c = c.substring(1);
}
if (c.indexOf(name) == 0) {
return c.substring(name.length, c.length);
}
}
return "";
}
Function explained:

Take the cookiename as parameter (cname).

Create a variable (name) with the text to search for (cname + "=").

Decode the cookie string, to handle cookies with special characters, e.g. '$'

Split document.cookie on semicolons into an array called ca (ca = decodedCookie.split(';')).

Loop through the ca array (i = 0; i < ca.length; i++), and read out each value c = ca[i]).

If the cookie is found (c.indexOf(name) == 0), return the value of the cookie (c.substring(name.length, c.length).

If the cookie is not found, return "".

A Function to Check a Cookie
Last, we create the function that checks if a cookie is set.

If the cookie is set it will display a greeting.

If the cookie is not set, it will display a prompt box, asking for the name of the user, and stores the username cookie for 365 days, by calling the setCookie function:

Example
function checkCookie() {
var username = getCookie("username");
if (username != "") {
alert("Welcome again " + username);
} else {
username = prompt("Please enter your name:", "");
if (username != "" && username != null) {
setCookie("username", username, 365);
}
}
}

All Together Lets See

Example
function setCookie(cname, cvalue, exdays) {
var d = new Date();
d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));
var expires = "expires="+d.toUTCString();
document.cookie = cname + "=" + cvalue + ";" + expires + ";path=/";
}

JavaScript Popup boxes Tutorial

Arnab Dey — Mon, 31 May 2021 02:44:21 +0000

JavaScript has three kind of popup boxes: Alert box, Confirm box, and Prompt box.

Alert Box
An alert box is often used if you want to make sure information comes through to the user.

When an alert box pops up, the user will have to click "OK" to proceed.

Syntax
window.alert("sometext");

The window.alert() method can be written without the window prefix.

Example
alert("I am an alert box!");

Confirm Box
A confirm box is often used if you want the user to verify or accept something.

When a confirm box pops up, the user will have to click either "OK" or "Cancel" to proceed.

If the user clicks "OK", the box returns true. If the user clicks "Cancel", the box returns false.

Syntax
window.confirm("sometext");

The window.confirm() method can be written without the window prefix.

Example
if (confirm("Press a button!")) {
txt = "You pressed OK!";
} else {
txt = "You pressed Cancel!";
}

Prompt Box
A prompt box is often used if you want the user to input a value before entering a page.

When a prompt box pops up, the user will have to click either "OK" or "Cancel" to proceed after entering an input value.

If the user clicks "OK" the box returns the input value. If the user clicks "Cancel" the box returns null.

Syntax
window.prompt("sometext","defaultText");
The window.prompt() method can be written without the window prefix.

Example
var person = prompt("Please enter your name", "Harry Potter");

if (person == null || person == "") {
txt = "User cancelled the prompt.";
} else {
txt = "Hello " + person + "! How are you today?";
}

Line Breaks
To display line breaks inside a popup box, use a back-slash followed by the character n.

Example
alert("Hello\nHow are you?");

Balloon Shooter Game Using Python

Arnab Dey — Mon, 31 May 2021 02:20:28 +0000

Balloon Shooter

Balloon shooting is a simple archery game or Balloon smasher game. Balloon bursting game has simple rules but require great skill of shooting. Balloon popping or balloon shooting is best game to play in your leisure time. This game is similar to classic Bubble breaker or bubble pop game. You will get limited arrows to shoot the balloons and you have to utilize it in best possible way to score high by bursting the balloons. The smaller the balloon you shoot, more the score you get. The objective of this balloon shooting game is to pop as many balloons as possible using as few arrows as possible. You can shoot multiple balloons with one arrow as well, make best use of your arrows to shoot multiple balloons coming in line. In this game a lot of options are available to score more with special balloons coming in the way like balloon with bomb, 3 balloons at a time, wheels and small balloon. It all depends on your shooting skill and logical thinking how you can score more.

This fun learning game is all time favourite among kids and adults. Rule of Balloon shooting game is simple and fun is never less, game still remains challenging. Show your mastery in this amazing game by pulling the rope and adjusting the angle of arrows to shoot maximum balloons in one shot, aim carefully. Multiply your scores by aiming at multiple balloons with one shot. It is like sniper games where the bullets are replaced with bundles of arrows, and you get a predictable, physics-based ricochet effect. Balloons of all colors, shapes and sizes are coming down your way. Prepare your strategy and become master in balloon shooting.

Be warned this addictive game is hard to stop. It is very intuitive and easy to learn but you need to master it to score high. Amazing graphics, interesting sound effects and smooth animation spices up the entertainment in the game. Compile this interesting game and let the fun begin.

Let us learn how to develop balloon shooting game and its technique with Pygame

------------------------------------

Balloon Shooter
Language - Python
Modules - pygame, sys, random, math
Controls - Mouse
By - Arnab Dey

------------------------------------

import pygame
import sys
import random
from math import *

pygame.init()

width = 500
height = 500

display = pygame.display.set_mode((width, height))
pygame.display.set_caption("Balloon Shooter")
clock = pygame.time.Clock()

margin = 100
lowerBound = 100

score = 0

Colors

white = (230, 230, 230)
lightBlue = (174, 214, 241)
red = (231, 76, 60)
lightGreen = (25, 111, 61)
darkGray = (40, 55, 71)
darkBlue = (21, 67, 96)
green = (35, 155, 86)
yellow = (244, 208, 63)
blue = (46, 134, 193)
purple = (155, 89, 182)
orange = (243, 156, 18)

font = pygame.font.SysFont("Snap ITC", 25)

Balloon Class

class Balloon:
def init(self, speed):
self.a = random.randint(30, 40)
self.b = self.a + random.randint(0, 10)
self.x = random.randrange(margin, width - self.a - margin)
self.y = height - lowerBound
self.angle = 90
self.speed = -speed
self.probPool = [-1, -1, -1, 0, 0, 0, 0, 1, 1, 1]
self.length = random.randint(50, 100)
self.color = random.choice([red, green, purple, orange, yellow, blue])

# Move balloon around the Screen
def move(self):
    direct = random.choice(self.probPool)

    if direct == -1:
        self.angle += -10
    elif direct == 0:
        self.angle += 0
    else:
        self.angle += 10

    self.y += self.speed*sin(radians(self.angle))
    self.x += self.speed*cos(radians(self.angle))

    if (self.x + self.a > width) or (self.x < 0):
        if self.y > height/5:
            self.x -= self.speed*cos(radians(self.angle)) 
        else:
            self.reset()
    if self.y + self.b < 0 or self.y > height + 30:
        self.reset()

# Show/Draw the balloon  
def show(self):
    pygame.draw.line(display, darkBlue, (self.x + self.a/2, self.y + self.b), (self.x + self.a/2, self.y + self.b + self.length))
    pygame.draw.ellipse(display, self.color, (self.x, self.y, self.a, self.b))
    pygame.draw.ellipse(display, self.color, (self.x + self.a/2 - 5, self.y + self.b - 3, 10, 10))

# Check if Balloon is bursted
def burst(self):
    global score
    pos = pygame.mouse.get_pos()

    if onBalloon(self.x, self.y, self.a, self.b, pos):
        score += 1
        self.reset()

# Reset the Balloon
def reset(self):
    self.a = random.randint(30, 40)
    self.b = self.a + random.randint(0, 10)
    self.x = random.randrange(margin, width - self.a - margin)
    self.y = height - lowerBound 
    self.angle = 90
    self.speed -= 0.002
    self.probPool = [-1, -1, -1, 0, 0, 0, 0, 1, 1, 1]
    self.length = random.randint(50, 100)
    self.color = random.choice([red, green, purple, orange, yellow, blue])

balloons = []
noBalloon = 10
for i in range(noBalloon):
obj = Balloon(random.choice([1, 1, 2, 2, 2, 2, 3, 3, 3, 4]))
balloons.append(obj)

def onBalloon(x, y, a, b, pos):
if (x < pos[0] < x + a) and (y < pos[1] < y + b):
return True
else:
return False

show the location of Mouse

def pointer():
pos = pygame.mouse.get_pos()
r = 25
l = 20
color = lightGreen
for i in range(noBalloon):
if onBalloon(balloons[i].x, balloons[i].y, balloons[i].a, balloons[i].b, pos):
color = red
pygame.draw.ellipse(display, color, (pos[0] - r/2, pos[1] - r/2, r, r), 4)
pygame.draw.line(display, color, (pos[0], pos[1] - l/2), (pos[0], pos[1] - l), 4)
pygame.draw.line(display, color, (pos[0] + l/2, pos[1]), (pos[0] + l, pos[1]), 4)
pygame.draw.line(display, color, (pos[0], pos[1] + l/2), (pos[0], pos[1] + l), 4)
pygame.draw.line(display, color, (pos[0] - l/2, pos[1]), (pos[0] - l, pos[1]), 4)

def lowerPlatform():
pygame.draw.rect(display, darkGray, (0, height - lowerBound, width, lowerBound))

def showScore():
scoreText = font.render("Balloons Bursted : " + str(score), True, white)
display.blit(scoreText, (150, height - lowerBound + 50))

def close():
pygame.quit()
sys.exit()

def game():
global score
loop = True

while loop:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            close()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_q:
                close()
            if event.key == pygame.K_r:
                score = 0
                game()

        if event.type == pygame.MOUSEBUTTONDOWN:
            for i in range(noBalloon):
                balloons[i].burst()

    display.fill(lightBlue)

    for i in range(noBalloon):
        balloons[i].show()

    pointer()

    for i in range(noBalloon):
        balloons[i].move()


    lowerPlatform()
    showScore()
    pygame.display.update()
    clock.tick(60)

game()

Github Source Code : https://github.com/arnab132/Balloon-Shooter-Game-Python

Python vs Java. Key differences, Features and History

Arnab Dey — Mon, 31 May 2021 02:01:35 +0000

Key Differences between Python and Java

1.Java is a compiled+ interpreted Language whereas Python is an Interpreted Language

2.Java is statically typed whereas Python is dynamically typed

3.Java has a complex learning curve whereas Python is easy to learn and use

4.Java is a multi-platform, object-oriented, and network-centric, programming language whereas Python is a high-level object-oriented programming language.

5.Java takes 10 lines of code to read from a file while Python only needs 2 lines of code.

6.Java language uses curly braces to define the beginning and end of each function and class definition, whereas Python uses indentation to separate code into separate blocks.

7.In Java, multiple inheritances is partially done through interfaces, whereas Python supports both single and multiple inheritances.

8.Java offers limited string related functions, whereas Python offers lots of string related functions.

9.Java program can run on any computer or mobile device which is able to run the Java virtual machine (JVM) while Python programs need an interpreter installed on the target machine to translate Python code. Compared to Java, Python is less portable.

10.Java is best for Desktop GUI apps, Embed Systems, Web application services, whereas Python is excellent for scientific and numeric computing, Machine learning apps, more.

11.Java offers stable connectivity, while Python offers weak connectivity.

What is Python?

Python is a high-level object-oriented programming language. It has built-in data structures, combined with dynamic binding and typing, which makes it an ideal choice for rapid application development. Python also offers support for modules and packages, which allows system modularity and code reuse.

It is one of the fastest programming languages as it requires very few lines of code. Its emphasis is on readability and simplicity, which make it a great choice for beginners.

Features of Python

1.Very simple syntax compared to Java, C and C++ languages.

2.Used for Machine Learning, Deep Learning, and the general overarching AI field. Very useful in data analysis and visualization.

3.Extensive library and handy tools for developers

4.Python is cross-compatible

5.Python has its auto-installed shell

6.Compared with the code of other languages, python code is easy to write and debug. Therefore, its source code is relatively easy to maintain.

7.Python is a portable language so that it can run on a wide variety of Operating systems and platforms.
Python comes with many prebuilt libraries, which makes your development task easy.

8.Python helps you to make complex programming simpler. As it internally deals with memory addresses, garbage collection.

9.Python provides an interactive shell that helps you to test the things before it's actual implementation.

10.Python offers database interfaces to all major commercial DBMS system.

11.Supports imperative and functional programming.

12.Python is famous for its use in IoT.

Features of Java

Here are the important features of Java.

1.Write code once and run it on almost any computing platform.

2.It is designed for building object-oriented applications.

3.It is a multithreaded language with automatic memory management

4.Facilitates distributed computing as its network-centric

History of Python

Here, are important landmarks for Python language

Python was first conceived in the late 1980s, but its implementation started only in December 1989
It was invented in the Netherlands, by Guido van Rossum.
Rossum published the first version of Python (0.9.0) in February 1999
It was derived from ABC programming language, which is a general-purpose programming language.
Nowadays, Python is maintained by a core development team although Rossum still plays a vital role in directing its progress.

History of Java

Here, are important landmarks for Java language

The Java language was initially called OAK. Originally, it was developed for handling portable devices and set-top boxes. Oak was a massive failure.
In 1995, Sun changed the name to "Java" and modified the language to take advantage of the burgeoning www (World Wide Web) development business.
Later, in 2009, Oracle Corporation acquired Sun Microsystems and took ownership of three key Sun software assets: Java, MySQL, and Solaris.

Banker's Safety Algorithm - Python Implementation

Arnab Dey — Mon, 31 May 2021 00:35:58 +0000

Implementation of Banker's Safety algorithm using Python

The banker’s algorithm is a resource allocation and deadlock avoidance algorithm that tests for safety by simulating the allocation for predetermined maximum possible amounts of all resources, then makes an “s-state” check to test for possible activities, before deciding whether allocation should be allowed to continue.

Following Data structures are used to implement the Banker’s Algorithm:

Let ‘n’ be the number of processes in the system and ‘m’ be the number of resources types.

Available :

It is a 1-d array of size ‘m’ indicating the number of available resources of each type. Available[ j ] = k means there are ‘k’ instances of resource type Rj Max :

It is a 2-d array of size ‘n*m’ that defines the maximum demand of each process in a system. Max[ i, j ] = k means process Pi may request at most ‘k’ instances of resource type Rj.

Allocation :

It is a 2-d array of size ‘n*m’ that defines the number of resources of each type currently allocated to each process. Allocation[ i, j ] = k means process Pi is currently allocated ‘k’ instances of resource type Rj Need :

It is a 2-d array of size ‘n*m’ that indicates the remaining resource need of each process. Need [ i, j ] = k means process Pi currently allocated ‘k’ instances of resource type Rj Need [ i, j ] = Max [ i, j ] – Allocation [ i, j ] Allocationi specifies the resources currently allocated to process Pi and Needi specifies the additional resources that process Pi may still request to complete its task.

Banker’s algorithm consist of Safety algorithm and Resource request algorithm

Safety Algorithm

The algorithm for finding out whether or not a system is in a safe state can be described as follows:

Let Work and Finish be vectors of length ‘m’ and ‘n’ respectively.

Initialize: Work= Available Finish [i]=false; for i=1,2,……,n

Find an i such that both a) Finish [i]=false b) Need_i<=work

if no such i exists goto step (4) Work=Work + Allocation_i Finish[i]= true goto step(2) If Finish[i]=true for all i, then the system is in safe state. Safe sequence is the sequence in which the processes can be safely executed.

In this post, implementation of Safety algorithm of Banker’s Algorithm is done.

We must determine whether the new system state is safe. To do so, we need to execute Safety algorithm on the above given allocation chart.

Following is the resource allocation graph:

Executing safety algorithm shows that sequence < P1, P3, P4, P0, P2 > satisfies safety requirement.

Code:

Python code to illustrate Banker's Algorithm

P = 5 (Processes)
R = 3 (Resources)

Function to find the need of each process

def calculateNeed(need, maxm, allot):

# Calculating Need of each P
for i in range(P):
    for j in range(R):

        # Need of instance = maxm instance -
        # allocated instance
        need[i][j] = maxm[i][j] - allot[i][j]

Function to find the system is in

safe state or not

def isSafe(processes, avail, maxm, allot):
need = []
for i in range(P):
l = []
for j in range(R):
l.append(0)
need.append(l)

Function to calculate need matrix
calculateNeed(need, maxm, allot)

Mark all processes as infinish
finish = [0] * P

To store safe sequence
safeSeq = [0] * P

Make a copy of available resources
work = [0] * R
for i in range(R):
    work[i] = avail[i]

While all processes are not finished or system is not in safe state.
count = 0
while (count < P):

    # Find a process which is not finish
    # and whose needs can be satisfied
    # with current work[] resources.
    found = False
    for p in range(P):

        # First check if a process is finished,
        # if no, go for next condition
        if (finish[p] == 0):

            # Check if for all resources
            # of current P need is less
            # than work
            for j in range(R):
                if (need[p][j] > work[j]):
                    break

            # If all needs of p were satisfied.
            if (j == R - 1):

                # Add the allocated resources of
                # current P to the available/work
                # resources i.e.free the resources
                for k in range(R):
                    work[k] += allot[p][k]

                # Add this process to safe sequence.
                safeSeq[count] = p
                count += 1

                # Mark this p as finished
                finish[p] = 1

                found = True

    # If we could not find a next process
    # in safe sequence.
    if (found == False):
        print("System is not in Safe state")
        return False

# If system is in safe state then
# safe sequence will be as below
print("System is in Safe state.",
        "\n Safe sequence is: ", end = " ")
print(*safeSeq)

return True

Driver code

if name =="main":

processes = [0, 1, 2, 3, 4]

# Available instances of resources
avail = [3, 3, 2]

# Maximum R that can be allocated
# to processes
maxm = [[7, 5, 3], [3, 2, 2],
        [9, 0, 2], [2, 2, 2],
        [4, 3, 3]]

# Resources allocated to processes
allot = [[0, 1, 0], [2, 0, 0],
        [3, 0, 2], [2, 1, 1],
        [0, 0, 2]]

# Check system is in safe state or not
isSafe(processes, avail, maxm, allot)

Time complexity = O(nnm) where n = number of processes and m = number of resources.

Prims Algorithm using Python

Arnab Dey — Mon, 31 May 2021 00:20:56 +0000

Prims Algorithm Graph Theory

Prim’s algorithm is also a Greedy algorithm. It starts with an empty spanning tree. The idea is to maintain two sets of vertices. The first set contains the vertices already included in the MST, the other set contains the vertices not yet included. At every step, it considers all the edges that connect the two sets, and picks the minimum weight edge from these edges. After picking the edge, it moves the other endpoint of the edge to the set containing MST.

A group of edges that connects two set of vertices in a graph is called cut in graph theory. So, at every step of Prim’s algorithm, we find a cut (of two sets, one contains the vertices already included in MST and other contains rest of the vertices), pick the minimum weight edge from the cut and include this vertex to MST Set (the set that contains already included vertices).

How does Prim’s Algorithm Work? The idea behind Prim’s algorithm is simple, a spanning tree means all vertices must be connected. So the two disjoint subsets (discussed above) of vertices must be connected to make a Spanning Tree. And they must be connected with the minimum weight edge to make it a Minimum Spanning Tree.

Algorithm
1) Create a set mstSet that keeps track of vertices already included in MST.
2) Assign a key value to all vertices in the input graph. Initialize all key values as INFINITE. Assign key value as 0 for the first vertex so that it is picked first.
3) While mstSet doesn’t include all vertices
….a) Pick a vertex u which is not there in mstSet and has minimum key value.
….b) Include u to mstSet.
….c) Update key value of all adjacent vertices of u. To update the key values, iterate through all adjacent vertices. For every adjacent vertex v, if weight of edge u-v is less than the previous key value of v, update the key value as weight of u-v

The idea of using key values is to pick the minimum weight edge from cut. The key values are used only for vertices which are not yet included in MST, the key value for these vertices indicate the minimum weight edges connecting them to the set of vertices included in MST.

How to implement the above algorithm?
We use a boolean array mstSet[] to represent the set of vertices included in MST. If a value mstSet[v] is true, then vertex v is included in MST, otherwise not. Array key[] is used to store key values of all vertices. Another array parent[] to store indexes of parent nodes in MST. The parent array is the output array which is used to show the constructed MST.

The set mstSet is initially empty and keys assigned to vertices are {0, INF, INF, INF, INF, INF, INF, INF} where INF indicates infinite. Now pick the vertex with the minimum key value. The vertex 0 is picked, include it in mstSet. So mstSet becomes {0}. After including to mstSet, update key values of adjacent vertices. Adjacent vertices of 0 are 1 and 7. The key values of 1 and 7 are updated as 4 and 8. Following subgraph shows vertices and their key values, only the vertices with finite key values are shown. The vertices included in MST are shown in green color.

Pick the vertex with minimum key value and not already included in MST (not in mstSET). The vertex 1 is picked and added to mstSet. So mstSet now becomes {0, 1}. Update the key values of adjacent vertices of 1. The key value of vertex 2 becomes 8.

Pick the vertex with minimum key value and not already included in MST (not in mstSET). We can either pick vertex 7 or vertex 2, let vertex 7 is picked. So mstSet now becomes {0, 1, 7}. Update the key values of adjacent vertices of 7. The key value of vertex 6 and 8 becomes finite (1 and 7 respectively).

Pick the vertex with minimum key value and not already included in MST (not in mstSET). Vertex 6 is picked. So mstSet now becomes {0, 1, 7, 6}. Update the key values of adjacent vertices of 6. The key value of vertex 5 and 8 are updated.

We repeat the above steps until mstSet includes all vertices of given graph. Finally, we get the following graph.

Python program for Prim's Minimum Spanning Tree (MST) algorithm

The program is for adjacency matrix representation of the graph

Code:

import sys
class Graph():

def __init__(self, vertices):
    self.V = vertices
    self.graph = [[0 for column in range(vertices)]
                for row in range(vertices)]

# A utility function to print the constructed MST stored in parent[]
def printMST(self, parent):
    print "Edge \tWeight"
    for i in range(1, self.V):
        print parent[i], "-", i, "\t", self.graph[i][ parent[i] ]

# A utility function to find the vertex with
# minimum distance value, from the set of vertices
# not yet included in shortest path tree
def minKey(self, key, mstSet):

    # Initilaize min value
    min = sys.maxint

    for v in range(self.V):
        if key[v] < min and mstSet[v] == False:
            min = key[v]
            min_index = v

    return min_index

# Function to construct and print MST for a graph
# represented using adjacency matrix representation
def primMST(self):

    # Key values used to pick minimum weight edge in cut
    key = [sys.maxint] * self.V
    parent = [None] * self.V # Array to store constructed MST
    # Make key 0 so that this vertex is picked as first vertex
    key[0] = 0
    mstSet = [False] * self.V

    parent[0] = -1 # First node is always the root of

    for cout in range(self.V):

        # Pick the minimum distance vertex from
        # the set of vertices not yet processed.
        # u is always equal to src in first iteration
        u = self.minKey(key, mstSet)

        # Put the minimum distance vertex in
        # the shortest path tree
        mstSet[u] = True

        # Update dist value of the adjacent vertices
        # of the picked vertex only if the current
        # distance is greater than new distance and
        # the vertex in not in the shotest path tree
        for v in range(self.V):

            # graph[u][v] is non zero only for adjacent vertices of m
            # mstSet[v] is false for vertices not yet included in MST
            # Update the key only if graph[u][v] is smaller than key[v]
            if self.graph[u][v] > 0 and mstSet[v] == False and key[v] > self.graph[u][v]:
                    key[v] = self.graph[u][v]
                    parent[v] = u

    self.printMST(parent)

g = Graph(5)
g.graph = [ [0, 2, 0, 6, 0],
[2, 0, 3, 8, 5],
[0, 3, 0, 0, 7],
[6, 8, 0, 0, 9],
[0, 5, 7, 9, 0]]

g.primMST();

Time Complexity of the above program is O(V^2). If the input graph is represented using adjacency list, then the time complexity of Prim’s algorithm can be reduced to O(E log V) with the help of binary heap.

Cyber Security: Indian View

Arnab Dey — Tue, 05 Jan 2021 19:00:29 +0000

The rapid growth of the internet and computer technology over the past few years has led to the growth in new forms of crime — dubbed cyber crime — throughout the world. The term “cyber crime” has nowhere been defined in any statute or Act passed or enacted by the Indian Parliament. Today, the world is moving towards a point where everything from banking to stock exchanges and traffic control, telephones to electric power, health care, welfare and education depends on software. This exponential growth, and the increase in the capacity and accessibility of computers coupled with the decrease in cost, has brought about revolutionary changes in every aspect of human civilization, including crime. It is rapidly evolving from simple e-mail mischief where offenders send obscene e-mail, to more serious offences like theft of information, e-mail bombing to crashing servers, etc. It is sure all of us have encountered unwanted product advertisements. Piracy is also a serious threat that involves illegal reproduction and distribution of software applications, games, movies and audio CDs which is causing a huge monetary loss to entertainment industry worldwide.

Hacking is also a serious crime by a hacker who is simply a talented computer user who misuses his vast knowledge. Virus attacks that say “I love you” enter our computer and destroy all the computer information are also a serious threat. Computer frauds, thefts and harassment through social networking sites like Twitter and Facebook are also risking our lives.

Undoubtedly we cannot single out only one crime that is posing maximum threat but all forms of crimes are equally posing a serious threat to both business and individuals. Cyber Crime in the Act is neither comprehensive nor exhaustive. Cases of spam, hacking, stalking and e-mail fraud are rampant although cyber crimes cells have been set-up in major Indian cities. The problem is that most cases remain unreported due to lack of awareness. Capacity of human mind is unfathomable. It is not possible to eliminate cyber crime from the cyber space. However, it is quite possible to check them.

The home user segment is the largest recipient of cyber attacks as they are less likely to have established security measures in place and therefore it is necessary that people should be made aware of their rights and duties. The fight against cyber crime starts in our very own home. We should not reply any e-mail from unknown persons; learn to report spam mails to the e-mail servers. We should not upload our personal information on social networking sites or our account details on other such sites.

Also the use of antivirus software can be a great help to fight against viruses and worms. Users must try and save any electronic information trail on their computers, firewalls, use of intrusion detection system, etc. and further making the application of the laws more stringent to check crime. Potentially, everything from generic word processing software to customized computer programs designed for a specific company could work on a cloud computing system.

It is a good idea to rely on another computer system to run programs and store data as it would enable clients to access their applications and data from anywhere at any time. They could access the cloud computing system using any computer linked to the Internet. Data would not be confined to a hard drive on one user’s computer or even a corporation’s internal network.

Also, it could bring hardware costs down as the client would not need to buy the fastest computer with the most memory, because the cloud system would take care of the rest. Often, scientists and researchers work with calculations so complex that it would take years for individual computers to complete them. The cloud system would tap into the processing power of all available computers on the back end, significantly speeding up the calculation.

There will always be new and unexpected challenges to stay ahead of cyber criminals and cyber terrorists but we can win only through partnership and collaboration of both individuals and government. There is much we can do to ensure a safe, secure and trustworthy computing environment. It is crucial not only to our national sense of well-being, but also to our national security and economy.

Pygame: A Beginner's Guide

Arnab Dey — Tue, 05 Jan 2021 18:44:36 +0000

Pygame is a set of Python modules designed for writing video games. Pygame adds functionality on top of the excellent SDL library. This allows you to create fully featured games and multimedia programs in the python language.

Pygame is highly portable and runs on nearly every platform and operating system.

Pygame itself has been downloaded millions of times.

Game programming is very rewarding nowadays and it can also be used in advertising and as a teaching tool too. Game development includes mathematics, logic, physics, AI, and much more and it can be amazingly fun. In python, game programming is done in pygame and it is one of the best modules for doing so.

Installing pygame:
Pygame requires Python; if you don’t already have it, you can download it from python.org. Use python 3.6.1 or greater, because it is much friendlier to newbies, and additionally runs faster.
The best way to install pygame is with the pip tool (which python uses to install packages). Note, this comes with python in recent versions. We use the –user flag to tell it to install into the home directory, rather than globally.

python3 -m pip install -U pygame --user

To see if it works, run one of the included examples:

python3 -m pygame.examples.aliens

If it works, we are ready to go!
Once you have installed pygame, you’re ready to create your very first pygame instance.

Pygame is free. Released under the LGPL licence, you can create open source, freeware, shareware, and commercial games with it. See the licence for full details.

For a nice introduction to pygame, examine the line-by-line chimp tutorial, and the introduction for python programmers. buffer, and many other different backends... including an ASCII art backend! OpenGL is often broken on linux systems, and also on windows systems - which is why professional games use multiple backends.

Code

import the pygame module

import pygame

import pygame.locals for easier

access to key coordinates

from pygame.locals import *

Define our square object and call super to

give it all the properties and methods of pygame.sprite.Sprite

Define the class for our square objects

class Square(pygame.sprite.Sprite):
def init(self):
super(Square, self).init()

    # Define the dimension of the surface
    # Here we are making squares of side 25px
    self.surf = pygame.Surface((25, 25))

    # Define the color of the surface using RGB color coding.
    self.surf.fill((0, 200, 255))
    self.rect = self.surf.get_rect()

initialize pygame

pygame.init()

Define the dimensions of screen object

screen = pygame.display.set_mode((800, 600))

instantiate all square objects

square1 = Square()
square2 = Square()
square3 = Square()
square4 = Square()

Variable to keep our game loop running

gameOn = True

Our game loop

while gameOn:
# for loop through the event queue
for event in pygame.event.get():

    # Check for KEYDOWN event
    if event.type == KEYDOWN:

        # If the Backspace key has been pressed set
        # running to false to exit the main loop
        if event.key == K_BACKSPACE:
            gameOn = False

    # Check for QUIT event
    elif event.type == QUIT:
        gameOn = False

# Define where the squares will appear on the screen
# Use blit to draw them on the screen surface
screen.blit(square1.surf, (40, 40))
screen.blit(square2.surf, (40, 530))
screen.blit(square3.surf, (730, 40))
screen.blit(square4.surf, (730, 530))

# Update the display using flip
pygame.display.flip()