OOPS Python : Create Class

class Country():
    # Class object Attribute
    area = 3287000
    def __init__(self,name,population):
        self.population = population
        self.name=name
    def describe(self):
        print("population of {} is {}".format(self.name,self.population))
        #print("Area sq km of {} is {}".format(self.name,self.area)) also
        print("Area sq km of {} is {}".format(self.name,Country.area))
       
    def update_population(self,new_population):
        self.population = new_population
       
c1 = Country('India',1300000000)
c1.update_population(1350000000)
c1.describe()

Indexer for search engine in python

import sys
import os
import urllib
import re
from bs4 import BeautifulSoup
#first time
#from whoosh.fields import Schema, TEXT, KEYWORD, ID, STORED ,NUMERIC
#from whoosh.index import create_in, open_dir
#from whoosh.query import *
import whoosh.index as index
ix = index.open_dir("index")
#then onwards
from whoosh.analysis.tokenizers import RegexTokenizer
from whoosh.analysis.tokenizers import IDTokenizer
#--------------------------------------------------------------------------------------
#creating the schema
schema = Schema(lid= TEXT(stored=True),ldata=TEXT(stored=True))
#creating the index
if not os.path.exists("index"):
    os.mkdir("index")
ix = create_in("index",schema)
ix = open_dir("index")
writer = ix.writer()
#--------------------------------------------------------------------------------------
soup = BeautifulSoup(open("39/390099"))
#tag = soup.find('title')
#print(tag.text)
#print(soup.prettify())
#for link in soup.find_all('a'):
#   print(link.get('href'))
#print(soup.get_text())
text1=soup.get_text()
text2=text1.split()

def LowercaseFilter(tokens):
    for t in tokens:
        t.text = t.text.lower()
        yield t

regt = RegexTokenizer()
idt = IDTokenizer()
#-----------------------------------------------------------------------------

for token in regt(text1):
   writer.add_document(lid=unicode(LowercaseFilter(token.text.encode('utf-8'))),ldata=unicode(LowercaseFilter(token.text.encode('utf-8'))))
   break
   #print unicode(token.text.encode('utf-8'))
  
#length=len(words_list)


 
   #print unicode(token) , fdist1[token]
 
   #print words_list[i]


#------------------------------------------------------------------------------------------------------

testVar=raw_input("enter a search keyword : ")
from whoosh.qparser import QueryParser
ix.searcher().documents()
with ix.searcher() as searcher:
    #query = QueryParser("ldata", ix.schema).parse(u'methylotrophus')
    query = QueryParser("ldata", ix.schema).parse(testVar)
    results = searcher.search(query)
    for result in results:
        print result

find all the substrings in a python string

def find_subs(s):
  n = len(s)
  return [s[i:j + 1] for i in range(n) for j in range(i,n)]

python remove text from string after character(s) without using regex

pivot = '...'
required = text.split(pivot, 1)[0]

regex to find datetime in text format

import re
r = re.compile('(?P<dow>[a-zA-Z]+,) (?P<date>[0-9]{2}) (?P<month>[A-Za-z]+) (?P<year>[0-9]{4}) (?P<hour>[0-9]{2}):(?P<minute>[0-9]{2}) (?P<ampm>[A-Z]{2})')

s = "Monday, 14 January 2019 11:50 PM"

print([m.groupdict() for m in r.finditer(s)][0])

output :

{'dow': 'Monday,', 'date': '14', 'month': 'January', 'year': '2019', 'hour': '11', 'minute': '50', 'ampm': 'PM'}

Python code for Quick Sort using original Hoare partition scheme

from random import randint
def quicksort(array, low, high):
    if low < high:
        p = partition(array, low, high)
        quicksort(array, low, p)
        quicksort(array, p + 1, high)

def partition(array, low, high):
    pivot = array[low]
    i=low-1
    j=high+1
    while 1:
    i = i + 1
        while array[i] < pivot:
            i = i + 1
        j=j-1
        while array[j] > pivot:
            j=j-1
       
        if i >= j:
            return j
        array[i],array[j]=array[j],array[i]




array=[]
for p in range(10):
    array.append(randint(1,100))

quicksort(array,0,len(array)-1)
print array

Implementation of iterative deepening A* (Star) Algorithm

#node              current node
#g                 the cost to reach current node
#f                 estimated cost of the cheapest path (root..node..goal)
#h(node)           estimated cost of the cheapest path (node..goal)
#cost(node, succ)  step cost function
#is_goal(node)     goal test
#successors(node)  node expanding function
V={}
E={}
V=({'A':7,'B':9,'C':6,'D':5,'E':6,'F':4.5,'H':4,'I':2,'J':3,'K':3.5,'G':0})
E=({('B','D'):2,('A','B'):4,('A','C'):4,('A','D'):7,('D','E'):6,('E','F'):5,('D','F'):8,('D','H'):5,('H','I'):3,('I','J'):3,('J','K'):3,('K','H'):3,('F','G'):5})
INFINITY=10000000
cameFrom={}
def h(node):
    return V[node]
