Python - Determine Primality of a number

 
# Determining primality by using a simple trial division test. 
# 
# This approach tests whether n is a multiple of an integer i 
# between 2 and √n.  If it is a multiple of any of these integers 
# then it is not a prime. 
 
import math
import time
 
def isPrime(n):
    for i in range(2, int(math.sqrt(n))):
        if n % i == 0:
            return False
    return True
 
def withTimer(n):
    start = time.time()
    prime = isPrime(n)
    elapsed = time.time() - start
    print("{0}   {1}    time:{2}").format(prime, n, elapsed)
 
# Primality of 2 to 13 digit known primes 
withTimer(13)
withTimer(715827883)
withTimer(2932031007403)
 
# test non primes 
withTimer(52)
withTimer(5820384023)
withTimer(2059384726303)
 
# my output: 
# True   13    time:0.0 
# True   715827883    time:0.00300002098083 
# True   2932031007403    time:0.521000146866 
# False   52    time:0.0 
# False   5820384023    time:0.000999927520752 
# False   2059384726303    time:0.029000043869 
 
 
 

Python - limit cpu percentage for script

# It is sometimes useful to monitor how much cpu time or 
# cpu percentage your script is consuming. 
# This script will limit the cpu usage of your script 
 
# This example demostrates how to calculate the system 
# and user cpu time and cpu percentage 
 
# Note: this example is in python 3.0 
#   however, it is easily ported back to 2.x 
#   by replaceing print() with print 
 
import os
import time
 
def getPercentage(unew, uold, start):
    """ 
    calculate the percentage of cpu time 
    """ 
    return 100 * (float(unew) - float(uold)) / (time.time()-float(start))
 
def looper(timeCount, percentageGoal):
    """ 
    loop over many tasks and keep the total cpu percentage 
    consumtion to a desired level 
    """ 
    start = time.time()
    time.sleep(0.1)
    keepLooping = True
    uold, sold, cold, c, e = os.times()
    percentage = 0.0
    while keepLooping:
        unew, snew, cnew, c, e = os.times()
        # since we are calculating the times from before we started looping the 
        # percentages will be averaged over the duration of the script. 
        print ("user %", percentage)
 
        # This just toggles to stop looping 
        # when a time has been reached. In a real 
        # script you would check for more work and 
        # toggle off when there is no more work to 
        # be done. 
        if time.time()-start > timeCount:
            keepLooping = False
        #else: 
        #    print( time.time()-start) 
 
        # do work: 
        #   In order for this script to actually help limit 
        #   the cpu usage you would need to break your script into 
        #   sections. 
        #   For example: if you were going to iterate through a large 
        #       list of data and perform actions on the contents 
        #       of the list then you should perform on action here 
        #       and keep looping through until all the actions 
        #       are accomplished. 
        # 
        # in this case we're just eating cpu so we get some numbers 
        print("do work...")
        for i in range(1,1000000):
            b = 8*342*i*234
 
        # tone back cpu usage 
        while True:
            percentage = getPercentage(unew, uold, start)
            if percentage > percentageGoal:
                time.sleep(0.1)
            else:
                break;
 
if __name__ == '__main__':
    # loop through work (for 4 seconds) and keep the cpu % 
    # to less than 30% 
    looper(4, 30)
 
## my output: 
##      user % 0.0 
##      do work... 
##      user % 0.0 
##      do work... 
##      user % 29.6673831301 
##      do work... 
##      user % 29.1137166495 
##      do work... 
##      user % 29.7617156875 
##      do work... 
##      user % 29.5707887319 
##      do work... 
##      user % 29.8122197706 
##      do work... 
##      user % 29.3053848216 
##      do work... 
##      user % 29.9385051866 
##      do work... 
 
 

Python - pure python ping using raw sockets

# I've searched the web far and wide.  I've written my own

#    os.popen() version to ride an operating system's ping.

#    I finally found a pure raw ping implementation in python

#    that seems to work!

#

# I copied the entire page from:

#   http://svn.pylucid.net/pylucid/CodeSnippets/ping.py

#########################################################

