## Thursday, June 14, 2018

### VIDEO: Good article and video about asymptotic complexity of algorithms

By Vasudev Ram

I saw this nice tutorial about the asympotic complexity of algorithms (Big-Oh notation etc.) via this HN thread:

A Gentle Introduction to Algorithm Complexity Analysis (discrete.gr)

It is by Dionysis Zindros of the University of Athens, Greece.

The HN thread has only a few comments as of now, but one of them led to another good resource on this topic:

Asymptotic Notation, by Jackson Steinkamp of Harvard's CS50 program

The video is also embedded below. It is short, but gives a good idea of the topic.

In my next post, I'll do that analysis of the prime number checker that I ported from Q to Python.

Here is the embedded video:

- Enjoy.

- My Codementor profile

Get fast web hosting with A2Hosting.com

My ActiveState Code recipes

Are you a blogger with some traffic? Get Convertkit:

Email marketing for professional bloggers

## Friday, June 1, 2018

### Improved simple Python debugging function

By Vasudev Ram

[ I rewrote parts of this post, which was originally published two days ago on my blog (but intentionally not to the Planet Python, earlier, because I did not set the python label that makes that happen), for more clarity and to give a standalone example of the use of the use of the debug1 function. ]

A simple Python debugging function

Some time later I created an improved version of it, that does not need the user to set an environment variable to turn the debugging on or off.

Here is the code for the new function, now called debug1, in module debug1:
```# debug1.py

from __future__ import print_function

# A simple debugging function for Python programs.
# How to use it:
# If the -O option is not given on the Python command line (the more common case
# during development), the in-built special variable __debug__ is defined as True,
# and the debug1 function displays debugging messages, i.e. it prints the message
# and all other (optional) values passed to it.
# If the -O option is given, the variable __debug__ is defined as False,
# and the debug1 function does nothing is defined as a no-op, so does nothing.

import os

if __debug__:
def debug1(message, *values):
if len(values) == 0:
print(message)
else:
print("{}:".format(message), end=" ")
print(" ".join([repr(value) for value in values]))
else:
def debug1(message, *values):
# Do nothing.
pass

def main():
# Test the debug1 function with some calls.
debug1('message only')
debug1('message with int', 1)
debug1('message with int, float', 1, 2.3)
debug1('message with long, string', 4L, "hi")
debug1('message with boolean, tuple, set', True, (1, 2), { 3, 4} )
debug1('message with string, boolean, list', "hi", True, [2, 3])
debug1('message with complex, dict', 1 + 2j, {'a': 'apple', 'b': 'banana'})
class Foo: pass
foo = Foo()
debug1('message with object', foo)
debug1('message with class', Foo)
debug1('message with xrange', xrange(3))
debug1('message with listiterator', iter(range(4)))

if __name__ == '__main__':
main()
```

To use it in the normal way, import the debug1() function from the debug1 module into a Python file where you want to use it.
Then just call the function in your code at the places where you want to print some message, with or without the value of one or more variables. Here is an example:

# In your program, say factorial.py
```from debug1 import debug1

def factorial(n):
# This line prints the message and the value of n when debug1 is enabled.
debug1("entered factorial, n", n)
if n < 0:
raise Exception("Factorial argument must be integer, 0 or greater.")
if n == 0:
return 1
p = 1
for i in range(1, n + 1):
p *= i
# This line prints the message and the changing values
# of i and p when debug1 is enabled.
debug1("in for loop, i, p", i, p)
return p

print "i\tfactorial(i)"
for i in range(6):
print "{}\t{}".format(i, factorial(i))
```
Then to run factorial.py with debugging on, no specific enabling step is needed (unlike with the earlier version, vr_debug.py where you had to set the environment variable VR_DEBUG to 1 or some other non-null value). Just run your program as usual and debugging output will be shown:
```\$ python factorial.py
i       factorial(i)
0       1
in for loop, i, p: 1 1
1       1
in for loop, i, p: 1 1
in for loop, i, p: 2 2
2       2
in for loop, i, p: 1 1
in for loop, i, p: 2 2
in for loop, i, p: 3 6
3       6
in for loop, i, p: 1 1
in for loop, i, p: 2 2
in for loop, i, p: 3 6
in for loop, i, p: 4 24
4       24
in for loop, i, p: 1 1
in for loop, i, p: 2 2
in for loop, i, p: 3 6
in for loop, i, p: 4 24
in for loop, i, p: 5 120
5       120
```
Once you have debugged and fixed any bugs in your program, with the help of the debugging output, you can easily turn off debugging messages like this, by adding the -O option to the python command line, to get only the normal program output:
```\$ python -O factorial.py
i       factorial(i)
0       1
1       1
2       2
3       6
4       24
5       120
```
The debug1 module internally checks the value of the built-in Python variable __debug__, and conditionally defines the function debug1() as either the real function, or a no-op, based on __debug__'s value at runtime.

The __debug__ variable is normally set by the Python interpreter to True, unless you pass python the -O option, which sets it to False.

Know of any different or better debugging functions? Feel free to mention them in the comments. Like I said in the previous post about the first version of this debug function (linked above), I've never been quite satisfied with the various attempts I've made to write debugging functions of this kind.

Of course, Python IDEs like Wing IDE or PyCharm can be used, which have features like stepping through (or over, in the case of functions) the code, setting breakpoints and watches, etc., but sometimes the good old debugging print statement technique is more suitable, particularly when there are many iterations of a loop, in which case the breakpoint / watch method becomes tedious, unless conditional breakpoints or suchlike are supported.

There are also scenarios where IDE debugging does not work well or is not supported, like in the case of web development. Although some IDEs have made attempts in this direction, sometimes it is only available in a paid or higher version.

Interested in learning Python programming by email? Contact me for the course details (use the Gmail id at that preceding link).
Enjoy.

My ActiveState Code recipes

Are you a blogger with some traffic? Get Convertkit:

Email marketing for professional bloggers

### Porting a prime checker from Q to Python (with improvements)

By Vasudev Ram

Q => Py

I was checking out the Q programming language.

It's an interesting language, a descendant of APL, that supports array and functional programming styles. Some information about Q from its Wikipedia page:

Designed by: Arthur Whitney
Developer: Kx Systems
First appeared: 2003
Typing discipline: Dynamic, strong
Influenced by: A+, APL, Scheme, K

Q is a proprietary array processing language developed by Arthur Whitney and commercialized by Kx Systems. The language serves as the query language for kdb+, a disk based and in-memory, column-based database. kdb+ is based upon K, a terse variant of APL. Q is a thin wrapper around K, providing a more readable, English-like interface.

I had tried out Q a bit recently, using one of the tutorials.

[
When x is an integer greater than 2, the following function will return 1 if it is a prime, otherwise 0:

{min x mod 2_til x}
The function is evaluated from right to left:

"til x" enumerate the positive integers less than x.
"2_" drops the first two elements of the enumeration (0 and 1).
"x mod" performs modulo division between the original integer and each value in the truncated list.
"min" find the minimum value of the list of modulo result.
]

It's basically an algorithm in Q to find whether a given number x (> 2) is prime or not [1]. The algorithm returns 1 if x is a prime, else 0. Notice how concise it is. That conciseness is a property of the APL family of languages, such as APL, J and Q. In fact Q is slightly less concise than some of the others, I've read, because it puts a thin English-like wrapper on the hard-core APL symbolic syntax. But all of them are still very concise.

So I thought of implementing that algorithm in Python, just for fun. I first wrote a naive version, more or less a port of the Q version. Then I rewrote that first version in a more functional way. Then I realized that there are other opportunities for improving the code [2], and implemented a few of them.

