Python: Binary Search

Binary Search: Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, narrow the interval to the lower half. Otherwise narrow it to the upper half. Repeatedly check until the value is found or the interval is empty.

The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(Log n).

class BinarySearch(object) :

    def binarySearch(self, A, K):

        # Returns index of x in arr if present, else -1 

    def binarySearch(arr, l, r, x):

       # Check base case             

       if r >= l:
                print("r,l:",r,", ",l)
                mid = round(l + (r - l) / 2)

                # If element is present at the middle itself 

                if arr[mid] == x:
                    return mid

                # If element is smaller than mid, then it can only 

                # be present in left subarray 

                elif arr[mid] ==  x:
                    print("search left side of the array: arr[mid] is ", arr[mid])
                    return binarySearch(arr, l, mid - 1, x)

                    # Else the element can only be present in right subarray                 

                else:
                    print("search right side of the array: arr[mid] is  ", arr[mid])
                    return binarySearch(arr, mid + 1, r, x)

            else:
                # Element is not present in the array 

                return -1

        result = binarySearch(A, 0, len(A)-1, K)
        return result

def main():
    x = BinarySearch()
    A = [10, 7, 8, 9, 1, 5]
    k = 1    #output = 8    #A =[7, 10, 4, 3, 20, 15]
    A.sort()
    print("array is: ",A)
    print("element ",k, " of array ", A, " is index ", x.binarySearch(A,k))

if __name__ == '__main__':
    main()

Python Convert 12 Hour to 24 Hour Time

For computation purposes, 24 hour time works better. Here is a function to convert the 12 Hour time String to 24 hour time string.

def time_convert_12_24(self,str_time):
    
    time_arr = str_time.split()  # split by space    n = time_arr[0].count(':')
    time_str : str ='' 

    if n == 1 :
       #5:30        

       time_str = time_arr[0]+':00'     

    elif n == 0 :
       #5 

       time_str = time_arr[0]+':00:00'     

    else :
       time_str = time_arr[0]
    #change 12:00 am to 00:00
    if time_arr[1].upper() == 'AM' and time_str[:1] == "12":
        "00" + time_str[2:-2]

    # add 12 hour to PM hours
    if time_arr[1].upper() == 'PM' :
        str_part = time_str.split(':')
        if int(str_part[0]) != 12 :
            return str(int(str_part[0]) + 12) +':'+str_part[1] + ':'+ str_part[2]
        else :
            return time_str
    else :
        return time_str

Get Date OF Week From Datetime

The following function reture weekday in differe format from a day.  

def getWeekDayChar(self,date_time : datetime,rt_type : str ) -> str :

    ''' 

     :param date_time: datetime     

     :param rt_type: 'i' = number, 'l' = long form, 's' = short form     

     :return: week date in spefified format 

    ''' 

    week_date_dict : dict = {0: ('Monday','Mon'), 1:('Tuesday','Tus'),2 : ('Wendsday', 'Wed'),
                             3:('Thursday','Thu'), 4: ('Friday','Fri') ,
                             5 :('Saturday','Sat')   ,6:('Sunday','Sun')}

    week_date_num : int = date_time.weekday()

    if rt_type == 'i' :
        return week_date_num
    elif rt_type == 'l' :
        return week_date_dict(week_date_num)(0)
    elif rt_type == 's' :
        return week_date_dict(week_date_num)(1)
    else :
        return None

Enable Logging In Python

Python’s logging module is part of the Python Standard Library. The logging module’s basicConfig() method 
is the quickest way to configure the desired behavior of your logger. However,  applications use file-based or 
dictionary-based logging configuration requires a slightly different configuration.

One simple way to set up file-based logging is to use a config file and fileConfig module to read the log configuration properties. 

The log config file will have a format like the one below:

[loggers]

keys=root,pipeline

[handlers]

keys=fileHandler

[formatters]

keys=simpleFormatter

[logger_root]

level=DEBUG

handlers=fileHandler

[logger_pipeline]

level=DEBUG

handlers=fileHandler

qualname=pipeline

propagate=0

[handler_fileHandler]

class=FileHandler

level=DEBUG

formatter=simpleFormatter

args=('./log/pipeline.log','a')

[formatter_simpleFormatter]

format=%(asctime)s - %(name)s - %(levelname)s - %(message)s

datefmt=

To make it a bit simple to enable logging inside the application, a utility module can be created to handle the logging.

import logging

from logging.config import fileConfig

class AppLogger():

   #ensure a singleton. We only want one log per applcation.

   __instance = None

   #create a static methold to get a logger instance.

   # The staticmethod() built-in function returns a static method for a given function.

   @staticmethod

   def get_applog():

       if AppLogger.__instance is None:

           AppLogger()

       return AppLogger.__instance

   def __init__(self):

       if AppLogger.__instance is not None:

           raise Exception("Only one application log should be activated at a time")

       AppLogger.__instance = AppLogger.create_applogger()

   @staticmethod

   def create_applogger():

       fileConfig('./config/applog_config.cfg', disable_existing_loggers=False)

       logger = logging.getLogger('pipeline')

       return logger

Now, in any of the modules within the application, we can involve the logger by calling the log module.

from util.log import AppLogger

Logger = AppLogger.get_applog()

class TestClass() :

    def  a_fuction():

       try:

           # codes here

       

       except Exception as e:

           Logger.error(“Error occurred {0}“.format(str(e))

         finally:

           #do something

The Python documention provides good reference on how to implement logging:

https://docs.python.org/3/howto/logging-cookbook.html

Related Post: Setup Application Configuration File

Setup An Application Configuration File In Python

it's a common practice to store configuration variables in a configuration file and retrieve the properties while they are needed.

Python provides a module called ConfigParser to help managed application configurations. The configParser module can be used to create a configuration file as well as to retrieve property values from a configuration file.

A configuration file in Python is similar to a Windows version of init (.ini) file. The file is divided by “Sections” and “options”. Following is a sample configuration file:

[DEFAULT]
work_directory =/tmp
Log_directory = /var/logs
app_user = app

[DEVELOPMENT]
hostname = mydevhost.com
database = devdb
user_id =devuser
Password =

[STAGE]
hostname = mystagehost.com
database = stagedb
user_id =stageuser
Password =

In the above example, [DEFAULT], [DEVELOPMENT], and [STAGE] are called section. Work_directory, log_directory, hostname,etc are called option.

Here is an example of how to retrieve the properties from the configuration file assuming the above configuration filename is called config.cfg:

import configparser
class GetConfigProperty():

def get_property(self,config_file: str, section: str, property: str) -> str:
     property_value: str
     config = configparser.ConfigParser()
     config.read_file(open('./config/' + config_file))
     property_value = config.get( section, property,fallback=None)
     return property_value

Now, we can call the above function to get the configuration properties in the application like the following:

getConfigProperty = GetConfigProperty()
working_dir : str = getConfigProperty.get_property("config.cfg", "DEFAULT", "working_dir");
dev_hostname : str = getConfigProperty.get_property("file_config.cfg", "DEVELOPMENT", "hostname");

Related Post: Setup Logging In Python