#!/usr/bin/env python 

 
"""
    A pure python ping implementation using raw socket.
 
 
    Note that ICMP messages can only be sent from processes running as root.
 
 
    Derived from ping.c distributed in Linux's netkit. That code is
    copyright (c) 1989 by The Regents of the University of California.
    That code is in turn derived from code written by Mike Muuss of the
    US Army Ballistic Research Laboratory in December, 1983 and
    placed in the public domain. They have my thanks.
 
    Bugs are naturally mine. I'd be glad to hear about them. There are
    certainly word - size dependenceies here.
 
    Copyright (c) Matthew Dixon Cowles, <http://www.visi.com/~mdc/>.
    Distributable under the terms of the GNU General Public License
    version 2. Provided with no warranties of any sort.
 
    Original Version from Matthew Dixon Cowles:
      -> ftp://ftp.visi.com/users/mdc/ping.py
 
    Rewrite by Jens Diemer:
      -> http://www.python-forum.de/post-69122.html#69122
 
 
    Revision history
    ~~~~~~~~~~~~~~~~
 
    May 30, 2007
    little rewrite by Jens Diemer:
     -  change socket asterisk import to a normal import
     -  replace time.time() with time.clock()
     -  delete "return None" (or change to "return" only)
     -  in checksum() rename "str" to "source_string"
 
    November 22, 1997
    Initial hack. Doesn't do much, but rather than try to guess
    what features I (or others) will want in the future, I've only
    put in what I need now.
 
    December 16, 1997
    For some reason, the checksum bytes are in the wrong order when
    this is run under Solaris 2.X for SPARC but it works right under
    Linux x86. Since I don't know just what's wrong, I'll swap the
    bytes always and then do an htons().
 
    December 4, 2000
    Changed the struct.pack() calls to pack the checksum and ID as
    unsigned. My thanks to Jerome Poincheval for the fix.
 
 
    Last commit info:
    ~~~~~~~~~~~~~~~~~
    $LastChangedDate: $
    $Rev: $
    $Author: $
""" 
 
 
import os, sys, socket, struct, select, time 
 
# From /usr/include/linux/icmp.h; your milage may vary. 
ICMP_ECHO_REQUEST = 8 # Seems to be the same on Solaris. 
 
 
def checksum(source_string): 
    """
    I'm not too confident that this is right but testing seems
    to suggest that it gives the same answers as in_cksum in ping.c
    """ 
    sum = 0 
    countTo = (len(source_string)/2)*2 
    count = 0 
    while count<countTo: 
        thisVal = ord(source_string[count + 1])*256 + ord(source_string[count]) 
        sum = sum + thisVal 
        sum = sum & 0xffffffff # Necessary? 
        count = count + 2 
 
    if countTo<len(source_string): 
        sum = sum + ord(source_string[len(source_string) - 1]) 
        sum = sum & 0xffffffff # Necessary? 
 
    sum = (sum >> 16)  +  (sum & 0xffff) 
    sum = sum + (sum >> 16) 
    answer = ~sum 
    answer = answer & 0xffff 
 
    # Swap bytes. Bugger me if I know why. 
    answer = answer >> 8 | (answer << 8 & 0xff00) 
 
    return answer 
 
 
def receive_one_ping(my_socket, ID, timeout): 
    """
    receive the ping from the socket.
    """ 
    timeLeft = timeout 
    while True: 
        startedSelect = time.clock() 
        whatReady = select.select([my_socket], [], [], timeLeft) 
        howLongInSelect = (time.clock() - startedSelect) 
        if whatReady[0] == []: # Timeout 
            return 
 
        timeReceived = time.clock() 
        recPacket, addr = my_socket.recvfrom(1024) 
        icmpHeader = recPacket[20:28] 
        type, code, checksum, packetID, sequence = struct.unpack( 
            "bbHHh", icmpHeader 
        ) 
        if packetID == ID: 
            bytesInDouble = struct.calcsize("d") 
            timeSent = struct.unpack("d", recPacket[28:28 + bytesInDouble])[0] 
            return timeReceived - timeSent 
 
        timeLeft = timeLeft - howLongInSelect 
        if timeLeft <= 0: 
            return 
 
 
def send_one_ping(my_socket, dest_addr, ID): 
    """
    Send one ping to the given >dest_addr<.
    """ 
    dest_addr  =  socket.gethostbyname(dest_addr) 
 
    # Header is type (8), code (8), checksum (16), id (16), sequence (16) 
    my_checksum = 0 
 
    # Make a dummy heder with a 0 checksum. 
    header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum, ID, 1) 
    bytesInDouble = struct.calcsize("d") 
    data = (192 - bytesInDouble) * "Q" 
    data = struct.pack("d", time.clock()) + data 
 
    # Calculate the checksum on the data and the dummy header. 
    my_checksum = checksum(header + data) 
 
    # Now that we have the right checksum, we put that in. It's just easier 
    # to make up a new header than to stuff it into the dummy. 
    header = struct.pack( 
        "bbHHh", ICMP_ECHO_REQUEST, 0, socket.htons(my_checksum), ID, 1 
    ) 
    packet = header + data 
    my_socket.sendto(packet, (dest_addr, 1)) # Don't know about the 1 
 
 