So I combined the few different versions of the is_prime_* functions (where * = 1, 2, 3, etc.) that I had written, in a single program, with a driver function to exercise all of them. The code is in file is_prime.py, shown further below. There are comments in the program that explain the logic and improvements or differences of the various is_prime function versions.

[1] Prime_number

[2] There are obviously many other ways of checking if numbers are prime, and many of them are faster than these approaches; see [3]. These are not among the most efficient ways, or even close; I was just experimenting with different ways of rewriting and refactoring the code, after the initial port from Q to Python. Even the original Q version in the Wikipedia page was not meant to be a fast version, since it does not use any of the improvements I mention below, let alone using any special Q-specific algorithm or language feature, or advanced general prime-finding algorithms.

[3] Primality test

There might still be some scope for further changes or improvements, some of which I may do in a future post. A few such improvements are:

1. Don't divide x by all values up to x - 1. Instead, only check up to the square root of x. This is a standard improvement often taught to programming beginners; in fact, it is mentioned in the Wikipedia articles about primes.

2. Terminate early when the first remainder equal to 0 is found. This avoids unnecessarily computing all the other remainders. I did that in is_prime_3().

3. Don't check for divisibility by any even number > 2 (call it b), because if any such b divides x evenly, then so will 2, and we would have checked earlier if 2 divides x evenly.

4. Create a function for the output statements, most of which are common across the different is_prime versions, and call that function instead from those places.

5. Use a generator to lazily yield divisors, and when any divisor gives a zero remainder, exit early, since it means the number is not prime. Done in is_prime_4().

Other ways of doing it may include use of some other functional programming features of Python such as filter(), itertools.takewhile/dropwhile, etc. (The itertools module has many functions and is very interesting, but that is a subject for a different post.)

I also observed some interesting behavior when running the program with large ranges of inputs for prime number checking. Will analyze that a bit and write about my opinions on that in a future post.

Here is the code for is_prime.py:
```# File: isprime.py
# A port of a primality checking algorithm from the Q language to Python,
# plus a few improvements / variations, using Python features.
# Ref: https://en.wikipedia.org/wiki/Q_(programming_language_from_Kx_Systems)
# Search for the word "prime" in that page to see the Q code.

# Author: Vasudev Ram
# Web site: https://vasudevram.github.io

from __future__ import print_function
from debug1 import debug1

import sys

# Naive, mostly procedural port from the Q version.
def is_prime_1(x):
# Guard against invalid argument.
assert x > 2, "in is_prime_1: x > 2 failed"
# The range of integers from 0 to x - 1
til_x = range(x)
# The range without the first 2 items, 0 and 1.
divs = til_x[2:]
# The remainders after dividing x by each integer in divs.
mods = map(lambda d: x % d, divs)
# x is prime if the minimum-valued remainder equals 1.
return min(mods) == 1

# Shorter, more functional version, with nested calls
# to min, map and range.
def is_prime_2(x):
assert x > 2, "in is_prime_2: x > 2 failed"
# Eliminate slicing used in is_prime_1, just do range(2, x).
return min(map(lambda d: x % d, range(2, x))) == 1

# Early-terminating version, when 1st remainder equal to 0 found,
# using a list for the range of divisors.
def is_prime_3(x):
assert x > 2, "in is_prime_3: x > 2 failed"
divs = range(2, x)
# Check if x is divisible by any integer in divs; if so,
# x is not prime, so terminate early.
debug1("in is_prime_3, x", x)
for div in divs:
debug1("  in loop, div", div)
if x % div == 0:
return False
# If we reach here, x was not divisible by any integer in
# 2 to x - 1, so x is prime.
return True

# Generator function to yield the divisors one at a time, to
# avoid creating the whole list of divisors up front.
def gen_range(start, x):
assert start > 0, "in gen_range, start > 0 failed"
assert x > start, "in gen_range, x > start failed"
i = start
while i < x:
yield i
i += 1

# Early-terminating version, when 1st remainder equal to 0 found,
# using a generator for the range of divisors.
def is_prime_4(x):
assert x > 2, "in is_prime_4, x > 2 failed"
divs = gen_range(2, x)
debug1("in is_prime_4, x", x)
for div in divs:
debug1("  in loop, div", div)
if x % div == 0:
return False
return True

def check_primes(low, high):
assert low <= high, "in check_primes, low <= high failed"

"""
print("\nWith a for loop:")
for x in range(low, high + 1):
print(x, "is" if is_prime_1(x) else "is not", "prime,", end=" ")
print()
"""

print("\nWith nested function calls:")
output = [ str(x) + (" prime" if is_prime_2(x) else " not prime") \
for x in range(low, high + 1) ]
print(", ".join(output))

print("\nWith a list of divisors and early termination:")
output = [ str(x) + (" prime" if is_prime_3(x) else " not prime") \
for x in range(low, high + 1) ]
print(", ".join(output))

print("\nWith a generator of divisors and early termination:")
output = [ str(x) + (" prime" if is_prime_4(x) else " not prime") \
for x in range(low, high + 1) ]
print(", ".join(output))

def main():
try:
low = int(sys.argv[1])
high = int(sys.argv[2])
if low <= 2:
print("Error: Low value must be > 2.")
sys.exit(1)
if high < low:
print("Error: High value must be >= low value.")
sys.exit(1)
print("Checking primality of integers between {} and {}".format(low, high))
check_primes(low, high)
sys.exit(0)
except ValueError as ve:
print("Caught ValueError: {}".format(str(ve)))
except IndexError as ie:
print("Caught IndexError: {}".format(str(ie)))
sys.exit(1)

if __name__ == '__main__':
main()
```
And here are some runs of the output, below, both for normal and error cases. Note that I used my debug1() debugging utility function in a few places, to show what divisors are being used, in a few places. This helps show that the early termination logic works. To turn off debugging output, simply use the -O option, like this example:

python -O is_prime.py other_args

This improved version of the debug1 function (get it here), unlike the earlier version that was shown in this blog post:

A simple Python debugging function

, does not require the user to set any environment variables like VR_DEBUG, since it uses Python's built-in __debug__ variable instead. So to enable debugging, nothing extra needs to be done, since that variable is set to True by default. To disable debugging, all we have to do is pass the -O option on the python command line.

Here is the prime program's output:

```Try this one later (if you're trying out the program), since it takes
longer to run. You may observe some interesting behavior:

\$ python -O is_prime.py 3 10000 | less

where less is the Unix 'less' command, a text pager. Any command-line text pager
that can read standard input (from a pipe) will work.

Try some of these below (both normal and error cases) before the one above:

Some error-handling cases:

\$ python -O is_prime.py 0 0
Error: Low value must be > 2.

\$ python -O is_prime.py 2 0
Error: Low value must be > 2.

\$ python -O is_prime.py 3 0
Error: High value must be >= low value.

\$ python -O is_prime.py 4 2
Error: High value must be >= low value.

Some normal cases:

\$ python -O is_prime.py 3 3
Checking primality of integers between 3 and 3

With nested function calls:
3 prime

With a list of divisors and early termination:
3 prime

With a generator of divisors and early termination:
3 prime

To show that the early termination logic works, run the program without
the -O option.
Here is one such run. Due to more debugging output, I've only checked
two numbers, 4 and 5. But you can try with any number of values if you
page the output, or redirect it to a file.

\$ python is_prime.py 4 5
Checking primality of integers between 4 and 5

With nested function calls:
4 not prime, 5 prime

With a list of divisors and early termination:
in is_prime_3, x: 4
in loop, div: 2
in is_prime_3, x: 5
in loop, div: 2
in loop, div: 3
in loop, div: 4
4 not prime, 5 prime

With a generator of divisors and early termination:
in is_prime_4, x: 4
in loop, div: 2
in is_prime_4, x: 5
in loop, div: 2
in loop, div: 3
in loop, div: 4
4 not prime, 5 prime

You can see from the above run that for 4, the checking stops early,
at the first divisor (2), in fact, because it evenly divides 4.
But for 5, all divisors from 2 to 4 are checked, because 5 has
no prime factors (except itself and 1).

And here is a run checking for primes between 3 and 30:

\$ python -O is_prime.py 3 30
Checking primality of integers between 3 and 30

With nested function calls:
3 prime, 4 not prime, 5 prime, 6 not prime, 7 prime, 8 not prime, 9 not prime,
10 not prime, 11 prime, 12 not prime, 13 prime, 14 not prime, 15 not prime,
16 not prime, 17 prime, 18 not prime, 19 prime, 20 not prime, 21 not prime,
22 not prime, 23 prime, 24 not prime, 25 not prime, 26 not prime, 27 not prime,
28 not prime, 29 prime, 30 not prime

With a list of divisors and early termination:
3 prime, 4 not prime, 5 prime, 6 not prime, 7 prime, 8 not prime, 9 not prime,
10 not prime, 11 prime, 12 not prime, 13 prime, 14 not prime, 15 not prime,
16 not prime, 17 prime, 18 not prime, 19 prime, 20 not prime, 21 not prime,
22 not prime, 23 prime, 24 not prime, 25 not prime, 26 not prime, 27 not prime,
28 not prime, 29 prime, 30 not prime

With a generator of divisors and early termination:
3 prime, 4 not prime, 5 prime, 6 not prime, 7 prime, 8 not prime, 9 not prime,
10 not prime, 11 prime, 12 not prime, 13 prime, 14 not prime, 15 not prime,
16 not prime, 17 prime, 18 not prime, 19 prime, 20 not prime, 21 not prime,
22 not prime, 23 prime, 24 not prime, 25 not prime, 26 not prime, 27 not prime,
28 not prime, 29 prime, 30 not prime

You can see that all three functions (is_prime_2 to 4) give the same results.
(I commented out the call to the naive function version, is_prime_1, after
a few runs (not shown), so none of these outputs shows its results, but they
are the same as the others, except for minor formatting differences, due to
the slightly different output statements used.

I also timed the program for finding primes up to 1000 and 10,000
(using my own simple command timing program written in Python - not shown).

Command: python -O is_prime.py 3 1000
Time taken: 2.79 seconds
Return code: 0

Command: python -O is_prime.py 3 10000
Time taken: 66.28 seconds
Return code: 0
```

