35 views

Uploaded by khazarhayat

Functional Programming in Python-3

save

- NUMERICAL MODELLING OF TIME DEPENDENT PORE PRESSURE RESPONSE INDUCED BY HELICAL PILE INSTALLATION
- Python for You and Me
- EC 2-Manual of Numerical Methods in Concrete
- Scientific Programming in Python
- The Navier-Stokes Equations Theory And Numerical Methods
- solar cell numerical solution
- Numerical and experimental studies of nonlinear wave loads of ships
- LaTeX Tutorial
- Numerical Ability for Bank Exam
- Python quick reference
- MIT Numerical PDE
- Numerical Methods Book.pdf
- Python Basic concept
- Python Strings Reference Card
- numerical_matrix_analysis_linear_systems_and_lea.pdf
- HowtoStudy&TakeExams
- Creating Network Graphs With Python
- Mathematical Techniques for Engineers and Scientists _ Publications_ SPIE
- Advance numerical analysis
- Ex Numerical Method
- Boundary Elements an Introductory Course - Brebbia and Dominguez
- Numerical Methods
- Multithreading in Python
- Elsevier - Handbook of Numerical Analysis V1 Part1 - Finite Difference Methods
- Advanced Numerical Methods
- Numerical Analysis 8th Editionpdf
- python design pattern
- Delaunay Triangulation and Meshing - George & Borouchaki
- Python distutils
- Numerical Renaissance
- Exercise 1
- Design Document
- Android Manual
- Accenture Changing Scale Offshore Wind
- Jouriles Boys
- Mathematics With MATLAB
- APA Beginners Guide 6th Edition
- ACMA-S-13-00078
- COTO379
- Dyadic Adjustment Scale DAS
- RePrint
- whismandavilagoodman2011jfp.pdf
- Exercise 1
- DNVGL_Offshore open day Busan_2014-06-20_Flyer+Agenda
- Pablo_Castillo_r.pdf
- Wind Turbine Blade Stress Analysis and Natural Frequencies_1978
- User's Manual BECASv2 - Executable version - JP Blasques (C) Risø DTU National Laboratory for Sustainable Energy 04122012
- Main
- Mechanics of Composite Beams
- s Truc t Aero Composite Idealization
- APA Beginners Guide 6th Edition
- DesignDocmument.pdf
- android_manual.pdf
- Composites in Wind Turbine Blades Daily Dose
- Presentation SHM
- Composites in Wind Turbine Blades Daily Dose
- cse11
- Self Measures for Marital Satisfaction MARITAL ADJUSTMENT TEST(1)
- Wearable Sensor

You are on page 1of 7

.................

**Advanced search IBM home | Products & services | Support & downloads | My account
**

IBM : developerWorks : Linux | Open source : Linux articles | Open source articles

Charming Python: Functional programming in Python, Part 3 Currying and other higher-order functions David Mertz, Ph.D. (mertz@gnosis.cx) Applied Metaphysician, Gnosis Software, Inc. June 2001 Author David Mertz touched on many basic concepts of functional programming in earlier Charming Python articles: "Functional programming in Python", Part 1 and Part 2. Here he continues the discussion by illustrating additional capabilities, like currying and other higher-order functions contained in the Xoltar Toolkit. Expression bindings Never content with partial solutions, one reader -- Richard Davies -- raised the issue of whether we might move bindings all the way into individual expressions. Let's take a quick look at why we might want to do that, and also show a remarkably elegant means of expression provided by a comp.lang.python contributor. Let's first recall the Bindings class of the functional module. Using the attributes of that class, we were able to assure that a particular name means only one thing within a given block scope: Listing 1: Python FP session with guarded rebinding >>> from functional import * >>> let = Bindings() >>> let.car = lambda lst: lst[0] >>> let.car = lambda lst: lst[2] Traceback (innermost last): File "<stdin>", line 1, in ? File "d:\tools\functional.py", line 976, in __setattr__ raise BindingError, "Binding '%s' cannot be modified." % name functional.BindingError: Binding 'car' cannot be modified. >>> let.car(range(10)) 0 The Bindings class does what we want within a module or function def scope, but there is no way to make it work within a single expression. In ML-family languages, however, it is natural to create bindings within a single expression: Listing 2: Haskell expression-level name bindings Contents: Expression bindings Higher-order functions: currying Miscellaneous higher-order functions Until next time Resources About the author Rate this article