def do_one(dest_addr, timeout): 
    """
    Returns either the delay (in seconds) or none on timeout.
    """ 
    icmp = socket.getprotobyname("icmp") 
    try: 
        my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) 
    except socket.error, (errno, msg): 
        if errno == 1: 
            # Operation not permitted 
            msg = msg + ( 
                " - Note that ICMP messages can only be sent from processes" 
                " running as root." 
            ) 
            raise socket.error(msg) 
        raise # raise the original error 
 
    my_ID = os.getpid() & 0xFFFF 
 
    send_one_ping(my_socket, dest_addr, my_ID) 
    delay = receive_one_ping(my_socket, my_ID, timeout) 
 
    my_socket.close() 
    return delay 
 
 
def verbose_ping(dest_addr, timeout = 2, count = 4): 
    """
    Send >count< ping to >dest_addr< with the given >timeout< and display
    the result.
    """ 
    for i in xrange(count): 
        print "ping %s..." % dest_addr, 
        try: 
            delay  =  do_one(dest_addr, timeout) 
        except socket.gaierror, e: 
            print "failed. (socket error: '%s')" % e[1] 
            break 
 
        if delay  ==  None: 
            print "failed. (timeout within %ssec.)" % timeout 
        else: 
            delay  =  delay * 1000 
            print "get ping in %0.4fms" % delay 
    print 
 
 
if __name__ == '__main__': 
    verbose_ping("heise.de") 
    verbose_ping("google.com") 
    verbose_ping("a-test-url-taht-is-not-available.com") 
    verbose_ping("192.168.1.1") 
 
 
#output (for me): 
##        ping heise.de... get ping in 161.5423ms 
##        ping heise.de... get ping in 161.8938ms 
##        ping heise.de... get ping in 161.8139ms 
##        ping heise.de... get ping in 161.0677ms 
## 
##        ping google.com... get ping in 55.2157ms 
##        ping google.com... get ping in 54.8570ms 
##        ping google.com... get ping in 54.9019ms 
##        ping google.com... get ping in 54.7282ms 
## 
##        ping a-test-url-taht-is-not-available.com... failed. (socket error: 'getaddrinfo failed') 
## 
##        ping 192.168.1.1... get ping in 2.6651ms 
##        ping 192.168.1.1... get ping in 3.4502ms 
##        ping 192.168.1.1... get ping in 2.0416ms 
##        ping 192.168.1.1... get ping in 1.9452ms 

python - while loop specified time frame

import time

def looper(timeCount):
   start = time.time()
   keepLooping = True
   while keepLooping:
       if time.time()-start > timeCount:
           keepLooping = False
       else:
           print time.time()-start
       time.sleep(0.1)



if __name__ == '__main__':
       looper(10.0)

Python - sleep and random

# sleep for a random amount of time
# here is another sleep example 

import time
import random

random.seed()

for i in xrange(10):
    n = random.random()
    print str(i) + ": sleep for seconds: " + str(n)
    time.sleep(n)




#output (for this run):
#0: sleep for seconds: 0.611660870691
#1: sleep for seconds: 0.0712530683474
#2: sleep for seconds: 0.74601244734
#3: sleep for seconds: 0.942065303858
#4: sleep for seconds: 0.880462544493
#5: sleep for seconds: 0.315049974845
#6: sleep for seconds: 0.446147135853
#7: sleep for seconds: 0.306590705779

#8: sleep for seconds: 0.420561109255
#9: sleep for seconds: 0.950325171948

Python - compare two images

 
# PIL is a great python library for doing everything related to images 
 
# check out the other PIL and Image examples: 
#   Find and Label objects in Images l 
#   Find and outline the sun  
#   Replace or remove colors from an image  
#   Find the average RGB color for and image   
#   Determine an image's type (regardless of extension)  
 
 
# here is the zipped full source for this example  
from PIL import Image
import time
import sys
 
