This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

There are no additional requirements for this article.

What exactly is a Sudoku Puzzle?

According to Wikipedia, Sudoku (originally called Number Place) is a logic-based, combinatorial number-placement puzzle.

The objective is to fill a 9×9 grid with digits so that each column, each row, and each of the nine 3×3 subgrids that compose the grid (also called “boxes”, “blocks”, or “regions”) contain all of the digits from 1 to 9.

The puzzle setter provides a partially completed grid, which for a well-posed puzzle has a single solution.

Note: The number of classic 9×9 Sudoku solution grids is 6,670,903,752,021,072,936,960 (sequence A107739 in the OEIS), or around 6.67×1021.

So, generating all the grids and choosing the solution is not efficient. To minimize this task, we can use a Backtracking approach.

What is Backtracking?

It is algorithmic-technique for finding all solutions to the same computational problems, notably constraint satisfaction problems, that incrementally builds candidates to the solutions, and abandons a candidate as soon as it determines that the candidate cannot possibly be completed to a valid solution.

In our problem, we need to traverse each block of the grid, check which digit can be placed in this block, repeat till we have a solution. If a digit cannot be placed in the current block, we go to the previous block and try placing another digit in that block, changing the next possible solution.

This basically means, whenever we arrive at a dead-end, we go back to the previous choice we made and change our choice, such that we will have a different possible solution.

Let’s first find a sudoku problem to solve

1 million Sudoku games

You can either download the CSV file or copy a string of the sudoku puzzle problem and create a grid in the code.

Forming the Puzzle

#Forming the Puzzle Grid
def form_grid(puzzle_string):
    global grid
    print('The Sudoku Problem')
    for i in range(0, len(puzzle_string), 9):
        row = puzzle_string[i:i+9]
        temp = []
        for block in row:
            temp.append(int(block))
        grid.append(temp)    
    printGrid()

Function to print the Grid

#Function to print the grid
def printGrid():
    global grid
    for row in grid:
        print(row)

Function to check if a digit can be placed in the current block