Q (programming_language from Kx_Systems

Kx Systems

Kdb+

Column-oriented DBMS

In-memory database

Enjoy.

- Vasudev Ram - Online Python training and consulting

Get fast web hosting with A2Hosting.com

My ActiveState Code recipes

Are you a blogger with some traffic? Get Convertkit:

Email marketing for professional bloggers

## Saturday, May 5, 2018

### A Python version of the Linux watch command

By Vasudev Ram

[ Update: A note to those reading this post via Planet Python or other aggregators:

Before first pulbishing it, I reviewed the post in Blogger's preview mode, and it appeared okay, regarding the use of the less-than character, so I did not escape it. I did not know (or did not remember) that Planet Python's behavior may be different. As a result, the code had appeared without the less-than signs in the Planet, thereby garbling it. After noticing this, I fixed the issue in the post. Apologies to those seeing the post twice as a result. ]

I was browsing Linux command man pages (section 1) for some work, and saw the page for an interesting command called watch. I had not come across it before. So I read the watch man page, and after understanding how it works (it's pretty straightforward [1]), thought of creating a Python version of it. I have not tried to implement exactly the same functionality as watch, though, just something similar to it. I called the program watch.py.

[1] The one-line description of the watch command is:

watch - execute a program periodically, showing output fullscreen

How watch.py works:

It is a command-line Python program. It takes an interval argument (in seconds), followed by a command with optional arguments. It runs the command with those arguments, repeatedly, at that interval. (The Linux watch command has a few more options, but I chose not to implement those in this version. I may add some of them [2], and maybe some other features that I thought of, in a future version.)

[2] For example, the -t, -b and -e options should be easy to implement. The -p (--precise) option is interesting. The idea here is that there is always some time "drift" [3] when trying to run a command periodically at some interval, due to unpredictable and variable overhead of other running processes, OS scheduling overhead, and so on. I had experienced this issue earlier when I wrote a program that I called pinger.sh, at a large company where I worked earlier.

[3] You can observe the time drift in the output of the runs of the watch.py program, shown below its code below. Compare the interval with the time shown for successive runs of the same command.

I had written it at the request of some sysadmin friends there, who wanted a tool like that to monitor the uptime of multiple Unix servers on the company network. So I wrote the tool, using a combination of Unix shell, Perl and C. They later told me that it was useful, and they used it to monitor the uptime of multiple servers of the company in different cities. The C part was where the more interesting stuff was, since I used C to write a program (used in the overall shell script) that sort of tried to compensate for the time drift, by doing some calculations about remaining time left, and sleeping for those intervals. It worked somewhat okay, in that it reduced the drift a good amount. I don't remember the exact logic I used for it right now, but do remember finding out later, that the gettimeofday function might have been usable in place of the custom code I wrote to solve the issue. Good fun. I later published the utility and a description of it in the company's Knowledge Management System.

Anyway, back to watch.py: each time, it first prints a header line with the interval, the command string (truncated if needed), and the current date and time, followed by some initial lines of the output of that command (this is what "watching" the command means). It does this by creating a pipe with the command, using subprocess.Popen and then reading the standard output of the command, and printing the first num_lines lines, where num_lines is an argument to the watch() function in the program.

The screen is cleared with "clear" for Linux and "cls" for Windows. Using "echo ^L" instead of "clear" works on some Linux systems, so changing the clear screen command to that may make the program a little faster, on systems where echo is a shell built-in, since there will be no need to load the clear command into memory each time [4]. (As a small aside, on earlier Unix systems I've worked on, on which there was sometimes no clear command (or it was not installed), as a workaround, I used to write a small C program that printed 25 newlines to the screen, and compile and install that as a command called clear or cls :)

[4] Although, on recent Windows and Linux systems, after a program is run once, if you run it multiple times a short while later, I've noticed that the startup time is faster from the second time onwards. I guess this is because the OS loads the program code into a memory cache in some way, and runs it from there for the later times it is called. Not sure if this is the same as the OS buffer cache, which I think is only for data. I don't know if there is a standard name for this technique. I've noticed for sure, that when running Python programs, for example, the first time you run:

python some_script_name.py

it takes a bit of time - maybe a second or three, but after the first time, it starts up faster. Of course this speedup disappears when you run the same program after a bigger gap, say the next day, or after a reboot. Presumably this is because that program cache has been cleared.

Here is the code for watch.py.
```"""
------------------------------------------------------------------
File: watch.py
Version: 0.1
Purpose: To work somewhat like the Linux watch command.
See: http://man7.org/linux/man-pages/man1/watch.1.html
Does not try to replicate its functionality exactly.

Author: Vasudev Ram
Web site: https://vasudevram.github.io
------------------------------------------------------------------
"""

from __future__ import print_function

import sys
import os
from subprocess import Popen, PIPE
import time

from error_exit import error_exit

# Assuming 25-line terminal. Adjust if different.
# If on Unix / Linux, can get value of environment variable
# COLUMNS (if defined) and use that instead of 80.
DEFAULT_NUM_LINES = 20

def usage(args):
lines = [
"Usage: python {} interval command [ argument ... ]".format(
args[0]),
"Run command with the given arguments every interval seconds,",
"and show some initial lines from command's standard output.",
"Clear screen before each run.",
]
for line in lines:
sys.stderr.write(line + '\n')

def watch(command, interval, num_lines):
# Truncate command for display in the header of watch output.
if len(command) > 50:
command_str = command[:50] + "..."
else:
command_str = command
hdr_part_1 = "Every {}s: {} ".format(interval, command_str)
# Assuming 80 columns terminal width. Adjust if different.
# If on Unix / Linux, can get value of environment variable
# COLUMNS (if defined) and use that instead of 80.
columns = 80
# Compute pad_len only once, before the loop, because
# neither len(hdr_part_1) nor len(hdr_part_2) change,
# even though hdr_part_2 is recomputed each time in the loop.
hdr_part_2 = time.asctime()
pad_len = columns - len(hdr_part_1) - len(hdr_part_2) - 1
while True:
# Clear screen based on OS platform.
if "win" in sys.platform:
os.system("cls")
elif "linux" in sys.platform:
os.system("clear")
hdr_str = hdr_part_1 + (" " * pad_len) + hdr_part_2
print(hdr_str + "\n")
# Run the command, read and print its output up to num_lines lines.
# os.popen is the old deprecated way, Python docs recommend to use
# subprocess.Popen.
#with os.popen(command) as pipe:
with Popen(command, shell=True, stdout=PIPE).stdout as pipe:
for line_num, line in enumerate(pipe):
print(line, end='')
if line_num >= num_lines:
break
time.sleep(interval)
hdr_part_2 = time.asctime()

def main():

sa, lsa = sys.argv, len(sys.argv)

# Check arguments and exit if invalid.
if lsa < 3:
usage(sa)
error_exit(
"At least two arguments are needed: interval and command;\n"
"optional arguments can be given following command.\n")

try:
# Get the interval argument as an int.
interval = int(sa[1])
if interval < 1:
error_exit("{}: Invalid interval value: {}".format(sa[0],
interval))
# Build the command to run from the remaining arguments.
command = " ".join(sa[2:])
# Run the command repeatedly at the given interval.
watch(command, interval, DEFAULT_NUM_LINES)
except ValueError as ve:
error_exit("{}: Caught ValueError: {}".format(sa[0], str(ve)))
except OSError as ose:
error_exit("{}: Caught OSError: {}".format(sa[0], str(ose)))
except Exception as e:
error_exit("{}: Caught Exception: {}".format(sa[0], str(e)))

if __name__ == "__main__":
main()
```
Here is the code for error_exit.py, which watch imports.
```# error_exit.py

# Author: Vasudev Ram
# Web site: https://vasudevram.github.io

# Purpose: This module, error_exit.py, defines a function with
# the same name, error_exit(), which takes a string message
# as an argument. It prints the message to sys.stderr, or
# to another file object open for writing (if given as the
# second argument), and then exits the program.
# The function error_exit can be used when a fatal error condition occurs,
# and you therefore want to print an error message and exit your program.

import sys

def error_exit(message, dest=sys.stderr):
dest.write(message)
sys.exit(1)

def main():
error_exit("Testing error_exit with dest sys.stderr (default).\n")
error_exit("Testing error_exit with dest sys.stdout.\n",
sys.stdout)
with open("temp1.txt", "w") as fil:
error_exit("Testing error_exit with dest temp1.txt.\n", fil)

if __name__ == "__main__":
main()
```
Here are some runs of watch.py and their output:
(BTW, the dfs command shown, is from the Quick-and-dirty disk free space checker for Windows post that I had written recently.)

```\$ python watch.py 15 ping google.com

Every 15s: ping google.com                             Fri May 04 21:15:56 2018

Pinging google.com [2404:6800:4007:80d::200e] with 32 bytes of data:

Ping statistics for 2404:6800:4007:80d::200e:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 109ms, Maximum = 137ms, Average = 120ms

Every 15s: ping google.com                             Fri May 04 21:16:14 2018

Pinging google.com [2404:6800:4007:80d::200e] with 32 bytes of data:

Ping statistics for 2404:6800:4007:80d::200e:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 56ms, Maximum = 501ms, Average = 196ms

Every 15s: ping google.com                             Fri May 04 21:16:33 2018

Pinging google.com [2404:6800:4007:80d::200e] with 32 bytes of data:

Ping statistics for 2404:6800:4007:80d::200e:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 141ms, Maximum = 268ms, Average = 210ms

\$ python watch.py 15 c:\ch\bin\date

Every 15s: c:\ch\bin\date                              Tue May 01 00:33:00 2018

Tue May  1 00:33:00 India Standard Time 2018

Every 15s: c:\ch\bin\date                              Tue May 01 00:33:15 2018

Tue May  1 00:33:16 India Standard Time 2018

Every 15s: c:\ch\bin\date                              Tue May 01 00:33:31 2018

Tue May  1 00:33:31 India Standard Time 2018

Every 15s: c:\ch\bin\date                              Tue May 01 00:33:46 2018

Tue May  1 00:33:47 India Standard Time 2018

In one CMD window:

\$ d:\temp\fill-and-free-disk-space

In another:

\$ python watch.py 10 dfs d:\

Every 10s: dfs d:\                                     Tue May 01 00:43:25 2018
Disk free space on d:\
37666.6 MiB = 36.78 GiB

Every 10s: dfs d:\                                     Tue May 01 00:43:35 2018
Disk free space on d:\
37113.7 MiB = 36.24 GiB

\$ python watch.py 20 dir /b "|" sort

Every 20s: dir /b | sort                               Fri May 04 21:29:41 2018

runner.py
watch-outputs.txt
watch-outputs2.txt
watch.py
watchnew.py

\$ python watch.py 10 ping com.nosuchsite

Every 10s: ping com.nosuchsite                         Fri May 04 21:30:49 2018

Ping request could not find host com.nosuchsite. Please check the name and try again.

\$ python watch.py 20 dir z:\

Every 20s: dir z:\                                     Tue May 01 00:54:37 2018
The system cannot find the path specified.

\$ python watch.py 2b echo testing
watch.py: Caught ValueError: invalid literal for int() with base 10: '2b'

\$ python watch.py 20 foo

Every 20s: foo                                         Fri May 04 21:33:35 2018

'foo' is not recognized as an internal or external command,
operable program or batch file.

\$ python watch.py -1 foo
watch.py: Invalid interval value: -1
```
- Enjoy.

Interested in a Python programming or Linux commands and shell scripting course? I have good experience built over many years of real-life experience, as well as teaching, in both those subject areas. Contact me for course details via my contact page here.

Fast web hosting with A2 Hosting

My ActiveState Code recipes

Are you a blogger with some traffic? Get Convertkit:

Email marketing for professional bloggers

## Wednesday, April 18, 2018

### Support the PSF during the 2018 Fundraising Drive

By Vasudev Ram

Support the PSF during the 2018 Fundraising Drive

Excerpt from the above post by the PSF (Python Software Foundation):

[ The PSF is launching an exciting fundraising drive with a goal of raising \$20,000.00 USD by May 12th. The drive begins April 16, 2018 and concludes at PyCon on May 12th.

Your donations help the Python community worldwide by supporting sprints, meetups, community events and projects, the Python Ambassador Program, fiscal sponsorships, and of course, software development and open source projects. All of these initiatives help improve the Python community and Python tools that you use daily. The work cannot be done without the generous financial support that individuals and organizations provide us.

It is easy to donate - simply click on the amount you would like to give, and enter your email address. Confirm your contribution and you will be able to pay with your PayPal account or a credit or debit card. Contributions are tax deductible for individuals and organizations in the United States. ]

Note: The original PSF post about the donation drive, linked above, did not have a clickable link. There is a link for the donation in that post, but it was plain text, not clickable, at the time when I wrote this post. (That might change by the time you read my post, if they notice and fix it.) If not, you will have to copy-and-paste that link manually into a browser tab and then it will take you to another page where you can donate.

- Vasudev Ram - Online Python training and consulting