def compareTwoPics(picture_1, picture_2, step=20):
    step = int(step)
    if step < 1:
        step = 1
 
    percent_similar = 0.0
    percent_red = 0.0
    percent_green = 0.0
    percent_blue = 0.0
    percent_totalcolor = 0.0
 
 
    total_check_points = 0.0
    total_not_match = 0.0
    percent_similar = 0.0
 
    pic1_total_red = 0
    pic1_total_green = 0
    pic1_total_blue = 0
    pic1_total_color = 0
 
    pic2_total_red = 0
    pic2_total_green = 0
    pic2_total_blue = 0
    pic2_total_color = 0
 
    #print picture_1 
    #print picture_2 
 
    try:
        pic1 = Image.open(picture_1)
        pic2 = Image.open(picture_2)
    except:
        # tried to open an unsupported format!! 
        #print str(picture_1) + " is not a supported image format" 
        #print str(picture_2) + " is not a supported image format" 
        return -1.0, 0.0, 0.0, 0.0
 
    pic1_width = pic1.size[0]
    pic1_height = pic1.size[1]
 
    pic2_width = pic2.size[0]
    pic2_height = pic2.size[1]
 
 
    if pic1_width != pic2_width:
        print "\n widths must be the same \n" 
        sys.exit()
    if pic1_height != pic2_height:
        print "\n widths must be the same \n" 
        sys.exit()
 
 
    for x in range(0, pic1_width):
        for y in range(0, pic1_height):
 
            if x % step == 0:
                pic1_color = pic1.getpixel((x,y))
                pic2_color = pic2.getpixel((x,y))
 
                total_check_points += 3
 
                if pic1_color[0] != pic2_color[0]:
                    total_not_match += 1
                if pic1_color[1] != pic2_color[1]:
                    total_not_match += 1
                if pic1_color[2] != pic2_color[2]:
                    total_not_match += 1
 
                pic1_total_red += pic1_color[0]
                pic1_total_green += pic1_color[1]
                pic1_total_blue += pic1_color[2]
 
 
                pic2_total_red += pic2_color[0]
                pic2_total_green += pic2_color[1]
                pic2_total_blue += pic2_color[2]
 
                #print "     pic1 count: "+ str(pic1_total_red) 
                #print "     pic2 count: "+ str(pic2_total_red) 
 
 
 
    pic1_total_color = pic1_total_red + pic1_total_green + pic1_total_blue
    pic2_total_color = pic2_total_red + pic2_total_green + pic2_total_blue
 
 
    percent_similar = 1 - (total_not_match / total_check_points)
    percent_red = abs(float(pic2_total_red) / float(pic1_total_red))
    percent_green = abs(float(pic2_total_green) / float(pic1_total_green))
    percent_blue = abs(float(pic2_total_blue) / float(pic1_total_blue))
    percent_totalcolor = abs(float(pic2_total_color) / float(pic1_total_color))
 
    print '----' 
    print "total % comparible red:  " + str(percent_red)
    print "total % comparible green:" + str(percent_green)
    print "total % comparible blue: " + str(percent_blue)
    print "total % comparible:      " + str(percent_totalcolor)
    print "total pic1:              " + str(pic1_total_color)
    print "total pic2               " + str(pic2_total_color)
 
 
    return percent_similar, percent_totalcolor, pic1_total_color, pic2_total_color
 
 
 
if __name__ == '__main__':
    try:
        import psyco
        psyco.full()
    except ImportError:
        print "...installing psyco would provide additional performance" 
 
 
    thedetail = 20
    if len( sys.argv ) < 3:
        print "\n\n" 
        print "Usage: " + str(sys.argv[0]) + " <photo1.png> <photo2.png> [detail]" 
        print "" 
        print " - photo1.png and photo2.png are the photos you are comparing" 
        print " - detail is just a number.  The higher the number the faster" 
        print " and less detailed the comparison will be.  Default detail is 20" 
        print "" 
        print "example:" 
        print " # Highest quality comparison, slowest turn around" 
        print " " + str(sys.argv[0]) + " photo.png photo2.png 1" 
        print " " 
        print " # Low quality comparison, high turn around" 
        print " " + str(sys.argv[0]) + " photo.png photo2.png 100" 
        sys.exit()
    else:
        try:
            thedetail = sys.argv[3]
        except:
            thedetail = 20
 
        tt = time.time()
        print str(compareTwoPics(sys.argv[1], sys.argv[2], step=thedetail))
        print "execution seconds: " + str(time.time() - tt)