In a previous post I wrote:
For example, you can define car and cdr of LISP fame:
def car(mylist): if len(mylist)==0: return [] else: return mylist[0]
def cdr(mylist): if len(mylist)==0: return [] else: return mylist[1:]
That's clearly not quite right. Here's car and cdr in action in DrScheme: Welcome to DrScheme, version 101. Language: Textual Full Scheme (MzScheme).
(car '()) car: expects argument of type <pair>; given () (car '(1)) 1 (cdr '(1)) ()
In other words, the car of an empty list is undefined. The car of a 1-member list is that member. The cdr of a 1 member list is the empty list (provided it's a proper list of cons pairs -- but that's another story). So... def car(mylist): return mylist[0] # first member def cdr(mylist): if len(mylist)==1: return [] # returns empty list else: return mylist[1:] # else, rest of list
car((1,)) 1 cdr((1,)) []
You get error messages if your argument to either is an empty list. Then: def Reduce(operator,mylist): if len(mylist)==1: return car(mylist) else: return apply(operator, ( car(mylist), Reduce(operator,cdr(mylist)) ) ) Usage:
Reduce(operator.mul,range(1,11)) 3628800 1*2*3*4*5*6*7*8*9*10 3628800
I'm not saying we should customarily program this way, simply that it's possible to communicate some of the flavor of Scheme by bringing analogous features of Python into the foreground. One could go on to define caaaar, cddddr, cdadar, cdar, cadadr -- the whole set of weird (unpronouncable) words for doing "slice arithemetic". http://www.cs.washington.edu/education/courses/341/99su/lectures/scheme/img0 28.GIF shows ([lambda (x y)(+ (* 2 x) y)] 4 5) evaluating to 13. In DrScheme:
([lambda (x y)(+ (* 2 x) y)] 4 5) 13
In Python:
apply(lambda x,y: 2*x + y, (4,5)) 13
Like in Scheme, in Python you can bind the lambda part to a name:
f = lambda x,y: 2*x + y f(4,5) 13
Alternatively:
def f(x,y): return apply(lambda x,y: 2*x + y,(x,y))
f(4,5) 13
Which is just a rather long-winded way of just saying:
def f(x,y): return 2*x + y
http://www.cs.washington.edu/education/courses/341/99su/lectures/scheme/img0 68.GIF shows a "procedure factory": We go
(filter [lambda (x) (>= x 0)] '(-2 -3 -1 3 1 4)) (3 1 4)
i.e. returns x's >= 0 -- this doesn't seem to work in DrScheme (apparently filter is not a primitive).
(filter [lambda (x) (>= x 2)] '(-2 -3 -1 3 1 4)) (3 4)
returns x's >= 2 So we'd like to define a function which creates other functions with n being whatever number we have to be greater than. In Scheme, that looks like: (define (greater-than-n?? n) (lambda (x) (>= x n))) Then you can say: (define greater-than-2 (greater-than-n?? 2)) ^^^^^^^^^^^^^^^^^^^^ returns a pointer to a procedure and get a procedure, i.e.
((greater-than-2) '(-2 -3 -1 3 1 4)) (3 4)
In Python:
def gt_n(n): return eval('lambda x: x>%s' % n)
gt_2 = gt_n(2) ^^^^^^ returns a pointer to a procedure
gt_2(-1) 0 gt_2(3) 1 filter(gt_2,[-3, -2, 1, 3, 1, 4]) [3, 4]
Thanks to Jeff Cogswell for teaching me the above. Thanks to Greg Badros's lecture notes re Scheme at http://www.cs.washington.edu/education/courses/341/99su/lectures/scheme/ for slide GIFs. Thanks to John Clements, Matthias Felleisen, Robby Findler, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, and Paul Steckler et al for the Dr. Scheme software. http://www.npr.org/ramfiles/wesun/19990404.wesun.07.ram to hear Paul Steckler play that Sunday game program on NPR. Also, listen to Matthias on http://www.cs.rice.edu/CS/PLT/Miscellaneous/matthias-kuhf.mp3 Kirby