def cost(node, succ):
    return E[node,succ]

def successors(node):
    neighbours=[]
    for item in E:
        if node==item[0][0]:
            neighbours.append(item[1][0])
    return neighbours

def reconstruct_path(cameFrom, current):
    total_path = [current]
    while current in cameFrom:
        current = cameFrom[current]
        total_path.append(current)
    return total_path
   
def ida_star(root,goal):
    global cameFrom
    def search(node, g, bound):
        min_node=None
        global cameFrom
        f = g + h(node)
        if f > bound:return f
        if node==goal:return "FOUND"
        minn = INFINITY
        for succ in successors(node):
            t = search(succ, g + cost(node, succ), bound)
            if t == "FOUND":return "FOUND"
            if t < minn:
                minn = t
                min_node=succ
        cameFrom[min_node]=node
        return minn
       
    bound= h(root)
    count =1
    while 1:
        print "itertion"+str(count)
        count+=1
        t = search(root, 0, bound)
        if t == "FOUND":
            print reconstruct_path(cameFrom, goal)
            return bound
        if t == INFINITY:return "NOT_FOUND"
        bound = t
  
print ida_star('A','G')
   

Implementation of A* algorithm in python

V={}
E={}
V=({'A':7,'B':9,'C':6,'D':5,'E':6,'F':4.5,'H':4,'I':2,'J':3,'K':3.5,'G':0})
E=({('B','D'):2,('A','B'):4,('A','C'):4,('A','D'):7,('D','E'):6,('E','F'):4.5,('D','F'):8,('D','H'):4,('H','I'):3,('I','J'):3,('J','K'):3,('K','H'):3,('F','G'):5})



INFINITY=10000000
def find_neighbours(node):
    neighbours=[]
    for item in E:
        if node==item[0][0]:
            neighbours.append(item[1][0])
    return neighbours
   


def reconstruct_path(cameFrom, current):
    total_path = [current]
    while current in cameFrom:
        current = cameFrom[current]
        total_path.append(current)
    return total_path
    #

def Astar(start, goal):
   
    current = start
    fScore={}
    gScore={}
   
   
   
   
    # The set of currently discovered nodes still to be evaluated.
    openSet = set()
    # The set of nodes already evaluated.
    closedSet = set()
    # Initially, only the start node is known.
    openSet.add(current)
   
    # For each node, which node it can most efficiently be reached from.
    # If a node can be reached from many nodes, cameFrom will eventually contain the
    # most efficient previous step.
    cameFrom ={}#the empty map

    # For each node, the cost of getting from the start node to that node.
    for node in V:
        gScore[node] = INFINITY #map with default value of Infinity
    # The cost of going from start to start is zero.
    gScore[start] = 0
    # For each node, the total cost of getting from the start node to the goal
    # by passing by that node. That value is partly known, partly heuristic.
    for node in V:
        fScore[node] = INFINITY #map with default value of Infinity
    # For the first node, that value is completely heuristic.
    fScore[start] = V[start]#heuristic_cost_estimate(start, goal)
   
    def heuristic_cost_estimate(node, goal):
    return E[cameFrom[node],node]+V[node]
    count=0
    while openSet:
        count+=1
        if count>10:
            break
        print openSet
        minn=INFINITY
        for node in openSet:
            if fScore[node]<minn:
                current=node
        if current==None:
            current=start
        #current = node in openSet having the lowest fScore[] value)
        if current == goal:
            return reconstruct_path(cameFrom, goal)

        openSet.remove(current)
        #Add it to the closed set
        closedSet.add(current)
        for neighbor in find_neighbours(current):
            if neighbor in closedSet:
                continue        # Ignore the neighbor which is already evaluated.
            # The distance from start to goal passing through current and the neighbor.
            tentative_gScore = gScore[current] + E[(current, neighbor)]
            if neighbor not in openSet:    # Discover a new node
                openSet.add(neighbor)
            elif tentative_gScore >= gScore[neighbor]:
                continue        # This is not a better path.

            # This path is the best until now. Record it!
            cameFrom[neighbor] = current
            gScore[neighbor] = tentative_gScore
            fScore[neighbor] = gScore[neighbor] + heuristic_cost_estimate(neighbor, goal)

    return "failure"



print Astar('A','K')

python code to change extension of all files in a folder

import os

for root,dirs,files in os.walk('./'):
   for file in files:
       if file.endswith('.oldext'):
          F=open(os.path.join(root,file),'r')
          W=open('./foldername/'+file.replace('.oldext','.newext'),'w')
          for line in F.readlines():
             W.write(line)
           W.close()
           F.close()
print 'All Extensions changed Successfully'

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

change the file extensions as your need 

replace oldext with the extension your files are currently having

replace newext with the new extension you want to have for all of ur files

save the above code in a file with .py extension

create a folder named foldername in same directory where the python file is saved 

keep all the files whose extension you want to change in the same folder as code   file