Code and data driven programming

Note that in Python 2, the division operator "/" does an integer division if both operands are integer.

Note that in Python 3, the division operator "/" does an floating point division.

Note that in Python 3, the division operator "//" does an integer division. Here is the Python code.

def colorToHex1(color1):
	if color1 == "red":
		hex1 = "FF0000"
	elif color1 == "green":
		hex1 = "00FF00"
	elif color1 == "blue":
		hex1 = "00FF00"
	elif color1 == "cyan":
		hex1 = "00FF00"
	elif color1 == "magenta":
		hex1 = "00FF00"
	elif color1 == "yellow":
		hex1 = "00FF00"
	elif color1 == "black":
		hex1 = "000000"
	elif color1 == "white":
		hex1 = "FFFFFF"
	else:
		hex1 = "CCCCCC"
	return hex1

colorList1 = [
	"red",
	"green",
	"blue",
	"cyan",
	"magenta",
	"yellow",
	"black",
	"white",
	"other",
	]
for color1 in colorList1:
	hex1 = colorToHex1(color1)
	print("{0:s} :: {1:s}".format(hex1,color1))

Here is the output of the Python code.

FF0000 :: red
00FF00 :: green
00FF00 :: blue
00FF00 :: cyan
00FF00 :: magenta
00FF00 :: yellow
000000 :: black
FFFFFF :: white
CCCCCC :: other

Notice that there is no select statement in Python. One uses a series of else-if statements.

Is there a better way? Here is the Python code.

colorDict1 = {
	"red" : "FF0000",
	"green" : "00FF00",
	"blue" : "0000FF",
	"cyan" : "00FFFF",
	"magenta" : "FF00FF",
	"yellow" : "FFFF00",
	"black" : "000000",
	"white" : "FFFFFF"
	}

def colorToHex2(color1):
	if isset(colorDict2[color1]):
		hex1 = colorDict1[color1]
	else:
		hex1 = "CCCCCC"
	return hex1


def colorToHex1(color1):
	return colorDict1.get(color1,"CCCCCC")

colorList1 = [
	"red",
	"green",
	"blue",
	"cyan",
	"magenta",
	"yellow",
	"black",
	"white",
	"other",
	]
for color1 in colorList1:
	hex1 = colorToHex1(color1)
	print("{0:s} :: {1:s}".format(hex1,color1))

Here is the output of the Python code.

FF0000 :: red
00FF00 :: green
0000FF :: blue
00FFFF :: cyan
FF00FF :: magenta
FFFF00 :: yellow
000000 :: black
FFFFFF :: white
CCCCCC :: other

Consider the evaluation of arithmetic operations. Here is the Python code.

opList1 = [
	["add", 3, 2],
	["sub", 3, 2],
	["mul", 3, 2],
	["div", 3, 2],
	["mod", 3, 2]
	]
for op1, value1, value2 in opList1:
	if op1 == "add":

		value3 = value1 + value2
		ch1 = "+"
	elif op1 == "sub":
		value3 = value1 - value2
		ch1 = "-"
	elif op1 == "mul":
		value3 = value1 * value2
		ch1 = "*"
	elif op1 == "div":
		value3 = value1 // value2
		ch1 = "/"
	elif op1 == "mod":
		value3 = value1 % value2
		ch1 = "%"
	print("{0:s} :: {1:d} {2:s} {3:d} is {4:d}".format(op1,value1,ch1,value2,value3))

Here is the output of the Python code.

add :: 3 + 2 is 5
sub :: 3 - 2 is 1
mul :: 3 * 2 is 6
div :: 3 / 2 is 1
mod :: 3 % 2 is 1

Python, like many newer languages, supports functional programming concepts of functional variables.

C# makes this somewhat cumbersome via delegates.
Java makes this very cumbersome via interfaces.

Here is the Python code.

def addDo1(x1, y1):
	return x1 + y1


def subDo1(x1, y1):
	return x1 - y1


def mulDo1(x1, y1):
	return x1 * y1


def divDo1(x1, y1):
	return x1 // y1


def modDo1(x1, y1):
	return x1 % y1

opDict1 = {
	"add" : ["+", addDo1],
	"sub" : ["-", subDo1],
	"mul" : ["*", mulDo1],
	"div" : ["/", divDo1],
	"mod" : ["%", modDo1]
	}
opList1 = [
	["add", 3, 2],
	["sub", 3, 2],
	["mul", 3, 2],
	["div", 3, 2],
	["mod", 3, 2]
	]
for op1, value1, value2 in opList1:
	ch1, action1 = opDict1[op1]
	value3 = action1(value1, value2)
	print("{0:s} :: {1:d} {2:s} {3:d} is {4:d}".format(op1,value1,ch1,value2,value3))

Here is the output of the Python code.

add :: 3 + 2 is 5
sub :: 3 - 2 is 1
mul :: 3 * 2 is 6
div :: 3 / 2 is 1
mod :: 3 % 2 is 1

A lambda construct is a way to make an anonymous function. When you see lambda, think "make function".

The name has a historical origin - from the lambda calculus as a way to determine the limits of computation.

lambda calculus by Alonzo Church - functional way
Turning machine by Alan Turing - operational way

Church-Turning hypothesis/thesis - what is computable is that computable via a Turing machine. Here is the Python code.

opDict1 = {
	"add" : ["+", lambda x1, y1 : x1 + y1],
	"sub" : ["-", lambda x1, y1 : x1 - y1],
	"mul" : ["*", lambda x1, y1 : x1 * y1],
	"div" : ["/", lambda x1, y1 : x1 // y1],
	"mod" : ["%", lambda x1, y1 : x1 % y1]
	}
opList1 = [
	["add", 3, 2],
	["sub", 3, 2],
	["mul", 3, 2],
	["div", 3, 2],
	["mod", 3, 2]
	]
for op1, value1, value2 in opList1:
	ch1, action1 = opDict1[op1]
	value3 = action1(value1,value2)
	print("{0:s} :: {1:d} {2:s} {3:d} is {4:d}".format(op1,value1,ch1,value2,value3))

Here is the output of the Python code.

add :: 3 + 2 is 5
sub :: 3 - 2 is 1
mul :: 3 * 2 is 6
div :: 3 / 2 is 1
mod :: 3 % 2 is 1