Related dW content:

Functional programming in Python, Part 1 Functional programming in Python, Part 2

http://www-106.ibm.com/developerworks/library/l-prog3.html (1 of 7) [6/27/2001 1:26:45 PM]

8.*could* create module-level binding list_of_list = [[1.)] [1.7] Greg Ewing observed that it is possible to accomplish the same effect using Python's list comprehensions.. even in cases where a list is not what we finally want: Listing 5: "Stepping down" from Python list comprehension # Compare Haskell expression: # result = func car_car # where # car (x:xs) = x # car_car = car (car list_of_list) # func x = x + x^2 >>> [func for x in list_of_list .6].3].4..9]] -. but if we want to use map().6]. 7] Not bad.html (2 of 7) [6/27/2001 1:26:45 PM] . we can even do it in a way that is nearly as clean as Haskell's syntax: Listing 3: Python 2.[7.9]] >>> [car_x for x in list_of_list for car_x in (x[0].3]. list_of_list = [[1. As an "optimization" we http://www-106.list_of_list] where car (x:xs) = x -.list_of_list) 4.[4.'where' clause for expression-level binding firsts1 = [car x | x <.car = lambda l: l[0] map(let.ibm. Part 3 -. the scope of the binding remains a little broader than we might want.[7.8.8.2.5. as with: Listing 4: Python block-level bindings with 'map()' >>> >>> >>> >>> [1. for car in (x[0].)][0] 2 We have performed an arithmetic calculation on the first element of the first element of list_of_list while also naming the arithmetic calculation (but only in expression scope).) ..9]] let = Bindings() let. Nonetheless.[4.5. for func in (car+car**2.Charming Python: Functional programming in Python.2. we still need to use block-level bindings.Result: firsts1 == firsts2 == firsts3 == [1.6]. 7] This trick of putting an expression inside a single-item tuple in a list comprehension does not provide any way of using expression-level bindings with higher-order functions.com/developerworks/library/l-prog3.[7.list_of_list] -.5.more idiomatic higher-order 'map' technique firsts3 = map car list_of_list where car (x:xs) = x -.car. 4.[4.0+ expression-level name bindings >>> list_of_list = [[1.'let' clause for expression-level binding firsts2 = let car (x:xs) = x in [car x | x <.. To use the higher-order functions.3].car (x:xs) = x -. it is possible to coax list comprehensions into doing our name bindings for us.2.

. Possibly the most famous and most important higher-order function is curry().. curry() is named after the logician Haskell Curry.. and whose usefulness have been proven over many years.com/developerworks/library/l-prog3. which I discussed in Part 2 of this series.each successive call to a curried return function "fills in" more of the data involved in a final computation (data attached to a procedure)..) . and filter().and the reason we call them "higher-order" -. since we choose only the first element with the ending index 0: Listing 6: Efficient stepping down from list comprehension >>> [func for x in list_of_list[:1] .Result: check == answer == 657 http://www-106..is take other functions as (some of) their arguments. Part 3 might not bother to create a list longer than one element to start with.html (3 of 7) [6/27/2001 1:26:45 PM] .." This works quite similarly to the closures I wrote about in Part 2 -.)][0] 2 Higher-order functions: currying Three of the most general higher-order functions are built into Python: map(). All that is necessary for currying to work is to allow the return value of functions to themselves be functions. for car in (x[0]. . but not these built-ins.Charming Python: Functional programming in Python. Most of the functions that Xoltar's functional module provides are ones developed in various traditionally functional languages. The underlying insight of "currying" is that it is possible to treat (almost) every function as a partial function of just one argument. . Other higher-order functions... then with the same example repeated in Python using the functional module: Listing 8: Currying a Haskell computation computation a b c d = (a + b^2+ c^3 + d^4) check = 1 + 2^2 + 3^3 + 5^4 fillOne fillTwo fillThree answer = = = = computation 1 fillOne 2 fillTwo 3 fillThree 5 ----specify specify specify specify "a" "b" "c" "d" -... comes with a nice collection of higher-order functions.ibm. A trivial case might look like this: Listing 7: Trivial Python function factory >>> .. return function objects. What these functions do -. whose first name is also used to name the above-mentioned programming language. >>> >>> Foo def foo_factory(): def foo(): print "Foo function from factory" return foo f = foo_factory() f() function from factory The Xoltar Toolkit. but with the returned functions "narrowed" or "closer to completion. reduce(). Python has always given users the ability to construct their own higher-order functions by virtue of the first-class status of function objects. Let's illustrate currying first with a very simple example in Haskell.. for func in (car+car**2. .

functional provides a grab-bag of interesting higher-order functions. The second print statement in the example at one level is a trivial spelling change from simply calling the normal taxcalc(50000. The ones in functional provide some interesting ideas.0. higher-order functions feel like "enhanced" versions of the standard map().ibm.b. we need to curry the arguments in a specific order (left to right).30) taxCurry = taxCurry(10000) print "Curried taxes due =".30. For the most part. The functions sequential() and also() both create a function based on a sequence of component functions.a rather surprising idea to those new to it. Part 3 Now in Python: Listing 9: Currying a Python computation >>> >>> >>> 657 >>> >>> >>> >>> >>> >>> 657 from functional import curry computation = lambda a. The main difference between the two is simply that sequential() expects a single list as an argument. Let's look at some of what functional provides. and reduce(). at the least." Again.2. Miscellaneous higher-order functions Beyond the "fundamental" operation of currying. Moreover. filter(). The component functions can then be called with the same argument(s).3. while also() http://www-106. numerous variations are possible. Another pattern is "take a collection of functions and create a function that combines their functionality. Often.rate. it makes rather clear the concept that every function can be a function of just one argument -. But note that functional also contains an rcurry() class that will start at the other end (right to left). then apply the function(s) to list arguments. In a different level.d: (a + b**2 + c**3 + d**4) computation(1.30)(10000) Unlike with closures. \ curry(taxcalc)(50000)(0.taxCurry print "Curried expression taxes due =".html (4 of 7) [6/27/2001 1:26:45 PM] . however.either with or without functional.com/developerworks/library/l-prog3.Charming Python: Functional programming in Python. the pattern in these functions is roughly "take a function or functions and some lists as arguments.c.10000).5) fillZero fillOne fillTwo fillThree answer answer = = = = = curry(computation) fillZero(1) # specify fillOne(2) # specify fillTwo(3) # specify fillThree(5) # specify "a" "b" "c" "d" It is possible to further illustrate the parallel with closures by presenting the same simple tax-calculation program used in Part 2 (this time using curry()): Listing 10: Python curried tax calculations from functional import * taxcalc = lambda income.deduct: (income-(deduct))*rate taxCurry = curry(taxcalc) taxCurry = taxCurry(50000) taxCurry = taxCurry(0." There are a surprising number of interesting and useful ways to play on this theme. it is really not hard to write your own higher-order functions -.

.. Part 3 takes a list of arguments.6.3.. joinfuncs() is similar to also().. isEven) A particularly interesting higher-order function for those with a little bit of mathematics background is compose(). print x. Logical shortcutting is applied. The programmer who composes several functions is responsible http://www-106. return "a" .5.c) >>> r <functional. . print x*2.7].. but returns a tuple of the components' return values rather than selecting a main one. these are useful for function side effects. but sequential() optionally lets you choose which function provides the combined return value: Listing 11: Sequential calls to functions (with same args) >>> def a(x): . But disjoin() asks whether any component functions return true (given the argument(s)). But these particular higher-order functions from functional ask Boolean questions about collections of return values.. In most cases.main=c)('x') x xx xxx 'c' The functions disjoin() and conjoin() are similar to sequential() and also() in terms of creating new functions that apply argument(s) to several component functions. where possible.8].Charming Python: Functional programming in Python. Where the previous functions let you call multiple functions with the same argument(s). >>> def b(x): . isEven) none_of([1.3..5. and conjoin() asks whether all components return true. print x*3. these are a bit like the built-in map(). isEven) all([2.3. and none_of() let you call the same function against a list of arguments. For example: Listing 12: Ask about collections of return values >>> >>> >>> 1 >>> 0 >>> 1 >>> 1 >>> 0 from functional import * isEven = lambda n: (n%2 == 0) any([1.8].. reduce(). .ibm.7].. any(). In general structure. return "c" . so some side effects might not occur with disjoin(). isEven) any([1.. The composition of several functions is a "chaining together" of the return value of one function to the input of the next function..7]. >>> r = also(a.b.4. return "b" . isEven) all([2..b... all()..com/developerworks/library/l-prog3.6. .html (5 of 7) [6/27/2001 1:26:45 PM] .. >>> def c(x): .c]..5.sequential instance at 0xb86ac> >>> r(5) 5 10 15 'a' >>> sequential([a.. filter() functions.4.

.html (6 of 7) [6/27/2001 1:26:45 PM] . Since the functional module is itself written entirely in Python. if only in Emacs). Resources G David's previous columns (Part 1 and Part 2) on functional programming in Python serve as an introduction to this topic. Read additional articles from David's Charming Python column: H Developing a full-text indexer in Python G G G G G http://www-106... Simon Thompson (Addison-Wesley.com/developerworks/library/l-prog3. with a somewhat more applied feel is The Haskell School of Expression: Learning Functional Programming Through Multimedia.ibm.Charming Python: Functional programming in Python. Let me know how it goes.but then. 1999). Other Python programmers might similarly have an easier time without quite so many parentheses and prefix (Polish) operators. I have found it much easier to get a grasp of functional programming in the language Haskell than in Lisp/Scheme (even though the latter is probably more widely used. A simple example makes it clear: Listing 13: Creating compositional functions >>> . perhaps a later installment of this ad hoc series will discuss the novel and fascinating ideas that readers continue to provide. >>> . which includes the module functional.. with a lot of power in compact definitions. Bryn Keller's Xoltar Toolkit. some might well prove useful and powerful. Part 3 for making sure the outputs and inputs match up -. Try to create some of your own higher-order functions.times3) timesminus(10) minus7(times3(10)) Until next time I hope this latest look at higher-order functions will arouse readers' interest in a certain style of thinking. Paul Hudak (Cambridge University Press. But Keller has figured out a very nicely integrated set of extensions. what it does was already possible in Python itself. An equally good introductory book to Haskell. An excellent introductory book is: Haskell: The Craft of Functional Programming (2nd Edition). play with it.lang. adds a large number of useful FP extensions to Python. By all means. G A good starting point for functional programming is the Frequently Asked Questions for comp.minus7) minustimes(10) times3(minus7(10)) timesminus = compose(minus7. >>> 3 >>> >>> 9 >>> 9 >>> >>> 23 >>> 23 def minus7(n): return n-7 def times3(n): return n*3 minus7(10) minustimes = compose(times3.functional. that is true any time a programmer uses a return value. 2000).

or future columns are welcome. his life pored over at http://gnosis. David may be reached at mertz@gnosis. blind.com/developerworks/library/l-prog3. David Mertz wants a cast sculpture of Milton for his office. past. What do you think of this article? Killer! (5) Comments? Good stuff (4) So-so. Suggestions and recommendations on this. Part 3 H H H H H H H H H H H H Getting version 2.cx/publish/. Start planning for his birthday.NET TK programming in Python Reloading on the fly Inside Python's implementations Curses programming Text processing in Python Using state machines My first Web-based filtering proxy The dynamics of DOM Tinkering with XML and Python About the author Since conceptions without intuitions are empty.0 Updating your Python reading list Inside JPython and Python for .ibm.html (7 of 7) [6/27/2001 1:26:45 PM] . and intuitions without conceptions. not bad (3) Needs work (2) Lame! (1) Submit feedback About IBM | Privacy | Legal | Contact http://www-106.Charming Python: Functional programming in Python.cx.

- NUMERICAL MODELLING OF TIME DEPENDENT PORE PRESSURE RESPONSE INDUCED BY HELICAL PILE INSTALLATIONUploaded byAlex
- Python for You and MeUploaded bystvx007
- EC 2-Manual of Numerical Methods in ConcreteUploaded byjan_matej5651
- Scientific Programming in PythonUploaded bystreetcribdealer
- The Navier-Stokes Equations Theory And Numerical MethodsUploaded byMiguel Angel Morua Ramirez
- solar cell numerical solutionUploaded byBhargav Chaitanya
- Numerical and experimental studies of nonlinear wave loads of shipsUploaded byrammi4978
- LaTeX TutorialUploaded bytcdnetsoc
- Numerical Ability for Bank ExamUploaded bycurrentaffairsquiz
- Python quick referenceUploaded byRahul
- MIT Numerical PDEUploaded byKruger Joe
- Numerical Methods Book.pdfUploaded byCengiz Görkem Ela
- Python Basic conceptUploaded byGuru Prasanna V
- Python Strings Reference CardUploaded byaltkommein
- numerical_matrix_analysis_linear_systems_and_lea.pdfUploaded bymarianandrone
- HowtoStudy&TakeExamsUploaded byRimpa Dey
- Creating Network Graphs With PythonUploaded byiggix
- Mathematical Techniques for Engineers and Scientists _ Publications_ SPIEUploaded byKarthiganesbe85
- Advance numerical analysisUploaded byRavi Shankar
- Ex Numerical MethodUploaded byNote Ponart
- Boundary Elements an Introductory Course - Brebbia and DominguezUploaded byKarthiganesbe85
- Numerical MethodsUploaded byAnuragSh1994
- Multithreading in PythonUploaded byTanoy Bose
- Elsevier - Handbook of Numerical Analysis V1 Part1 - Finite Difference MethodsUploaded byKarthiganesbe85
- Advanced Numerical MethodsUploaded byvanbuyten
- Numerical Analysis 8th EditionpdfUploaded byguysarkis
- python design patternUploaded byMeo Map
- Delaunay Triangulation and Meshing - George & BorouchakiUploaded byKarthiganesbe85
- Python distutilsUploaded byVasanth Kumar
- Numerical RenaissanceUploaded bypabsrams

- Exercise 1Uploaded bykhazarhayat
- Design DocumentUploaded bykhazarhayat
- Android ManualUploaded bykhazarhayat
- Accenture Changing Scale Offshore WindUploaded bykhazarhayat
- Jouriles BoysUploaded bykhazarhayat
- Mathematics With MATLABUploaded bykhazarhayat
- APA Beginners Guide 6th EditionUploaded bykhazarhayat
- ACMA-S-13-00078Uploaded bykhazarhayat
- COTO379Uploaded bykhazarhayat
- Dyadic Adjustment Scale DASUploaded bykhazarhayat
- RePrintUploaded bykhazarhayat
- whismandavilagoodman2011jfp.pdfUploaded bykhazarhayat
- Exercise 1Uploaded bykhazarhayat
- DNVGL_Offshore open day Busan_2014-06-20_Flyer+AgendaUploaded bykhazarhayat
- Pablo_Castillo_r.pdfUploaded bykhazarhayat
- Wind Turbine Blade Stress Analysis and Natural Frequencies_1978Uploaded bykhazarhayat
- User's Manual BECASv2 - Executable version - JP Blasques (C) Risø DTU National Laboratory for Sustainable Energy 04122012Uploaded bykhazarhayat
- MainUploaded bykhazarhayat
- Mechanics of Composite BeamsUploaded bykhazarhayat
- s Truc t Aero Composite IdealizationUploaded bykhazarhayat
- APA Beginners Guide 6th EditionUploaded bykhazarhayat
- DesignDocmument.pdfUploaded bykhazarhayat
- android_manual.pdfUploaded bykhazarhayat
- Composites in Wind Turbine Blades Daily DoseUploaded bykhazarhayat
- Presentation SHMUploaded bykhazarhayat
- Composites in Wind Turbine Blades Daily DoseUploaded bykhazarhayat
- cse11Uploaded bykhazarhayat
- Self Measures for Marital Satisfaction MARITAL ADJUSTMENT TEST(1)Uploaded bykhazarhayat
- Wearable SensorUploaded bykhazarhayat