id
int64 0
25.6k
| text
stringlengths 0
4.59k
|
|---|---|
1,100 | annotation valuesspecified as name:value (or name:value=default when defaults are presentthis is simply additional syntax for arguments and does not augment or change the argument-ordering rules described here the function itself can also have an annotation valuegiven as def ()->value python attaches annotation values to the function object see the discussion of function annotation in for more details keyword and default examples this is all simpler in code than the preceding descriptions may imply if you don' use any special matching syntaxpython matches names by position from left to rightlike most other languages for instanceif you define function that requires three argumentsyou must call it with three argumentsdef (abc)print(abcf( herewe pass by position-- is matched to is matched to and so on (this works the same in python and xbut extra tuple parentheses are displayed in because we're using print calls againkeywords in pythonthoughyou can be more specific about what goes where when you call function keyword arguments allow us to match by nameinstead of by position using the same functionf( = = = the = in this callfor examplemeans send to the argument named more formallypython matches the name in the call to the argument named in the function definition' headerand then passes the value to that argument the net effect of this call is the same as that of the prior callbut notice that the left-to-right order of the arguments no longer matters when keywords are used because arguments are matched by namenot by position it' even possible to combine positional and keyword arguments in single call in this caseall positionals are matched first from left to right in the headerbefore keywords are matched by namef( = = gets by positionb and passed by name when most people see this the first timethey wonder why one would use such tool keywords typically have two roles in python firstthey make your calls bit more selfdocumenting (assuming that you use better argument names than aband !for examplea call of this form arguments |
1,101 | is much more meaningful than call with three naked values separated by commasespecially in larger programs--the keywords serve as labels for the data in the call the second major use of keywords occurs in conjunction with defaultswhich we turn to next defaults we talked about defaults in brief earlierwhen discussing nested function scopes in shortdefaults allow us to make selected function arguments optionalif not passed valuethe argument is assigned its default before the function runs for examplehere is function that requires one argument and defaults twodef (ab= = )print(abca requiredb and optional when we call this functionwe must provide value for aeither by position or by keywordhoweverproviding values for and is optional if we don' pass values to and cthey default to and respectivelyf( ( = use defaults if we pass two valuesonly gets its defaultand with three valuesno defaults are usedf( ( override defaults finallyhere is how the keyword and default features interact because they subvert the normal left-to-right positional mappingkeywords allow us to essentially skip over arguments with defaultsf( = choose defaults herea gets by positionc gets by keywordand bin betweendefaults to be careful not to confuse the special name=value syntax in function header and function callin the call it means match-by-name keyword argumentwhile in the header it specifies default for an optional argument in both casesthis is not an assignment statement (despite its appearance)it is special syntax for these two contextswhich modifies the default argument-matching mechanics combining keywords and defaults here is slightly larger example that demonstrates keywords and defaults in action in the followingthe caller must always pass at least two arguments (to match spam and special argument-matching modes |
1,102 | ham to the defaults specified in the headerdef func(spameggstoast= ham= )print((spameggstoastham)first required func( func( ham= eggs= func(spam= eggs= func(toast= eggs= spam= func( output( output( output( output( output( notice again that when keyword arguments are used in the callthe order in which the arguments are listed doesn' matterpython matches by namenot by position the caller must supply values for spam and eggsbut they can be matched by position or by name againkeep in mind that the form name=value means different things in the call and the defa keyword in the call and default in the header beware mutable defaultsas footnoted in the prior if you code default to be mutable object ( def ( =[]))the samesingle mutable object is reused every time the function is later called--even if it is changed in place within the function the net effect is that the argument' default retains its value from the prior calland is not reset to its original value coded in the def header to reset anew on each callmove the assignment into the function body instead mutable defaults allow state retentionbut this is often surprise since this is such common trapwe'll postpone further exploration until this part' "gotchaslist at the end of arbitrary arguments examples the last two matching extensionsand **are designed to support functions that take any number of arguments both can appear in either the function definition or function calland they have related purposes in the two locations headerscollecting arguments the first usein the function definitioncollects unmatched positional arguments into tupledef (*args)print(argswhen this function is calledpython collects all the positional arguments into new tuple and assigns the variable args to that tuple because it is normal tuple objectit can be indexedstepped through with for loopand so onf(( ( ( , arguments |
1,103 | ( the *feature is similarbut it only works for keyword arguments--it collects them into new dictionarywhich can then be processed with normal dictionary tools in sensethe *form allows you to convert from keywords to dictionarieswhich you can then step through with keys callsdictionary iteratorsand the like (this is roughly what the dict call does when passed keywordsbut it returns the new dictionary)def (**args)print(argsf({ ( = = {' ' ' ' finallyfunction headers can combine normal argumentsthe *and the *to implement wildly flexible call signatures for instancein the following is passed to by position and are collected into the pargs positional tupleand and wind up in the kargs keyword dictionarydef ( *pargs**kargs)print(apargskargsf( = = ( {' ' ' ' such code is rarebut shows up in functions that need to support multiple call patterns (for backward compatibilityfor instancein factthese features can be combined in even more complex ways that may seem ambiguous at first glance--an idea we will revisit later in this firstthoughlet' see what happens when and *are coded in function calls instead of definitions callsunpacking arguments in all recent python releaseswe can use the syntax when we call functiontoo in this contextits meaning is the inverse of its meaning in the function definition--it unpacks collection of argumentsrather than building collection of arguments for examplewe can pass four arguments to function in tuple and let python unpack them into individual argumentsdef func(abcd)print(abcdargs ( args +( func(*args same as func( similarlythe *syntax in function call unpacks dictionary of key/value pairs into separate keyword argumentsargs {' ' ' ' ' ' args[' ' special argument-matching modes |
1,104 | same as func( = = = = againwe can combine normalpositionaland keyword arguments in the call in very flexible waysfunc(*( )**{' ' ' ' } func( *( )**{' ' } func( = *( ,)**{' ' } func( *( ) = func( *( ,) = **{' ': } same as func( = = same as func( = same as func( = = same as func( = same as func( = = this sort of code is convenient when you cannot predict the number of arguments that will be passed to function when you write your scriptyou can build up collection of arguments at runtime instead and call the function generically this way againdon' confuse the */*starred-argument syntax in the function header and the function call --in the header it collects any number of argumentswhile in the call it unpacks any number of arguments in bothone star means positionalsand two applies to keywords as we saw in the *pargs form in call is an iteration contextso technically it accepts any iterable objectnot just tuples or other sequences as shown in the examples here for instancea file object works after the *and unpacks its lines into individual arguments ( func(*open('fname')watch for additional examples of this utility in after we study generators this generality is supported in both python and xbut it holds true only for calls-- *pargs in call allows any iterablebut the same form in def header always bundles extra arguments into tuple this header behavior is similar in spirit and syntax to the in python extended sequence unpacking assignment forms we met in ( * )though that star usage always creates listsnot tuples applying functions generically the prior section' examples may seem academic (if not downright esoteric)but they are used more often than you might expect some programs need to call arbitrary functions in generic fashionwithout knowing their names or arguments ahead of time in factthe real power of the special "varargscall syntax is that you don' need to know how many arguments function call requires before you write script for exampleyou can use if logic to select from set of functions and argument listsand call any of them generically (functions in some of the following examples are hypothetical) arguments |
1,105 | actionargs func ( ,elseactionargs func ( etc action(*argscall func with one arg in this case call func with three args here dispatch generically this leverages both the formand the fact that functions are objects that may be both referenced byand called throughany variable more generallythis varargs call syntax is useful anytime you cannot predict the arguments list if your user selects an arbitrary function via user interfacefor instanceyou may be unable to hardcode function call when writing your script to work around thissimply build up the arguments list with sequence operationsand call it with starred-argument syntax to unpack the argumentsdefine or import func args ( , args +( ,args ( func (*argsbecause the arguments list is passed in as tuple herethe program can build it at runtime this technique also comes in handy for functions that test or time other functions for instancein the following code we support any function with any arguments by passing along whatever arguments were sent in (this is file tracer py in the book examples package)def tracer(func*pargs**kargs)print('calling:'func __name__return func(*pargs**kargsaccept arbitrary arguments pass along arbitrary arguments def func(abcd)return print(tracer(func = = )this code uses the built-in __name__ attribute attached to every function (as you might expectit' the function' name string)and uses stars to collect and then unpack the arguments intended for the traced function in other wordswhen this code is runarguments are intercepted by the tracer and then propagated with varargs call syntaxcallingfunc for another example of this techniquesee the preview near the end of the preceding where it was used to reset the built-in open function we'll code additional examples of such roles later in this booksee especially the sequence timing examples in and the various decorator utilities we will code in it' common technique in general tools special argument-matching modes |
1,106 | prior to python xthe effect of the *args and **args varargs call syntax could be achieved with built-in function named apply this original technique has been removed in because it is now redundant ( cleans up many such dusty tools that have been subsumed over the yearsit' still available in all python releasesthoughand you may come across it in older code in shortthe following are equivalent prior to python xfunc(*pargs**kargsapply(funcpargskargsnewer call syntaxfunc(*sequence**dictdefunct built-inapply(funcsequencedictfor exampleconsider the following functionwhich accepts any number of positional or keyword argumentsdef echo(*args**kwargs)print(argskwargsecho( = = ( {' ' ' ' in python xwe can call it generically with applyor with the call syntax that is now required in xpargs ( kargs {' ': ' ': apply(echopargskargs( {' ' ' ' echo(*pargs**kargs( {' ' ' ' both forms work for built-in functions in too (notice ' trailing for its long integers)apply(pow( ) pow(*( ) the unpacking call syntax form is newer than the apply functionis preferred in generaland is required in (technicallyit was added in was documented as deprecated in is still usable without warning in and is gone in and later apart from its symmetry with the collector forms in def headersand the fact that it requires fewer keystrokesthe newer call syntax also allows us to pass along additional arguments without having to manually extend argument sequences or dictionariesecho( = *pargs**kargs( {' ' ' ' ' ' normalkeyword*sequence**dictionary that isthe call syntax form is more general since it' required in xyou should now disavow all knowledge of apply (unlessof courseit appears in code you must use or maintain arguments |
1,107 | python generalizes the ordering rules in function headers to allow us to specify keyword-only arguments--arguments that must be passed by keyword only and will never be filled in by positional argument this is useful if we want function to both process any number of arguments and accept possibly optional configuration options syntacticallykeyword-only arguments are coded as named arguments that may appear after *args in the arguments list all such arguments must be passed using keyword syntax in the call for examplein the followinga may be passed by name or positionb collects any extra positional argumentsand must be passed by keyword only in xdef kwonly( *bc)print(abckwonly( = ( , kwonly( = = ( kwonly( typeerrorkwonly(missing required keyword-only argument'cwe can also use character by itself in the arguments list to indicate that function does not accept variable-length argument list but still expects all arguments following the to be passed as keywords in the next functiona may be passed by position or name againbut and must be keywordsand no extra positionals are alloweddef kwonly( *bc)print(abckwonly( = = kwonly( = = = kwonly( typeerrorkwonly(takes positional argument but were given kwonly( typeerrorkwonly(missing required keyword-only arguments'band 'cyou can still use defaults for keyword-only argumentseven though they appear after the in the function header in the following codea may be passed by name or positionand and are optional but must be passed by keyword if useddef kwonly( * ='spam' ='ham')print(abckwonly( spam ham kwonly( = spam kwonly( = spam ham kwonly( = = = special argument-matching modes |
1,108 | typeerrorkwonly(takes positional argument but were given in factkeyword-only arguments with defaults are optionalbut those without defaults effectively become required keywords for the functiondef kwonly( *bc='spam')print(abckwonly( ='eggs' eggs spam kwonly( ='eggs'typeerrorkwonly(missing required keyword-only argument'bkwonly( typeerrorkwonly(takes positional argument but were given def kwonly( * = cd= )print(abcdkwonly( = kwonly( = = kwonly( typeerrorkwonly(missing required keyword-only argument'ckwonly( typeerrorkwonly(takes positional argument but were given ordering rules finallynote that keyword-only arguments must be specified after single starnot two --named arguments cannot appear after the **args arbitrary keywords formand *can' appear by itself in the arguments list both attempts generate syntax errordef kwonly( **pargsbc)syntaxerrorinvalid syntax def kwonly( **bc)syntaxerrorinvalid syntax this means that in function headerkeyword-only arguments must be coded before the **args arbitrary keywords form and after the *args arbitrary positional formwhen both are present whenever an argument name appears before *argsit is possibly default positional argumentnot keyword-onlydef ( * **dc= )print(abcdsyntaxerrorinvalid syntax keyword-only before **def ( *bc= ** )print(abcdcollect args in header ( = = ( {' ' ' ' default used ( = = = ( {' ' ' ' override default arguments |
1,109 | ( {' ' ' ' anywhere in keywords def (ac= * ** )print(abcdc is not keyword-only heref( = ( , {' ' in factsimilar ordering rules hold true in function callswhen keyword-only arguments are passedthey must appear before **args form the keyword-only argument can be coded either before or after the *argsthoughand may be included in **argsdef ( *bc= ** )print(abcdkw-only between and * ( *( )**dict( = = ) ( {' ' ' ' unpack args at call ( *( )**dict( = = ) = syntaxerrorinvalid syntax keywords before **argsf( *( ) = **dict( = = ) ( {' ' ' ' override default ( = *( )**dict( = = ) ( {' ' ' ' after or before ( *( )**dict( = = = ) ( {' ' ' ' keyword-only in *trace through these cases on your ownin conjunction with the general argumentordering rules described formally earlier they may appear to be worst cases in the artificial examples herebut they can come up in real practiceespecially for people who write libraries and tools for other python programmers to use why keyword-only argumentsso why care about keyword-only argumentsin shortthey make it easier to allow function to accept both any number of positional arguments to be processedand configuration options passed as keywords while their use is optionalwithout keywordonly arguments extra work may be required to provide defaults for such options and to verify that no superfluous keywords were passed imagine function that processes set of passed-in objects and allows tracing flag to be passedprocess(xyzprocess(xynotify=trueuse flag' default override flag default without keyword-only arguments we have to use both *args and **args and manually inspect the keywordsbut with keyword-only arguments less code is required the following guarantees that no positional argument will be incorrectly matched against notify and requires that it be keyword if passedspecial argument-matching modes |
1,110 | since we're going to see more realistic example of this later in this in "emulating the python print function, 'll postpone the rest of this story until then for an additional example of keyword-only arguments in actionsee the iteration options timing case study in and for additional function definition enhancements in python xstay tuned for the discussion of function annotation syntax in the min wakeup callok--it' time for something more realistic to make this concepts more concretelet' work through an exercise that demonstrates practical application of argument-matching tools suppose you want to code function that is able to compute the minimum value from an arbitrary set of arguments and an arbitrary set of object data types that isthe function should accept zero or more argumentsas many as you wish to pass moreoverthe function should work for all kinds of python object typesnumbersstringslistslists of dictionariesfilesand even none the first requirement provides natural example of how the feature can be put to good use--we can collect arguments into tuple and step over each of them in turn with simple for loop the second part of the problem definition is easybecause every object type supports comparisonswe don' have to specialize the function per type (an application of polymorphism)we can simply compare objects blindly and let python worry about what sort of comparison to perform according to the objects being compared full credit the following file shows three ways to code this operationat least one of which was suggested by student in one of my courses (this example is often group exercise to circumvent dozing after lunch)the first function fetches the first argument (args is tupleand traverses the rest by slicing off the first (there' no point in comparing an object to itselfespecially if it might be large structurethe second version lets python pick off the first and rest of the arguments automaticallyand so avoids an index and slice the third converts from tuple to list with the built-in list call and employs the list sort method arguments |
1,111 | but the linear scans of the first two techniques may make them faster much of the time the file mins py contains the code for all three solutionsdef min (*args)res args[ for arg in args[ :]if arg resres arg return res def min (first*rest)for arg in restif arg firstfirst arg return first def min (*args)tmp list(argstmp sort(return tmp[ orin python +return sorted(args)[ print(min ( )print(min ("bb""aa")print(min ([ , ][ , ][ , ])all three solutions produce the same result when the file is run try typing few calls interactively to experiment with these on your ownpython mins py aa [ notice that none of these three variants tests for the case where no arguments are passed in they couldbut there' no point in doing so here--in all three solutionspython will automatically raise an exception if no arguments are passed in the first variant raises an exception when we try to fetch item the second when python detects an argument list mismatchand the third when we try to return item at the end this is exactly what we want to happen--because these functions support any data typethere is no valid sentinel value that we could pass back to designate an errorso we may as well let the exception be raised there are exceptions to this rule ( you actuallythis is fairly complicated the python sort routine is coded in and uses highly optimized algorithm that attempts to take advantage of partial ordering in the items to be sorted it' named "timsortafter tim petersits creatorand in its documentation it claims to have "supernatural performanceat times (pretty goodfor sort!stillsorting is an inherently exponential operation (it must chop up the sequence and put it back together many times)and the other versions simply perform one linear left-toright scan the net effect is that sorting is quicker if the arguments are partially orderedbut is likely to be slower otherwise (this still holds true in test runs in even sopython performance can change over timeand the fact that sorting is implemented in the language can help greatlyfor an exact analysisyou should time the alternatives with the time or timeit modules--we'll see how in the min wakeup call |
1,112 | that triggers an error automatically)but in general it' better to assume that arguments will work in your functionscode and let python raise errors for you when they do not bonus points you can get bonus points here for changing these functions to compute the maximumrather than minimumvalues this one' easythe first two versions only require changing and the third simply requires that we return tmp[- instead of tmp[ for an extra pointbe sure to set the function name to "maxas well (though this part is strictly optionalit' also possible to generalize single function to compute either minimum or maximum valueby evaluating comparison expression strings with tool like the eval built-in function (see the library manualand various appearances hereespecially in or passing in an arbitrary comparison function the file minmax py shows how to implement the latter schemedef minmax(test*args)res args[ for arg in args[ :]if test(argres)res arg return res def lessthan(xy)return def grtrthan(xy)return see alsolambdaeval print(minmax(lessthan )print(minmax(grtrthan )self-test code python minmax py functions are another kind of object that can be passed into function like this one to make this max (or otherfunctionfor examplewe simply pass in the right sort of test function this may seem like extra workbut the main point of generalizing functions this way--instead of cutting and pasting to change just single character--is that we'll only have one version to change in the futurenot two the punch line of courseall this was just coding exercise there' really no reason to code min or max functionsbecause both are built-ins in pythonwe met them briefly in in conjunction with numeric toolsand again in when exploring iteration contexts the built-in versions work almost exactly like oursbut they're coded in for optimal speed and accept either single iterable or multiple arguments still arguments |
1,113 | be useful in other scenarios generalized set functions let' look at more useful example of special argument-matching modes at work at the end of we wrote function that returned the intersection of two sequences (it picked out items that appeared in bothhere is version that intersects an arbitrary number of sequences (one or moreby using the varargs matching form *args to collect all the passed-in arguments because the arguments come in as tuplewe can process them in simple for loop just for funwe'll code union function that also accepts an arbitrary number of arguments to collect items that appear in any of the operandsdef intersect(*args)res [for in args[ ]if in rescontinue for other in args[ :]if not in otherbreak elseres append(xreturn res def union(*args)res [for seq in argsfor in seqif not in resres append(xreturn res scan first sequence skip duplicates for all other args item in each onenobreak out of loop yesadd items to end for all args for all nodes add new items to result because these are tools potentially worth reusing (and they're too big to retype interactively)we'll store the functions in module file called inter py (if you've forgotten how modules and imports worksee the introduction in or stay tuned for in-depth coverage in part vin both functionsthe arguments passed in at the call come in as the args tuple as in the original intersectboth work on any kind of sequence herethey are processing stringsmixed typesand more than two sequencespython from inter import intersectunion "spam""scam""slamintersect( )union( ([' '' '' '][' '' '' '' '' ']two operands intersect([ ]( )[ mixed types intersect( [' '' '' 'three operands generalized set functions |
1,114 | [' '' '' '' '' '' 'to test more thoroughlythe following codes function to apply the two tools to arguments in different orders using simple shuffling technique that we saw in --it slices to move the first to the end on each loopuses to unpack argumentsand sorts so results are comparabledef tester(funcitemstrace=true)for in range(len(items))items items[ :items[: if traceprint(itemsprint(sorted(func(*items))tester(intersect(' ''abcdefg''abdst''albmcnd')('abcdefg''abdst''albmcnd'' '[' '('abdst''albmcnd'' ''abcdefg'[' '('albmcnd'' ''abcdefg''abdst'[' '(' ''abcdefg''abdst''albmcnd'[' 'tester(union(' ''abcdefg''abdst''albmcnd')false[' '' '' '' '' '' '' '' '' '' '' '' '[' '' '' '' '' '' '' '' '' '' '' '' '[' '' '' '' '' '' '' '' '' '' '' '' '[' '' '' '' '' '' '' '' '' '' '' '' 'tester(intersect('ba''abcdefg''abdst''albmcnd')false[' '' '[' '' '[' '' '[' '' 'the argument scrambling here doesn' generate all possible argument orders (that would require full permutationand orderings for arguments)but suffices to check if argument order impacts results here if you test these furtheryou'll notice that duplicates won' appear in either intersection or union resultswhich qualify them as set operations from mathematical perspectiveintersect([ ]( )[ union([ ]( )[ tester(intersect('ababa''abcdefga''aaaab')false[' '' '[' '' '[' '' 'these are still far from optimal from an algorithmic perspectivebut due to the following notewe'll leave further improvements to this code as suggested exercise also arguments |
1,115 | tooland the tester would be simpler if we delegated this to another functionone that would be free to create or generate argument combinations as it saw fitdef tester(funcitemstrace=true)for args in scramble(items)use args in fact we will--watch for this example to be revised in to address this last pointafter we've learned how to code user-defined generators we'll also recode the set operations one last time in and solution to part vi exercise as classes that extend the list object with methods because python now has set object type (described in )none of the set-processing examples in this book are strictly required anymorethey are included just as demonstrations of coding techniquesand are today instructional only because it' constantly improving and growingpython has an uncanny way of conspiring to make my book examples obsolete over timeemulating the python print function to round out the let' look at one last example of argument matching at work the code you'll see here is intended for use in python or earlier (it works in xtoobut is pointless there)it uses both the *args arbitrary positional tuple and the **args arbitrary keyword-arguments dictionary to simulate most of what the python print function does python might have offered code like this as an option in rather than removing the print entirelybut chose clean break with the past instead as we learned in this isn' actually requiredbecause programmers can always enable the print function with an import of this form (available in and )from __future__ import print_function to demonstrate argument matching in generalthoughthe following fileprint pydoes the same job in small amount of reusable codeby building up the print string and routing it per configuration arguments#!python ""emulate most of the print function for use in (and xcall signatureprint (*argssep='end='\ 'file=sys stdout""import sys def print (*args**kargs)sep kargs get('sep''keyword arg defaults emulating the python print function |
1,116 | file kargs get('file'sys stdoutoutput 'first true for arg in argsoutput +('if first else sepstr(argfirst false file write(output endto test itimport this into another file or the interactive promptand use it like the print function here is test scripttestprint py (notice that the function must be called "print "because "printis reserved word in )from print import print print ( print ( sep=''print ( sep='print ( [ ]( ,)sep='print ( sep=''end=''print ( print (suppress separator various object types suppress newline add newline (or blank lineimport sys print ( sep='??'end=\ 'file=sys stderrredirect to file when this is run under xwe get the same results as ' print functionc:\codec:\python \python testprint py [ ( , ?? ?? although pointless in xthe results are identical when run there as usualthe generality of python' design allows us to prototype or develop concepts in the python language itself in this caseargument-matching tools are as flexible in python code as they are in python' internal implementation using keyword-only arguments it' interesting to notice that this example could be coded with python keywordonly argumentsdescribed earlier in this to automatically validate configuration arguments the following variantin the file print _alt pyillustrates#!python "use only keyword-only argsimport sys def print (*argssep='end='\ 'file=sys stdout)output ' arguments |
1,117 | for arg in argsoutput +('if first else sepstr(argfirst false file write(output endthis version works the same as the originaland it' prime example of how keywordonly arguments come in handy the original version assumes that all positional arguments are to be printedand all keywords are for options only that' almost sufficientbut any extra keyword arguments are silently ignored call like the followingfor instancewill generate an exception correctly with the keyword-only formprint ( name='bob'typeerrorprint (got an unexpected keyword argument 'namebut will silently ignore the name argument in the original version to detect superfluous keywords manuallywe could use dict pop(to delete fetched entriesand check if the dictionary is not empty the following versionin the file print _alt pyis equivalent to the keyword-only version--it triggers built-in exception with raise statementwhich works just as though python had done so (we'll study this in more detail in part vii)#!python "use / keyword args deletion with defaultsimport sys def print (*args**kargs)sep kargs pop('sep''end kargs pop('end''\ 'file kargs pop('file'sys stdoutif kargsraise typeerror('extra keywords%skargsoutput 'first true for arg in argsoutput +('if first else sepstr(argfirst false file write(output endthis works as beforebut it now catches extraneous keyword argumentstooprint ( name='bob'typeerrorextra keywords{'name''bob'this version of the function runs under python xbut it requires four more lines of code than the keyword-only version unfortunatelythe extra code is unavoidable in this case--the keyword-only version works on onlywhich negates most of the reason that wrote this example in the first placea emulator that only works on isn' incredibly usefulin programs written to run on onlythoughkeywordonly arguments can simplify specific category of functions that accept both arguments and options for another example of keyword-only argumentsbe sure to see the iteration timing case study in emulating the python print function |
1,118 | as you can probably telladvanced argument-matching modes can be complex they are also largely optional in your codeyou can get by with just simple positional matchingand it' probably good idea to do so when you're starting out howeverbecause some python tools make use of themsome general knowledge of these modes is important for examplekeyword arguments play an important role in tkinterthe de facto standard gui api for python (this module' name is tkinter in python xwe touch on tkinter only briefly at various points in this bookbut in terms of its call patternskeyword arguments set configuration options when gui components are built for instancea call of the formfrom tkinter import widget button(text="press me"command=somefunctioncreates new button and specifies its text and callback functionusing the text and command keyword arguments since the number of configuration options for widget can be largekeyword arguments let you pick and choose which to apply without themyou might have to either list all the possible options by position or hope for judicious positional argument defaults protocol that would handle every possible option arrangement many built-in functions in python expect us to use keywords for usage-mode options as wellwhich may or may not have defaults as we learned in for instancethe sorted built-insorted(iterablekey=nonereverse=falseexpects us to pass an iterable object to be sortedbut also allows us to pass in optional keyword arguments to specify dictionary sort key and reversal flagwhich default to none and falserespectively since we normally don' use these optionsthey may be omitted to use defaults as we've also seenthe dictstr formatand print calls accept keywords as well --other usages we had to introduce in earlier because of their forward dependence on argument-passing modes we've studied here (alasthose who change python already know python!summary in this we studied the second of two key concepts related to functionsarguments--how objects are passed into function as we learnedarguments are passed into function by assignmentwhich means by object reference (which really means by pointerwe also studied some more advanced extensionsincluding default and keyword argumentstools for using arbitrarily many argumentsand keyword-only arguments in finallywe saw how mutable arguments can exhibit the same be arguments |
1,119 | it' sent inchanging passed-in mutable in function can impact the caller the next continues our look at functions by exploring some more advanced function-related ideasfunction annotationsrecursionlambdasand functional tools such as map and filter many of these concepts stem from the fact that functions are normal objects in pythonand so support some advanced and very flexible processing modes before diving into those topicshowevertake this quiz to review the argument ideas we've studied here test your knowledgequiz in most of this quiz' questionsresults may vary slightly in --with enclosing parentheses and commas when multiple values are printed to match the answers exactly in ximport print_function from __future__ before starting what is the output of the following codeand whydef func(ab= = )print(abcfunc( what is the output of this codeand whydef func(abc= )print(abcfunc( = = how about this codewhat is its outputand whydef func( *pargs)print(apargsfunc( what does this code printand whydef func( **kargs)print(akargsfunc( = = = what gets printed by thisand whydef func(abc= = )print(abcdfunc( *( ) one last timewhat is the output of this codeand whydef func(abc) [ ' ' [' ''yl= =[ ] ={' ': test your knowledgequiz |
1,120 | lmn ntest your knowledgeanswers the output here is because and are passed to and by positionand is omitted in the call and defaults to the output this time is is passed to by positionand and are passed and by name (the left-to-right order doesn' matter when keyword arguments are used like this this code prints ( )because is passed to and the *pargs collects the remaining positional arguments into new tuple object we can step through the extra positional arguments tuple with any iteration tool ( for arg in pargs this time the code prints {' ' ' ' }because is passed to by name and the **kargs collects the remaining keyword arguments into dictionary we could step through the extra keyword arguments dictionary by key with any iteration tool ( for key in kargsnote that the order of the dictionary' keys may vary per python and other variables the output here is the matches by position and match and by *name positionals ( overrides ' default)and defaults to because it was not passed value this displays ( [' ']{' '' '})--the first assignment in the function doesn' impact the callerbut the second two do because they change passed-in mutable objects in place arguments |
1,121 | advanced function topics this introduces collection of more advanced function-related topicsrecursive functionsfunction attributes and annotationsthe lambda expressionand functional programming tools such as map and filter these are all somewhat advanced tools thatdepending on your job descriptionyou may not encounter on regular basis because of their roles in some domainsthougha basic understanding can be usefullambdasfor instanceare regular customers in guisand functional programming techniques are increasingly common in python code part of the art of using functions lies in the interfaces between themso we will also explore some general function design principles here the next continues this advanced theme with an exploration of generator functions and expressions and revival of list comprehensions in the context of the functional tools we will study here function design concepts now that we've had chance to study function basics in pythonlet' begin this with few words of context when you start using functions in earnestyou're faced with choices about how to glue components together--for instancehow to decompose task into purposeful functions (known as cohesion)how your functions should communicate (called coupling)and so on you also need to take into account concepts such as the size of your functionsbecause they directly impact code usability some of this falls into the category of structured analysis and designbut it applies to python code as to any other we introduced some ideas related to function and module coupling in when studying scopesbut here is review of few general guidelines for readers new to function design principlescouplinguse arguments for inputs and return for outputs generallyyou should strive to make function independent of things outside of it arguments and return statements are often the best ways to isolate external dependencies to small number of well-known places in your code |
1,122 | ( names in the enclosing moduleare usually poor way for functions to communicate they can create dependencies and timing issues that make programs difficult to debugchangeand reuse couplingdon' change mutable arguments unless the caller expects it functions can change parts of passed-in mutable objectsbut (as with global variablesthis creates tight coupling between the caller and calleewhich can make function too specific and brittle cohesioneach function should have singleunified purpose when designed welleach of your functions should do one thing--something you can summarize in simple declarative sentence if that sentence is very broad ( "this function implements my whole program")or contains lots of conjunctions ( "this function gives employee raises and submits pizza order")you might want to think about splitting it into separate and simpler functions otherwisethere is no way to reuse the code behind the steps mixed together in the function sizeeach function should be relatively small this naturally follows from the preceding goalbut if your functions start spanning multiple pages on your displayit' probably time to split them especially given that python code is so concise to begin witha long or deeply nested function is often symptom of design problems keep it simpleand keep it short couplingavoid changing variables in another module file directly we introduced this concept in and we'll revisit it in the next part of the book when we focus on modules for referencethoughremember that changing variables across file boundaries sets up coupling between modules similar to how global variables couple functions--the modules become difficult to understand and reuse use accessor functions whenever possibleinstead of direct assignment statements figure - summarizes the ways functions can talk to the outside worldinputs may come from items on the left sideand results may be sent out in any of the forms on the right good function designers prefer to use only arguments for inputs and return statements for outputswhenever possible of coursethere are plenty of exceptions to the preceding design rulesincluding some related to python' oop support as you'll see in part vipython classes depend on changing passed-in mutable object--class functions set attributes of an automatically passed-in argument called self to change per-object state information ( self name='bob'moreoverif classes are not usedglobal variables are often the most straightforward way for functions in modules to retain single-copy state between calls side effects are usually dangerous only if they're unexpected in general thoughyou should strive to minimize external dependencies in functions and other program components the more self-contained function isthe easier it will be to understandreuseand modify advanced function topics |
1,123 | figure - function execution environment functions may obtain input and produce output in variety of waysthough functions are usually easier to understand and maintain if you use arguments for input and return statements and anticipated mutable argument changes for output in python onlyoutputs may also take the form of declared nonlocal names that exist in an enclosing function scope recursive functions we mentioned recursion in relation to comparisons of core types in while discussing scope rules near the start of we also briefly noted that python supports recursive functions--functions that call themselves either directly or indirectly in order to loop in this sectionwe'll explore what this looks like in our functionscode recursion is somewhat advanced topicand it' relatively rare to see in pythonpartly because python' procedural statements include simpler looping structures stillit' useful technique to know aboutas it allows programs to traverse structures that have arbitrary and unpredictable shapes and depths--planning travel routesanalyzing languageand crawling links on the webfor example recursion is even an alternative to simple loops and iterationsthough not necessarily the simplest or most efficient one summation with recursion let' look at some examples to sum list (or other sequenceof numberswe can either use the built-in sum function or write more custom version of our own here' what custom summing function might look like when coded with recursiondef mysum( )if not lreturn elsereturn [ mysum( [ :]call myself recursively recursive functions |
1,124 | at each levelthis function calls itself recursively to compute the sum of the rest of the listwhich is later added to the item at the front the recursive loop ends and zero is returned when the list becomes empty when using recursion like thiseach open level of call to the function has its own copy of the function' local scope on the runtime call stack--herethat means is different in each level if this is difficult to understand (and it often is for new programmers)try adding print of to the function and run it againto trace the current list at each call leveldef mysum( )print(lif not lreturn elsereturn [ mysum( [ :]trace recursive levels shorter at each level mysum([ ][ [ [ [ [ [ as you can seethe list to be summed grows smaller at each recursive leveluntil it becomes empty--the termination of the recursive loop the sum is computed as the recursive calls unwind on returns coding alternatives interestinglywe can use python' if/else ternary expression (described in to save some code real estate here we can also generalize for any summable type (which is easier if we assume at least one item in the inputas we did in ' minimum value exampleand use python ' extended sequence assignment to make the first/rest unpacking simpler (as covered in )def mysum( )return if not else [ mysum( [ :]use ternary expression def mysum( )return [ if len( = else [ mysum( [ :]any typeassume one def mysum( )first*rest return first if not rest else first mysum(restuse ext seq assign the latter two of these fail for empty lists but allow for sequences of any object type that supports +not just numbers advanced function topics |
1,125 | mysum([ ] mysum((' '' '' '' ')'spammysum(['spam''ham''eggs']'spamhameggsmysum([]fails in last but various types now work run these on your own for more insight if you study these three variantsyou'll find thatthe latter two also work on single string argument ( mysum('spam'))because strings are sequences of one-character strings the third variant works on arbitrary iterablesincluding open input files (mysum(open(name)))but the others do not because they index illustrates extended sequence assignment on filesthe function header def mysum(first*rest)although similar to the third variantwouldn' work at allbecause it expects individual argumentsnot single iterable keep in mind that recursion can be directas in the examples so faror indirectas in the following ( function that calls another functionwhich calls back to its callerthe net effect is the samethough there are two function calls at each level instead of onedef mysum( )if not lreturn return nonempty(lcall function that calls me def nonempty( )return [ mysum( [ :]indirectly recursive mysum([ ] loop statements versus recursion though recursion works for summing in the prior sectionsexamplesit' probably overkill in this context in factrecursion is not used nearly as often in python as in more esoteric languages like prolog or lispbecause python emphasizes simpler procedural statements like loopswhich are usually more natural the whilefor exampleoften makes things bit more concreteand it doesn' require that function be defined to allow recursive callsl [ sum while lsum + [ [ :recursive functions |
1,126 | better yetfor loops iterate for us automaticallymaking recursion largely extraneous in many cases (andin all likelihoodless efficient in terms of memory space and execution time) [ sum for in lsum + sum with looping statementswe don' require fresh copy of local scope on the call stack for each iterationand we avoid the speed costs associated with function calls in general (stay tuned for ' timer case study for ways to compare the execution times of alternatives like these handling arbitrary structures on the other handrecursion--or equivalent explicit stack-based algorithms we'll meet shortly--can be required to traverse arbitrarily shaped structures as simple example of recursion' role in this contextconsider the task of computing the sum of all the numbers in nested sublists structure like this[ [ [ ] ] [ ]arbitrarily nested sublists simple looping statements won' work here because this is not linear iteration nested looping statements do not suffice eitherbecause the sublists may be nested to arbitrary depth and in an arbitrary shape--there' no way to know how many nested loops to code to handle all cases insteadthe following code accommodates such general nesting by using recursion to visit sublists along the wayfile sumtree py def sumtree( )tot for in lif not isinstance(xlist)tot + elsetot +sumtree(xreturn tot for each item at this level add numbers directly recur for sublists [ [ [ ] ] [ ]print(sumtree( )arbitrary nesting prints pathological cases print(sumtree([ [ [ [ [ ]]]]])print(sumtree([[[[[ ] ] ] ] ])prints (right-heavyprints (left-heavy advanced function topics |
1,127 | their nested lists recursion versus queues and stacks it sometimes helps to understand that internallypython implements recursion by pushing information on call stack at each recursive callso it remembers where it must return and continue later in factit' generally possible to implement recursive-style procedures without recursive callsby using an explicit stack or queue of your own to keep track of remaining steps for instancethe following computes the same sums as the prior examplebut uses an explicit list to schedule when it will visit items in the subjectinstead of issuing recursive callsthe item at the front of the list is always the next to be processed and summeddef sumtree( )tot items list(lwhile itemsfront items pop( if not isinstance(frontlist)tot +front elseitems extend(frontreturn tot breadth-firstexplicit queue start with copy of top level fetch/delete front item add numbers directly <=append all in nested list technicallythis code traverses the list in breadth-first fashion by levelsbecause it adds nested listscontents to the end of the listforming first-in-first-out queue to emulate the traversal of the recursive call version more closelywe can change it to perform depth-first traversal simply by adding the content of nested lists to the front of the listforming last-in-first-out stackdef sumtree( )tot items list(lwhile itemsfront items pop( if not isinstance(frontlist)tot +front elseitems[: front return tot depth-firstexplicit stack start with copy of top level fetch/delete front item add numbers directly <=prepend all in nested list for more on the last two examples (and another variant)see file sumtree py in the book' examples it adds items list tracing so you can watch it grow in both schemesand can show numbers as they are visited so you see the search order for instancethe breadth-first and depth-first variants visit items in the same three test lists used for the recursive version in the following ordersrespectively (sums are shown last) :\codesumtree py recursive functions |
1,128 | in generalthoughonce you get the hang of recursive callsthey are more natural than the explicit scheduling lists they automateand are generally preferred unless you need to traverse structure in specialized ways some programsfor exampleperform bestfirst search that requires an explicit search queue ordered by relevance or other criteria if you think of web crawler that scores pages visited by contentthe applications may start to become clearer cyclespathsand stack limits as isthese programs suffice for our examplebut larger recursive applications can sometimes require bit more infrastructure than shown herethey may need to avoid cycles or repeatsrecord paths taken for later useand expand stack space when using recursive calls instead of explicit queues or stacks for instanceneither the recursive call nor the explicit queue/stack examples in this section do anything about avoiding cycles--visiting location already visited that' not required herebecause we're traversing strictly hierarchical list object trees if data can be cyclic graphthoughboth these schemes will failthe recursive call version will fall into an infinite recursive loop (and may run out of call-stack space)and the others will fall into simple infinite loopsre-adding the same items to their lists (and may or may not run out of general memorysome programs also need to avoid repeated processing for state reached more than onceeven if that wouldn' lead to loop to do betterthe recursive call version could simply keep and pass setdictionaryor list of states visited so far and check for repeats as it goes we will use this scheme in later recursive examples in this bookif state not in visitedvisited add(stateproceed add(state) [state]=trueor append(statethe nonrecursive alternatives could similarly avoid adding states already visited with code like the following note that checking for duplicates already on the items list would avoid scheduling state twicebut would not prevent revisiting state traversed earlier and hence removed from that listvisited add(frontproceed items extend([ for in front if not in visited]this model doesn' quite apply to this section' use case that simply adds numbers in listsbut larger applications will be able to identify repeated states-- url of previ advanced function topics |
1,129 | and repeats in later examples listed in the next section some programs may also need to record complete paths for each state followed so they can report solutions when finished in such caseseach item in the nonrecursive scheme' stack or queue may be full path list that suffices for record of states visitedand contains the next item to explore at either end also note that standard python limits the depth of its runtime call stack--crucial to recursive call programs--to trap infinite recursion errors to expand ituse the sys modulesys getrecursionlimit( sys setrecursionlimit( help(sys setrecursionlimit calls deep default allow deeper nesting read more about it the maximum allowed setting can vary per platform this isn' required for programs that use stacks or queues to avoid recursive calls and gain more control over the traversal process more recursion examples although this section' example is artificialit is representative of larger class of programsinheritance trees and module import chainsfor examplecan exhibit similarly general structuresand computing structures such as permutations can require arbitrarily many nested loops in factwe will use recursion again in such roles in more realistic examples later in this bookin ' permute pyto shuffle arbitrary sequences in ' reloadall pyto traverse import chains in ' classtree pyto traverse class inheritance trees in ' lister pyto traverse class inheritance trees again in appendix ' solutions to two exercises at the end of this part of the bookcountdowns and factorials the second and third of these will also detect states already visited to avoid cycles and repeats although simple loops should generally be preferred to recursion for linear iterations on the grounds of simplicity and efficiencywe'll find that recursion is essential in scenarios like those in these later examples moreoveryou sometimes need to be aware of the potential of unintended recursion in your programs as you'll also see later in the booksome operator overloading methods in classes such as __setattr__ and __getattribute__ and even __repr__ have the potential to recursively loop if used incorrectly recursion is powerful toolbut it tends to be best when both understood and expectedrecursive functions |
1,130 | python functions are more flexible than you might think as we've seen in this part of the bookfunctions in python are much more than code-generation specifications for compiler--python functions are full-blown objectsstored in pieces of memory all their own as suchthey can be freely passed around program and called indirectly they also support operations that have little to do with calls at all--attribute storage and annotation indirect function calls"first classobjects because python functions are objectsyou can write programs that process them generically function objects may be assigned to other namespassed to other functionsembedded in data structuresreturned from one function to anotherand moreas if they were simple numbers or strings function objects also happen to support special operationthey can be called by listing arguments in parentheses after function expression stillfunctions belong to the same general category as other objects this is usually called first-class object modelit' ubiquitous in pythonand necessary part of functional programming we'll explore this programming mode more fully in this and the next because its motif is founded on the notion of applying functionsfunctions must be treated as data we've seen some of these generic use cases for functions in earlier examplesbut quick review helps to underscore the object model for examplethere' really nothing special about the name used in def statementit' just variable assigned in the current scopeas if it had appeared on the left of an sign after def runsthe function name is simply reference to an object--you can reassign that object to other names freely and call it through any referencedef echo(message)print(messagename echo assigned to function object echo('direct call'direct call call object through original name echo ('indirect call!'indirect callnow references the function too call object through name by adding (because arguments are passed by assigning objectsit' just as easy to pass functions to other functions as arguments the callee may then call the passed-in function just by adding arguments in parenthesesdef indirect(funcarg)func(argindirect(echo'argument call!'argument call advanced function topics call the passed-in object by adding (pass the function to another function |
1,131 | or strings the followingfor exampleembeds the function twice in list of tuplesas sort of actions table because python compound types like these can contain any sort of objectthere' no special case hereeitherschedule (echo'spam!')(echo'ham!'for (funcargin schedulefunc(argcall functions embedded in containers spamhamthis code simply steps through the schedule listcalling the echo function with one argument each time through (notice the tuple-unpacking assignment in the for loop headerintroduced in as we saw in ' examplesfunctions can also be created and returned for use elsewhere--the closure created in this mode also retains state from the enclosing scopedef make(label)make function but don' call it def echo(message)print(label ':messagereturn echo make('spam' ('ham!'spam:hamf('eggs!'spam:eggslabel in enclosing scope is retained call the function that make returned python' universal first-class object model and lack of type declarations make for an incredibly flexible programming language function introspection because they are objectswe can also process functions with normal object tools in factfunctions are more flexible than you might expect for instanceonce we make functionwe can call it as usualdef func( ) 'spamreturn func( 'spamspamspamspamspamspamspamspambut the call expression is just one operation defined to work on function objects we can also inspect their attributes generically (the following is run in python but results are similar)func __name__ 'funcdir(func['__annotations__''__call__''__class__''__closure__''__code__'function objectsattributes and annotations |
1,132 | '__repr__''__setattr__''__sizeof__''__str__''__subclasshook__'introspection tools allow us to explore implementation details too--functions have attached code objectsfor examplewhich provide details on aspects such as the functionslocal variables and argumentsfunc __code__ "line dir(func __code__['__class__''__delattr__''__dir__''__doc__''__eq__''__format__''__ge__'more omitted total 'co_argcount''co_cellvars''co_code''co_consts''co_filename''co_firstlineno''co_flags''co_freevars''co_kwonlyargcount''co_lnotab''co_name''co_names''co_nlocals''co_stacksize''co_varnames'func __code__ co_varnames (' '' 'func __code__ co_argcount tool writers can make use of such information to manage functions (in factwe will too in to implement validation of function arguments in decoratorsfunction attributes function objects are not limited to the system-defined attributes listed in the prior sectionthough as we learned in it' been possible to attach arbitrary userdefined attributes to them as well since python func func count func count + func count func handles 'button-pressfunc handles 'button-pressdir(func['__annotations__''__call__''__class__''__closure__''__code__'and morein all others have double underscores so your names won' clash __str__''__subclasshook__''count''handles'python' own implementation-related data stored on functions follows naming conventions that prevent them from clashing with the more arbitrary attribute names you might assign yourself in xall function internalsnames have leading and trailing double underscores ("__x__") follows the same schemebut also assigns some names that begin with "func_x" :\codepy - def ()pass advanced function topics |
1,133 | run on your own to see len(dir( ) [ for in dir(fif not startswith('__')[ :\codepy - def ()pass dir(frun on your own to see len(dir( ) [ for in dir(fif not startswith('__')['func_closure''func_code''func_defaults''func_dict''func_doc''func_globals''func_name'if you're careful not to name attributes the same wayyou can safely use the function' namespace as though it were your own namespace or scope as we saw in that such attributes can be used to attach state information to function objects directlyinstead of using other techniques such as globalsnonlocalsand classes unlike nonlocalssuch attributes are accessible anywhere the function itself iseven from outside its code in sensethis is also way to emulate "static localsin other languages--variables whose names are local to functionbut whose values are retained after function exits attributes are related to objects instead of scopes (and must be referenced through the function name within its code)but the net effect is similar moreoveras we learned in when attributes are attached to functions generated by other factory functionsthey also support multiple copyper-calland writeable state retentionmuch like nonlocal closures and class instance attributes function annotations in in python (but not )it' also possible to attach annotation information--arbitrary user-defined data about function' arguments and result--to function object python provides special syntax for specifying annotationsbut it doesn' do anything with them itselfannotations are completely optionaland when present are simply attached to the function object' __annotations__ attribute for use by other tools for instancesuch tool might use annotations in the context of error testing we met python ' keyword-only arguments in the preceding annotations generalize function header syntax further consider the following nonannotated functionwhich is coded with three arguments and returns resultdef func(abc)return function objectsattributes and annotations |
1,134 | syntacticallyfunction annotations are coded in def header linesas arbitrary expressions associated with arguments and return values for argumentsthey appear after colon immediately following the argument' namefor return valuesthey are written after -following the arguments list this codefor exampleannotates all three of the prior function' argumentsas well as its return valuedef func( 'spam' ( )cfloat-intreturn func( calls to an annotated function work as usualbut when annotations are present python collects them in dictionary and attaches it to the function object itself argument names become keysthe return value annotation is stored under key "returnif coded (which suffices because this reserved word can' be used as an argument name)and the values of annotation keys are assigned to the results of the annotation expressionsfunc __annotations__ {' '' '( )' ''spam''return'because they are just python objects attached to python objectannotations are straightforward to process the following annotates just two of three arguments and steps through the attached annotations genericallydef func( 'spam'bc )return func( func __annotations__ {' ' ' ''spam'for arg in func __annotations__print(arg'=>'func __annotations__[arg] = =spam there are two fine points to note here firstyou can still use defaults for arguments if you code annotations--the annotation (and its characterappear before the default (and its characterin the followingfor examplea'spam means that argument defaults to and is annotated with the string 'spam'def func( 'spam ( cfloat -intreturn func( func( advanced function topics (all defaults |
1,135 | (keywords work normally func __annotations__ {' '' '( )' ''spam''return'secondnote that the blank spaces in the prior example are all optional--you can use spaces between components in function headers or notbut omitting them might degrade your code' readability to some observers (and probably improve it to others!)def func( :'spam'= :( , )= :float= )->intreturn func( # + + func __annotations__ {' '' '( )' ''spam''return'annotations are new feature in xand some of their potential uses remain to be uncovered it' easy to imagine annotations being used to specify constraints for argument types or valuesthoughand larger apis might use this feature as way to register function interface information in factwe'll see potential application in where we'll look at annotations as an alternative to function decorator arguments-- more general concept in which information is coded outside the function header and so is not limited to single role like python itselfannotation is tool whose roles are shaped by your imagination finallynote that annotations work only in def statementsnot lambda expressionsbecause lambda' syntax already limits the utility of the functions it defines coincidentallythis brings us to our next topic anonymous functionslambda besides the def statementpython also provides an expression form that generates function objects because of its similarity to tool in the lisp languageit' called lambda like defthis expression creates function to be called laterbut it returns the function instead of assigning it to name this is why lambdas are sometimes known as anonymous ( unnamedfunctions in practicethey are often used as way to inline function definitionor to defer execution of piece of code the lambda tends to intimidate people more than it should this reaction seems to stem from the name "lambdaitself-- name that comes from the lisp languagewhich got it from lambda calculuswhich is form of symbolic logic in pythonthoughit' really just keyword that introduces the expression syntactically obscure mathematical heritage asidelambda is simpler to use than you may think anonymous functionslambda |
1,136 | the lambda' general form is the keyword lambdafollowed by one or more arguments (exactly like the arguments list you enclose in parentheses in def header)followed by an expression after colonlambda argument argument argumentn expression using arguments function objects returned by running lambda expressions work exactly the same as those created and assigned by defsbut there are few differences that make lambdas useful in specialized roleslambda is an expressionnot statement because of thisa lambda can appear in places def is not allowed by python' syntax--inside list literal or function call' argumentsfor example with deffunctions can be referenced by name but must be created elsewhere as an expressionlambda returns value ( new functionthat can optionally be assigned name in contrastthe def statement always assigns the new function to the name in the headerinstead of returning it as result lambda' body is single expressionnot block of statements the lambda' body is similar to what you' put in def body' return statementyou simply type the result as naked expressioninstead of explicitly returning it because it is limited to an expressiona lambda is less general than def--you can only squeeze so much logic into lambda body without using statements such as if this is by designto limit program nestinglambda is designed for coding simple functionsand def handles larger tasks apart from those distinctionsdefs and lambdas do the same sort of work for instancewe've seen how to make function with def statementdef func(xyz)return func( but you can achieve the same effect with lambda expression by explicitly assigning its result to name through which you can later call the functionf lambda xyzx ( heref is assigned the function object the lambda expression createsthis is how def workstoobut its assignment is automatic defaults work on lambda argumentsjust like in defx (lambda ="fee" ="fie" ="foe" cx("wee"'weefiefoe advanced function topics |
1,137 | def lambda expressions introduce local scope much like nested defwhich automatically sees names in enclosing functionsthe moduleand the built-in scope (via the legb ruleand per )def knights()title 'siraction (lambda xtitle xreturn action act knights(msg act('robin'msg 'sir robintitle in enclosing def scope return function object 'robinpassed to act acta functionnot its result at ca in this exampleprior to release the value for the name title would typically have been passed in as default argument value insteadflip back to the scopes coverage in if you've forgotten why why use lambdagenerally speakinglambda comes in handy as sort of function shorthand that allows you to embed function' definition within the code that uses it they are entirely optional--you can always use def insteadand should if your function requires the power of full statements that the lambda' expression cannot easily provide--but they tend to be simpler coding constructs in scenarios where you just need to embed small bits of executable code inline at the place it is to be used for instancewe'll see later that callback handlers are frequently coded as inline lambda expressions embedded directly in registration call' arguments listinstead of being defined with def elsewhere in file and referenced by name (see the sidebar "why you will carelambda callbackson page for an examplelambda is also commonly used to code jump tableswhich are lists or dictionaries of actions to be performed on demand for examplel [lambda xx * lambda xx * lambda xx * inline function definition list of three callable functions for in lprint( ( )prints print( [ ]( )prints the lambda expression is most useful as shorthand for defwhen you need to stuff small pieces of executable code into places where statements are illegal syntactically the preceding code snippetfor examplebuilds up list of three functions by embedanonymous functionslambda |
1,138 | because it is statementnot an expression the equivalent def coding would require temporary function names (which might clash with othersand function definitions outside the context of intended use (which might be hundreds of lines away)def ( )return * def ( )return * def ( )return * define named functions [ reference by name for in lprint( ( )prints print( [ ]( )prints multiway branch switchesthe finale in factyou can do the same sort of thing with dictionaries and other data structures in python to build up more general sorts of action tables here' another example to illustrateat the interactive promptkey 'got{'already'(lambda )'got'(lambda )'one'(lambda * )}[key]( herewhen python makes the temporary dictionaryeach of the nested lambdas generates and leaves behind function to be called later indexing by key fetches one of those functionsand parentheses force the fetched function to be called when coded this waya dictionary becomes more general multiway branching tool than what could fully show you in ' coverage of if statements to make this work without lambdayou' need to instead code three def statements somewhere else in your fileoutside the dictionary in which the functions are to be usedand reference the functions by namedef ()return def ()return def ()return * key 'one{'already' 'got' 'one' }[key]( this workstoobut your defs may be arbitrarily far away in your fileeven if they are just little bits of code the code proximity that lambdas provide is especially useful for functions that will only be used in single context--if the three functions here are not useful anywhere elseit makes sense to embed their definitions within the dictionary advanced function topics |
1,139 | functions that may clash with other names in this file (perhaps unlikelybut always possible lambdas also come in handy in function-call argument lists as way to inline temporary function definitions not used anywhere else in your programwe'll see some examples of such other uses later in this when we study map how (notto obfuscate your python code the fact that the body of lambda has to be single expression (not series of statementswould seem to place severe limits on how much logic you can pack into lambda if you know what you're doingthoughyou can code most statements in python as expression-based equivalents for exampleif you want to print from the body of lambda functionsimply say print(xin python where this becomes call expression instead of statementor say sys stdout write(str( )+'\ 'in either python or to make sure it' an expression portably (recall from that this is what print really doessimilarlyto nest selection logic in lambdayou can use the if/else ternary expression introduced in or the equivalent but trickier and/or combination also described there as you learned earlierthe following statementif ab elsec can be emulated by either of these roughly equivalent expressionsb if else (( and bor cbecause expressions like these can be placed inside lambdathey may be used to implement selection logic within lambda functionlower (lambda xyx if else ylower('bb''aa''aalower('aa''bb''aa student once noted that you could skip the dispatch table dictionary in such code if the function name is the same as its string lookup key--run an eval(funcname)(to kick off the call while true in this case and sometimes usefulas we saw earlier ( )eval is relatively slow (it must compile and run code)and insecure (you must trust the string' sourcemore fundamentallyjump tables are generally subsumed by polymorphic method dispatch in pythoncalling method does the "right thingbased on the type of object to see whystay tuned for part vi anonymous functionslambda |
1,140 | like map calls and list comprehension expressions--tools we met in earlier and will revisit in this and the next import sys showall lambda xlist(map(sys stdout writex) xmust use list showall(['spam\ ''toast\ ''eggs\ '] xcan use print spam toast eggs showall lambda [sys stdout write(linefor line in xt showall(('bright\ ''side\ ''of\ ''life\ ')bright side of life showall lambda [print(lineend=''for line in xsame only showall lambda xprint(*xsep=''end=''same only there is limit to emulating statements with expressionsyou can' directly achieve an assignment statement' effectfor instancethough tools like the setattr built-inthe __dict__ of namespacesand methods that change mutable objects in place can sometimes stand inand functional programming techniques can take you deep into the dark realm of convoluted expression now that 've shown you these tricksi am required to ask you to please only use them as last resort without due carethey can lead to unreadable ( obfuscatedpython code in generalsimple is better than complexexplicit is better than implicitand full statements are better than arcane expressions that' why lambda is limited to expressions if you have larger logic to codeuse deflambda is for small pieces of inline code on the other handyou may find these techniques useful in moderation scopeslambdas can be nested too lambdas are the main beneficiaries of nested function scope lookup (the in the legb scope rule we studied in as reviewin the following the lambda appears inside def--the typical case--and so can access the value that the name had in the enclosing function' scope at the time that the enclosing function was calleddef action( )return (lambda yx ymake and return functionremember act action( act at ca act( call what action returned what wasn' illustrated in the prior discussion of nested function scopes is that lambda also has access to the names in any enclosing lambda this case is somewhat obscurebut imagine if we recoded the prior def with lambda advanced function topics |
1,141 | act action( act( ((lambda (lambda yx ))( ))( herethe nested lambda structure makes function that makes function when called in both casesthe nested lambda' code has access to the variable in the enclosing lambda this worksbut it seems fairly convoluted codein the interest of readabilitynested lambdas are generally best avoided why you will carelambda callbacks another very common application of lambda is to define inline callback functions for python' tkinter gui api (this module is named tkinter in python xfor examplethe following creates button that prints message on the console when pressedassuming tkinter is available on your computer (it is by default on windowsmaclinuxand other oss)import sys from tkinter import buttonmainloop tkinter in buttontext='press me'command=(lambda:sys stdout write('spam\ ')) pack(mainloop(this may be optional in console mode xprint(herewe register the callback handler by passing function generated with lambda to the command keyword argument the advantage of lambda over def here is that the code that handles button press is right hereembedded in the button-creation call in effectthe lambda defers execution of the handler until the event occursthe write call happens on button pressesnot when the button is createdand effectively "knowsthe string it should write when the event occurs because the nested function scope rules apply to lambdas as wellthey are also easier to use as callback handlersas of python --they automatically see names in the functions in which they are coded and no longer require passed-in defaults in most cases this is especially handy for accessing the special self instance argument that is local variable in enclosing class method functions (more on classes in part vi)class myguidef makewidgets(self)button(command=(lambdaself onpress("spam"))def onpress(selfmessage)use message in early versions of pythoneven self had to be passed in to lambda with defaults as we'll see laterclass objects with __call__ and bound methods often serve in callback roles too--watch for coverage of these in and anonymous functionslambda |
1,142 | by most definitionstoday' python blends support for multiple programming paradigmsprocedural (with its basic statements)object-oriented (with its classes)and functional for the latter of thesepython includes set of built-ins used for functional programming--tools that apply functions to sequences and other iterables this set includes tools that call functions on an iterable' items (map)filter out items based on test function (filter)and apply functions to pairs of items and running results (reducethough the boundaries are sometimes bit greyby most definitions python' functional programming arsenal also includes the first-class object model explored earlierthe nested scope closures and anonymous function lambdas we met earlier in this part of the bookthe generators and comprehensions we'll be expanding on in the next and perhaps the function and class decorators of this book' final part for our purposes herelet' wrap up this with quick survey of built-in functions that apply other functions to iterables automatically mapping functions over iterablesmap one of the more common things programs do with lists and other sequences is apply an operation to each item and collect the results--selecting columns in database tablesincrementing pay fields of employees in companyparsing email attachmentsand so on python has multiple tools that make such collection-wide operations easy to code for instanceupdating all the counters in list can be done easily with for loopcounters [ updated [for in countersupdated append( add to each item updated [ but because this is such common operationpython also provides built-ins that do most of the work for you the map function applies passed-in function to each item in an iterable object and returns list containing all the function call results for exampledef inc( )return function to be run list(map(inccounters)[ collect results we met map briefly in and as way to apply built-in function to items in an iterable herewe make more general use of it by passing in userdefined function to be applied to each item in the list--map calls inc on each list item and collects all the return values into new list remember that map is an iterable in advanced function topics |
1,143 | this isn' necessary in (see if you've forgotten this requirementbecause map expects function to be passed in and appliedit also happens to be one of the places where lambda commonly appearslist(map((lambda xx )counters)[ function expression herethe function adds to each item in the counters listas this little function isn' needed elsewhereit was written inline as lambda because such uses of map are equivalent to for loopswith little extra code you can always code general mapping utility yourselfdef mymap(funcseq)res [for in seqres append(func( )return res assuming the function inc is still as it was when it was shown previouslywe can map it across sequence (or other iterablewith either the built-in or our equivalentlist(map(inc[ ])[ mymap(inc[ ][ built-in is an iterable ours builds list (see generatorshoweveras map is built-init' always availablealways works the same wayand has some performance benefits (as we'll prove in it' faster than manually coded for loop in some usage modesmoreovermap can be used in more advanced ways than shown here for instancegiven multiple sequence argumentsit sends items taken from sequences in parallel as distinct arguments to the functionpow( ** list(map(pow[ ][ ]) ** ** ** [ with multiple sequencesmap expects an -argument function for sequences herethe pow function takes two arguments on each call--one from each sequence passed to map it' not much extra work to simulate this multiple-sequence generality in codetoobut we'll postpone doing so until later in the next after we've met some additional iteration tools the map call is similar to the list comprehension expressions we studied in and will revisit in the next from functional perspectivelist(map(inc[ ])[ [inc(xfor in [ ][ use (parens to generate items instead in some casesmap may be faster to run than list comprehension ( when mapping built-in function)and it may also require less coding on the other handbecause functional programming tools |
1,144 | less general tooland often requires extra helper functions or lambdas moreoverwrapping comprehension in parentheses instead of square brackets creates an object that generates values on request to save memory and increase responsivenessmuch like map in -- topic we'll take up in the next selecting items in iterablesfilter the map function is primary and relatively straightforward representative of python' functional programming toolset its close relativesfilter and reduceselect an iterable' items based on test function and apply functions to item pairsrespectively because it also returns an iterablefilter (like rangerequires list call to display all its results in for examplethe following filter call picks out items in sequence that are greater than zerolist(range(- )[- - - - - an iterable in list(filter((lambda xx )range(- ))[ an iterable in we met filter briefly earlier in sidebarand while exploring iterables in items in the sequence or iterable for which the function returns true result are added to the result list like mapthis function is roughly equivalent to for loopbut it is built-inconciseand often fastres [for in range(- )if res append(xthe statement equivalent res [ also like mapfilter can be emulated by list comprehension syntax with often-simpler results (especially when it can avoid creating new function)and with similar generator expression when delayed production of results is desired--though we'll save the rest of this story for the next [ for in range(- if [ use (to generate items combining items in iterablesreduce the functional reduce callwhich is simple built-in function in but lives in the functools module in xis more complex it accepts an iterable to processbut it' not an iterable itself--it returns single result here are two reduce calls that compute the sum and product of the items in list advanced function topics |
1,145 | reduce((lambda xyx )[ ] reduce((lambda xyx )[ ] import in xnot in at each stepreduce passes the current sum or productalong with the next item from the listto the passed-in lambda function by defaultthe first item in the sequence initializes the starting value to illustratehere' the for loop equivalent to the first of these callswith the addition hardcoded inside the loopl [ , , , res [ for in [ :]res res res coding your own version of reduce is actually fairly straightforward the following function emulates most of the built-in' behavior and helps demystify its operation in generaldef myreduce(functionsequence)tally sequence[ for next in sequence[ :]tally function(tallynextreturn tally myreduce((lambda xyx )[ ] myreduce((lambda xyx )[ ] the built-in reduce also allows an optional third argument placed before the items in the sequence to serve as default result when the sequence is emptybut we'll leave this extension as suggested exercise if this coding technique has sparked your interestyou might also be interested in the standard library operator modulewhich provides functions that correspond to builtin expressions and so comes in handy for some uses of functional tools (see python' library manual for more details on this module)import operatorfunctools functools reduce(operator add[ ]function-based functools reduce((lambda xyx )[ ] togethermapfilterand reduce support powerful functional programming techniques as mentionedmany observers would also extend the functional programming toolset in python to include nested function scope closures ( factory functionsand the anonymous function lambda--both discussed earlier--as well as generators and comprehensionstopics we will return to in the next functional programming tools |
1,146 | this took us on tour of advanced function-related conceptsrecursive functionsfunction annotationslambda expression functionsfunctional tools such as mapfilterand reduceand general function design ideas the next continues the advanced topics motif with look at generators and reprisal of iterables and list comprehensions--tools that are just as related to functional programming as to looping statements before you move onthoughmake sure you've mastered the concepts covered here by working through this quiz test your knowledgequiz how are lambda expressions and def statements related what' the point of using lambda compare and contrast mapfilterand reduce what are function annotationsand how are they used what are recursive functionsand how are they used what are some general design guidelines for coding functions name three or more ways that functions can communicate results to caller test your knowledgeanswers both lambda and def create function objects to be called later because lambda is an expressionthoughit returns function object instead of assigning it to nameand it can be used to nest function definition in places where def will not work syntactically lambda allows for only single implicit return value expressionthoughbecause it does not support block of statementsit is not ideal for larger functions lambdas allow us to "inlinesmall units of executable codedefer its executionand provide it with state in the form of default arguments and enclosing scope variables using lambda is never requiredyou can always code def instead and reference the function by name lambdas come in handythoughto embed small pieces of deferred code that are unlikely to be used elsewhere in program they commonly appear in callback-based programs such as guisand they have natural affinity with functional tools like map and filter that expect processing function these three built-in functions all apply another function to items in sequence (or other iterableobject and collect results map passes each item to the function and collects all resultsfilter collects items for which the function returns true valueand reduce computes single value by applying the function to an accumulator advanced function topics |
1,147 | module in xnot the built-in scopereduce is built-in in function annotationsavailable in ( and later)are syntactic embellishments of function' arguments and resultwhich are collected into dictionary assigned to the function' __annotations__ attribute python places no semantic meaning on these annotationsbut simply packages them for potential use by other tools recursive functions call themselves either directly or indirectly in order to loop they may be used to traverse arbitrarily shaped structuresbut they can also be used for iteration in general (though the latter role is often more simply and efficiently coded with looping statementsrecursion can often be simulated or replaced by code that uses explicit stacks or queues to have more control over traversals functions should generally be small and as self-contained as possiblehave single unified purposeand communicate with other components through input arguments and return values they may use mutable arguments to communicate results too if changes are expectedand some types of programs imply other communication mechanisms functions can send back results with return statementsby changing passed-in mutable argumentsand by setting global variables globals are generally frowned upon (except for very special caseslike multithreaded programsbecause they can make code more difficult to understand and use return statements are usually bestbut changing mutables is fine (and even useful)if expected functions may also communicate results with system devices such as files and socketsbut these are beyond our scope here test your knowledgeanswers |
1,148 | comprehensions and generations this continues the advanced function topics themewith reprisal of the comprehension and iteration concepts previewed in and introduced in because comprehensions are as much related to the prior functional tools ( map and filteras they are to for loopswe'll revisit them in this context here we'll also take second look at iterables in order to study generator functions and their generator expression relatives--user-defined ways to produce results on demand iteration in python also encompasses user-defined classesbut we'll defer that final part of this story until part viwhen we study operator overloading as this is the last pass we'll make over built-in iteration toolsthoughwe will summarize the various tools we've met thus far the next continues this thread by timing the relative performance of these tools as larger case study before thatthoughlet' continue the comprehensions and iterations storyand extend it to include value generators list comprehensions and functional tools as mentioned early in this bookpython supports the proceduralobject-orientedand function programming paradigms in factpython has host of tools that most would considered functional in naturewhich we enumerated in the preceding -closuresgeneratorslambdascomprehensionsmapsdecoratorsfunction objectsand more these tools allow us to apply and combine functions in powerful waysand often offer state retention and coding solutions that are alternatives to classes and oop for instancethe prior explored tools such as map and filter--key members of python' early functional programming toolset inspired by the lisp language--that map operations over iterables and collect results because this is such common task in python codingpython eventually sprouted new expression--the list comprehension--that is even more flexible than the tools we just studied per python historylist comprehensions were originally inspired by similar tool in the functional programming language haskellaround the time of python in shortlist comprehensions apply an arbitrary expression to items in an iterablerather than ap |
1,149 | comprehension was extended to other roles--setsdictionariesand even the value generator expressions we'll explore in this it' not just for lists anymore we first met list comprehensions in ' previewand studied them further in in conjunction with looping statements because they're also related to functional programming tools like the map and filter callsthoughwe'll resurrect the topic here for one last look technicallythis feature is not tied to functions--as we'll seelist comprehensions can be more general tool than map and filter--but it is sometimes best understood by analogy to function-based alternatives list comprehensions versus map let' work through an example that demonstrates the basics as we saw in python' built-in ord function returns the integer code point of single character (the chr built-in is the converse--it returns the character for an integer code pointthese happen to be ascii codes if your characters fall into the ascii character set' bit code point rangeord(' ' nowsuppose we wish to collect the ascii codes of all characters in an entire string perhaps the most straightforward approach is to use simple for loop and append the results to listres [for in 'spam'res append(ord( )manual results collection res [ now that we know about mapthoughwe can achieve similar results with single function call without having to manage list construction in the coderes list(map(ord'spam')res [ apply function to sequence (or otherhoweverwe can get the same results from list comprehension expression--while map maps function over an iterablelist comprehensions map an expression over sequence or other iterableres [ord(xfor in 'spam'res [ apply expression to sequence (or otherlist comprehensions collect the results of applying an arbitrary expression to an iterable of values and return them in new list syntacticallylist comprehensions are enclosed in square brackets--to remind you that they construct lists in their simple formwithin comprehensions and generations |
1,150 | the brackets you code an expression that names variable followed by what looks like for loop header that names the same variable python then collects the expression' results for each iteration of the implied loop the effect of the preceding example is similar to that of the manual for loop and the map call list comprehensions become more convenientthoughwhen we wish to apply an arbitrary expression to an iterable instead of function[ * for in range( )[ herewe've collected the squares of the numbers through (we're just letting the interactive prompt print the resulting list objectassign it to variable if you need to retain itto do similar work with map callwe would probably need to invent little function to implement the square operation because we won' need this function elsewherewe' typically (but not necessarilycode it inlinewith lambdainstead of using def statement elsewherelist(map((lambda xx * )range( ))[ this does the same joband it' only few keystrokes longer than the equivalent list comprehension it' also only marginally more complex (at leastonce you understand the lambdafor more advanced kinds of expressionsthoughlist comprehensions will often require considerably less typing the next section shows why adding tests and nested loopsfilter list comprehensions are even more general than shown so far for instanceas we learned in you can code an if clause after the for to add selection logic list comprehensions with if clauses can be thought of as analogous to the filter builtin discussed in the preceding -they skip an iterable' items for which the if clause is not true to demonstratefollowing are both schemes picking up even numbers from to like the map list comprehension alternative of the prior sectionthe filter version here must invent little lambda function for the test expression for comparisonthe equivalent for loop is shown here as well[ for in range( if = [ list(filter((lambda xx = )range( ))[ res [for in range( )if = res append(xlist comprehensions and functional tools |
1,151 | [ all of these use the modulus (remainder of divisionoperator%to detect even numbersif there is no remainder after dividing number by it must be even the filter call here is not much longer than the list comprehension either howeverwe can combine an if clause and an arbitrary expression in our list comprehensionto give it the effect of filter and mapin single expression[ * for in range( if = [ this timewe collect the squares of the even numbers from through the for loop skips numbers for which the attached if clause on the right is falseand the expression on the left computes the squares the equivalent map call would require lot more work on our part--we would have to combine filter selections with map iterationmaking for noticeably more complex expressionlistmap((lambda xx** )filter((lambda xx = )range( ))[ formal comprehension syntax in factlist comprehensions are more general still in their simplest formyou must always code an accumulation expression and single for clauseexpression for target in iterable though all other parts are optionalthey allow richer iterations to be expressed--you can code any number of nested for loops in list comprehensionand each may have an optional associated if test to act as filter the general structure of list comprehensions looks like thisexpression for target in iterable if condition for target in iterable if condition for targetn in iterablen if conditionn this same syntax is inherited by set and dictionary comprehensions as well as the generator expressions coming upthough these use different enclosing characters (curly braces or often-optional parentheses)and the dictionary comprehension begins with two expressions separated by colon (for key and valuewe experimented with the if filter clause in the previous section when for clauses are nested within list comprehensionthey work like equivalent nested for loop statements for exampleres [ for in [ for in [ ]res [ this has the same effect as this substantially more verbose equivalentres [for in [ ] comprehensions and generations |
1,152 | res append( yres [ although list comprehensions construct list resultsremember that they can iterate over any sequence or other iterable type here' similar bit of code that traverses strings instead of lists of numbersand so collects concatenation results[ for in 'spamfor in 'spam'['ss''sp''sa''sm''ps''pp''pa''pm''as''ap''aa''am''ms''mp''ma''mm'each for clause can have an associated if filterno matter how deeply the loops are nested--though use cases for the following sort of codeapart from perhaps multidimensional arraysstart to become more and more difficult to imagine at this level[ for in 'spamif in 'smfor in 'spamif in (' '' ')['sp''sa''mp''ma'[ for in 'spamif in 'smfor in 'spamif in (' '' 'for in ' if ' '['sp ''sp ''sa ''sa ''mp ''mp ''ma ''ma 'finallyhere is similar list comprehension that illustrates the effect of attached if selections on nested for clauses applied to numeric objects rather than strings[(xyfor in range( if = for in range( if = [( )( )( )( )( )( )this expression combines even numbers from through with odd numbers from through the if clauses filter out items in each iteration here is the equivalent statement-based coderes [for in range( )if = for in range( )if = res append((xy)res [( )( )( )( )( )( )recall that if you're confused about what complex list comprehension doesyou can always nest the list comprehension' for and if clauses inside each other like this-indenting each clause successively further to the right--to derive the equivalent statements the result is longerbut perhaps clearer in intent to some human readers on first glanceespecially those more familiar with basic statements list comprehensions and functional tools |
1,153 | nestedso won' even try showing it here 'll leave its coding as an exercise for zen mastersex-lisp programmersand the criminally insaneexamplelist comprehensions and matrixes not all list comprehensions are so artificialof course let' look at one more application to stretch few synapses as we saw in and one basic way to code matrixes ( multidimensional arraysin python is with nested list structures the followingfor exampledefines two matrixes as lists of nested listsm [[ ][ ][ ] [[ ][ ][ ]given this structurewe can always index rowsand columns within rowsusing normal index operationsm[ [ row [ ][ row item list comprehensions are powerful tools for processing such structuresthoughbecause they automatically scan rows and columns for us for instancealthough this structure stores the matrix by rowsto collect the second column we can simply iterate across the rows and pull out the desired columnor iterate through positions in the rows and index as we go[row[ for row in [ column [ [row][ for row in ( )[ using offsets given positionswe can also easily perform tasks such as pulling out diagonal the first of the following expressions uses range to generate the list of offsets and then indexes with the row and column the samepicking out [ ][ ]then [ ][ ]and so on the second scales the column index to fetch [ ][ ] [ ][ ]etc (we assume the matrix has the same number of rows and columns)[ [ ][ifor in range(len( ))[ [ [ ][len( )- -ifor in range(len( ))[ comprehensions and generations diagonals |
1,154 | differ) [[ ][ ]for in range(len( ))for in range(len( [ ])) [ ][ + update in place [[ ][ ]we can' really do the same with list comprehensionsas they make new listsbut we could always assign their results to the original name for similar effect for examplewe can apply an operation to every item in matrixproducing results in either simple vector or matrix of the same shape[col for row in for col in row[ assign to to retain new value [[col for col in rowfor row in [[ ][ ][ ]to understand thesetranslate to their simple statement form equivalents that follow --indent parts that are further to the right in the expression (as in the first loop in the following)and make new list when comprehensions are nested on the left (like the second loop in the followingas its statement equivalent makes clearerthe second expression in the preceding works because the row iteration is an outer loopfor each rowit runs the nested column iteration to build up one row of the result matrixres [for row in mfor col in rowres append(col statement equivalents indent parts further right res [ res [for row in mtmp [for col in rowtmp append(col res append(tmpleft-nesting starts new list res [[ ][ ][ ]finallywith bit of creativitywe can also use list comprehensions to combine values of multiple matrixes the following first builds flat list that contains the result of multiplying the matrixes pairwiseand then builds nested list structure having the same values by nesting list comprehensions againm [[ ][ ][ ]list comprehensions and functional tools |
1,155 | [[ ][ ][ ][ [row][coln[row][colfor row in range( for col in range( )[ [[ [row][coln[row][colfor col in range( )for row in range( )[[ ][ ][ ]this last expression works because the row iteration is an outer loop againit' equivalent to this statement-based coderes [for row in range( )tmp [for col in range( )tmp append( [row][coln[row][col]res append(tmpand for more funwe can use zip to pair items to be multiplied--the following comprehension and loop statement forms both produce the same list-of-lists pairwise multiplication result as the last preceding example (and because zip is generator of values in xthis isn' as inefficient as it may seem)[[col col for (col col in zip(row row )for (row row in zip(mn)res [for (row row in zip(mn)tmp [for (col col in zip(row row )tmp append(col col res append(tmpcompared to their statement equivalentsthe list comprehension versions here require only one line of codemight run substantially faster for large matrixesand just might make your head explodewhich brings us to the next section don' abuse list comprehensionskiss with such generalitylist comprehensions can quickly becomewellincomprehensibleespecially when nested some programming tasks are inherently complexand we can' sugarcoat them to make them any simpler than they are (see the upcoming permutations for prime exampletools like comprehensions are powerful solutions when used wiselyand there' nothing inherently wrong with using them in your scripts at the same timecode like that of the prior section may push the complexity envelope more than it should--andfranklytends to disproportionately pique the interest of those holding the darker and misguided assumption that code obfuscation somehow implies talent because such tools tend to appeal to some people more than they probably shouldi need to be clear about their scope here comprehensions and generations |
1,156 | using complicated and tricky code where not warranted is both bad engineering and bad software citizenship to repurpose line from the first programming is not about being clever and obscure--it' about how clearly your program communicates its purpose orto quote from python' import this mottosimple is better than complex writing complicated comprehension code may be fun academic recreationbut it doesn' have place in programs that others will someday need to understand consequentlymy advice is to use simple for loops when getting started with pythonand comprehensions or map in isolated cases where they are easy to apply the "keep it simplerule applies here as alwayscode conciseness is much less important goal than code readability if you have to translate code to statements to understand itit should probably be statements in the first place in other wordsthe age-old acronym kiss still applieskeep it simple--followed either by word that is today too sexist (sir)or another that is too colorful for family-oriented book like this on the other handperformanceconcisenessexpressiveness howeverin this casethere is currently substantial performance advantage to the extra complexitybased on tests run under python todaymap calls can be twice as fast as equivalent for loopsand list comprehensions are often faster than map calls this speed difference can vary per usage pattern and pythonbut is generally due to the fact that map and list comprehensions run at language speed inside the interpreterwhich is often much faster than stepping through python for loop bytecode within the pvm in additionlist comprehensions offer code conciseness that' compelling and even warranted when that reduction in size doesn' also imply reduction in meaning for the next programmer moreovermany find the expressiveness of comprehensions to be powerful ally because map and list comprehensions are both expressionsthey also can show up syntactically in places that for loop statements cannotsuch as in the bodies of lambda functionswithin list and dictionary literalsand more because of thislist comprehensions and map calls are worth knowing and using for simpler kinds of iterationsespecially if your application' speed is an important consideration stillbecause for loops make logic more explicitthey are generally recommended on the grounds of simplicityand often make for more straightforward code when usedyou should try to keep your map calls and list comprehensions simplefor more complex tasksuse full statements instead list comprehensions and functional tools |
1,157 | here can depend on call patternsas well as changes and optimizations in python itself recent python releases have sped up the simple for loop statementfor example on some codethoughlist comprehensions are still substantially faster than for loops and even faster than mapthough map can still win when the alternatives must apply function callbuiltin functions or otherwise at least until this story changes arbitrarily-to time these alternatives yourselfsee tools in the standard library' time module or in the newer timeit module added in release or stay tuned for the extended coverage of both of these in the next where we'll prove the prior paragraph' claims why you will carelist comprehensions and map here are some more realistic examples of list comprehensions and map in action we solved the first with list comprehensions in but we'll revive it here to add map alternatives recall that the file readlines method returns lines with \ end-of-line characters at the ends (the following assumes -line text file in the current directory)open('myfile'readlines(['aaa\ ''bbb\ ''ccc\ 'if you don' want the end-of-line charactersyou can slice them off all the lines in single step with list comprehension or map call (map results are iterables in python xso we must run them through list to display all their results at once)[line rstrip(for line in open('myfile'readlines()['aaa''bbb''ccc'[line rstrip(for line in open('myfile')['aaa''bbb''ccc'list(map((lambda lineline rstrip())open('myfile'))['aaa''bbb''ccc'the last two of these make use of file iteratorsas we saw in this means that you don' need method call to read lines in iteration contexts such as these the map call is slightly longer than the list comprehensionbut neither has to manage result list construction explicitly list comprehension can also be used as sort of column projection operation python' standard sql database api returns query results as sequence of sequences like the following--the list is the tabletuples are rowsand items in tuples are column valueslistoftuple [('bob' 'mgr')('sue' 'dev') for loop could pick up all the values from selected column manuallybut map and list comprehensions can do it in single stepand faster[age for (nameagejobin listoftuple[ comprehensions and generations |
1,158 | [ the first of these makes use of tuple assignment to unpack row tuples in the listand the second uses indexing in python (but not in --see the note on argument unpacking in )map can use tuple unpacking on its argumenttoo only list(map((lambda (nameagejob)age)listoftuple)[ see other books and resources for more on python' database api besides the distinction between running functions versus expressionsthe biggest difference between map and list comprehensions in python is that map is an iterablegenerating results on demand to achieve the same memory economy and execution time divisionlist comprehensions must be coded as generator expressions-- major topic of this generator functions and expressions python today supports procrastination much more than it did in the past--it provides tools that produce results only when neededinstead of all at once we've seen this at work in built-in toolsfiles that read lines on requestand functions like map and zip that produce items on demand in such laziness isn' confined to python itselfthough in particulartwo language constructs delay result creation whenever possible in user-defined operationsgenerator functions (available since are coded as normal def statementsbut use yield statements to return results one at timesuspending and resuming their state between each generator expressions (available since are similar to the list comprehensions of the prior sectionbut they return an object that produces results on demand instead of building result list because neither constructs result list all at oncethey save memory space and allow computation time to be split across result requests as we'll seeboth of these ultimately perform their delayed-results magic by implementing the iteration protocol we studied in these features are not new (generator expressions were available as an option as early as python )and are fairly common in python code today python' notion of generators owes much to other programming languagesespecially icon though they may initially seem unusual if you're accustomed to simpler programming modelsyou'll probably find generators to be powerful tool where applicable moreoverbecause they are natural extension to the functioncomprehensionand iteration ideas we've generator functions and expressions |
1,159 | expect generator functionsyield versus return in this part of the bookwe've learned about coding normal functions that receive input parameters and send back single result immediately it is also possiblehoweverto write functions that may send back value and later be resumedpicking up where they left off such functionsavailable in both python and xare known as generator functions because they generate sequence of values over time generator functions are like normal functions in most respectsand in fact are coded with normal def statements howeverwhen createdthey are compiled specially into an object that supports the iteration protocol and when calledthey don' return resultthey return result generator that can appear in any iteration context we studied iterables in and figure - gave formal and graphic summary of their operation herewe'll revisit them to see how they relate to generators state suspension unlike normal functions that return value and exitgenerator functions automatically suspend and resume their execution and state around the point of value generation because of thatthey are often useful alternative to both computing an entire series of values up front and manually saving and restoring state in classes the state that generator functions retain when they are suspended includes both their code locationand their entire local scope hencetheir local variables retain information between resultsand make it available when the functions are resumed the chief code difference between generator and normal functions is that generator yields valuerather than returning one--the yield statement suspends the function and sends value back to the callerbut retains enough state to enable the function to resume from where it left off when resumedthe function continues execution immediately after the last yield run from the function' perspectivethis allows its code to produce series of values over timerather than computing them all at once and sending them back in something like list iteration protocol integration to truly understand generator functionsyou need to know that they are closely bound up with the notion of the iteration protocol in python as we've seeniterator objects define __next__ method (next in )which either returns the next item in the iterationor raises the special stopiteration exception to end the iteration an iterable object' iterator is fetched initially with the iter built-in functionthough this step is no-op for objects that are their own iterator comprehensions and generations |
1,160 | through sequence or value generatorif the protocol is supported (if notiteration falls back on repeatedly indexing sequences insteadany object that supports this interface works in all iteration tools to support this protocolfunctions containing yield statement are compiled specially as generators--they are not normal functionsbut rather are built to return an object with the expected iteration protocol methods when later calledthey return generator object that supports the iteration interface with an automatically created method named __next__ to start or resume execution generator functions may also have return statement thatalong with falling off the end of the def blocksimply terminates the generation of values--technicallyby raising stopiteration exception after any normal function exit actions from the caller' perspectivethe generator' __next__ method resumes the function and runs until either the next yield result is returned or stopiteration is raised the net effect is that generator functionscoded as def statements containing yield statementsare automatically made to support the iteration object protocol and thus may be used in any iteration context to produce results over time and on demand as noted in in python xiterator objects define method named next instead of __next__ this includes the generator objects we are using here in this method is renamed to __next__ the next built-in function is provided as convenience and portability toolnext(iis the same as __next__(in and next(in and prior to programs simply call next(instead to iterate manually generator functions in action to illustrate generator basicslet' turn to some code the following code defines generator function that can be used to generate the squares of series of numbers over timedef gensquares( )for in range( )yield * resume here later this function yields valueand so returns to its callereach time through the loopwhen it is resumedits prior state is restoredincluding the last values of its variables and nand control picks up again immediately after the yield statement for examplewhen it' used in the body of for loopthe first iteration starts the function and gets its first resultthereaftercontrol returns to the function after its yield statement each time through the loopfor in gensquares( )print(iend='resume the function print last yielded value generator functions and expressions |
1,161 | to end the generation of valuesfunctions either use return statement with no value or simply allow control to fall off the end of the function body to most peoplethis process seems bit implicit (if not magicalon first encounter it' actually quite tangiblethough if you really want to see what is going on inside the forcall the generator function directlyx gensquares( you get back generator object that supports the iteration protocol we met in --the generator function was compiled to return this automatically the returned generator object in turn has __next__ method that starts the function or resumes it from where it last yielded valueand raises stopiteration exception when the end of the series of values is reached and the function returns for conveniencethe next(xbuilt-in calls an object' __next__(method for us in (and next(in )next(xsame as __next__(in next(xuse next(or next(in next( next( next(xtraceback (most recent call last)file ""line in stopiteration as we learned in for loops (and other iteration contextswork with generators in the same way--by calling the __next__ method repeatedlyuntil an exception is caught for generatorthe result is to produce yielded values over time if the object to be iterated over does not support this protocolfor loops instead use the indexing protocol to iterate notice that the top-level iter call of the iteration protocol isn' required here because generators are their own iteratorsupporting just one active iteration scan to put that another way generators return themselves for iterbecause they support next directly this also holds true in the generator expressions we'll meet later in this (more on this ahead) gensquares( iter(yis true next( returns generator which is its own iterator iter(is not requireda no-op here can run next()immediately comprehensions and generations |
1,162 | given the simple examples we're using to illustrate fundamentalsyou might be wondering just why you' ever care to code generator at all in this section' examplefor instancewe could also simply build the list of yielded values all at oncedef buildsquares( )res [for in range( )res append( * return res for in buildsquares( )print(xend=' for that matterwe could use any of the for loopmapor list comprehension techniquesfor in [ * for in range( )]print(xend=' for in map((lambda nn * )range( ))print(xend=' howevergenerators can be better in terms of both memory use and performance in larger programs they allow functions to avoid doing all the work up frontwhich is especially useful when the result lists are large or when it takes lot of computation to produce each value generators distribute the time required to produce the series of values among loop iterations moreoverfor more advanced usesgenerators can provide simpler alternative to manually saving the state between iterations in class objects--with generatorsvariables accessible in the function' scopes are saved and restored automatically we'll discuss class-based iterables in more detail in part vi generator functions are also much more broadly focused than implied so far they can operate on and return any type of objectand as iterables may appear in any of ' iteration contextsincluding tuple callsenumerationsand dictionary comprehensions interestinglygenerator functions are also something of "poor man'smultithreading device--they interleave function' work with that of its callerby dividing its operation into steps run between yields generators are not threadsthoughthe program is explicitly directed to and from the function within single thread of control in one sensethreading is more general (producers can run truly independently and post results to queue)but generators may be simpler to code see the footnote in for brief introduction to python multithreading tools note that because control is routed explicitly at yield and next callsgenerators are also not backtrackingbut are more strongly related to coroutines--formal concepts that are both beyond this scope generator functions and expressions |
1,163 | for sub in line split(',')yield sub upper(tuple(ups('aaa,bbb,ccc')('aaa''bbb''ccc'substring generator all iteration contexts {is for (isin enumerate(ups('aaa,bbb,ccc')){ 'aaa' 'bbb' 'ccc'in moment we'll see the same assets for generator expressions-- tool that trades function flexibility for comprehension conciseness later in this we'll also see that generators can sometimes make the impossible possibleby producing components of result sets that would be far too large to create all at once firstthoughlet' explore some advanced generator function features extended generator function protocolsend versus next in python send method was added to the generator function protocol the send method advances to the next item in the series of resultsjust like __next__but also provides way for the caller to communicate with the generatorto affect its operation technicallyyield is now an expression form that returns the item passed to sendnot statement (though it can be called either way--as yield xor (yield )the expression must be enclosed in parentheses unless it' the only item on the right side of the assignment statement for examplex yield is okas is (yield when this extra protocol is usedvalues are sent into generator by calling send(valuethe generator' code is then resumedand the yield expression in the generator returns the value passed to send if the regular __next__(method (or its next(gequivalentis called to advancethe yield simply returns none for exampledef gen()for in range( ) yield print(xg gen(next( send( send( next(gnone must call next(firstto start generator advanceand send value to yield expression next(and __next__(send none comprehensions and generations |
1,164 | being processed inside the generator in additiongenerators in and later also support throw(typemethod to raise an exception inside the generator at the latest yieldand close method that raises special generatorexit exception inside the generator to terminate the iteration entirely these are advanced features that we won' delve into in more detail heresee reference texts and python' standard manuals for more informationand watch for more on exceptions in part vii note that while python provides next(xconvenience built-in that calls the __next__(method of an objectother generator methodslike sendmust be called as methods of generator objects directly ( send( )this makes sense if you realize that these extra methods are implemented on built-in generator objects onlywhereas the __next__ method applies to all iterable objects--both built-in types and user-defined classes also note that python introduces an extension to yield-- from clause--that allows generators to delegate to nested generators since this is an extension to what is already fairly advanced topicwe'll delegate this topic itself to sidebarand move on here to tool that' close enough to be called twin generator expressionsiterables meet comprehensions because the delayed evaluation of generator functions was so usefulit eventually spread to other tools in both python and xthe notions of iterables and list comprehensions are combined in new toolgenerator expressions syntacticallygenerator expressions are just like normal list comprehensionsand support all their syntax --including if filters and loop nesting--but they are enclosed in parentheses instead of square brackets (like tuplestheir enclosing parentheses are often optional)[ * for in range( )[ list comprehensionbuild list ( * for in range( )generator expressionmake an iterable at in factat least on functionality basiscoding list comprehension is essentially the same as wrapping generator expression in list built-in call to force it to produce all its results in list at oncelist( * for in range( )[ list comprehension equivalence operationallyhowevergenerator expressions are very differentinstead of building the result list in memorythey return generator object--an automatically created iterable this iterable object in turn supports the iteration protocol to yield one piece of the result list at time in any iteration context the iterable object also retains gengenerator functions and expressions |
1,165 | generator' code location the net effect is much like that of generator functionsbut in the context of comprehension expressionwe get back an object that remembers where it left off after each part of its result is returned also like generator functionslooking under the hood at the protocol that these objects automatically support can help demystify themthe iter call is again not required at the top herefor reasons we'll expand on aheadg ( * for in range( )iter(gis true next( next( next( next( next(gtraceback (most recent call last)file ""line in stopiteration iter(goptional__iter__ returns self generator objectsautomatic methods at againwe don' typically see the next iterator machinery under the hood of generator expression like this because for loops trigger it for us automaticallyfor num in ( * for in range( ))print('% % (numnum )calls next(automatically as we've already learnedevery iteration context does this--including for loopsthe summapand sorted built-in functionslist comprehensionsand other iteration contexts we learned about in such as the anyalland list built-in functions as iterablesgenerator expressions can appear in any of these iteration contextsjust like the result of generator function call for examplethe following deploys generator expressions in the string join method call and tuple assignmentiteration contexts both in the first test herejoin runs the generator and joins the substrings it produces with nothing between--to simply concatenate'join( upper(for in 'aaa,bbb,cccsplit(',')'aaabbbcccabc ( '\nfor in 'aaa,bbb,cccsplit(',') comprehensions and generations |
1,166 | ('aaa\ ''ccc\ 'notice how the join call in the preceding doesn' require extra parentheses around the generator syntacticallyparentheses are not required around generator expression that is the sole item already enclosed in parentheses used for other purposes--like those of function call parentheses are required in all other caseshowevereven if they seem extraas in the second call to sorted that followssum( * for in range( ) sorted( * for in range( )[ sorted(( * for in range( ))reverse=true[ parens optional parens optional parens required like the often-optional parentheses in tuplesthere is no widely accepted rule on thisthough generator expression does not have as clear role as fixed collection of other objects as tuplemaking extra parentheses seem perhaps more spurious here why generator expressionsjust like generator functionsgenerator expressions are memory-space optimization --they do not require the entire result list to be constructed all at onceas the squarebracketed list comprehension does also like generator functionsthey divide the work of results production into smaller time slices--they yield results in piecemeal fashioninstead of making the caller wait for the full set to be created in single call on the other handgenerator expressions may also run slightly slower than list comprehensions in practiceso they are probably best used only for very large result setsor applications that cannot wait for full results generation more authoritative statement about performancethoughwill have to await the timing scripts we'll code in the next though more subjectivegenerator expressions offer coding advantages too--as the next sections show generator expressions versus map one way to see the coding benefits of generator expressions is to compare them to other functional toolsas we did for list comprehensions for examplegenerator expressions often are equivalent to map callsbecause both generate result items on request like list comprehensionsthoughgenerator expressions may be simpler to code when the operation applied is not function call in xmap makes temporary lists and generator expressions do notbut the same coding comparisons applylist(map(abs(- - ))[ list(abs(xfor in (- - )[ map function on tuple generator expression generator functions and expressions |
1,167 | [ list( for in ( )[ nonfunction case simpler as generatorthe same holds true for text-processing use cases like the join call we saw earlier-- list comprehension makes an extra temporary list of resultswhich is completely pointless in this context because the list is not retainedand map loses simplicity points compared to generator expression syntax when the operation being applied is not callline 'aaa,bbb,ccc'join([ upper(for in line split(',')]'aaabbbccc'join( upper(for in line split(',')'aaabbbccc'join(map(str upperline split(','))'aaabbbccc'join( for in line split(',')'aaaaaabbbbbbcccccc'join(map(lambda xx line split(','))'aaaaaabbbbbbccccccmakes pointless list generates results generates results simpler as generatorboth map and generator expressions can also be arbitrarily nestedwhich supports general use in programsand requires list call or other iteration context to start the process of producing results for examplethe list comprehension in the following produces the same result as the map and generator equivalents that follow itbut makes two physical liststhe others generate just one integer at time with nested generatorsand the generator expression form may more clearly reflect its intent[ for in [abs(xfor in (- - )][ nested comprehensions list(map(lambda xx map(abs(- - )))[ nested maps list( for in (abs(xfor in (- - ))[ nested generators although the effect of all three of these is to combine operationsthe generators do so without making multiple temporary lists in xthe next example both nests and combines generators--the nested generator expression is activated by mapwhich in turn is only activated by list import math list(map(math sqrt( * for in range( )))[ nested combinations technically speakingthe range on the right in the preceding is value generator in tooactivated by the generator expression itself--three levels of value generationwhich produce individual values from inner to outer only on requestand which "just works comprehensions and generations |
1,168 | arbitrarily mixed and deepthough some may be more valid than otherslist(map(absmap(absmap(abs(- ))))nesting gone bad[ list(abs(xfor in (abs(xfor in (abs(xfor in (- )))[ these last examples illustrate how general generators can bebut are also coded in an intentionally complex form to underscore that generator expressions have the same potential for abuse as the list comprehensions discussed earlier--as usualyou should keep them simple unless they must be complexa theme we'll revisit later in this when used wellthoughgenerator expressions combine the expressiveness of list comprehensions with the space and time benefits of other iterables herefor examplenonnested approaches provide simpler solutions but still leverage generatorsstrengths --per python mottoflat is generally better than nestedunnested equivalents list(abs( for in (- - )[ list(math sqrt( * for in range( )[ list(abs(xfor in (- )[ flat is often better generator expressions versus filter generator expressions also support all the usual list comprehension syntax--including if clauseswhich work like the filter call we met earlier because filter is an iterable in that generates its results on requesta generator expression with an if clause is operationally equivalent (in xfilter produces temporary list that the generator does notbut the code comparisons again applyagainthe join in the following suffices to force all forms to produce their resultsline 'aa bbb 'join( for in line split(if len( 'aabbb'join(filter(lambda xlen( line split())'aabbbgenerator with 'ifsimilar to filter the generator seems marginally simpler than the filter here as for list comprehensionsthoughadding processing steps to filter results requires map toowhich makes filter noticeably more complex than generator expression'join( upper(for in line split(if len( 'aabbb'join(map(str upperfilter(lambda xlen( line split()))'aabbbin effectgenerator expressions do for iterables like map and filter what list comprehensions do for the list-builder flavors of these calls--they provide more general generator functions and expressions |
1,169 | like list comprehensionsthere is always statement-based equivalent to generator expressionthough it sometimes renders substantially more code'join( upper(for in line split(if len( 'aabbbres 'for in line split()if len( res + upper(statement equivalentthis is also join res 'aabbbin this casethoughthe statement form isn' quite the same--it cannot produce items one at timeand it' also emulating the effect of the join that forces results to be produced all at once the true equivalent to generator expression would be generator function with yieldas the next section shows generator functions versus generator expressions let' recap what we've covered so far in this sectiongenerator functions function def statement that contains yield statement is turned into generator function when calledit returns new generator object with automatic retention of local scope and code positionan automatically created __iter__ method that simply returns itselfand an automatically created __next__ method (next in xthat starts the function or resumes it where it last left offand raises stopitera tion when finished producing results generator expressions comprehension expression enclosed in parentheses is known as generator expression when runit returns new generator object with the same automatically created method interface and state retention as generator function call' results --with an __iter__ method that simply returns itselfand _next__ method (next in xthat starts the implied loop or resumes it where it last left offand raises stopiteration when finished producing results the net effect is to produce results on demand in iteration contexts that employ these interfaces automatically as implied by some of the preceding sectionsthe same iteration can often be coded with either generator function or generator expression the following generator expressionfor examplerepeats each character in string four timesg ( for in 'spam'list( ['ssss''pppp''aaaa''mmmm' comprehensions and generations generator expression force generator to produce all results |
1,170 | needed in factthis is essentially the same as the prior tradeoff between lambda and def--expression conciseness versus statement powerdef timesfour( )for in syield timesfour('spam'list( ['ssss''pppp''aaaa''mmmm'generator function iterate automatically to clientsthe two are more similar than different both expressions and functions support both automatic and manual iteration--the prior list call iterates automaticallyand the following iterate manuallyg ( for in 'spam' iter(gnext( 'ssssnext( 'ppppg timesfour('spam' iter(gnext( 'ssssnext( 'ppppiterate manually (expressioniterate manually (functionin either casepython automatically creates generator objectwhich has both the methods required by the iteration protocoland state retention for variables in the generator' code and its current code location notice how we make new generators here to iterate again--as explained in the next sectiongenerators are one-shot iterators firstthoughhere' the true statement-based equivalent of expression at the end of the prior sectiona function that yields values--though the difference is irrelevant if the code using it produces all results with tool like joinline 'aa bbb 'join( upper(for in line split(if len( 'aabbbexpression def gensub(line)for in line split()if len( yield upper(function 'join(gensub(line)'aabbbbut why generategenerator functions and expressions |
1,171 | simple statement equivalent shown earlier may be difficult to justifyexcept on stylistic grounds on the other handtrading four lines for one may to many seem fairly compelling stylistic groundsgenerators are single-iteration objects subtle but important pointboth generator functions and generator expressions are their own iterators and thus support just one active iteration--unlike some built-in typesyou can' have multiple iterators of either positioned at different locations in the set of results because of thisa generator' iterator is the generator itselfin factas suggested earliercalling iter on generator expression or function is an optional noopg ( for in 'spam'iter(gis true my iterator is myselfg has __next__ if you iterate over the results stream manually with multiple iteratorsthey will all point to the same positiong ( for in 'spam' iter(gnext( 'ssssnext( 'ppppi iter(gnext( 'aaaamake new generator iterate manually second iterator at same positionmoreoveronce any iteration runs to completionall are exhausted--we have to make new generator to start againlist( ['mmmm'next( stopiteration collect the rest of ' items iter(gnext( stopiteration ditto for new iterators iter( for in 'spam'next( 'ssssnew generator to start over other iterators exhausted too the same holds true for generator functions--the following def statement-based equivalent supports just one active iterator and is exhausted after one passdef timesfour( )for in syield comprehensions and generations |
1,172 | iter(gis true iter( )iter(gnext( 'ssssnext( 'ppppnext( 'aaaagenerator functions work the same way at same position as this is different from the behavior of some built-in typeswhich support multiple iterators and passes and reflect their in-place changes in active iteratorsl [ iter( )iter(lnext( next( next( del [ :next( stopiteration lists support multiple iterators changes reflected in iterators though not readily apparent in these simple examplesthis can matter in your codeif you wish to scan generator' values multiple timesyou must either create new generator for each scan or build rescannable list out of its values-- single generator' values will be consumed and exhausted after single pass see this sidebar "why you will careone-shot iterationson page for prime example of the sort of code that must accommodate this generator property when we begin coding class-based iterables in part viwe'll also see that it' up to us to decide how many iterations we wish to support for our objectsif any in generalobjects that wish to support multiple scans will return supplemental class objects instead of themselves the next section previews more of this model the python yield from extension python introduces extended syntax for the yield statement that allows delegation to subgenerator with from generator clause in simple casesit' the equivalent to yielding for loop--the list here in the following forces the generator to produce all its valuesand the comprehension in parentheses is generator expressioncovered in this def both( )for in range( )yield for in ( * for in range( ))yield list(both( )[ generator functions and expressions |
1,173 | the usual generator usage contextsdef both( )yield from range(nyield from ( * for in range( )list(both( )[ join(str(ifor in both( )' in more advanced roleshoweverthis extension allows subgenerators to receive sent and thrown values directly from the calling scopeand return final value to the outer generator the net effect is to allow such generators to be split into multiple subgenerators much as single function can be split into multiple subfunctions since this is only available in and laterand is beyond this generator coverage in generalwe'll defer to python ' manuals for additional details for an additional yield from examplealso see the solution to this part' exercise described at the end of generation in built-in typestoolsand classes finallyalthough we've focused on coding value generators ourselves in this sectiondon' forget that many built-in types behave in similar ways--as we saw in for exampledictionaries are iterables with iterators that produce keys on each iterationd {' ': ' ': ' ': iter(dnext( 'cnext( 'blike the values produced by handcoded generatorsdictionary keys may be iterated over both manually and with automatic iteration tools including for loopsmap callslist comprehensionsand the many other contexts we met in for key in dprint(keyd[key] as we've also seenfor file iteratorspython simply loads lines from the file on demandfor line in open('temp txt')print(lineend='' comprehensions and generations |
1,174 | flesh wound while built-in type iterables are bound to specific type of value generationthe concept is similar to the multipurpose generators we code with expressions and functions iteration contexts like for loops accept any iterable that has the expected methodswhether user-defined or built-in generators and library toolsdirectory walkers though beyond this book' scopemany python standard library tools generate values today tooincluding email parsersand the standard directory walker--which at each level of tree yields tuple of the current directoryits subdirectoriesand its filesimport os for (rootsubsfilesin os walk(')for name in filesif name startswith('call')print(rootnamedirectory walk generator python 'findoperation callables py \dualpkg callables py in factos walk is coded as recursive function in python in its os py standard library filein :\python \lib on windows because it uses yield (and in yield from instead of for loopto return resultsit' normal generator functionand hence an iterable objectg os walk( ' :\code\pkg'iter(gis single-scan iteratoriter(goptional true iter(gnext( (' :\\code\\pkg'['__pycache__']['eggs py''eggs pyc''main py'etc ]next( (' :\\code\\pkg\\__pycache__'[]['eggs cpython- pyc'etc ]next(istopiteration by yielding results as it goesthe walker does not require its clients to wait for an entire tree to be scanned see python' manuals and follow-up books such as programming python for more on this tool also see and others for os popen-- related iterable used to run shell command and read its output generators and function application in we noted that starred arguments can unpack an iterable into individual arguments now that we've seen generatorswe can also see what this means in code in both and (though ' range is list)def (abc)print('% %sand % (abc) ( normal positionals generator functions and expressions |
1,175 | (*range( ) and (*( for in range( )) and unpack range valuesiterable in unpack generator expression values this applies to dictionaries and views too (though dict values is also list in xand order is arbitrary when passing values by position) dict( ='bob' ='dev' = ) {' ''dev'' ' ' ''bob' ( ='bob' ='dev' = normal keywords bobdevand (**dunpack dictkey=value bobdevand (*dunpack keys iterator bcand (* values()unpack view iteratoriterable in dev and bob because the built-in print function in prints all its variable number of argumentsthis also makes the following three forms equivalent--the latter using to unpack the results forced from generator expression (though the second also creates list of return valuesand the first may leave your cursor at the end of the output line in some shellsbut not in the idle gui)for in 'spam'print( upper()end=' list(print( upper()end='for in 'spam' [nonenonenonenoneprint(*( upper(for in 'spam') see for an additional example that unpacks file' lines by iterator into arguments previewuser-defined iterables in classes although beyond the scope of this it is also possible to implement arbitrary user-defined generator objects with classes that conform to the iteration protocol such classes define special __iter__ method run by the iter built-in functionwhich in turn returns an object having __next__ method (next in xrun by the next built-in functionclass someiterabledef __init__)def __next__)on iter()return self or supplemental object on next()coded hereor in another class as the prior section suggestedthese classes usually return their objects directly for single-iteration behavioror supplemental object with scan-specific state for multiplescan support comprehensions and generations |
1,176 | alternativelya user-defined iterable class' method functions can sometimes use yield to transform themselves into generatorswith an automatically created __next__ method-- common application of yield we'll meet in that is both wildly implicit and potentially usefula __getitem__ indexing method is also available as fallback option for iterationthough this is often not as flexible as the __iter__ and __next__ scheme (but has advantages for coding sequencesthe instance objects created from such class are considered iterable and may be used in for loops and all other iteration contexts with classesthoughwe have access to richer logic and data structuring optionssuch as inheritancethat other generator constructs cannot offer by themselves by coding methodsclasses also can make iteration behavior much more explicit than the "magicgenerator objects associated with built-in types and generator functions and expressions (though classes wield some magic of their ownhencethe iterator and generator story won' really be complete until we've seen how it maps to classestoo for nowwe'll have to settle for postponing its conclusion-and its final sequel--until we study class-based iterables in examplegenerating scrambled sequences to demonstrate the power of iteration tools in actionlet' turn to some more complete use case examples in we wrote testing function that scrambled the order of arguments used to test generalized intersection and union functions therei noted that this might be better coded as generator of values now that we've learned how to write generatorsthis serves to illustrate practical application one note up frontbecause they slice and concatenate objectsall the examples in the section (including the permutations at the endwork only on sequences like strings and listnot on arbitrary iterables like filesmapsand other generators that issome of these examples will be generators themselvesproducing values on requestbut they cannot process generators as their inputs generalization for broader categories is left as an open issuethough the code here will suffice unchanged if you wrap nonsequence generators in list calls before passing them in scrambling sequences as coded in we can reorder sequence with slicing and concatenationmoving the front item to the end on each loopslicing instead of indexing the item allows to work for arbitrary sequence typesls [ ]'spamfor in range(len( )) [ : [: print(send='for repeat counts move front item to the end pams amsp mspa spam generator functions and expressions |
1,177 | [ : [: print(lend='slice so any sequence type works [ [ [ alternativelyas we saw in we get the same results by moving an entire front section to the endthough the order of the results varies slightlyfor in range(len( )) [ : [:iprint(xend='for positions rear part front part (same effectspam pams amsp mspa simple functions as isthis code works on specific named variables only to generalizewe can turn it into simple function to work on any object passed to its argument and return resultsince the first of these exhibits the classic list comprehension patternwe can save some work by coding it as such in the seconddef scramble(seq)res [for in range(len(seq))res append(seq[ :seq[: ]return res scramble('spam'['spam''pams''amsp''mspa'def scramble(seq)return [seq[ :seq[:ifor in range(len(seq))scramble('spam'['spam''pams''amsp''mspa'for in scramble(( ))print(xend='( ( ( we could use recursion here as wellbut it' probably overkill in this context generator functions the preceding section' simple approach worksbut must build an entire result list in memory all at once (not great on memory usage if it' massive)and requires the caller to wait until the entire list is complete (less than ideal if this takes substantial amount of timewe can do better on both fronts by translating this to generator function that yields one result at timeusing either coding schemedef scramble(seq)for in range(len(seq)) comprehensions and generations |
1,178 | yield seq def scramble(seq)for in range(len(seq))yield seq[ :seq[:ilist(scramble('spam')['spam''pams''amsp''mspa'list(scramble(( ))[( )( )( )for in scramble(( ))print(xend='generator function assignments work here generator function yield one item per iteration list()generates all results any sequence type works for loops generate results ( ( ( generator functions retain their local scope state while activeminimize memory space requirementsand divide the work into shorter time slices as full functionsthey are also very general importantlyfor loops and other iteration tools work the same whether stepping through real list or generator of values--the function can select between the two schemes freelyand even change strategies in the future generator expressions as we've seengenerator expressions--comprehensions in parentheses instead of square brackets--also generate values on request and retain their local state they're not as flexible as full functionsbut because they yield their values automaticallyexpressions can often be more concise in specific use cases like thiss 'spamg ( [ : [:ifor in range(len( ))list( ['spam''pams''amsp''mspa'generator expression equivalent notice that we can' use the assignment statement of the first generator function version herebecause generator expressions cannot contain statements this makes them bit narrower in scopein many casesthoughexpressions can do similar workas shown here to generalize generator expression for an arbitrary subjectwrap it in simple function that takes an argument and returns generator that uses itf lambda seq(seq[ :seq[:ifor in range(len(seq)) (sat list( ( )['spam''pams''amsp''mspa'list( ([ ])[[ ][ ][ ]for in (( ))print(xend='generator functions and expressions |
1,179 | tester client finallywe can use either the generator function or its expression equivalent in ' tester to produce scrambled arguments--the sequence scrambling function becomes tool we can use in other contextsfile scramble py def scramble(seq)for in range(len(seq))yield seq[ :seq[:igenerator function yield one item per iteration scramble lambda seq(seq[ :seq[:ifor in range(len(seq))and by moving the values generation out to an external toolthe tester becomes simplerfrom scramble import scramble from inter import intersectunion def tester(funcitemstrace=true)for args in scramble(items)if traceprint(argsprint(sorted(func(*args))use generator (orscramble (items)tester(intersect('aab''abcde''ababab')('aab''abcde''ababab'[' '' '('abcde''ababab''aab'[' '' '('ababab''aab''abcde'[' '' 'tester(intersect([ ][ ][ ])false[ [ [ permutationsall possible combinations these techniques have many other real-world applications--consider generating attachments in an email message or points to be plotted in gui moreoverother types of sequence scrambles serve central roles in other applicationsfrom searches to mathematics as isour sequence scrambler is simple reorderingbut some programs warrant the more exhaustive set of all possible orderings we get from permutations--produced using recursive functions in both list-builder and generator forms by the following module filefile permute py def permute (seq)if not seq comprehensions and generations shuffle any sequencelist |
1,180 | elseres [for in range(len(seq))rest seq[:iseq[ + :for in permute (rest)res append(seq[ : + xreturn res def permute (seq)if not seqyield seq elsefor in range(len(seq))rest seq[:iseq[ + :for in permute (rest)yield seq[ : + empty sequence delete current node permute the others add node at front shuffle any sequencegenerator empty sequence delete current node permute the others add node at front both of these functions produce the same resultsthough the second defers much of its work until it is asked for result this code is bit advancedespecially the second of these functions (and to some python newcomers might even be categorized as cruel and inhumane punishment!stillas 'll explain in momentthere are cases where the generator approach can be highly useful study and test this code for more insightand add prints to trace if it helps if it' still mysterytry to make sense of the first version firstremember that generator functions simply return objects with methods that handle next operations run by for loops at each leveland don' produce any results until iteratedand trace through some of the following examples to see how they're handled by this code permutations produce more orderings than the original shuffler--for itemswe get (factorialresults instead of just ( for in factthat' why we need recursion herethe number of nested loops is arbitraryand depends on the length of the sequence permutedfrom scramble import scramble from permute import permute permute list(scramble('abc')['abc''bca''cab'simple scramblesn permute ('abc'['abc''acb''bac''bca''cab''cba'list(permute ('abc')['abc''acb''bac''bca''cab''cba'permutations largerng permute ('abc'next( 'abcnext( 'acbfor in permute ('abc')print(xprints six lines iterate (iter(not neededgenerate all combinations automatic iteration generator functions and expressions |
1,181 | both space usage and delays for results for larger itemsthe set of all permutations is much larger than the simpler scrambler'spermute ('spam'=list(permute ('spam')true len(list(permute ('spam')))len(list(scramble('spam'))( list(scramble('spam')['spam''pams''amsp''mspa'list(permute ('spam')['spam''spma''sapm''samp''smpa''smap''psam''psma''pasm''pams''pmsa''pmas''aspm''asmp''apsm''apms''amsp''amps''mspa''msap''mpsa''mpas''masp''maps'per there are nonrecursive alternatives here toousing explicit stacks or queuesand other sequence orderings are common ( fixed-size subsets and combinations that filter out duplicates of differing order)but these require coding extensions we'll forgo here see the book programming python for more on this themeor experiment further on your own don' abuse generatorseibti generators are somewhat advanced tooland might be better treated as an optional topicbut for the fact that they permeate the python languageespecially in in factthey seem less optional to this book' audience than unicode (which was exiled to part viiias we've seenfundamental built-in tools such as rangemapdictionary keysand even files are now generatorsso you must be familiar with the concept even if you don' write new generators of your own moreoveruser-defined generators are increasingly common in python code that you might come across today--in the python standard libraryfor instance in generalthe same cautions gave for list comprehensions apply here as welldon' complicate your code with user-defined generators if they are not warranted especially for smaller programs and data setsthere may be no good reason to use these tools in such casessimple lists of results will sufficewill be easier to understandwill be garbage-collected automaticallyand may be produced quicker (and they are todaysee the next advanced tools like generators that rely on implicit "magiccan be fun to experiment withbut they have no place in real code that must be used by others except when clearly justified orto quote from python' import this motto againexplicit is better than implicit the acronym for thiseibtiis one of python' core guidelinesand for good reasonthe more explicit your code is about its behaviorthe more likely it is that the next programmer will be able to understand it this applies directly to generatorswhose comprehensions and generations |
1,182 | alternatives alwayskeep it simple unless it must be complicatedon the other handspace and timeconcisenessexpressiveness that being saidthere are specific use cases that generators can address well they can reduce memory footprint in some programsreduce delays in othersand can occasionally make the impossible possible considerfor examplea program that must produce all possible permutations of nontrivial sequence since the number of combinations is factorial that explodes exponentiallythe preceding permute recursive list-builder function will either introduce noticeable and perhaps interminable pause or fail completely due to memory requirementswhereas the permute recursive generator will not--it returns each individual result quicklyand can handle very large result setsimport math math factorial( from permute import permute permute seq list(range( ) permute (seq seconds on ghz quad-core machine creates list of numbers len( ) [ ] [ ( [ ][ ]in this casethe list builder pauses for seconds on my computer to build -millionitem listbut the generator can begin returning results immediatelyp permute (seqnext( [ next( [ returns generator immediately and produces each result quickly on request list(permute (seq) = true about secondsthough still impractical same set of results generated naturallywe might be able to optimize the list builder' code to run quicker ( an explicit stack instead of recursion might change its performance)but for larger sequencesit' not an option at all--at just itemsthe number of permutations precludes building results listand would take far too long for mere mortals like us (and larger values will overflow the preset recursion stack depth limitsee the preceding the generatorhoweveris still viable--it is able to produce individual results immediatelymath factorial( permute (list(range( ))next( permute is not an option here[ generator functions and expressions |
1,183 | for more fun--and to yield results that are more variable and less obviously deterministic--we could also use python' random module of to randomly shuffle the sequence to be permuted before the permuter begins its work (in factwe might be able to use the random shuffler as permutation generator in generalas long as we either can assume that it won' repeat shuffles during the time we consume themor test its results against prior shuffles to avoid repeats--and hope that we do not live in the strange universe where random sequence repeats the same result an infinite number of times!in the followingeach permute and next call returns immediately as beforebut permute hangsimport random math factorial( seq list(range( )permute is not an option here random shuffle(seqshuffle sequence randomly first permute (seqnext( [ next( [ random shuffle(seqp permute (seqnext( [ next( [ the main point here is that generators can sometimes produce results from large solution sets when list builders cannot then againit' not clear how common such use cases may be in the real worldand this doesn' necessarily justify the implicit flavor of value generation that we get with generator functions and expressions as we'll see in part vivalue generation can also be coded as iterable objects with classes class-based iterables can produce items on request tooand are far more explicit than the magic objects and methods produced for generator functions and expressions part of programming is finding balance among tradeoffs like theseand there are no absolute rules here while the benefits of generators may sometimes justify their usemaintainability should always be top priority too like comprehensionsgenerators also offer an expressiveness and code economy that' hard to resist if you understand how they work--but you'll want to weigh this against the frustration of coworkers who might not comprehensions and generations |
1,184 | to help you evaluate their roles furtherlet' take quick look at one more example of generators in action that illustrates just how expressive they can be once you know about comprehensionsgeneratorsand other iteration toolsit turns out that emulating many of python' functional built-ins is both straightforward and instructive for examplewe've already seen how the built-in zip and map functions combine iterables and project functions across themrespectively with multiple iterable argumentsmap projects the function across items taken from each iterable in much the same way that zip pairs them ups 'abcs 'xyz list(zip( )[(' '' ')(' '' ')(' '' ')zip pairs itemstruncates at shortest list(zip([- - ])[(- ,)(- ,)( ,)( ,)( ,)list(zip([ ][ ])[( )( )( )map passes paired items to functiontruncates list(map(abs[- - ])[ list(map(pow[ ][ ])[ zip pairs items from iterables single sequence -ary tuples sequencesn-ary tuples single sequence -ary function sequencesn-ary function map and zip accept arbitrary iterables map(lambda xyx yopen('script py')open('script py')['import sys\nimport sys\ ''print(sys path)\nprint(sys path)\ 'etc [ for (xyin zip(open('script py')open('script py'))['import sys\nimport sys\ ''print(sys path)\nprint(sys path)\ 'etc though they're being used for different purposesif you study these examples long enoughyou might notice relationship between zip results and mapped function arguments that our next example can exploit coding your own map(funcalthough the map and zip built-ins are fast and convenientit' always possible to emulate them in code of our own in the preceding for examplewe saw function that emulated the map built-in for single sequence (or other iterableargument it doesn' take much more work to allow for multiple sequencesas the built-in doesmap(funcseqs workalike with zip def mymap(func*seqs)res [for args in zip(*seqs)res append(func(*args)generator functions and expressions |
1,185 | print(mymap(abs[- - ])print(mymap(pow[ ][ ])this version relies heavily upon the special *args argument-passing syntax--it collects multiple sequence (reallyiterableargumentsunpacks them as zip arguments to combineand then unpacks the paired zip results as arguments to the passed-in function that iswe're using the fact that the zipping is essentially nested operation in mapping the test code at the bottom applies this to both one and two sequences to produce this output--the same we would get with the built-in map (this code is in file mymap py in the book' examples if you want to run it live)[ [ reallythoughthe prior version exhibits the classic list comprehension patternbuilding list of operation results within for loop we can code our map more concisely as an equivalent one-line list comprehensionusing list comprehension def mymap(func*seqs)return [func(*argsfor args in zip(*seqs)print(mymap(abs[- - ])print(mymap(pow[ ][ ])when this is run the result is the same as beforebut the code is more concise and might run faster (more on performance in the section "timing iteration alternativeson page both of the preceding mymap versions build result lists all at oncethoughand this can waste memory for larger lists now that we know about generator functions and expressionsit' simple to recode both these alternatives to produce results on demand insteadusing generatorsyield and def mymap(func*seqs)res [for args in zip(*seqs)yield func(*argsdef mymap(func*seqs)return (func(*argsfor args in zip(*seqs)these versions produce the same results but return generators designed to support the iteration protocol--the first yields one result at timeand the second returns generator expression' result to do the same they produce the same results if we wrap them in list calls to force them to produce their values all at onceprint(list(mymap(abs[- - ]))print(list(mymap(pow[ ][ ])) comprehensions and generations |
1,186 | the iteration protocol the generators returned by these functions themselvesas well as that returned by the python flavor of the zip built-in they useproduce results only on demand coding your own zipand map(noneof coursemuch of the magic in the examples shown so far lies in their use of the zip built-in to pair arguments from multiple sequences or iterables our map workalikes are also really emulating the behavior of the python map--they truncate at the length of the shortest argumentand they do not support the notion of padding results when lengths differas map does in python with none argumentc:codec:\python \python map(none[ ][ ][( )( )( )(none )map(none'abc''xyz '[(' '' ')(' '' ')(' '' ')(none' ')(none' ')(none' ')using iteration toolswe can code workalikes that emulate both truncating zip and ' padding map--these turn out to be nearly the same in codezip(seqs and map(noneseqs workalikes def myzip(*seqs)seqs [list(sfor in seqsres [while all(seqs)res append(tuple( pop( for in seqs)return res def mymappad(*seqspad=none)seqs [list(sfor in seqsres [while any(seqs)res append(tuple(( pop( if else padfor in seqs)return res 'abc''xyz print(myzip( )print(mymappad( )print(mymappad( pad= )both of the functions coded here work on any type of iterable objectbecause they run their arguments through the list built-in to force result generation ( files would work as argumentsin addition to sequences like stringsnotice the use of the all and any built-ins here--these return true if all and any items in an iterable are true (or equivalentlynonempty)respectively these built-ins are used to stop looping when any or all of the listified arguments become empty after deletions also note the use of the python keyword-only argumentpadunlike the mapour version will allow any pad object to be specified (if you're using xuse generator functions and expressions |
1,187 | functions are runthe following results are printed-- zipand two padding maps[(' '' ')(' '' ')(' '' ')[(' '' ')(' '' ')(' '' ')(none' ')(none' ')(none' ')[(' '' ')(' '' ')(' '' ')( ' ')( ' ')( ' ')these functions aren' amenable to list comprehension translation because their loops are too specific as beforethoughwhile our zip and map workalikes currently build and return result listsit' just as easy to turn them into generators with yield so that they each return one piece of their result set at time the results are the same as beforebut we need to use list again to force the generators to yield their values for displayusing generatorsyield def myzip(*seqs)seqs [list(sfor in seqswhile all(seqs)yield tuple( pop( for in seqsdef mymappad(*seqspad=none)seqs [list(sfor in seqswhile any(seqs)yield tuple(( pop( if else padfor in seqss 'abc''xyz print(list(myzip( ))print(list(mymappad( ))print(list(mymappad( pad= ))finallyhere' an alternative implementation of our zip and map emulators--rather than deleting arguments from lists with the pop methodthe following versions do their job by calculating the minimum and maximum argument lengths armed with these lengthsit' easy to code nested list comprehensions to step through argument index rangesalternate implementation with lengths def myzip(*seqs)minlen min(len(sfor in seqsreturn [tuple( [ifor in seqsfor in range(minlen)def mymappad(*seqspad=none)maxlen max(len(sfor in seqsindex range(maxlenreturn [tuple(( [iif len(si else padfor in seqsfor in indexs 'abc''xyz print(myzip( )print(mymappad( )print(mymappad( pad= )because these use len and indexingthey assume that arguments are sequences or similarnot arbitrary iterablesmuch like our earlier sequence scramblers and permuters comprehensions and generations |
1,188 | comprehensions (passed to tuplestep through the passed-in sequences to pull out arguments in parallel when they're runthe results are as before most strikinglygenerators and iterators seem to run rampant in this example the arguments passed to min and max are generator expressionswhich run to completion before the nested comprehensions begin iterating moreoverthe nested list comprehensions employ two levels of delayed evaluation--the python range built-in is an iterableas is the generator expression argument to tuple in factno results are produced here until the square brackets of the list comprehensions request values to place in the result list--they force the comprehensions and generators to run to turn these functions themselves into generators instead of list buildersuse parentheses instead of square brackets again here' the case for our zipusing generatorsdef myzip(*seqs)minlen min(len(sfor in seqsreturn (tuple( [ifor in seqsfor in range(minlen) 'abc''xyz print(list(myzip( ))go[(' '' ')(' '' ')(' '' ')in this caseit takes list call to activate the generators and other iterables to produce their results experiment with these on your own for more details developing further coding alternatives is left as suggested exercise (see also the sidebar "why you will careone-shot iterationson page for investigation of one such optionwatch for more yield examples in where we'll use it in conjunction with the __iter__ operator overloading method to implement user-defined iterable objects in an automated fashion the state retention of local variables in this role serves as an alternative to class attributes in the same spirit as the closure functions of as we'll seethoughthis technique combines classes and functional tools instead of posing paradigm alternative why you will careone-shot iterations in we saw how some built-ins (like mapsupport only single traversal and are empty after it occursand promised to show you an example of how that can become subtle but important in practice now that we've studied few more iteration topicsi can make good on this promise consider the following clever alternative coding for this zip emulation examplesadapted from one in python' manuals at the time wrote these wordsdef myzip(*args)iters map(iterargswhile itersgenerator functions and expressions |
1,189 | yield tuple(resbecause this code uses iter and nextit works on any type of iterable note that there is no reason to catch the stopiteration raised by the next(itinside the comprehension here when any one of the argumentsiterators is exhausted--allowing it to pass ends this generator function and has the same effect that return statement would the while iterssuffices to loop if at least one argument is passedand avoids an infinite loop otherwise (the list comprehension would always return an empty listthis code works fine in python as islist(myzip('abc''lmnop')[(' '' ')(' '' ')(' '' ')but it falls into an infinite loop and fails in python xbecause the map returns one-shot iterable object instead of list as in in xas soon as we've run the list comprehension inside the loop onceiters will be exhausted but still true (and res will be []forever to make this work in xwe need to use the list built-in function to create an object that can support multiple iterationsdef myzip(*args)iters list(map(iterargs)rest as is allow multiple scans run this on your own to trace its operation the lesson herewrapping map calls in list calls in is not just for displaycomprehension syntax summary we've been focusing on list comprehensions and generators in this but keep in mind that there are two other comprehension expression forms available in both and set and dictionary comprehensions we met these briefly in and but with our new knowledge of comprehensions and generatorsyou should now be able to grasp these extensions in fullfor setsthe new literal form { is equivalent to set([ ])and the new set comprehension syntax { (xfor in if ( )is like the generator expression set( (xfor in if ( ))where (xis an arbitrary expression for dictionariesthe new dictionary comprehension syntax {keyval for (keyvalin zip(keysvals)works like the form dict(zip(keysvals))and {xf(xfor in itemsis like the generator expression dict((xf( )for in itemshere' summary of all the comprehension alternatives in and the last two are new and are not available in and earlier[ for in range( )[ comprehensions and generations list comprehensionbuilds list like list(generator expr |
1,190 | generator expressionproduces items parens are often optional { for in range( ){ set comprehension and {xyis set in these versions too {xx for in range( )dictionary comprehension and { scopes and comprehension variables now that we've seen all comprehension formsbe sure to also review ' overview of the localization of loop variables in these expressions python localizes loop variables in all four forms--temporary loop variable names in generatorsetdictionaryand list comprehensions are local to the expression they don' clash with names outsidebut are also not available thereand work differently than the for loop iteration statementc:\codepy - ( for in range( )at nameerrorname 'xis not defined [ for in range( )[ for in range( )pass xgeneratorsetdictand list localize but loop statements do not localize names as mentioned in variables assigned in comprehension are really further nested special-case scopeother names referenced within these expressions follow the usual legb rules in the following generatorfor examplez is localized in the comprehensionbut and are found in the enclosing local and global scopes as usualx 'aaadef func() 'bbbprint('join( for in ) comprehensiony localx global func(aaabbb python is the same in this regardexcept that list comprehension variables are not localized--they work just like for loops and keep their last iteration valuesbut are also comprehension syntax summary |
1,191 | localize names as in xc:\codepy - ( for in range( )at ee nameerrorname 'xis not defined [ for in range( )[ for in range( )pass xlist does not localize its nameslike for for loops do not localize names in or if you care about version portabilityand symmetry with the for loop statementuse unique names for variables in comprehension expressions as rule of thumb the behavior makes sense given that generator object is discarded after it finishes producing resultsbut list comprehension is equivalent to for loop--though this analogy doesn' hold for the set and dictionary forms that localize their names in both pythonsand aresomewhat coincidentallythe topic of the next section comprehending set and dictionary comprehensions in senseset and dictionary comprehensions are just syntactic sugar for passing generator expressions to the type names because both accept any iterablea generator works well here{ for in range( ){ set( for in range( ){ comprehension generator and type name {xx for in range( ){ dict((xx xfor in range( ){ nameerrorname 'xis not defined loop variable localized in as for list comprehensionsthoughwe can always build the result objects with manual codetoo here are statement-based equivalents of the last two comprehensions (though they differ in that name localization)res set(for in range( ) comprehensions and generations set comprehension equivalent |
1,192 | res { res {for in range( )res[xx dict comprehension equivalent res { localized in comprehension expressionsbut not in loop statements notice that although both set and dictionary comprehensions accept and scan iterablesthey have no notion of generating results on demand--both forms build complete objects all at once if you mean to produce keys and values upon requesta generator expression is more appropriateg ((xx xfor in range( )next( ( next( ( extended comprehension syntax for sets and dictionaries like list comprehensions and generator expressionsboth set and dictionary comprehensions support nested associated if clauses to filter items out of the result--the following collect squares of even items ( items having no remainder for division by in range[ for in range( if = [ { for in range( if = { {xx for in range( if = { lists are ordered but sets are not neither are dict keys nested for loops work as wellthough the unordered and no-duplicates nature of both types of objects can make the results bit less straightforward to decipher[ for in [ for in [ ][ { for in [ for in [ ]{ {xy for in [ for in [ ]{ lists keep duplicates but sets do not neither do dict keys like list comprehensionsthe set and dictionary varieties can also iterate over any type of iterable--listsstringsfilesrangesand anything else that supports the iteration protocolcomprehension syntax summary |
1,193 | {'ac''bd''bc''ad'{ (ord( )ord( )for in 'abfor in 'cd'{'ac'( )'bd'( )'bc'( )'ad'( ){ for in ['spam''ham''sausage'if [ =' '{'sausagesausage''spamspam'{ upper() for in ['spam''ham''sausage'if [ =' '{'sausage''sausagesausage''spam''spamspam'for more detailsexperiment with these tools on your own they may or may not have performance advantage over the generator or for loop alternativesbut we would have to time their performance explicitly to be sure--which seems natural segue to the next summary this wrapped up our coverage of built-in comprehension and iteration tools it explored list comprehensions in the context of functional toolsand presented generator functions and expressions as additional iteration protocol tools as finalewe also summarized the four forms of comprehension in python today--listgeneratorsetand dictionary though we've now seen all the built-in iteration toolsthe subject will resurface when we study user-defined iterable class objects in the next is something of continuation of the theme of this one--it rounds out this part of the book with case study that times the performance of the tools we've studied hereand serves as more realistic example at the midpoint in this book before we move ahead to benchmarking comprehensions and generatorsthoughthis quizzes give you chance to review what you've learned about them here test your knowledgequiz what is the difference between enclosing list comprehension in square brackets and parentheses how are generators and iterators related how can you tell if function is generator function what does yield statement do how are map calls and list comprehensions relatedcompare and contrast the two test your knowledgeanswers list comprehensions in square brackets produce the result list all at once in memory when they are enclosed in parentheses insteadthey are actually generator comprehensions and generations |
1,194 | once insteadgenerator expressions return generator objectwhich yields one item in the result at time when used in an iteration context generators are iterable objects that support the iteration protocol automatically-they have an iterator with __next__ method (next in xthat repeatedly advances to the next item in series of results and raises an exception at the end of the series in pythonwe can code generator functions with def and yieldgenerator expressions with parenthesized comprehensionsand generator objects with classes that define special method named __iter__ (discussed later in the book generator function has yield statement somewhere in its code generator functions are otherwise identical to normal functions syntacticallybut they are compiled specially by python so as to return an iterable generator object when called that object retains state and code location between values when presentthis statement makes python compile the function specially as generatorwhen calledthe function returns generator object that supports the iteration protocol when the yield statement is runit sends result back to the caller and suspends the function' statethe function can then be resumed after the last yield statementin response to next built-in or __next__ method call issued by the caller in more advanced rolesthe generator send method similarly resumes the generatorbut can also pass value that shows up as the yield expression' value generator functions may also have return statementwhich terminates the generator the map call is similar to list comprehension--both produce series of valuesby collecting the results of applying an operation to each item in sequence or other iterableone item at time the primary difference is that map applies function call to each itemand list comprehensions apply arbitrary expressions because of thislist comprehensions are more generalthey can apply function call expression like mapbut map requires function to apply other kinds of expressions list comprehensions also support extended syntax such as nested for loops and if clauses that subsume the filter built-in in python xmap also differs in that it produces generator of valuesthe list comprehension materializes the result list in memory all at once in xboth tools create result lists test your knowledgeanswers |
1,195 | the benchmarking interlude now that we know about coding functions and iteration toolswe're going to take short side trip to put both of them to work this closes out the function part of this book with larger case study that times the relative performance of the iteration tools we've met so far along the waythis case study surveys python' code timing toolsdiscusses benchmarking techniques in generaland allows us to explore code that' bit more realistic and useful than most of what we've seen up to this point we'll also measure the speed of current python implementations-- data point that may or may not be significantdepending on the type of code you write finallybecause this is the last in this part of the bookwe'll close with the usual sets of "gotchasand exercises to help you start coding the ideas you've read about firstthoughlet' have some fun with tangible python application timing iteration alternatives we've met quite few iteration alternatives in this book like much in programmingthey represent tradeoffs--in terms of both subjective factors like expressivenessand more objective criteria such as performance part of your job as programmer and engineer is selecting tools based on factors like these in terms of performancei've mentioned few times that list comprehensions sometimes have speed advantage over for loop statementsand that map calls can be faster or slower than both depending on call patterns the generator functions and expressions of the preceding tend to be slightly slower than list comprehensionsthough they minimize memory space requirements and don' delay result generation all that is generally true todaybut relative performance can vary over time because python' internals are constantly being changed and optimizedand code structure can influence speed arbitrarily if you want to verify their performance for yourselfyou need to time these alternatives on your own computer and your own version of python |
1,196 | luckilypython makes it easy to time code for exampleto get the total time taken to run multiple calls to function with arbitrary positional argumentsthe following firstcut function might sufficefile timer py import time def timer(func*args)start time clock(for in range( )func(*argsreturn time clock(start simplistic timing function total elapsed time in seconds this works--it fetches time values from python' time moduleand subtracts the system start time from the stop time after running , calls to the passed-in function with the passed-in arguments on my computer in python from timer import timer timer(pow timer(str upper'spam' time to call pow( times time to call 'spamupper( times though simplethis timer is also fairly limitedand deliberately exhibits some classic mistakes in both function design and benchmarking among theseitdoesn' support keyword arguments in the tested function call hardcodes the repetitions count charges the cost of range to the tested function' time always uses time clockwhich might not be best outside windows doesn' give callers way to verify that the tested function actually worked only gives total timewhich might fluctuate on some heavily loaded machines in other wordstiming code is more complex than you might expectto be more general and accuratelet' expand this into still simple but more useful timer utility functions we can use both to see how iteration alternative options stack up nowand apply to other timing needs in the future these functions are coded in module file so they can be used in variety of programsand have docstrings giving some basic details that pydoc can display on request--see figure - in for screenshot of the documentation pages rendered for the timing modules we're coding herefile timer py ""homegrown timing tools for function calls does total timebest-of timeand best-of-totals time ""import timesys timer time clock if sys platform[: ='winelse time time the benchmarking interlude |
1,197 | ""total time to run func(reps times returns (total timelast result""repslist list(range(reps)start timer(for in repslistret func(*pargs**kargselapsed timer(start return (elapsedretdef bestof(repsfunc*pargs**kargs)""quickest func(among reps runs returns (best timelast result""best * for in range(reps)start timer(ret func(*pargs**kargselapsed timer(start if elapsed bestbest elapsed return (bestrethoist outequalize or perf_counter/other in years seems large enough range usage not timed here or call total(with reps= or add to list and take min(def bestoftotal(reps reps func*pargs**kargs)""best of totals(best of reps runs of (total of reps runs of func)""return bestof(reps totalreps func*pargs**kargsoperationallythis module implements both total time and best time callsand nested best of totals that combines the other two in eachit times call to any function with any positional and keyword arguments passed individuallyby fetching the start timecalling the functionand subtracting the start time from the stop time points to notice about how this version addresses the shortcomings of its predecessorpython' time module gives access to the current timewith precision that varies per platform on windows its clock function is claimed to give microsecond granularity and so is very accurate because the time function may be better on unixthis script selects between them automatically based on the platform string in the sys moduleit starts with "winif running in windows see also the sidebar "new timer calls in on page on other time options in and later not used here for portabilitywe will also be timing python where these newer calls are not availableand their results on windows appear similar in in any event the range call is hoisted out of the timing loop in the total functionso its construction cost is not charged to the timed function in python in range is an iterableso this step is neither required nor harmfulbut we still run the result through list so its traversal cost is the same in both and this doesn' apply to the bestof functionsince no range factors are charged to the test' time timing iteration alternatives |
1,198 | any number of both positional and keyword arguments are collected with starredargument syntaxso they must be sent individuallynot in sequence or dictionary if neededcallers can unpack argument collections into individual arguments with stars in the callas done by the bestoftotal function at the end see for refresher if this code doesn' make sense the first function in this module returns total elapsed time for all calls in tuplealong with the timed function' final return value so callers can verify its operation the second function does similarbut returns the best (minimumtime among all calls instead of the total--more useful if you wish to filter out the impacts of other activity on your computerbut less for tests that run too quickly to produce substantial runtimes to address the prior pointthe last function in this file runs nested total tests within best-of testto get the best-of-totals time the nested total operation can make runtimes more usefulbut we still get the best-of filter this function' code may be easier to understand if you remember that every function is passable objecteven the testing functions themselves from larger perspectivebecause these functions are coded in module filethey become generally useful tools anywhere we wish to import them modules and imports were introduced in and you'll learn more about them in the next part of this bookfor nowsimply import the module and call the function to use one of this file' timers in simple usagethis module is similar to its predecessorbut will be more robust in larger contexts in python againimport timer timer total( pow )[ timer total( str upper'spam'( 'spam'timer bestof( str upper'spam'( - 'spam'timer bestof( pow )[ compare to timer results above returns (timelast call' result / as long as total time timer bestof( timer total str upper'spam'( ( 'spam')timer bestoftotal( str upper'spam'( ( 'spam')the last two calls here calculate the best-of-totals times--the lowest time among runseach of which computes the total time to call str upper , times (roughly corresponding to the total times at the start of this listingthe function used in the last call is really just convenience that maps to the call form preceding itboth return the best-of tuplewhich embeds the last total call' result tuple the benchmarking interlude |
1,199 | min(timer total( str upper'spam'for in range( )( 'spam'taking the min of an iteration of total results this way has similar effect because the times in the result tuples dominate comparisons made by min (they are leftmost in the tuplewe could use this in our module too (and will in later variations)it varies slightly by omitting very small overhead in the best-of function' code and not nesting result tuplesthough either result suffices for relative comparisons as isthe best-of function must pick high initial lowest time value--though years is probably longer than most of the tests you're likely to run(((( * (((( * / / / / plus few extra days floorsee new timer calls in this section uses the time module' clock and time calls because they apply to all readers of this book python introduces new interfaces in this module that are designed to be more portable specificallythe behavior of this module' clock and time calls varies per platformbut its new perf_counter and process_time functions have well-defined and platform-neutral semanticstime perf_counter(returns the value in fractional seconds of performance counterdefined as clock with the highest available resolution to measure short duration it includes time elapsed during sleep states and is system-wide time process_time(returns the value in fractional seconds of the sum of the system and user cpu time of the current process it does not include time elapsed during sleepand is process-wide by definition for both of these callsthe reference point of the returned value is undefinedso that only the difference between the results of consecutive calls is valid the perf_counter call can be thought of as wall timeand as of python is used by default for benchmarking in the timeit module discussed aheadprocess_time gives cpu time portably the time clock call is still usable on windows todayas shown in this book it is documented as being deprecated in ' manualsbut issues no warning when used there --meaning it may or may not become officially deprecated in later releases if neededyou can detect python or later with code like thiswhich opted to not use for the sake of brevity and timer comparabilityif sys version_info[ > and sys version_info[ > timer time perf_counter or process_time elsetimer time clock if sys platform[: ='winelse time time alternativelythe following code would also add portability and insulate you from future deprecationsthough it depends on exception topics we haven' studied in full timing iteration alternatives |
Subsets and Splits