#Function to check if a digit can be placed in the given block
def possible(row,col,digit):
    global grid
    for i in range(0,9):
        if grid[row][i] == digit:
            return False
    for i in range(0,9):
        if grid[i][col] == digit:
            return False
    square_row = (row//3)*3
    square_col = (col//3)*3
    for i in range(0,3):
        for j in range(0,3):
            if grid[square_row+i][square_col+j] == digit:
                return False    
    return True

Traversing through all blocks w/ Backtracking

def solve():
    global grid
    for row in range(9):
        for col in range(9):
            if grid[row][col] == 0:
                for digit in range(1,10):
                    if possible(row,col,digit):
                        grid[row][col] = digit
                        solve()
                        grid[row][col] = 0  #Backtrack step
                return
    print('\nThe Solution')
    printGrid()

Finally, passing the Grid and calling the function to Solve the Puzzle

puzzle_string = "004300209005009001070060043006002087190007400050083000600000105003508690042910300"
grid = []
form_grid(puzzle_string)
solve()

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Solving Sudoku Puzzle using Backtracking in Python | Daily Python #29 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

Requirements:

1. Python 3.0
2. Pip

Install the following packages:

1. PyPDF2 — PDF toolkit based on Python

pip install PyPDF2

Let’s import the required modules

from os import listdir,mkdir,startfile
from os.path import isfile, join,exists
from PyPDF2 import PdfFileMerger

1. listdir — used to list the files in the given directory
2. mkdir — used to create a new directory
3. startfile — used to launch a file
4. isfile — used to check if an input is a file
5. join — used to join one or more path components intelligently
6. exists — used to check if a folder or file exists
7. PDFFileMerger — used to merge the pdf files

Let’s take the path from where the PDF files are to be fetched and print the file names

#Input file path and print the pdf files in that path
path = input("Enter the folder location: ")
pdffiles = [f for f in listdir(path) if isfile(join(path, f)) and '.pdf' in f]
print('\nList of PDF Files:\n')
for file in pdffiles:
    print(file)

Accept the name of the result file

#Input the name of the result file
resultFile = input("\nEnter the name of the result file : ")
if '.pdf' not in resultFile:
    resultFile += '.pdf'

Traverse through the pdf files and append them

#Append the pdf files
merger = PdfFileMerger()
for pdf in pdffiles:
    merger.append(path+'\\'+pdf)

Create an Output directory if none exists

#If the Output directory does not exist then create one
if not exists(path+'\\Output'):
    mkdir(path+'\\Output')

Now, merge the files and write it to the output directory

#Write the merged result file to the Output directory
merger.write(path+'\\Output\\'+resultFile)
merger.close()

Finally, we launch the result file, a merged pdf of the given pdf files

#Launch the result file
print('\n'+resultFile,'Successfully created!!! at ',path+'\\Output\\')
startfile(path+'\\Output\\'+resultFile)

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Python script to merge PDF Files | Daily Python #28 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a tutorial on implementing the Fibonacci Search algorithm in Python and is in continuation with Daily Python #21

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

There are no additional requirements for this article.

If you haven’t read Part 1 of basic searching algorithms then you can read it from here:

Implementing basic searching algorithms in Python — Part 1 | Daily Python #21

Fibonacci Search

Fibonacci Search is a comparison-based technique that uses Fibonacci numbers to search an element in a sorted array.

1. Works for sorted arrays
2. A Divide and Conquer Algorithm.
3. Has Log n time complexity.

Differences with Binary Search:

1. Fibonacci Search divides given array in unequal parts
2. Binary Search uses the division operator to divide range. Fibonacci Search doesn’t use /, but uses + and -. The division operator may be costly on some CPUs.
3. Fibonacci Search examines relatively closer elements in subsequent steps. So when the input array is big that cannot fit in CPU cache or even in RAM, Fibonacci Search can be useful.

Background:

Fibonacci Numbers are recursively defined as F(n) = F(n-1) + F(n-2), F(0) = 0, F(1) = 1. First few Fibonacci Numbers are 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …

Let’s define a function to generate a Fibonacci number at the index of n

def FibonacciGenerator(n):
    if n < 1:
        return 0
    elif n == 1:
        return 1
    else:
        return FibonacciGenerator(n - 1) + FibonacciGenerator(n - 2)

Let’s consider the following array and the number to be searched

arr = [10, 22, 30, 44, 56, 58, 60, 70, 100, 110, 130] 
x = 60

Now, let’s define a function that will divide the list and search for the number as per the Fibonacci Search

def FibonacciSearch(arr, x):
    m = 0 
    while FibonacciGenerator(m) < len(arr): # 
        m = m + 1 
    offset = -1    
    while (FibonacciGenerator(m) > 1):
        i = min( offset + FibonacciGenerator(m - 2) , len(arr) - 1)
        print('Current Element : ',arr[i])
        if (x > arr[i]):
            m = m - 1
            offset = i
        elif (x < arr[i]):
            m = m - 2
        else:
            return i        
    if(FibonacciGenerator(m - 1) and arr[offset + 1] == x):
        return offset + 1
    return -1

print('Number found at index : ',FibonacciSearch(arr, x))

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Implementing Fibonacci Search algorithm in Python | Daily Python #27 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a tutorial to build a bot that tweets inspirational quotes every minute using Python.

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

Requirements:

1. Python 3.0
2. Pip

Install the following packages:

1. tweepy — Library that provides easy access to Twitter APIs
2. requests — Library to making HTTP requests.
3. json — Library to handle JSON objects
4. time

pip install tweepy requests

Let’s import the required modules

import requests
import tweepy
import time
import json

The first step is to set up the Twitter Bot using ‘tweepy’

Note: Follow the instructions in the following article and create your app

Python script to fetch tweets based on hashtags(#)| Daily Python #2

After you have created your twitter application and generated the API Keys and Access tokens, define a function to set up the twitter bot.

def setup_Bot():
    consumerKey = "YOUR_API_KEY"
    consumerSecret = "YOUR_API_KEY_SECRET"
    accessToken = "YOUR_ACCESS_TOKEN"
    accessTokenSecret = "YOUR_ACCESS_TOKEN_SECRET"
    auth = tweepy.OAuthHandler(consumerKey, consumerSecret)
    auth.set_access_token(accessToken, accessTokenSecret)
    api = tweepy.API(auth)
    return api

Now, let’s write a function that will fetch an inspirational quote for the bot

The following API provides random inspirational quotes:

Quotes and expressions. The most inspiring expressions of mankind.

We need to make a call to this method in order to fetch a random inspirational quote for our twitter bot.

def get_Quote():
    params = {
        'method':'getQuote',
        'lang':'en',
        'format':'json'
    }
    res = requests.get('http://api.forismatic.com/api/1.0/',params)
    jsonText =json.loads(response.text)
    return jsonText["quoteText"],jsonText["quoteAuthor"]

Using the JSON module we can convert the response text to a JSON object and access its individual key-value pairs.

Finally, let’s write a loop that will tweet an inspirational quote every minute

api = setup_Bot()
while True:
    try:
        quote,author = get_Quote()
        status = quote+" -"+author+"\n"+"#python \
        #dailypython #twitterbot #pythonquotes #programming"
        print('\nUpdating : ',status)
        api.update_status(status=status)
        print("\nGoing to Sleep for 1 min")
        time.sleep(60)
    except Exception as ex:
        print(ex)
        break

Modify this code and make your twitter bot do what you want. Read the terms and conditions given by twitter for developing twitter bots.

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Requirements:

1. Python 3.0
2. Pip

Install the following packages:

1. requests — Library to making HTTP requests.
2. pprint — PrettyPrinter:

pip install requests pprint

First, let’s sign up on the Goibibo’s API portal

Fill in the details and activate your account from the email received. You will now be able to access the API key and the Application ID, which will be used for making calls with the APIs.

First, let’s import the requests module

import requests
from pprint import PrettyPrinter
pp = PrettyPrinter()

Store the App ID and the API Key into variables for future use

AppID = "YOUR_GOIBIBO_APP_ID"
AppKey = "YOUR_GOIBIBO_APP_KEY"

The parameters required for fetching flights using the API

Let’s create a dictionary to store the values of these parameters

params = {
    "app_id":AppID,
    "app_key":AppKey,
    "format":"json",
    "source":"PNQ",
    "destination":"BOM",
    "dateofdeparture":"20200215",
    "dateofarrival":"",
    "":"",
    "seatingclass":"E",
    "adults":"1",
    "children":"0",
    "counter":"100",  
}

Let’s hit the API Url and fetch the result for the above parameters

URL = "http://developer.goibibo.com/api/search/"

response = requests.get(URL,params=params).json()
pp.pprint(response)

We can loop this code and try to find the best flight price for the given locations and then simply send an email reminder using the mail service which was discussed in Daily Python #1.

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Python script to search flights using Goibibo API | Daily Python #25 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

Requirements:

1. Python 3.0
2. Pip

Install the following packages:

1. pyperclip — Library to handle clipboard content
2. emoji — Library to generate emojis
3. howdoi — Library to guide through python
4. antigravity
5. wikipedia — Library to fetch wikipedia content
6. dis — Library to uncover how Python works internally

Pyperclip

I have discussed how to handle clipboard content using ‘pynput’. This library is an alternative to that and quite easy to implement. We just need to use the copy and paste functions to copy from or to write to the clipboard. Below is an example of how you can use ‘pyperclip’.

#1. Pyperclip
import pyperclip
pyperclip.copy('Heyyy this is being copied to clipboard')
print(pyperclip.paste())

Emoji

This library makes it easy to create emojis in Python. If you are building a chatbot and want to recommend emojis based on text, then you can suggest relevant emojis by applying regular expressions on the input string. The ‘emojize’ function returns the Unicode characters for the given emoji name.

#2. Emoji
from emoji import emojize
print(emojize(':thumbs_up:'),emojize(':snake:'))

How Do I?

This library is quite handy if you want to avoid going to google and searching for how to do a particular operation in Python. You can directly access this module through the terminal or you can import it in a Python script and pass the required query. The following code snippet demonstrates how to open a file in Python using ‘howdoi ’module.

#3. Howdoi
from howdoi import howdoi
query = "open a file in python"
parser = howdoi.get_parser()
args = vars(parser.parse_args(query.split(' ')))
output = howdoi.howdoi(args)
print(output)

Antigravity

This library opens up a webpage that contains comics related to python. The reason this module is here is that this is quite fun! It’s basically an easter egg in Python 3 which is used in Google App Engines. It was added to Google App Engines just as a medium to amuse the users.

#4. Antigravity
import antigravity

Wikipedia

As the name suggests, this module is built to easily access Wikipedia pages from Python. If you are building an application that needs to access Wikipedia pages, then this module is quite handy and easy to integrate into any application. You can also get the summary of the page by using the summary attribute of the Wikipedia page.

#5. Wikipedia
import wikipedia
page = wikipedia.page("Python")
print(page.summary)

Dissembler Python

In simple terms, this module shows what happens under the hood of the Python interpreter. The dis module supports the analysis of CPython bytecode by disassembling it. The CPython bytecode which this module takes as an input is defined in the file Include/opcode.h and used by the compiler and the interpreter.

CPython implementation detail: Bytecode is an implementation detail of the CPython interpreter. No guarantees are made that bytecode will not be added, removed, or changed between versions of Python. The use of this module should not be considered to work across Python VMs or Python releases.

#6. Dissemble Python
import dis
def myfun(num):
    return('Number to string : ',str(num))

dis.dis(myfun)

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Interesting Python modules for Beginners | Daily Python #24 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

Requirements:

1. Python 3.0
2. Pip

Install the following packages:

1. pandas — BSD-licensed library providing high-performance, easy-to-use data structures, and data analysis tools.
2. sklearn — provides dozens of built-in machine learning algorithms and models
3. graphviz— facilitates the creation, and rendering of graph descriptions in the DOT language

What is a Classifier?

According to Wikipedia — An algorithm that implements classification, especially in a concrete implementation, is known as a classifier. The term “classifier” sometimes also refers to the mathematical function, implemented by a classification algorithm, that maps input data to a category.

Then, what is a Decision Tree?

A decision tree is a decision support tool that uses a tree-like model of decisions and their possible consequences, including chance event outcomes, resource costs, and utility. It is one way to display an algorithm that only contains conditional control statements.

A decision tree consists of three types of nodes:

1. Decision nodes — typically represented by squares
2. Chance nodes — typically represented by circles
3. End nodes — typically represented by triangles

A Decision Tree Classifier classifies a given data into different classes depending on the tree developed using the training data.

Advantages of decision trees

Among decision support tools, decision trees (and influence diagrams) have several advantages. Decision trees:

• Are simple to understand and interpret. People are able to understand decision tree models after a brief explanation.
• Have value even with little hard data. Important insights can be generated based on experts describing a situation (its alternatives, probabilities, and costs) and their preferences for outcomes.
• Help determine worst, best and expected values for different scenarios.
• Use a white-box model. If a given result is provided by a model.
• It can be combined with other decision techniques.

Disadvantages of decision trees:

• They are unstable, meaning that a small change in the data can lead to a large change in the structure of the optimal decision tree.
• They are often relatively inaccurate. Many other predictors perform better with similar data. This can be remedied by replacing a single decision tree with a random forest of decision trees, but a random forest is not as easy to interpret as a single decision tree.
• For data including categorical variables with a different number of levels, information gain in decision trees is biased in favor of those attributes with more levels.
• Calculations can get very complex, particularly if many values are uncertain and/or if many outcomes are linked.

Chapter 3 : Decision Tree Classifier — Theory

Go through the above article for a detailed explanation of the Decision Tree Classifier and the various methods which can be used to build a decision tree.

What is Sci-kit Learn?

Scikit-learn (formerly scikits.learn and also known as sklearn) is a free software machine learning library for the Python programming language. It features various classification, regression and clustering algorithms including support vector machines, random forests, gradient boosting, k-means and DBSCAN, and is designed to interoperate with the Python numerical and scientific libraries NumPy and SciPy.

Data that we will be using for classification

Capital Share — Capital Bikeshare is metro DC’s bike-share service, with 4,300 bikes and 500+ stations across 7 jurisdictions: Washington, DC.; Arlington, VA; Alexandria, VA; Montgomery, MD; Prince George’s County, MD; Fairfax County, VA; and the City of Falls Church, VA. Designed for quick trips with convenience in mind, it’s a fun and affordable way to get around.

Trip History Data

Each quarter, we publish downloadable files of Capital Bikeshare trip data. The data includes:

• Duration — Duration of trip
• Start Date — Includes start date and time
• End Date — Includes end date and time
• Start Station — Includes starting station name and number
• End Station — Includes ending station name and number
• Bike Number — Includes ID number of bike used for the trip
• Member Type — Indicates whether user was a “registered” member (Annual Member, 30-Day Member or Day Key Member) or a “casual” rider (Single Trip, 24-Hour Pass, 3-Day Pass or 5-Day Pass)

This data has been processed to remove trips that are taken by staff as they service and inspect the system, trips that are taken to/from any of our “test” stations at our warehouses and any trips lasting less than 60 seconds (potentially false starts or users trying to re-dock a bike to ensure it’s secure).

Import the required libraries

# Importing the required packages 
import numpy as np 
import pandas as pd 
from sklearn.metrics import confusion_matrix 
from sklearn.model_selection import train_test_split 
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
from sklearn.metrics import accuracy_score 
from sklearn.metrics import classification_report 
import graphviz

Function to import the data from the CSV file

# Function importing Dataset 
def importdata(): 
 balance_data = pd.read_csv('capitalshare.csv') 
 balance_data = balance_data[['Duration','Start station number','End station number','Member type']]
 #print(balance_data)
 # Printing the dataswet shape 
 print ("Dataset Lenght: ", len(balance_data)) 
 print ("Dataset Shape: ", balance_data.shape) 
 
 # Printing the dataset obseravtions 
 print ("Dataset: ",balance_data.head()) 
 return balance_data

Function to split the data into training and test data

# Function to split the dataset 
def splitdataset(balance_data):

# Seperating the target variable 
 X = balance_data.values[:, :-1] 
 Y = balance_data.values[:, -1]

# Spliting the dataset into train and test 
 X_train, X_test, y_train, y_test = train_test_split( 
 X, Y, test_size = 0.3, random_state = 100) 
 
 return X_train, X_test, y_train, y_test

Function to visualize the developed tree model

#Function to visualize tree
def visualize_tree(data,clf,clf_name):
 features = data.columns
 features = features[:-1]
 class_names = list(set(data.iloc[:,-1]))
 dot_data = tree.export_graphviz(clf, out_file=None,  \
  feature_names=features,class_names=class_names,  \
  filled=True, rounded=True, special_characters=True)
 graph = graphviz.Source(dot_data)
 graph.render('dtree_render_'+clf_name,view=True)

Function to train the decision tree using Gini Index

# Function to perform training with giniIndex. 
def train_using_gini(X_train, X_test, y_train,data):

# Creating the classifier object 
 clf_gini = DecisionTreeClassifier(criterion = "gini", 
   random_state = 100,max_depth=3, min_samples_leaf=5)
        # Performing training 
 clf_gini.fit(X_train, y_train)
 visualize_tree(data,clf_gini,'gini')
 print('\nFeature Importance : ',clf_gini.feature_importances_)
 return  clf_gini

Function to train the decision tree using Entropy

# Function to perform training with entropy. 
def tarin_using_entropy(X_train, X_test, y_train,data):

# Decision tree with entropy 
 clf_entropy = DecisionTreeClassifier( 
   criterion = "entropy", random_state = 100, 
   max_depth = 3, min_samples_leaf = 5)

# Performing training 
 clf_entropy.fit(X_train, y_train)
 visualize_tree(data,clf_entropy,'entropy')
 print('\nFeature Importance : ',clf_entropy.feature_importances_)
 return clf_entropy

Function to predict the class after training

# Function to make predictions 
def prediction(X_test, clf_object):

# Predicton on test with giniIndex 
 y_pred = clf_object.predict(X_test) 
 print("Predicted values:") 
 print(y_pred) 
 return y_pred

Function to calculate accuracy

# Function to calculate accuracy 
def cal_accuracy(y_test, y_pred): 
 
 print("Confusion Matrix: ", 
  confusion_matrix(y_test, y_pred)) 
 
 print ("Accuracy : ", 
 accuracy_score(y_test,y_pred)*100) 
 
 print("Report : ", 
 classification_report(y_test, y_pred))

Main Process

# Main process   
def main(): 
 
 # Building Phase 
 data = importdata() 
 X_train, X_test, y_train, y_test = splitdataset(data) 
 clf_gini = train_using_gini(X_train, X_test, y_train,data) 
 clf_entropy = tarin_using_entropy(X_train, X_test, y_train,data) 
 
 # Operational Phase 
 print("Results Using Gini Index:") 
 
 # Prediction using gini 
 y_pred_gini = prediction(X_test, clf_gini) 
 cal_accuracy(y_test, y_pred_gini) 
 
 print("Results Using Entropy:") 
 # Prediction using entropy 
 y_pred_entropy = prediction(X_test, clf_entropy) 
 cal_accuracy(y_test, y_pred_entropy) 
 
 
# Calling main function 
if __name__=="__main__": 
 main()

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Simple Decision Tree Classifier using Python | Daily Python #23 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a tutorial on how to block websites in a given time frame.

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

Requirements:

1. Python 3.0
2. Pip

First, let’s find the hosts file stored by the operating system

Content of the ‘hosts’ file

What is the ‘hosts’ file?

The host is an operating system file that maps hostnames to IP addresses. In this program, we will be mapping hostnames of websites to our localhost address. Using python file handling manipulation we will write the hostname in hosts.txt and remove the lines after your working hours.

Note: The location of the host file may be different for different operating systems. Windows Users should create a copy of this hosts file.

Let’s write the Python script that will do the task

# Run this script as Administrator
import time 
from datetime import datetime as dt

hostsFilePath = "C:\\Windows\\System32\\drivers\\etc\\hosts"
# localhost's IP Address 
redirect_IP = "127.0.0.1"

# Websites that you want to block 
website_list =["www.facebook.com","facebook.com", 
  "www.gmail.com","gmail.com"]

while True: 
 # time of your work 
 if dt(dt.now().year, dt.now().month, dt.now().day,8) \
 < dt.now() < dt(dt.now().year, dt.now().month, dt.now().day,21): 
  with open(hostsFilePath, 'r+') as file: 
   content = file.read() 
   for website in website_list: 
    if website in content: 
     pass
    else: 
     # Mapping hostnames to be blocked to your localhost IP address 
     file.write(redirect_IP + " " + website + "\n") 
     print("Access Denied...") 
 else: 
  with open(hostsFilePath, 'r+') as file: 
   content=file.readlines() 
   file.seek(0) 
   for line in content: 
    if not any(website in line for website in website_list): 
     file.write(line) 
   # Removing hostnmes from hosts file 
   file.truncate() 
  print("Access Granted...") 
 time.sleep(5)

Change the extension of the Python file from ‘.py’ to ‘.pyw’ and run the script as Administrator to gain access to the hosts file.

You can also, schedule the above script to run At startup

Finally, Restart your machine, and check if the website blocker works.

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Python script to block Websites !!! | Daily Python #22 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is a tutorial on implementing basic searching algorithms in Python.

This article is a part of Daily Python challenge that I have taken up for myself. I will be writing short python articles daily.

There are no additional requirements for this article.

Searching Algorithms

Search algorithms form an important part of many programs. Some searches involve looking for an entry in a database, such as looking up your record in the IRS database. Other search algorithms trawl through a virtual space, such as those hunting for the best chess moves. Although programmers can choose from numerous search types, they select the algorithm that best matches the size and structure of the database to provide a user-friendly experience.

The general searching problem can be described as follows: Locate an element x in a list of distinct elements a1,a2,...an or determine that it is not in the list. The solution to this search problem is the location of the term in the list that equals x and is 0 if x is not in the list.

Linear Search

The linear search is the algorithm of choice for short lists, because it’s simple and requires minimal code to implement. The linear search algorithm looks at the first list item to see whether you are searching for it and, if so, you are finished. If not, it looks at the next item and on through each entry in the list.

Working of Linear Search

Linear search is the basic search algorithm used in data structures. It is also called as sequential search. Linear search is used to find a particular element in an array.

Let’s write a function to accept a sequence of numbers

def acceptSeq(order="random"):
  seq = list(map(int,input("Enter a "+order+" sequence of numbers : ").split(" ")))
  val = int(input("Enter the value to be serached : "))
  return seq ,val

Now, let’s define a function to perform Linear Search

def acceptSeq(order="random"):
  seq = list(map(int,input("Enter a "+order+" sequence of numbers : ").split(" ")))
  val = int(input("Enter the value to be serached : "))
  return seq ,val

def linearSearch(seql,val):
  for index in range(0,len(seq)):
    print('Current Index : ',index,\
'Value at this index : ',seq[index])

if seq[index] == val:
      print('Number found at index : ',index)
      return
  print('Number not found')

seq, val = acceptSeq()
linearSearch(seq,val)

Binary Search

Binary Search is one of the most fundamental and useful algorithms in Computer Science. It describes the process of searching for a specific value in an ordered collection.

Binary search is a popular algorithm for large databases with records ordered by numerical key. Example candidates include the IRS database keyed by social security number and the DMV records keyed by driver’s license numbers. The algorithm starts at the middle of the database — if your target number is greater than the middle number, the search will continue with the upper half of the database. If your target number is smaller than the middle number, the search will continue with the lower half of the database. It keeps repeating this process, cutting the database in half each time until it finds the record. This search is more complicated than the linear search but for large databases it’s much faster than a linear search.

Working of Binary Search

In its simplest form, Binary Search operates on a contiguous sequence with a specified left and right index. This is called the Search Space. Binary Search maintains the left, right, and middle indices of the search space and compares the search target or applies the search condition to the middle value of the collection; if the condition is unsatisfied or values unequal, the half in which the target cannot lie is eliminated and the search continues on the remaining half until it is successful. If the search ends with an empty half, the condition cannot be fulfilled and target is not found.

Let’s define a function to perform Binary Search

def binarySearch(seq,val):
  start,end = 0,len(seq)-1
  while start <= end:
    mid = int((start+end)/2)
    print('Current Index : ',mid,\
          'Value at this index : ',seq[mid])
    if seq[mid] == val:
      print('Number found at index : ',mid)
      return
    elif val > seq[mid]:
      start = mid+1
    elif val < seq[mid]:
      end = mid-1
  print('Number not found ')

seq, val = acceptSeq(order="sorted")
binarySearch(seq,val)

Exponential Search

Exponential search is also known as doubling or galloping search. This mechanism is used to find the range where the search key may present. If L and U are the upper and lower bound of the list, then L and U both are the power of 2. For the last section, the U is the last position of the list. For that reason, it is known as exponential.

Working of Exponential Search

Exponential search allows for searching through a sorted, unbounded list for a specified input value (the search “key”). The algorithm consists of two stages. The first stage determines a range in which the search key would reside if it were in the list. In the second stage, a binary search is performed on this range. In the first stage, assuming that the list is sorted in ascending order, the algorithm looks for the first exponent, j, where the value 2j is greater than the search key. This value, 2j becomes the upper bound for the binary search with the previous power of 2, 2j — 1, being the lower bound for the binary search

Let’s define a function to perform Exponential Search

def exponentialSearch(seq,val):
  index = 1
  if seq[0] == val:
    print('Number found at index : 0')
    return
  while index < len(seq) and seq[index] < val:
    print('Current Index : ',index)
    index = index * 2
    print(index)
  binarySearch(seq,val)

def breadthFirstSearch():
  pass

def depthFirstSearch():
  pass

seq, val = acceptSeq(order="sorted")
exponentialSearch(seq,val)

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Implementing basic searching algorithms in Python — Part 1 | Daily Python #21 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is an introduction to the Pygame module basics — Image load, movement, and key presses.

Requirements:

1. Python 3.0
2. Pip

Install the following packages:

1. pygame — Library for making multimedia applications like games

pip install pygame

What is Pygame?

is a Free and Open Source python programming language library for making multimedia applications like games built on top of the excellent SDL library. Like SDL, pygame is highly portable and runs on nearly every platform and operating system. Millions of people have downloaded pygame itself, which is a whole lot of bits flying across the interwebs.

Is Python suitable for gaming?

It depends on the game. Python is actually quite capable of running games. It will likely even surprise you how much is possible in under 30 milliseconds. Still, it is not hard to reach the ceiling once your game begins to get more complex. Any game running in realtime will be making full use of the computer.

Over the past several years there has been an interesting trend in game development, the move towards higher-level languages. Usually, a game is split into two major parts. The game engine, which must be as fast as possible, and the game logic, which makes the engine actually do something. It wasn’t long ago when the engine of a game was written in assembly, with portions are written in C. Nowadays, C has moved to the game engine, while often the game itself is written in higher-level scripting languages. Games like Quake3 and Unreal run these scripts as portable bytecode. More recently, Python has been used in a variety of games like Freedom Force, and Humungous’ Backyard Sports Series.

Pygame is fairly low-level when it comes to writing games. You’ll quickly find yourself needing to wrap common functions into your own game environment. The great thing about this is there is nothing inside pygame to get in your way. Your program is in full control of everything. The side effect of that is you will find yourself borrowing a lot of code to get a more advanced framework put together. You’ll need a better understanding of what you are doing.

Article’s Goal: Ball Control using Arrow Keys

Let’s import the required pygame module and initialize it

import pygame
pygame.init()

Let’s store some required measurements in variables

size = width,height = 500,500
color = (0,0,0)
vel = [2,2]
title = "First Py-Game"

Initialize the window/screen which will run the game

window = pygame.display.set_mode(size)
pygame.display.set_caption(title)

Download a ball icon with a transparent background

Import the ball and map it with a pygame’s rectangle object

ball = pygame.image.load("ball.png")
ballRect = ball.get_rect()

pygame.image.load(“ball.png”) — function returns us a Surface with the ball data. The Surface will keep any color-key or alpha transparency from the file. After loading the ball image we create a variable named ‘ballRect’. Pygame comes with a convenient utility object type named Rect, which represents a rectangular area.

Now we define an infinite loop which will keep the window open till we don’t explicitly exit

run = True
while run:
    #Reset the pos 
    pos = 0,0
    pygame.time.delay(100)
    print(pygame.event.get())
    #Handle Arrow Key event
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        pos = -10,0
    if keys[pygame.K_RIGHT]:
        pos = 10,0
    if keys[pygame.K_UP]:
        pos = 0,-10
    if keys[pygame.K_DOWN]:
        pos = 0,10
    #Break the loop when ESCAPE is pressed
    if keys[pygame.K_ESCAPE]:
        run = False
    #Move the rectangle
    ballRect = ballRect.move(pos)
    window.fill(color)
    window.blit(ball,ballRect)
    pygame.display.flip()

pygame.quit()

This article is a basic introduction to pygame and does not consider the boundaries where the ball can be moved. Boundaries and obstacles will be covered in future articles.

I hope this article was helpful, do leave some claps if you liked it.

Follow the Daily Python Challenge here:

• Ajinkya-Sonawane/Daily-Python
• Login * Instagram

Introduction to Pygame Basics — Part 1 | Daily Python #20 was originally published in Daily Python on Medium, where people are continuing the conversation by highlighting and responding to this story.