id
int64 0
25.6k
| text
stringlengths 0
4.59k
|
|---|---|
1,000 | for in 'abc'for in 'lmn'res append( yres ['al''am''an''bl''bm''bn''cl''cm''cn'beyond this complexity levelthoughlist comprehension expressions can often become too compact for their own good in generalthey are intended for simple types of iterationsfor more involved worka simpler for statement structure will probably be easier to understand and modify in the future as usual in programmingif something is difficult for you to understandit' probably not good idea because comprehensions are generally best taken in multiple doseswe'll cut this story short here for now we'll revisit list comprehensions in in the context of functional programming toolsand will define their syntax more formally and explore additional examples there as we'll findcomprehensions turn out to be just as related to functions as they are to looping statements blanket qualification for all performance claims in this booklist comprehension or otherthe relative speed of code depends much on the exact code tested and python usedand is prone to change from release to release for examplein cpython and todaylist comprehensions can still be twice as fast as corresponding for loops on some testsbut just marginally quicker on othersand perhaps even slightly slower on some when if filter clauses are used we'll see how to time code in and will learn how to interpret the file listcomp-speed txt in the book examples packagewhich times this code for nowkeep in mind that absolutes in performance benchmarks are as elusive as consensus in open source projectsother iteration contexts later in the bookwe'll see that user-defined classes can implement the iteration protocol too because of thisit' sometimes important to know which built-in tools make use of it--any tool that employs the iteration protocol will automatically work on any built-in type or user-defined class that provides it so fari've been demonstrating iterators in the context of the for loop statementbecause this part of the book is focused on statements keep in mindthoughthat every built-in tool that scans from left to right across objects uses the iteration protocol this includes the for loops we've seenfor line in open('script py')print(line upper()end=''use file iterators other iteration contexts |
1,001 | import sys print(sys pathx print( * but also much more for instancelist comprehensions and the map built-in function use the same protocol as their for loop cousin when applied to filethey both leverage the file object' iterator automatically to scan line by linefetching an iterator with __iter__ and calling __next__ each time throughuppers [line upper(for line in open('script py')uppers ['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'map(str upperopen('script py')map is itself an iterable in list(map(str upperopen('script py'))['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'we introduced the map call used here briefly in the preceding (and in passing in )it' built-in that applies function call to each item in the passed-in iterable object map is similar to list comprehension but is more limited because it requires function instead of an arbitrary expression it also returns an iterable object itself in python xso we must wrap it in list call to force it to give us all its values at oncemore on this change later in this because maplike the list comprehensionis related to both for loops and functionswe'll also explore both again in and many of python' other built-ins process iterablestoo for examplesorted sorts items in an iterablezip combines items from iterablesenumerate pairs items in an iterable with relative positionsfilter selects items for which function is trueand reduce runs pairs of items in an iterable through function all of these accept iterablesand zipenumerateand filter also return an iterable in python xlike map here they are in action running the file' iterator automatically to read line by linesorted(open('script py')['import sys\ ''print(sys path)\ ''print( * )\ '' \ 'list(zip(open('script py')open('script py'))[('import sys\ ''import sys\ ')('print(sys path)\ ''print(sys path)\ ')(' \ '' \ ')('print( * )\ ''print( * )\ ')list(enumerate(open('script py'))[( 'import sys\ ')( 'print(sys path)\ ')( ' \ ')( 'print( * )\ ')list(filter(boolopen('script py'))nonempty=true ['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'import functoolsoperator functools reduce(operator addopen('script py')'import sys\nprint(sys path)\nx \nprint( * )\ iterations and comprehensions |
1,002 | in the prior filter and reduce are in ' functional programming domainso we'll defer their details for nowthe point to notice here is their use of the iteration protocol for files and other iterables we first saw the sorted function used here at work inand we used it for dictionaries in sorted is built-in that employs the iteration protocol--it' like the original list sort methodbut it returns the new sorted list as result and runs on any iterable object notice thatunlike map and otherssorted returns an actual list in python instead of an iterable interestinglythe iteration protocol is even more pervasive in python today than the examples so far have demonstrated--essentially everything in python' built-in toolset that scans an object from left to right is defined to use the iteration protocol on the subject object this even includes tools such as the list and tuple built-in functions (which build new objects from iterables)and the string join method (which makes new string by putting substring between strings contained in an iterableconsequentlythese will also work on an open file and automatically read one line at timelist(open('script py')['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'tuple(open('script py')('import sys\ ''print(sys path)\ '' \ ''print( * )\ ''&&join(open('script py')'import sys\ &&print(sys path)\ && \ &&print( * )\neven some tools you might not expect fall into this category for examplesequence assignmentthe in membership testslice assignmentand the list' extend method also leverage the iteration protocol to scanand thus read file by lines automaticallyabcd open('script py'ad ('import sys\ ''print( * )\ 'sequence assignment * open('script py' extended form ab ('import sys\ '['print(sys path)\ '' \ ''print( * )\ ']' \nin open('script py'false ' \nin open('script py'true membership test [ slice assignment [ : open('script py' [ 'import sys\ ''print(sys path)\ '' \ ''print( * )\ ' [ extend(open('script py')list extend method other iteration contexts |
1,003 | [ 'import sys\ ''print(sys path)\ '' \ ''print( * )\ 'per extend iterates automaticallybut append does not--use the latter (or similarto add an iterable to list without iteratingwith the potential to be iterated across laterl [ append(open('script py')list append does not iterate [ list( [ ]['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'iteration is broadly supported and powerful model earlierwe saw that the built-in dict call accepts an iterable zip resulttoo (see and for that matterso does the set callas well as the newer set and dictionary comprehension expressions in python and which we met in and set(open('script py'){'print( * )\ ''import sys\ ''print(sys path)\ '' \ '{line for line in open('script py'){'print( * )\ ''import sys\ ''print(sys path)\ '' \ '{ixline for ixline in enumerate(open('script py')){ 'import sys\ ' 'print(sys path)\ ' ' \ ' 'print( * )\ 'in factboth set and dictionary comprehensions support the extended syntax of list comprehensions we met earlier in this including if tests{line for line in open('script py'if line[ =' '{'print( * )\ ''print(sys path)\ '{ixline for (ixlinein enumerate(open('script py')if line[ =' '{ 'print(sys path)\ ' 'print( * )\ 'like the list comprehensionboth of these scan the file line by line and pick out lines that begin with the letter they also happen to build sets and dictionaries in the endbut we get lot of work "for freeby combining file iteration and comprehension syntax later in the book we'll meet relative of comprehensions--generator expressions--that deploys the same syntax and works on iterables toobut is also iterable itselflist(line upper(for line in open('script py')see ['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'other built-in functions support the iteration protocol as wellbut franklysome are harder to cast in interesting examples related to filesfor examplethe sum call computes the sum of all the numbers in any iterablethe any and all built-ins return true if any or all items in an iterable are truerespectivelyand max and min return the largest and smallest item in an iterablerespectively like reduceall of the tools in the following iterations and comprehensions |
1,004 | but return single resultsum([ ] any(['spam''''ni']true all(['spam''''ni']false max([ ] min([ ] sum expects numbers only strictly speakingthe max and min functions can be applied to files as well--they automatically use the iteration protocol to scan the file and pick out the lines with the highest and lowest string valuesrespectively (though 'll leave valid use cases to your imagination)max(open('script py')' \nmin(open('script py')'import sys\nline with max/min string value there' one last iteration context that' worth mentioningalthough it' mostly previewin we'll learn that special *arg form can be used in function calls to unpack collection of values into individual arguments as you can probably predict by nowthis accepts any iterabletooincluding files (see for more details on this call syntax for section that extends this idea to generator expressionsand for tips on using the following' print in as usual)def (abcd)print(abcdsep='&' ( & & & (*[ ]unpacks into arguments & & & (*open('script py')iterates by lines tooimport sys &print(sys path& &print( * in factbecause this argument-unpacking syntax in calls accepts iterablesit' also possible to use the zip built-in to unzip zipped tuplesby making prior or nested zip results arguments for another zip call (warningyou probably shouldn' read the following example if you plan to operate heavy machinery anytime soon!) ( ( list(zip(xy)[( )( )zip tuplesreturns an iterable other iteration contexts |
1,005 | ab zip(*zip(xy) ( ( unzip zipstill other tools in pythonsuch as the range built-in and dictionary view objectsreturn iterables instead of processing them to see how these have been absorbed into the iteration protocol in python as wellwe need to move on to the next section new iterables in python one of the fundamental distinctions of python is its stronger emphasis on iterators than thisalong with its unicode model and mandated new-style classesis one of ' most sweeping changes specificallyin addition to the iterators associated with built-in types such as files and dictionariesthe dictionary methods keysvaluesand items return iterable objects in python xas do the built-in functions rangemapzipand filter as shown in the prior sectionthe last three of these functions both return iterables and process them all of these tools produce results on demand in python xinstead of constructing result lists as they do in impacts on codepros and cons although this saves memory spaceit can impact your coding styles in some contexts in various places in this book so farfor examplewe've had to wrap up some function and method call results in listcall in order to force them to produce all their results at once for displayzip('abc''xyz'an iterable in python ( list in xlist(zip('abc''xyz')[(' '' ')(' '' ')(' '' ')force list of results in to display similar conversion is required if we wish to apply list or sequence operations to most iterables that generate items on demand--to indexsliceor concatenate the iterable itselffor example the list results for these tools in support such operations directlyz zip(( )( )unlike listscannot indexetc [ typeerror'zipobject is not subscriptable as we'll see in more detail in conversion to lists may also be more subtly required to support multiple iterations for newly iterable tools that support just one iterations and comprehensions |
1,006 | after single passm map(lambda *xrange( )for in mprint( for in mprint(iunlike listsone pass only (zip toosuch conversion isn' required in xbecause functions like zip return lists of results in xthoughthey return iterable objectsproducing results on demand this may break codeand means extra typing is required to display the results at the interactive prompt (and possibly in some other contexts)but it' an asset in larger programs --delayed evaluation like this conserves memory and avoids pauses while large result lists are computed let' take quick look at some of the new iterables in action the range iterable we studied the range built-in' basic behavior in the preceding in xit returns an iterable that generates numbers in the range on demandinstead of building the result list in memory this subsumes the older xrange (see the upcoming version skew note)and you must use list(range)to force an actual range list if one is needed ( to display results) :\codec:\python \python range( range( range returns an iterablenot list iter(rnext( next( next( make an iterator from the range iterable advance to next result what happens in for loopscomprehensionsetc list(range( )[ to force list if required unlike the list returned by this call in xrange objects in support only iterationindexingand the len function they do not support any other sequence operations (use listif you require more list tools)len( [ range also does len and indexingbut no others new iterables in python |
1,007 | next( __next__( continue taking from iteratorwhere left off next(becomes __next__()but use new next(version skew noteas first mentioned in the preceding python also has built-in called xrangewhich is like range but produces items on demand instead of building list of results in memory all at once since this is exactly what the new iterator-based range does in python xxrange is no longer available in --it has been subsumed you may still both see and use it in codethoughespecially since range builds result lists there and so is not as efficient in its memory usage as noted in the prior the file xreadlines(method used to minimize memory use in has been dropped in python for similar reasonsin favor of file iterators the mapzipand filter iterables like rangethe mapzipand filter built-ins also become iterables in to conserve spacerather than producing result list all at once in memory all three not only process iterablesas in xbut also return iterable results in unlike rangethoughthey are their own iterators--after you step through their results oncethey are exhausted in other wordsyou can' have multiple iterators on their results that maintain different positions in those results here is the case for the map built-in we met in the prior as with other iterablesyou can force list with listif you really need onebut the default behavior can save substantial space in memory for large result setsm map(abs(- ) next( next( next( next(mstopiteration map returns an iterablenot list for in mprint(xmap iterator is now emptyone pass only map(abs(- )for in mprint(xmake new iterable/iterator to scan again iteration contexts auto call next( iterations and comprehensions use iterator manuallyexhausts results these do not support len(or indexing |
1,008 | list(map(abs(- ))[ can force real list if needed the zip built-inintroduced in the prior is an iteration context itselfbut also returns an iterable with an iterator that works the same wayz zip(( )( ) zip is the samea one-pass iterator list( [( )( )( )for pair in zprint(pairz zip(( )( )for pair in zprint(pair( ( ( zip(( )( )next( ( next( ( exhausted after one pass iterator used automatically or manually manual iteration (iter(not neededthe filter built-inwhich we met briefly in and will study in the next part of this bookis also analogous it returns items in an iterable for which passed-in function returns true (as we've learnedin python true includes nonempty objectsand bool returns an object' truth value)filter(bool['spam''''ni']list(filter(bool['spam''''ni'])['spam''ni'like most of the tools discussed in this sectionfilter both accepts an iterable to process and returns an iterable to generate results in it can also generally be emulated by extended list comprehension syntax that automatically tests truth values[ for in ['spam''''ni'if bool( )['spam''ni'[ for in ['spam''''ni'if ['spam''ni'new iterables in python |
1,009 | it' important to see how the range object differs from the built-ins described in this section--it supports len and indexingit is not its own iterator (you make one with iter when iterating manually)and it supports multiple iterators over its result that remember their positions independentlyr range( range allows multiple iterators next(rtypeerrorrange object is not an iterator iter(rnext( next( iter(rnext( next( two iterators on one range is at different spot than by contrastin zipmapand filter do not support multiple active iterators on the same resultbecause of this the iter call is optional for stepping through such objectsresults--their iter is themselves (in these built-ins return multiple-scan lists so the following does not apply) zip(( )( ) iter(zi iter(znext( ( next( ( next( ( map(abs(- ) iter( ) iter(mprint(next( )next( )next( ) next( stopiteration range( iter( )iter( [next( )next( )next( )[ next( two iterators on one zip ( xi is at same spot as ditto for map (and filter( xsingle scan is exhaustedbut range allows many iterators multiple active scanslike lists when we code our own iterable objects with classes later in the book ()we'll see that multiple iterators are usually supported by returning new objects for the iter calla single iterator generally means an object returns itself in we'll iterations and comprehensions |
1,010 | range in this regardsupporting just single active iteration scan in that we'll see some subtle implications of one-shot iterators in loops that attempt to scan multiple times--code that formerly treated these as lists may fail without manual list conversions dictionary view iterables finallyas we saw briefly in in python the dictionary keysvaluesand items methods return iterable view objects that generate result items one at timeinstead of producing result lists all at once in memory views are also available in as an optionbut under special method names to avoid impacting existing code view items maintain the same physical ordering as that of the dictionary and reflect changes made to the underlying dictionary now that we know more about iterables here' the rest of this story--in python (your key order may vary) dict( = = = {' ' ' ' ' ' keys( dict_keys([' '' '' '] view object in xnot list next(kviews are not iterators themselves typeerrordict_keys object is not an iterator iter(knext( 'anext( 'bview iterables have an iteratorwhich can be used manuallybut does not support len()index for in keys()print(kend=' all iteration contexts use auto as for all iterables that produce values on requestyou can always force dictionary view to build real list by passing it to the list built-in howeverthis usually isn' required except to display results interactively or to apply list operations like indexingk keys(list( [' '' '' ' values( dict_values([ ]list( [ can still force real list if needed ditto for values(and items(views need list(to display or index as list [ new iterables in python |
1,011 | list( )[ list( items()[(' ' )(' ' )(' ' )for (kvin items()print(kvend=' in addition dictionaries still are iterables themselveswith an iterator that returns successive keys thusit' not often necessary to call keys directly in this contextd {' ' ' ' ' ' iter(dnext( 'anext( 'bdictionaries still produce an iterator returns next key on each iteration for key in dprint(keyend=' still no need to call keys(to iterate but keys is an iterable in toofinallyremember again that because keys no longer returns listthe traditional coding pattern for scanning dictionary by sorted keys won' work in insteadconvert keys views first with list callor use the sorted call on either keys view or the dictionary itselfas follows we saw this in but it' important enough to programmers making the switch to demonstrate againd {' ' ' ' ' ' for in sorted( keys())print(kd[ ]end=' for in sorted( )print(kd[ ]end='"best practicekey sorting other iteration topics as mentioned in this introductionthere is more coverage of both list comprehensions and iterables in in conjunction with functionsand again in when we study classes as you'll see lateruser-defined functions can be turned into iterable generator functionswith yield statements list comprehensions morph into iterable generator expressions when coded in parentheses iterations and comprehensions |
1,012 | in particularuser-defined iterables defined with classes allow arbitrary objects and operations to be used in any of the iteration contexts we've met in this by supporting just single operation--iteration--objects may be used in wide variety of contexts and tools summary in this we explored concepts related to looping in python we took our first substantial look at the iteration protocol in python-- way for nonsequence objects to take part in iteration loops--and at list comprehensions as we sawa list comprehension is an expression similar to for loop that applies another expression to all the items in any iterable object along the waywe also saw other built-in iteration tools at work and studied recent iteration additions in python this wraps up our tour of specific procedural statements and related tools the next closes out this part of the book by discussing documentation options for python code though bit of diversion from the more detailed aspects of codingdocumentation is also part of the general syntax modeland it' an important component of wellwritten programs in the next we'll also dig into set of exercises for this part of the book before we turn our attention to larger structures such as functions as usualthoughlet' first exercise what we've learned here with quiz test your knowledgequiz how are for loops and iterable objects related how are for loops and list comprehensions related name four iteration contexts in the python language what is the best way to read line by line from text file today what sort of weapons would you expect to see employed by the spanish inquisitiontest your knowledgeanswers the for loop uses the iteration protocol to step through items in the iterable object across which it is iterating it first fetches an iterator from the iterable by passing the object to iterand then calls this iterator object' __next__ method in on each iteration and catches the stopiteration exception to determine when to stop looping the method is named next in xand is run by the next built-in function in both and any object that supports this model works in for loop and test your knowledgeanswers |
1,013 | initial iter call is extraneous but harmless both are iteration tools and contexts list comprehensions are concise and often efficient way to perform common for loop taskcollecting the results of applying an expression to all items in an iterable object it' always possible to translate list comprehension to for loopand part of the list comprehension expression looks like the header of for loop syntactically iteration contexts in python include the for looplist comprehensionsthe map built-in functionthe in membership test expressionand the built-in functions sortedsumanyand all this category also includes the list and tuple built-insstring join methodsand sequence assignmentsall of which use the iteration protocol (see answer # to step across iterable objects one item at time the best way to read lines from text file today is to not read it explicitly at allinsteadopen the file within an iteration context tool such as for loop or list comprehensionand let the iteration tool automatically scan one line at time by running the file' next handler method on each iteration this approach is generally best in terms of coding simplicitymemory spaceand possibly execution speed requirements 'll accept any of the following as correct answersfearintimidationnice red uniformsa comfy chairand soft pillows iterations and comprehensions |
1,014 | the documentation interlude this part of the book concludes with look at techniques and tools used for documenting python code although python code is designed to be readablea few wellplaced human-accessible comments can do much to help others understand the workings of your programs as we'll seepython includes both syntax and tools to make documentation easier in particularthe pydoc system covered here can render module' internal documentation as either plain text in shellor html in web browser although this is something of tools-related conceptthis topic is presented here partly because it involves python' syntax modeland partly as resource for readers struggling to understand python' toolset for the latter purposei'll also expand here on documentation pointers first given in as usualbecause this closes out its partit also ends with some warnings about common pitfalls and set of exercises for this part of the textin addition to its quiz python documentation sources by this point in the bookyou're probably starting to realize that python comes with an amazing amount of prebuilt functionality--built-in functions and exceptionspredefined object attributes and methodsstandard library modulesand more and we've really only scratched the surface of each of these categories one of the first questions that bewildered beginners often ask ishow do find information on all the built-in toolsthis section provides hints on the various documentation sources available in python it also presents documentation strings (docstringsand the pydoc system that makes use of them these topics are somewhat peripheral to the core language itselfbut they become essential knowledge as soon as your code reaches the level of the examples and exercises in this part of the book as summarized in table - there are variety of places to look for information on pythonwith generally increasing verbosity because documentation is such crucial tool in practical programmingwe'll explore each of these categories in the sections that follow |
1,015 | form role comments in-file documentation the dir function lists of attributes available in objects docstrings__doc__ in-file documentation attached to objects pydocthe help function interactive help for objects pydochtml reports module documentation in browser sphinx third-party tool richer documentation for larger projects the standard manual set official language and library descriptions web resources online tutorialsexamplesand so on published books commercially polished reference texts comments as we've learnedhash-mark comments are the most basic way to document your code python simply ignores all the text following (as long as it' not inside string literal)so you can follow this character with any words and descriptions meaningful to programmers such comments are accessible only in your source filesthoughto code comments that are more widely availableyou'll need to use docstrings in factcurrent best practice generally dictates that docstrings are best for larger functional documentation ( "my file does this")and comments are best limited to smaller code documentation ( "this strange expression does that"and are best limited in scope to statement or small group of statements within script or function more on docstrings in momentfirstlet' see how to explore objects the dir function as we've also seenthe built-in dir function is an easy way to grab list of all the attributes available inside an object ( its methods and simpler data itemsit can be called with no arguments to list variables in the caller' scope more usefullyit can also be called on any object that has attributesincluding imported modules and built-in typesas well as the name of data type for exampleto find out what' available in module such as the standard library' sysimport it and pass it to dirimport sys dir(sys['__displayhook__'more names omitted 'winver'these results are from python and ' omitting most returned names because they vary slightly elsewhererun this on your own for better look in factthere are currently attributes in systhough we generally care only about the that do not have leading double underscores (two usually means interpreter-relatedor the that have no the documentation interlude |
1,016 | len(dir(sys) len([ for in dir(sysif not startswith('__')] len([ for in dir(sysif not [ =' '] number names in sys non __x names only non underscore names to find out what attributes are provided in objects of built-in typesrun dir on literal or an existing instance of the desired type for exampleto see list and string attributesyou can pass empty objectsdir([]['__add__''__class__''__contains__'more 'append''clear''copy''count''extend''index''insert''pop''remove''reverse''sort'dir(''['__add__''__class__''__contains__'more 'split''splitlines''startswith','strip''swapcase''title''translate''upper''zfill'the dir results for any built-in type include set of attributes that are related to the implementation of that type (technicallyoperator overloading methods)much as in modules they all begin and end with double underscores to make them distinctand you can safely ignore them at this point in the book (they are used for oopfor instancethere are list attributesbut only that correspond to named methodslen(dir([]))len([ for in dir([]if not startswith('__')]( len(dir(''))len([ for in dir(''if not startswith('__')]( in factto filter out double-underscored items that are not of common program interestrun the same list comprehensions but print the attributes for instancehere are the named attributes in lists and dictionaries in python [ for in dir(listif not startswith('__')['append''clear''copy''count''extend''index''insert''pop''remove''reverse''sort'[ for in dir(dictif not startswith('__')['clear''copy''fromkeys''get''items''keys''pop''popitem''setdefault''update''values'this may seem like lot to type to get an attribute listbut beginning in the next we'll learn how to wrap such code in an importable and reusable function so we don' need to type it againdef dir ( )return [ for in dir(xif not startswith('__')see part iv dir (tuple['count''index'python documentation sources |
1,017 | of literaldir(str=dir(''true dir(list=dir([]true same resulttype name or literal this works because names like str and list that were once type converter functions are actually names of types in python todaycalling one of these invokes its constructor to generate an instance of that type part vi will have more to say about constructors and operator overloading methods when we discuss classes the dir function serves as sort of memory-jogger--it provides list of attribute namesbut it does not tell you anything about what those names mean for such extra informationwe need to move on to the next documentation source some ides for python workincluding idlehave features that list attributes on objects automatically within their guisand can be viewed as alternatives to dir idlefor examplewill list an object' attributes in pop-up selection window when you type period after the object' name and pause or press tab this is mostly meant as an autocomplete featurethoughnot an information source has more on idle docstrings__doc__ besides commentspython supports documentation that is automatically attached to objects and retained at runtime for inspection syntacticallysuch comments are coded as strings at the tops of module files and function and class statementsbefore any other executable code (commentsincluding unix-stye #lines are ok before thempython automatically stuffs the text of these stringsknown informally as docstringsinto the __doc__ attributes of the corresponding objects user-defined docstrings for exampleconsider the following filedocstrings py its docstrings appear at the beginning of the file and at the start of function and class within it herei've used triple-quoted block strings for multiline comments in the file and the functionbut any sort of string will worksingleor double-quoted one-liners like those in the class are finebut don' allow multiple-line text we haven' studied the def or class statements in detail yetso ignore everything about them here except the strings at their tops""module documentation words go here "" the documentation interlude |
1,018 | def square( )""function documentation can we have your liver then""return * square class employee"class documentationpass print(square( )print(square __doc__the whole point of this documentation protocol is that your comments are retained for inspection in __doc__ attributes after the file is imported thusto display the docstrings associated with the module and its objectswe simply import the file and print their __doc__ attributeswhere python has saved the textimport docstrings function documentation can we have your liver thenprint(docstrings __doc__module documentation words go here print(docstrings square __doc__function documentation can we have your liver thenprint(docstrings employee __doc__class documentation note that you will generally want to use print to print docstringsotherwiseyou'll get single string with embedded \ newline characters you can also attach docstrings to methods of classes (covered in part vi)but because these are just def statements nested in class statementsthey're not special case to fetch the docstring of method function inside class within moduleyou would simply extend the path to go through the classmodule class method __doc__ (we'll see an example of method docstrings in docstring standards and priorities as mentioned earliercommon practice today recommends hash-mark comments for only smaller-scale documentation about an expressionstatementor small group of python documentation sources |
1,019 | software beyond these guidelinesthoughyou still must decide what to write although some companies have internal standardsthere is no broad standard about what should go into the text of docstring there have been various markup language and template proposals ( html or xml)but they don' seem to have caught on in the python world franklyconvincing python programmers to document their code using handcoded html is probably not going to happen in our lifetimes that may be too much to askbut this doesn' apply to documenting code in general documentation tends to have lower priority among some programmers than it should too oftenif you get any comments in file at allyou count yourself lucky (and even better if it' accurate and up to datei strongly encourage you to document your code liberally--it really is an important part of well-written programs when you dothoughthere is presently no standard on the structure of docstringsif you want to use themanything goes today just as for writing code itselfit' up to you to create documentation content and keep it up to datebut common sense is probably your best ally on this task too built-in docstrings as it turns outbuilt-in modules and objects in python use similar techniques to attach documentation above and beyond the attribute lists returned by dir for exampleto see an actual human-readable description of built-in moduleimport it and print its __doc__ stringimport sys print(sys __doc__this module provides access to some objects used or maintained by the interpreter and to functions that interact strongly with the interpreter dynamic objectsargv -command line argumentsargv[ is the script pathname if known path -module search pathpath[ is the script directoryelse 'modules -dictionary of loaded modules more text omitted functionsclassesand methods within built-in modules have attached descriptions in their __doc__ attributes as wellprint(sys getrefcount __doc__getrefcount(object-integer return the reference count of object the count returned is generally one higher than you might expectbecause it includes the (temporaryreference as an argument to getrefcount(you can also read about built-in functions via their docstrings the documentation interlude |
1,020 | int( [base]-integer convert string or number to an integerif possible floating point argument will be truncated towards zero (this does not include more text omitted print(map __doc__map(func*iterables--map object make an iterator that computes the function using arguments from each of the iterables stops when the shortest iterable is exhausted you can get wealth of information about built-in tools by inspecting their docstrings this waybut you don' have to--the help functionthe topic of the next sectiondoes this automatically for you pydocthe help function the docstring technique proved to be so useful that python eventually added tool that makes docstrings even easier to display the standard pydoc tool is python code that knows how to extract docstrings and associated structural information and format them into nicely arranged reports of various types additional tools for extracting and formatting docstrings are available in the open source domain (including tools that may support structured text--search the web for pointers)but python ships with pydoc in its standard library there are variety of ways to launch pydocincluding command-line script options that can save the resulting documentation for later viewing (described both ahead and in the python library manualperhaps the two most prominent pydoc interfaces are the built-in help function and the pydoc guiand web-based html report interfaces we met the help function briefly in it invokes pydoc to generate simple textual report for any python object in this modehelp text looks much like "manpageon unix-like systemsand in fact pages the same way as unix "moreoutside guis like idle when there are multiple pages of text--press the space bar to move to the next pageenter to go to the next lineand to quitimport sys help(sys getrefcounthelp on built-in function getrefcount in module sysgetrefcountgetrefcount(object-integer return the reference count of object the count returned is generally one higher than you might expectbecause it includes the (temporaryreference as an argument to getrefcount(note that you do not have to import sys in order to call helpbut you do have to import sys to get help on sys this wayit expects an object reference to be passed in in pythons python documentation sources |
1,021 | module' name as string--for examplehelp('re')help('email message')--but support for this and other modes may differ across python versions for larger objects such as modules and classesthe help display is broken down into multiple sectionsthe preambles of which are shown here run this interactively to see the full report ( ' running this on )help(syshelp on built-in module sysname sys module reference more omitted description this module provides access to some objects used or maintained by the interpreter and to functions that interact strongly with the interpreter more omitted functions __displayhook__ displayhookdisplayhook(object-none more omitted data __stderr__ mode='wencoding='cp __stdin__ mode='rencoding='cp __stdout__ mode='wencoding='cp more omitted file (built-insome of the information in this report is docstringsand some of it ( function call patternsis structural information that pydoc gleans automatically by inspecting objectsinternalswhen available besides modulesyou can also use help on built-in functionsmethodsand types usage varies slightly across python versionsbut to get help for built-in typetry either the type name ( dict for dictionarystr for stringlist for list)an actual object of the type ( {}''[])or method of an actual object or type name ( str join the documentation interlude |
1,022 | type or the usage of that methodhelp(dicthelp on class dict in module builtinsclass dict(objectdict(-new empty dictionary dict(mapping-new dictionary initialized from mapping object' more omitted help(str replacehelp on method_descriptorreplaces replace (oldnew[count]-str return copy of with all occurrences of substring more omitted help('replacesimilar to prior result help(ordhelp on built-in function ord in module builtinsordord( -integer return the integer ordinal of one-character string finallythe help function works just as well on your modules as it does on built-ins here it is reporting on the docstrings py file we coded earlier againsome of this is docstringsand some is information automatically extracted by inspecting objectsstructuresimport docstrings help(docstrings squarehelp on function square in module docstringssquare(xfunction documentation can we have your liver thenhelp(docstrings employeehelp on class employee in module docstrings note that asking for help on an actual string object directly ( help('')doesn' work in recent pythonsyou usually get no helpbecause strings are interpreted specially--as request for help on an unimported modulefor instance (see earlieryou must use the str type name in this contextthough both other types of actual objects (help([])and string method names referenced through actual objects (help('join)work fine (at least in python --this has been prone to change over timethere is also an interactive help modewhich you start by typing just help(python documentation sources |
1,023 | class employee(builtins objectclass documentation more omitted help(docstringshelp on module docstringsname docstrings description module documentation words go here classes builtins object employee class employee(builtins objectclass documentation more omitted functions square(xfunction documentation can we have your liver thendata spam file :\code\docstrings py pydochtml reports the text displays of the help function are adequate in many contextsespecially at the interactive prompt to readers who've grown accustomed to richer presentation mediumsthoughthey may seem bit primitive this section presents the html-based flavor of pydocwhich renders module documentation more graphically for viewing in web browserand can even open one automatically for you the way this is run has changed as of python prior to python ships with simple gui desktop client for submitting search requests this client launches web browser to view documentation produced by an automatically started local server as of the former gui client is replaced by an all-browser interface schemewhich combines both search and display in web page that communicates with an automatically started local server the documentation interlude |
1,024 | well as the newer all-browser mode mandated as of because this book' audience is both users of the latest-and-greatest as well as the masses still using older tried-and-true pythonswe'll explore both schemes here as we dokeep in mind that the way these schemes differ pertains only to the top level of their user interfaces their documentation displays are nearly identicaland under either regime pydoc can also be used to generate both text in consoleand html files for later viewing in whatever manner you wish python and laterpydoc' all-browser mode as of python the original gui client mode of pydocpresent in and earlier releasesis no longer available this mode is present through python with the "module docsstart button entry on windows and earlierand via the pydoc - command line this gui mode was reportedly deprecated in though you had to look closely to notice--it works fine and without warning on on my machine in thoughthis mode goes away altogetherand is replaced with pydoc - command linewhich instead spawns both locally running documentation serveras well as web browser that functions as both search engine client and page display the browser is initially opened on module index page with enhanced functionality there are additional ways to use pydoc ( to save the html page to file for later viewingas described ahead)so this is relatively minor operational change to launch the newer browser-only mode of pydoc in python and latera commandline like any of the following sufficethey all use the - python command-line argument for convenience to locate pydoc' module file on your module import search path the first assumes python is on your system paththe second employs python ' new windows launcherand the third gives the full path to your python if the other two schemes won' work see appendix for more on -mand appendix for coverage of the windows launcher :\codepython - pydoc - server ready at server commands[ ]rowser[ ]uit serverq server stopped :\codepy - - pydoc - server ready at server commands[ ]rowser[ ]uit serverq server stopped :\codec:\python \python - pydoc - server ready at server commands[ ]rowser[ ]uit serverq server stopped python documentation sources |
1,025 | and laterwhich as of replaces the former gui client in earlier pythons however you run this command linethe effect is to start pydoc as locally running web server on dedicated (but by default arbitrary unusedportand pop up web browser to act as clientdisplaying page giving links to documentation for all the modules importable on your module search path (including the directory where pydoc is launchedpydoc' top-level web page interface is captured in figure - besides the module indexpydoc' web page also includes input fields at the top to request specific module' documentation page (getand search for related entries (search)which stand in for the prior interface' gui client fields you can also click on this page' links to go to the module index (the start page)topics (general python subjects)and keywords (overviews of statements and some expressionsnotice that the index page in figure - lists both modules and top-level scripts in the current directory--the book' :\codewhere pydoc was started by the earlier command lines pydoc is mostly intended for documenting importable modulesbut can sometimes be used to show documentation for scripts too selected file must be the documentation interlude |
1,026 | file' code modules normally just define tools when runso this is usually irrelevant if you ask for documentation for top-level script filethoughthe shell window where you launched pydoc serves as the script' standard input and output for any user interaction the net effect is that the documentation page for script will appear after it runsand after its printed output shows up in the shell window this may work better for some scripts than othersthoughinteractive inputfor examplemay interleave oddly with pydoc' own server command prompts once you get past the new start page in figure - the documentation pages for specific modules are essentially the same in both the newer all-browser mode and the earlier gui-client schemeapart from the additional input fields at the top of page in the former for instancefigure - shows the new documentation display pages-opened on two user-defined modules we'll be writing in the next part of this bookas part of ' benchmarking case study in either schemedocumentation pages contain automatically created hyperlinks that allow you to click your way through the documentation of related components in your application for instanceyou'll find links to open imported modulespages too because of the similarity in their display pagesthe next section on pre- pydoc and its screen shots largely apply after tooso be sure to read ahead for additional notes even if you're using more recent python in effect ' pydoc simply cuts out the pre- gui client "middleman,while retaining its browser and server pydoc in python also still supports other former usage modes for instancepydoc - port can be used to set its pydoc server portand pydoc - module still writes module' html documentation to file named module html for later viewing only the pydoc - gui client mode is removed and replaced by pydoc - you can also run pydoc to generate plain-text form of the documentation (its unix "manpageflavor shown earlier in this --the following command line is equivalent to the help call at an interactive python promptc:\codepy - - pydoc timeit command-line text help :\codepy - help("timeit"interactive prompt text help as an interactive systemyour best bet is to take pydoc' web-based interface for test driveso we'll cut its usage details short heresee python' manuals for additional details and command-line options also note that pydoc' server and browser functionality come largely "for freefrom tools that automate such utility in the portable modules of python' standard library ( webbrowserhttp serverconsult pydoc' python code in the standard library file pydoc py for additional details and inspiration python documentation sources |
1,027 | displaying two modules we will be coding in the next part of this book (changing pydoc' colors you won' be able to tell in the paper version of this bookbut if you have an ebook or start pydoc liveyou'll notice that it chooses colors that may or may not be to your liking unfortunatelythere presently is no easy way to customize pydoc' colors they are hardcoded deep in its source codeand can' be passed in as arguments to functions or command linesor changed in configuration files or global variables in the pydoc module itself except thatin an open source systemyou can always change the code--pydoc lives in the file pydoc py in python' standard librarywhich is directory :\python \lib on windows for python its colors are hardcoded rgb value hex strings embedded throughout its code for instanceits string '#eeaa specifies -byte ( -bitvalues for redgreenand blue levels (decimal and )yielding shade of orange for function banners the string '#ee aasimilarly renders the dark pinkish color used in nine placesincluding class and index page banners the documentation interlude |
1,028 | in idlean edit/find for regular expression #\ { will locate color strings (this matches six alphanumeric characters after per python' re module pattern syntaxsee the library manual for detailsto pick colorsin most programs with color selection dialogs you can map to and from rgb valuesthe book' examples include gui script setcolor py that does the same in my copy of pydoci replaced all #ee aa with # (tealto banish the dark pink replacing #ffc with # (greydoes similar for the light pink background of class docstrings such surgery isn' for the faint of heart--pydoc' file is currently , lines long--but makes for fair exercise in code maintenance be cautious when replacing colors like #ffffff and # (white and black)and be sure to make backup copy of pydoc py first so you have fallback this file uses tools we haven' yet metbut you can safely ignore the rest of its code while you make your tactical changes be sure to watch for pydoc changes on the configurations frontthis seems prime candidate for improvement in factthere already is an effort under wayissue on the python developerslist seeks to make pydoc more user-customizable by changing it to support css style sheets if successfulthis may allow users to make color and other display choices in external css files instead of pydoc' source code on the other handthis is currently not planned to appear until python and will require pydoc' users to also be proficient with css code--which unfortunately has nontrivial structure all its own that many people using python may not understand well enough to change as write thisfor examplethe proposed pydoc css file is already lines of code that probably won' mean much to people not already familiar with web development (and it hardly seems reasonable to ask them to learn web development tool just to tailor pydoc!today' pydoc in already supports css style sheet that offers some customization optionsbut only half-heartedlyand ships with one that is empty until this is hashed outcode changes seem the best option in any eventcss style sheets are well beyond this python book' scope--see the web for detailsand check future python release notes for pydoc developments python and earliergui client this section documents the original gui client mode of pydocfor readers using and earlierand gives some addition pydoc context in general it builds on the basics covered in the prior sectionwhich aren' repeated hereso be sure to at least scan the prior section if you're using an older python as mentionedthrough python pydoc provides top-level gui interface-- simple but portable python/tkinter script for submitting requests--as well as documentation server requests in the client are routed to the serverwhich produces reports displayed in popped-up web browser apart from your having to submit search requeststhis process is largely automatic python documentation sources |
1,029 | module you want documentation forpress enterselect the moduleand then press "go to selected(or omit the module name and press "open browserto see all available modulesto start pydoc in this modeyou generally first launch the search engine gui captured in figure - you can start this either by selecting the module docs item in python' start button menu on windows and earlieror by launching the pydoc py script in python' standard library directory with - command-line argumentit lives in lib on windowsbut you can use python' - flag to avoid typing script paths here tooc:\codec:\python \python - pydoc - :\codepy - - pydoc - explicit python path windows launcher version enter the name of module you're interested inand press the enter keypydoc will march down your module import search path (sys path)looking for the requested module and references to it once you've found promising entryselect it and click "go to selected pydoc will spawn web browser on your machine to display the report rendered in html format figure - shows the information pydoc displays for the built-in glob module notice the hyperlinks in the modules section of this page--you can click these to jump to the pydoc pages for related (importedmodules for larger pagespydoc also generates hyperlinks to sections within the page like the help function interfacethe gui interface works on user-defined modules as well as built-ins figure - shows the page generated for our docstrings py module file coded earlier make sure that the directory containing your module is on your module import search path--as mentionedpydoc must be able to import file to render its documentation this includes the current working directory--pydoc might not check the directory it was launched from (which is probably meaningless when started from the windows start button anyhow)so you may need to extend your pythonpath setting to get this to the documentation interlude |
1,030 | moduleand press "go to selected,the module' documentation is rendered in html and displayed in web browser window like this one work on pythons and had to add to my pythonpath to get pydoc' gui client mode to look in the directory it was started from by command linec:\codeset pythonpath;%pytyonpathc:\codepy - - pydoc - this setting was also required to see the current directory for the new all-browser pydoc - mode in howeverpython automatically includes in its index listso no path setting is required to view files in the directory where pydoc is started-- minor but noteworthy improvement pydoc can be customized and launched in various ways we won' cover heresee its entry in python' standard library manual for more details the main thing to take away from this section is that pydoc essentially gives you implementation reports "for free--if you are good about using docstrings in your filespydoc does all the work of collecting and formatting them for display pydoc helps only for objects like functions and modulesbut it provides an easy way to access middle level of documentation for such tools--its reports are more useful than raw attribute listsand less exhaustive than the standard manuals python documentation sources |
1,031 | the module search path here is the page for user-defined moduleshowing all its documentation strings (docstringsextracted from the source file pydoc can also be run to save the html documentation for module in file for later viewing or printingsee the preceding section for pointers alsonote that pydoc might not work well if run on scripts that read from standard input--pydoc imports the target module to inspect its contentsand there may be no connection for standard input text when it is run in gui modeespecially if run from the windows start button modules that can be imported without immediate input requirements will always work under pydocthough see also the preceding section' notes regarding scripts in pydoc' - mode in and laterlaunching pydoc' gui mode by command line works the same --you interact in the launch window the documentation interlude |
1,032 | in figure - ' windowpydoc will produce an index page containing hyperlink to every module you can possibly import on your computer this includes python standard library modulesmodules of installed third-party extensionsuser-defined modules on your import search pathand even statically or dynamically linked-in -coded modules such information is hard to come by otherwise without writing code that inspects all module sources on python you'll want to do this immediately after the gui opensas it may not fully work after searches also note that in pydoc' all-browser - interface in and lateryou get the same index functionality on its top-level start page of figure - beyond docstringssphinx if you're looking for way to document your python system in more sophisticated wayyou may wish to check out sphinx (currently at used by the standard python documentation described in the next sectionand many other projects it uses simple restructuredtext as its markup languageand inherits much from the docutils suite of restructuredtext parsing and translating tools among other thingssphinx supports variety of output formats (html including windows html helplatex for printable pdf versionsmanual pagesand plain text)extensive and automatic cross-referenceshierarchical structure with automatic links to relativesautomatic indexesautomatic code highlighting using pygments (itself notable python tool)and more this is probably overkill for smaller programs where docstrings and pydoc may sufficebut can yield professional-grade documentation for large projects see the web for more details on sphinx and its related tools the standard manual set for the complete and most up-to-date description of the language and its toolsetpython' standard manuals stand ready to serve python' manuals ship in html and other formatsand they are installed with the python system on windows--they are available in your start button' menu for python on windows and earlierand they can also be opened from the help menu within idle you can also fetch the manual set separately from that site (follow the documentation linkon windowsthe manuals are compiled help file to support searchesand the online versions at the python website include web-based search page when openedthe windows format of the manuals displays root page like that in figure - showing the local copy on windows the two most important entries here are most likely the library reference (which documents built-in typesfunctionsexceptionsand standard library modulesand the language reference (which provides python documentation sources |
1,033 | help menuand in the windows and earlier start button menu it' searchable help file on windowsand there is search engine for the online version of thesethe library reference is the one you'll want to use most of the time formal description of language-level detailsthe tutorial listed on this page also provides brief introduction for newcomerswhich you're probably already beyond of notable interestthe what' new documents in this standard manual set chronicle python changes made in each release beginning with python which came out in late --useful for those porting older python codeor older python skills these documents are especially useful for uncovering additional details on the differences in the python and language lines covered in this bookas well as in their standard libraries web resources at the official python website (python resourcessome of which cover special topics or domains click the documentation link to access an online tutorial and the beginners guide to python the site also lists non-english python resourcesand introductions scaled to different target audiences today you will also find numerous python wikisblogswebsitesand host of other resources on the web at large to sample the online communitytry searching for the documentation interlude |
1,034 | are good you'll find ample material to browse published books as final resourceyou can choose from collection of professionally edited and published reference books for python bear in mind that books tend to lag behind the cutting edge of python changespartly because of the work involved in writingand partly because of the natural delays built into the publishing cycle usuallyby the time book comes outit' three or more months behind the current python state (trust me on that--my books have nasty habit of falling out of date in minor ways between the time write them and the time they hit the shelves!unlike standard manualsbooks are also generally not free stillfor manythe convenience and quality of professionally published text is worth the cost moreoverpython changes so slowly that books are usually still relevant years after they are publishedespecially if their authors post updates on the web see the preface for pointers to other python books common coding gotchas before the programming exercises for this part of the booklet' run through some of the most common mistakes beginners make when coding python statements and programs many of these are warnings 've thrown out earlier in this part of the bookcollected here for ease of reference you'll learn to avoid these pitfalls once you've gained bit of python coding experiencebut few words now might help you avoid falling into some of these traps initiallydon' forget the colons always remember to type at the end of compound statement headers--the first line of an ifwhileforetc you'll probably forget at first ( didand so have most of my roughly , python students over the years)but you can take some comfort from the fact that it will soon become an unconscious habit start in column be sure to start top-level (unnestedcode in column that includes unnested code typed into module filesas well as unnested code typed at the interactive prompt blank lines matter at the interactive prompt blank lines in compound statements are always irrelevant and ignored in module filesbut when you're typing code at the interactive promptthey end the statement in other wordsblank lines tell the interactive command line that you've finished compound statementif you want to continuedon' hit the enter key at the prompt (or in idleuntil you're really done this also means you can' paste multiline code at this promptit must run one full statement at time common coding gotchas |
1,035 | unless you know what your text editor does with tabs otherwisewhat you see in your editor may not be what python sees when it counts tabs as number of spaces this is true in any block-structured languagenot just python--if the next programmer has tabs set differentlyit will be difficult or impossible to understand the structure of your code it' safer to use all tabs or all spaces for each block don' code in python reminder for / +programmersyou don' need to type parentheses around tests in if and while headers ( if ( == ):you canif you like (any expression can be enclosed in parentheses)but they are fully superfluous in this context alsodo not terminate all your statements with semicolonsit' technically legal to do this in python as wellbut it' totally useless unless you're placing more than one statement on single line (the end of line normally terminates statementand rememberdon' embed assignment statements in while loop testsand don' use {around blocks (indent your nested code blocks consistently insteaduse simple for loops instead of while or range another remindera simple for loop ( for in seq:is almost always simpler to code and often quicker to run than whileor range-based counter loop because python handles indexing internally for simple forit can sometimes be faster than the equivalent whilethough this can vary per code and python for code simplicity alonethoughavoid the temptation to count things in pythonbeware of mutables in assignments mentioned this in you need to be careful about using mutables in multiple-target assignment ( [])as well as in an augmented assignment ( +[ ]in both casesin-place changes may impact other variables see for details if you've forgotten why this is true don' expect results from functions that change objects in place we encountered this one earliertooin-place change operations like the list append and list sort methods introduced in do not return values (other than none)so you should call them without assigning the result it' not uncommon for beginners to say something like mylist mylist append(xto try to get the result of an appendbut what this actually does is assign mylist to nonenot to the modified list (in factyou'll lose your reference to the list altogethera more devious example of this pops up in python code when trying to step through dictionary items in sorted fashion it' fairly common to see code like for in keys(sort()this almost works--the keys method builds keys listand the sort method orders it--but because the sort method returns nonethe loop fails because it is ultimately loop over none ( nonsequencethis fails even sooner in python xbecause dictionary keys are viewsnot liststo code this correctlyeither use the newer sorted built-in functionwhich returns the sorted listor split the method calls out to statementsks list( keys())then ks sort()and finallyfor in ksthisby the wayis one case where you may the documentation interlude |
1,036 | dictionary iterators--iterators do not sort always use parentheses to call function you must add parentheses after function name to call itwhether it takes arguments or not ( use function()not functionin the next part of this bookwe'll learn that functions are simply objects that have special operation-- call that you trigger with the parentheses they can be referenced like any other object without triggering call in classesthis problem seems to occur most often with filesit' common to see beginners type file close to close filerather than file close(because it' legal to reference function without calling itthe first version with no parentheses succeeds silentlybut it does not close the filedon' use extensions or paths in imports and reloads omit directory paths and file extensions in import statements--say import modnot import mod py we discussed module basics in and will continue studying modules in part because modules may have other extensions besides py pycfor instance)hardcoding particular extension is not only illegal syntaxit doesn' make sense python picks an extension automaticallyand any platform-specific directory path syntax comes from module search path settingsnot the import statement and other pitfalls in other parts be sure to also see the built-in type warnings at the end of the prior partas they may qualify as coding issues too there are additional "gotchasthat crop up commonly in python coding--losing built-in function by reassigning its namehiding library module by using its name for one of your ownchanging mutable argument defaultsand so on--but we don' have enough background to cover them yet to learn more about both what you should and shouldn' do in pythonyou'll have to read onlater parts extend the set of "gotchasand fixes we've added to here summary this took us on tour of program documentation--both documentation we write ourselves for our own programsand documentation available for tools we use we met docstringsexplored the online and manual resources for python referenceand learned how pydoc' help function and web page interfaces provide extra sources of documentation because this is the last in this part of the bookwe also reviewed common coding mistakes to help you avoid them in the next part of this bookwe'll start applying what we already know to larger program constructs specificallythe next part takes up the topic of functions-- tool used to group statements for reuse before moving onhoweverbe sure to work through the set of lab exercises for this part of the book that appear at the end of this and even before thatlet' run through this quiz summary |
1,037 | when should you use documentation strings instead of hash-mark comments name three ways you can view documentation strings how can you obtain list of the available attributes in an object how can you get list of all available modules on your computer which python book should you purchase after this onetest your knowledgeanswers documentation strings (docstringsare considered best for largerfunctional documentationdescribing the use of modulesfunctionsclassesand methods in your code hash-mark comments are today best limited to smaller-scale documentation about arcane expressions or statements at strategic points on your code this is partly because docstrings are easier to find in source filebut also because they can be extracted and displayed by the pydoc system you can see docstrings by printing an object' __doc__ attributeby passing it to pydoc' help functionand by selecting modules in pydoc' html-based user interfaces--either the - gui client mode in python and earlieror the - allbrowser mode in python and later (and required as of both run clientserver system that displays documentation in popped-up web browser pydoc can also be run to save module' documentation in an html file for later viewing or printing the built-in dir(xfunction returns list of all the attributes attached to any object list comprehension of the form [ for in dir(xif not starts with('__')can be used to filter out internals names with underscores (we'll learn how to wrap this in function in the next part of the book to make it easier to use in python and earlieryou can run the pydoc gui interfaceand select "open browser"this opens web page containing link to every module available to your programs this gui mode no longer works as of python in python and lateryou get the same functionality by running pydoc' newer all-browser mode with - command-line switchthe top-level start page displayed in web browser in this newer mode has the same index page listing all available modules mineof course (seriouslythere are hundreds todaythe preface lists few recommended follow-up booksboth for reference and for application tutorialsand you should browse for books that fit your needs the documentation interlude |
1,038 | now that you know how to code basic program logicthe following exercises will ask you to implement some simple tasks with statements most of the work is in exercise which lets you explore coding alternatives there are always many ways to arrange statementsand part of learning python is learning which arrangements work better than others you'll eventually gravitate naturally toward what experienced python programmers call "best practice,but best practice takes practice see part iii in appendix for the solutions coding basic loops this exercise asks you to experiment with for loops write for loop that prints the ascii code of each character in string named use the built-in function ord(characterto convert each character to an ascii integer this function technically returns unicode code point in python xbut if you restrict its content to ascii charactersyou'll get back ascii codes (test it interactively to see how it works nextchange your loop to compute the sum of the ascii codes of all the characters in string finallymodify your code again to return new list that contains the ascii codes of each character in the string does the expression map(ordshave similar effecthow about [ord(cfor in ]why(hintsee backslash characters what happens on your machine when you type the following code interactivelyfor in range( )print('hello % \ \aibeware that if it' run outside of the idle interface this example may beep at youso you may not want to run it in crowded roomidle prints odd characters instead of beeping--spoiling much of the joke (see the backslash escape characters in table - sorting dictionaries in we saw that dictionaries are unordered collections write for loop that prints dictionary' items in sorted (ascendingorder (hintuse the dictionary keys and list sort methodsor the newer sorted built-in function program logic alternatives consider the following codewhich uses while loop and found flag to search list of powers of for the value of raised to the fifth power ( it' stored in module file called power py [ found false while not found and len( )test your knowledgepart iii exercises |
1,039 | found true elsei + if foundprint('at index'ielseprint( 'not found' :\book\testspython power py at index as isthe example doesn' follow normal python coding techniques follow the steps outlined here to improve it (for all the transformationsyou may either type your code interactively or store it in script file run from the system command line --using file makes this exercise much easier) firstrewrite this code with while loop else clause to eliminate the found flag and final if statement nextrewrite the example to use for loop with an else clauseto eliminate the explicit list-indexing logic (hintto get the index of an itemuse the list index method-- index(xreturns the offset of the first in list nextremove the loop completely by rewriting the example with simple in operator membership expression (see for more detailsor type this to test in [ , , finallyuse for loop and the list append method to generate the powers-of- list (linstead of hardcoding list literal deeper thoughtse do you think it would improve performance to move the * expression outside the loopshow would you code thatf as we saw in exercise python includes map(functionlisttool that can generate powers-of- listtoomap(lambda *xrange( )try typing this code interactivelywe'll meet lambda more formally in the next part of this bookespecially in would list comprehension help here (see ) code maintenance if you haven' already done soexperiment with making the code changes suggested in this sidebar "changing pydoc' colorson page much of the work of real software development is in changing existing codeso the sooner you begin doing sothe better for referencemy edited copy of pydoc is in the book' examples packagenamed mypydoc pyto see how it differsyou can run file compare (fc on windowswith the original pydoc py in (also includedlest it change radically in as the sidebar describesif pydoc is more easily customized by the time you read these wordscustomize the documentation interlude |
1,040 | hope the procedure will be well documented in python' manuals test your knowledgepart iii exercises |
1,041 | functions and generators |
1,042 | function basics in part iiiwe studied basic procedural statements in python herewe'll move on to explore set of additional statements and expressions that we can use to create functions of our own in simple termsa function is device that groups set of statements so they can be run more than once in program-- packaged procedure invoked by name functions also can compute result value and let us specify parameters that serve as function inputs and may differ each time the code is run coding an operation as function makes it generally useful toolwhich we can use in variety of contexts more fundamentallyfunctions are the alternative to programming by cutting and pasting--rather than having multiple redundant copies of an operation' codewe can factor it into single function in so doingwe reduce our future work radicallyif the operation must be changed laterwe have only one copy to update in the functionnot many scattered throughout the program functions are also the most basic program structure python provides for maximizing code reuseand lead us to the larger notions of program design as we'll seefunctions let us split complex systems into manageable parts by implementing each part as functionwe make it both reusable and easier to code table - previews the primary function-related tools we'll study in this part of the book-- set that includes call expressionstwo ways to make functions (def and lambda)two ways to manage scope visibility (global and nonlocal)and two ways to send results back to callers (return and yieldtable - function-related statements and expressions statement or expression examples call expressions myfunc('spam''eggs'meat=ham*restdef def printer(messge)print('hello messagereturn def adder(ab= * )return [ |
1,043 | statement or expression examples global 'olddef changer()global xx 'newnonlocal ( xdef outer() 'olddef changer()nonlocal xx 'newyield def squares( )for in range( )yield * lambda funcs [lambda xx** lambda xx** why use functionsbefore we get into the detailslet' establish clear picture of what functions are all about functions are nearly universal program-structuring device you may have come across them before in other languageswhere they may have been called subroutines or procedures as brief introductionfunctions serve two primary development rolesmaximizing code reuse and minimizing redundancy as in most programming languagespython functions are the simplest way to package logic you may wish to use in more than one place and more than one time up until nowall the code we've been writing has run immediately functions allow us to group and generalize code to be used arbitrarily many times later because they allow us to code an operation in single place and use it in many placespython functions are the most basic factoring tool in the languagethey allow us to reduce code redundancy in our programsand thereby reduce maintenance effort procedural decomposition functions also provide tool for splitting systems into pieces that have well-defined roles for instanceto make pizza from scratchyou would start by mixing the doughrolling it outadding toppingsbaking itand so on if you were programming pizza-making robotfunctions would help you divide the overall "make pizzatask into chunks--one function for each subtask in the process it' easier to implement the smaller tasks in isolation than it is to implement the entire process at once in generalfunctions are about procedure--how to do somethingrather than what you're doing it to we'll see why this distinction matters in part viwhen we start making new objects with classes in this part of the bookwe'll explore the tools used to code functions in pythonfunction basicsscope rulesand argument passingalong with few related concepts such as generators and functional tools because its importance begins to become more apparent at this level of codingwe'll also revisit the notion of polymorphismwhich was function basics |
1,044 | but they do lead us to some bigger programming ideas coding functions although it wasn' made very formalwe've already used some functions in earlier for instanceto make file objectwe called the built-in open functionsimilarlywe used the len built-in function to ask for the number of items in collection object in this we will explore how to write new functions in python functions we write behave the same way as the built-ins we've already seenthey are called in expressionsare passed valuesand return results but writing new functions requires the application of few additional ideas that haven' yet been introduced moreoverfunctions behave very differently in python than they do in compiled languages like here is brief introduction to the main concepts behind python functionsall of which we will study in this part of the bookdef is executable code python functions are written with new statementthe def unlike functions in compiled languages such as cdef is an executable statement--your function does not exist until python reaches and runs the def in factit' legal (and even occasionally usefulto nest def statements inside if statementswhile loopsand even other defs in typical operationdef statements are coded in module files and are naturally run to generate functions when the module file they reside in is first imported def creates an object and assigns it to name when python reaches and runs def statementit generates new function object and assigns it to the function' name as with all assignmentsthe function name becomes reference to the function object there' nothing magic about the name of function--as you'll seethe function object can be assigned to other namesstored in listand so on function objects may also have arbitrary user-defined attributes attached to them to record data lambda creates an object but returns it as result functions may also be created with the lambda expressiona feature that allows us to in-line function definitions in places where def statement won' work syntactically this is more advanced concept that we'll defer until return sends result object back to the caller when function is calledthe caller stops until the function finishes its work and returns control to the caller functions that compute value send it back to the caller with return statementthe returned value becomes the result of the function call return without value simply returns to the caller (and sends back nonethe default resultyield sends result object back to the callerbut remembers where it left off functions known as generators may also use the yield statement to send back coding functions |
1,045 | series of results over time this is another advanced topic covered later in this part of the book global declares module-level variables that are to be assigned by defaultall names assigned in function are local to that function and exist only while the function runs to assign name in the enclosing modulefunctions need to list it in global statement more generallynames are always looked up in scopes-places where variables are stored--and assignments bind names to scopes nonlocal declares enclosing function variables that are to be assigned similarlythe nonlocal statement added in python allows function to assign name that exists in the scope of syntactically enclosing def statement this allows enclosing functions to serve as place to retain state--information remembered between function calls--without using shared global names arguments are passed by assignment (object referencein pythonarguments are passed to functions by assignment (whichas we've learnedmeans by object referenceas you'll seein python' model the caller and function share objects by referencesbut there is no name aliasing changing an argument name within function does not also change the corresponding name in the callerbut changing passed-in mutable objects in place can change objects shared by the callerand serve as function result arguments are passed by positionunless you say otherwise values you pass in function call match argument names in function' definition from left to right by default for flexibilityfunction calls can also pass arguments by name with name=value keyword syntaxand unpack arbitrarily many arguments to send with *pargs and **kargs starred-argument notation function definitions use the same two forms to specify argument defaultsand collect arbitrarily many arguments received argumentsreturn valuesand variables are not declared as with everything in pythonthere are no type constraints on functions in factnothing about function needs to be declared ahead of timeyou can pass in arguments of any typereturn any kind of objectand so on as one consequencea single function can often be applied to variety of object types--any objects that sport compatible interface (methods and expressionswill doregardless of their specific types if some of the preceding words didn' sink indon' worry--we'll explore all of these concepts with real code in this part of the book let' get started by expanding on some of these ideas and looking at few examples def statements the def statement creates function object and assigns it to name its general format is as follows function basics |
1,046 | statements as with all compound python statementsdef consists of header line followed by block of statementsusually indented (or simple statement after the colonthe statement block becomes the function' body--that isthe code python executes each time the function is later called the def header line specifies function name that is assigned the function objectalong with list of zero or more arguments (sometimes called parametersin parentheses the argument names in the header are assigned to the objects passed in parentheses at the point of call function bodies often contain return statementdef name(arg arg argn)return value the python return statement can show up anywhere in function bodywhen reachedit ends the function call and sends result back to the caller the return statement consists of an optional object value expression that gives the function' result if the value is omittedreturn sends back none the return statement itself is optional tooif it' not presentthe function exits when the control flow falls off the end of the function body technicallya function without return statement also returns the none object automaticallybut this return value is usually ignored at the call functions may also contain yield statementswhich are designed to produce series of values over timebut we'll defer discussion of these until we survey generator topics in def executes at runtime the python def is true executable statementwhen it runsit creates new function object and assigns it to name (rememberall we have in python is runtimethere is no such thing as separate compile time because it' statementa def can appear anywhere statement can--even nested in other statements for instancealthough defs normally are run when the module enclosing them is importedit' also completely legal to nest function def inside an if statement to select between alternative definitionsif testdef func()elsedef func()func(define func this way or else this way call the version selected and built coding functions |
1,047 | it simply assigns name at runtime unlike in compiled languages such as cpython functions do not need to be fully defined before the program runs more generallydefs are not evaluated until they are reached and runand the code inside defs is not evaluated until the functions are later called because function definition happens at runtimethere' nothing special about the function name what' important is the object to which it refersothername func othername(assign function object call func again herethe function was assigned to different name and called through the new name like everything else in pythonfunctions are just objectsthey are recorded explicitly in memory at program execution time in factbesides callsfunctions allow arbitrary attributes to be attached to record information for later usedef func()func(func attr value create function object call object attach attributes first exampledefinitions and calls apart from such runtime concepts (which tend to seem most unique to programmers with backgrounds in traditional compiled languages)python functions are straightforward to use let' code first real example to demonstrate the basics as you'll seethere are two sides to the function picturea definition (the def that creates functionand call (an expression that tells python to run the function' bodydefinition here' definition typed interactively that defines function called timeswhich returns the product of its two argumentsdef times(xy)return create and assign function body executed when called when python reaches and runs this defit creates new function object that packages the function' code and assigns the object to the name times typicallysuch statement is coded in module file and runs when the enclosing file is importedfor something this smallthoughthe interactive prompt suffices calls the def statement makes function but does not call it after the def has runyou can call (runthe function in your program by adding parentheses after the function' name function basics |
1,048 | (assignedto the names in the function' headertimes( arguments in parentheses this expression passes two arguments to times as mentioned previouslyarguments are passed by assignmentso in this case the name in the function header is assigned the value is assigned the value and the function' body is run for this functionthe body is just return statement that sends back the result as the value of the call expression the returned object was printed here interactively (as in most languages is in python)but if we needed to use it later we could instead assign it to variable for examplex times( save the result object nowwatch what happens when the function is called third timewith very different kinds of objects passed intimes('ni' 'ninininifunctions are "typelessthis timeour function means something completely different (monty python reference again intendedin this third calla string and an integer are passed to and yinstead of two numbers recall that works on both numbers and sequencesbecause we never declare the types of variablesargumentsor return values in pythonwe can use times to either multiply numbers or repeat sequences in other wordswhat our times function means and does depends on what we pass into it this is core idea in python (and perhaps the key to using the language well)which merits bit of expansion here polymorphism in python as we just sawthe very meaning of the expression in our simple times function depends completely upon the kinds of objects that and are--thusthe same function can perform multiplication in one instance and repetition in another python leaves it up to the objects to do something reasonable for the syntax reallyis just dispatch mechanism that routes control to the objects being processed this sort of type-dependent behavior is known as polymorphisma term we first met in that essentially means that the meaning of an operation depends on the objects being operated upon because it' dynamically typed languagepolymorphism runs rampant in python in factevery operation is polymorphic operation in pythonprintingindexingthe operatorand much more this is deliberateand it accounts for much of the language' conciseness and flexibility single functionfor instancecan generally be applied to whole category of object first exampledefinitions and calls |
1,049 | protocol)the function can process them that isif the objects passed into function have the expected methods and expression operatorsthey are plug-and-play compatible with the function' logic even in our simple times functionthis means that any two objects that support will workno matter what they may beand no matter when they are coded this function will work on two numbers (performing multiplication)or string and number (performing repetition)or any other combination of objects supporting the expected interface--even class-based objects we have not even imagined yet moreoverif the objects passed in do not support this expected interfacepython will detect the error when the expression is run and raise an exception automatically it' therefore usually pointless to code error checking ourselves in factdoing so would limit our function' utilityas it would be restricted to work only on objects whose types we test for this turns out to be crucial philosophical difference between python and statically typed languages like +and javain pythonyour code is not supposed to care about specific data types if it doesit will be limited to working on just the types you anticipated when you wrote itand it will not support other compatible object types that may be coded in the future although it is possible to test for types with tools like the type built-in functiondoing so breaks your code' flexibility by and largewe code to object interfaces in pythonnot data types of coursesome programs have unique requirementsand this polymorphic model of programming means we have to test our code to detect errorsrather than providing type declarations compiler can use to detect some types of errors for us ahead of time in exchange for an initial bit of testingthoughwe radically reduce the amount of code we have to write and radically increase our code' flexibility as you'll learnit' net win in practice second exampleintersecting sequences let' look at second function example that does something bit more useful than multiplying arguments and further illustrates function basics in we coded for loop that collected items held in common in two strings we noted there that the code wasn' as useful as it could be because it was set up to work only on specific variables and could not be rerun later of coursewe could copy this polymorphic behavior has in recent years come to also be known as duck typing--the essential idea being that your code is not supposed to care if an object is duckonly that it quacks anything that quacks will doduck or notand the implementation of quacks is up to the objecta principle which will become even more apparent when we study classes in part vi graphic metaphor to be surethough this is really just new label for an older ideaand use cases for quacking software would seem limited in the tangible world (he saysbracing for emails from militant ornithologists function basics |
1,050 | good nor general--we' still have to edit each copy to support different sequence namesand changing the algorithm would then require changing multiple copies definition by nowyou can probably guess that the solution to this dilemma is to package the for loop inside function doing so offers number of advantagesputting the code in function makes it tool that you can run as many times as you like because callers can pass in arbitrary argumentsfunctions are general enough to work on any two sequences (or other iterablesyou wish to intersect when the logic is packaged in functionyou have to change code in only one place if you ever need to change the way the intersection works coding the function in module file means it can be imported and reused by any program run on your machine in effectwrapping the code in function makes it general intersection utilitydef intersect(seq seq )res [for in seq if in seq res append(xreturn res start empty scan seq common itemadd to end the transformation from the simple code of to this function is straightforwardwe've just nested the original logic under def header and made the objects on which it operates passed-in parameter names because this function computes resultwe've also added return statement to send result object back to the caller calls before you can call functionyou have to make it to do thisrun its def statementeither by typing it interactively or by coding it in module file and importing the file once you've run the defyou can call the function by passing any two sequence objects in parenthesess "spams "scamintersect( [' '' '' 'strings herewe've passed in two stringsand we get back list containing the characters in common the algorithm the function uses is simple"for every item in the first argumentif that item is also in the second argumentappend the item to the result it' little shorter to say that in python than in englishbut it works out the same second exampleintersecting sequences |
1,051 | mathematical intersection (there may be duplicates in the result)and isn' required at all (as we've seenpython' set data type provides built-in intersection operationindeedthe function could be replaced with single list comprehension expressionas it exhibits the classic loop collector code pattern[ for in if in [' '' '' 'as function basics examplethoughit does the job--this single piece of code can apply to an entire range of object typesas the next section explains in factwe'll improve and extend this to support arbitrarily many operands in after we learn more about argument passing modes polymorphism revisited like all good functions in pythonintersect is polymorphic that isit works on arbitrary typesas long as they support the expected object interfacex intersect([ ]( ) [ mixed types saved result object this timewe passed in different types of objects to our function-- list and tuple (mixed types)--and it still picked out the common items because you don' have to specify the types of arguments ahead of timethe intersect function happily iterates through any kind of sequence objects you send itas long as they support the expected interfaces for intersectthis means that the first argument has to support the for loopand the second has to support the in membership test any two such objects will workregardless of their specific types--that includes physically stored sequences like strings and listsall the iterable objects we met in including files and dictionariesand even any class-based objects we code that apply operator overloading techniques we'll discuss later in the book here againif we pass in objects that do not support these interfaces ( numbers)python will automatically detect the mismatch and raise an exception for us--which is exactly what we wantand the best we could do on our own if we coded explicit type this code will always work if we intersect filescontents obtained with file readlines(it may not work to intersect lines in open input files directlythoughdepending on the file object' implementation of the in operator or general iteration files must generally be rewound ( with file seek( or another openafter they have been read to end-of-file onceand so are single-pass iterators as we'll see in when we study operator overloadingobjects implement the in operator either by providing the specific __contains__ method or by supporting the general iteration protocol with the __iter__ or older __getitem__ methodsclasses can code these methods arbitrarily to define what iteration means for their data function basics |
1,052 | both reduce the amount of code we need to write and increase our code' flexibility local variables probably the most interesting part of this examplethoughis its names it turns out that the variable res inside intersect is what in python is called local variable-- name that is visible only to code inside the function def and that exists only while the function runs in factbecause all names assigned in any way inside function are classified as local variables by defaultnearly all the names in intersect are local variablesres is obviously assignedso it is local variable arguments are passed by assignmentso seq and seq aretoo the for loop assigns items to variableso the name is also local all these local variables appear when the function is called and disappear when the function exits--the return statement at the end of intersect sends back the result objectbut the name res goes away because of thisa function' variables won' remember values between callsalthough the object returned by function lives onretaining other sorts of state information requires other sorts of techniques to fully explore the notion of locals and statethoughwe need to move on to the scopes coverage of summary this introduced the core ideas behind function definition--the syntax and operation of the def and return statementsthe behavior of function call expressionsand the notion and benefits of polymorphism in python functions as we sawa def statement is executable code that creates function object at runtimewhen the function is later calledobjects are passed into it by assignment (recall that assignment means object reference in pythonwhichas we learned in really means pointer internally)and computed values are sent back by return we also began exploring the concepts of local variables and scopes in this but we'll save all the details on those topics for firstthougha quick quiz test your knowledgequiz what is the point of coding functions at what time does python create function what does function return if it has no return statement in it when does the code nested inside the function definition statement runtest your knowledgequiz |
1,053 | test your knowledgeanswers functions are the most basic way of avoiding code redundancy in python--factoring code into functions means that we have only one copy of an operation' code to update in the future functions are also the basic unit of code reuse in python --wrapping code in functions makes it reusable toolcallable in variety of programs finallyfunctions allow us to divide complex system into manageable partseach of which may be developed individually function is created when python reaches and runs the def statementthis statement creates function object and assigns it the function' name this normally happens when the enclosing module file is imported by another module (recall that imports run the code in file from top to bottomincluding any defs)but it can also occur when def is typed interactively or nested in other statementssuch as ifs function returns the none object by default if the control flow falls off the end of the function body without running into return statement such functions are usually called with expression statementsas assigning their none results to variables is generally pointless return statement with no expression in it also returns none the function body (the code nested inside the function definition statementis run when the function is later called with call expression the body runs anew each time the function is called checking the types of objects passed into function effectively breaks the function' flexibilityconstraining the function to work on specific types only without such checksthe function would likely be able to process an entire range of object types--any objects that support the interface expected by the function will work (the term interface means the set of methods and expression operators the function' code runs function basics |
1,054 | scopes introduced basic function definitions and calls as we sawpython' core function model is simple to usebut even simple function examples quickly led us to questions about the meaning of variables in our code this moves on to present the details behind python' scopes--the places where variables are defined and looked up like module filesscopes help prevent name clashes across your program' codenames defined in one program unit don' interfere with names in another as we'll seethe place where name is assigned in our code is crucial to determining what the name means we'll also find that scope usage can have major impact on program maintenance effortoveruse of globalsfor exampleis generally bad thing on the plus sidewe'll learn that scopes can provide way to retain state information between function callsand offer an alternative to classes in some roles python scope basics now that you're ready to start writing your own functionswe need to get more formal about what names mean in python when you use name in programpython createschangesor looks up the name in what is known as namespace-- place where names live when we talk about the search for name' value in relation to codethe term scope refers to namespacethat isthe location of name' assignment in your source code determines the scope of the name' visibility to your code just about everything related to namesincluding scope classificationhappens at assignment time in python as we've seennames in python spring into existence when they are first assigned valuesand they must be assigned before they are used because names are not declared ahead of timepython uses the location of the assignment of name to associate it with ( bind it toa particular namespace in other wordsthe place where you assign name in your source code determines the namespace it will live inand hence its scope of visibility besides packaging code for reusefunctions add an extra namespace layer to your programs to minimize the potential for collisions among variables of the same name--by |
1,055 | and no other this rule means thatnames assigned inside def can only be seen by the code within that def you cannot even refer to such names from outside the function names assigned inside def do not clash with variables outside the defeven if the same names are used elsewhere name assigned outside given def ( in different def or at the top level of module fileis completely different variable from name assigned inside that def in all casesthe scope of variable (where it can be usedis always determined by where it is assigned in your source code and has nothing to do with which functions call which in factas we'll learn in this variables may be assigned in three different placescorresponding to three different scopesif variable is assigned inside defit is local to that function if variable is assigned in an enclosing defit is nonlocal to nested functions if variable is assigned outside all defsit is global to the entire file we call this lexical scoping because variable scopes are determined entirely by the locations of the variables in the source code of your program filesnot by function calls for examplein the following module filethe assignment creates global variable named (visible everywhere in this file)but the assignment creates local variable (visible only within the def statement) global (modulescope def func() local (functionscope xa different variable even though both variables are named xtheir scopes make them different the net effect is that function scopes help to avoid name clashes in your programs and help to make functions more self-contained program units--their code need not be concerned with names used elsewhere scope details before we started writing functionsall the code we wrote was at the top level of module ( not nested in def)so the names we used either lived in the module itself or were built-ins predefined by python ( opentechnicallythe interactive prompt is module named __main__ that prints results and doesn' save its codein all other waysthoughit' like the top level of module file functionsthoughprovide nested namespaces (scopesthat localize the names they usesuch that names inside function won' clash with those outside it (in module or another functionfunctions define local scope and modules define global scope with the following properties scopes |
1,056 | isa namespace in which variables created (assignedat the top level of the module file live global variables become attributes of module object to the outside world after imports but can also be used as simple variables within the module file itself the global scope spans single file only don' be fooled by the word "globalhere--names at the top level of file are global to code within that single file only there is really no notion of singleall-encompassing global file-based scope in python insteadnames are partitioned into modulesand you must always import module explicitly if you want to be able to use the names its file defines when you hear "globalin pythonthink "module assigned names are local unless declared global or nonlocal by defaultall the names assigned inside function definition are put in the local scope (the namespace associated with the function callif you need to assign name that lives at the top level of the module enclosing the functionyou can do so by declaring it in global statement inside the function if you need to assign name that lives in an enclosing defas of python you can do so by declaring it in nonlocal statement all other names are enclosing function localsglobalsor built-ins names not assigned value in the function definition are assumed to be enclosing scope localsdefined in physically surrounding def statementglobals that live in the enclosing module' namespaceor built-ins in the predefined built-ins module python provides each call to function creates new local scope every time you call functionyou create new local scope--that isa namespace in which the names created inside that function will usually live you can think of each def statement (and lambda expressionas defining new local scopebut the local scope actually corresponds to function call because python allows functions to call themselves to loop--an advanced technique known as recursion and noted briefly in when we explored comparisons--each active call receives its own copy of the function' local variables recursion is useful in functions we write as wellto process structures whose shapes can' be predicted ahead of timewe'll explore it more fully in there are few subtleties worth underscoring here firstkeep in mind that code typed at the interactive command prompt lives in moduletooand follows the normal scope rulesthey are global variablesaccessible to the entire interactive session you'll learn more about modules in the next part of this book also note that any type of assignment within function classifies name as local this includes statementsmodule names in importfunction names in deffunction argument namesand so on if you assign name in any way within defit will become local to that function by default python scope basics |
1,057 | assignments do for instanceif the name is assigned to list at the top level of modulea statement within function will classify as localbut append(xwill not in the latter casewe are changing the list object that referencesnot itself -- is found in the global scope as usualand python happily modifies it without requiring global (or nonlocaldeclaration as usualit helps to keep the distinction between names and objects clearchanging an object is not an assignment to name name resolutionthe legb rule if the prior section sounds confusingit really boils down to three simple rules with def statementname assignments create or change local names by default name references search at most four scopeslocalthen enclosing functions (if any)then globalthen built-in names declared in global and nonlocal statements map assigned names to enclosing module and function scopesrespectively in other wordsall names assigned inside function def statement (or lambdaan expression we'll meet laterare locals by default functions can freely use names assigned in syntactically enclosing functions and the global scopebut they must declare such nonlocals and globals in order to change them python' name-resolution scheme is sometimes called the legb ruleafter the scope nameswhen you use an unqualified name inside functionpython searches up to four scopes--the local (lscopethen the local scopes of any enclosing (edefs and lambdasthen the global (gscopeand then the built-in (bscope--and stops at the first place the name is found if the name is not found during this searchpython reports an error when you assign name in function (instead of just referring to it in an expression)python always creates or changes the name in the local scopeunless it' declared to be global or nonlocal in that function when you assign name outside any function ( at the top level of module fileor at the interactive prompt)the local scope is the same as the global scope-the module' namespace because names must be assigned before they can be used (as we learned in )there are no automatic components in this modelassignments always determine name scopes unambiguously figure - illustrates python' four scopes note that the second scope lookup layere--the scopes of enclosing defs or lambdas--can technically correspond to more than one lookup level this case only comes into play when you nest functions within functionsand is enhanced by the nonlocal statement in scopes |
1,058 | this orderin the local scopein any enclosing functionslocal scopesin the global scopeand finally in the built-in scope the first occurrence wins the place in your code where variable is assigned usually determines its scope in python xnonlocal declarations can also force names to be mapped to enclosing function scopeswhether assigned or not also keep in mind that these rules apply only to simple variable names ( spamin parts and viwe'll see that qualified attribute names ( object spamlive in particular objects and follow completely different set of lookup rules than those covered here references to attribute names following periods search one or more objectsnot scopesand in fact may invoke something called inheritance in python' oop modelmore on this in part vi of this book other python scopespreview though obscure at this point in the bookthere are technically three more scopes in python--temporary loop variables in some comprehensionsexception reference variables in some try handlersand local scopes in class statements the first two of these are special cases that rarely impact real codeand the third falls under the legb umbrella rule most statement blocks and other constructs do not localize the names used within themwith the following version-specific exceptions (whose variables are not available tobut also will not clash withsurrounding codeand which involve topics covered in full later) the scope lookup rule was called the "lgb rulein the first edition of this book the enclosing def "elayer was added later in python to obviate the task of passing in enclosing scope names explicitly with default arguments-- topic usually of marginal interest to python beginners that we'll defer until later in this since this scope is now addressed by the nonlocal statement in python xthe lookup rule might be better named "lngbtodaybut backward compatibility matters in bookstoo the present form of this acronym also does not account for the newer obscure scopes of some comprehensions and exception handlersbut acronyms longer than four letters tend to defeat their purposepython scope basics |
1,059 | in comprehension expression such as [ for in ibecause they might clash with other names and reflect internal state in generatorsin xsuch variables are local to the expression itself in all comprehension formsgeneratorlistsetand dictionary in xthey are local to generator expressions and set and dictionary compressionsbut not to list comprehensions that map their names to the scope outside the expression by contrastfor loop statements never localize their variables to the statement block in any python see for more details and examples exception variables--the variable used to reference the raised exception in try statement handler clause such as except as because they might defer garbage collection' memory recoveryin xsuch variables are local to that except blockand in fact are removed when the block is exited (even if you've used it earlier in your code!in xthese variables live on after the try statement see for additional information these contexts augment the legb rulerather than modifying it variables assigned in comprehensionfor exampleare simply bound to further nested and special-case scopeother names referenced within these expressions follow the usual legb lookup rules it' also worth noting that the class statement we'll meet in part vi creates new local scope too for the names assigned inside the top level of its block as for defnames assigned inside class don' clash with names elsewhereand follow the legb lookup rulewhere the class block is the "llevel like modules and importsthese names also morph into class object attributes after the class statements ends unlike functionsthoughclass names are not created per callclass object calls generate instanceswhich inherit names assigned in the class and record per-object state as attributes as we'll also learn in although the legb rule is used to resolve names used in both the top level of class itself as well as the top level of method functions nested within itclasses themselves are skipped by scope lookups--their names must be fetched as object attributes because python searches enclosing functions for referenced namesbut not enclosing classesthe legb rule still applies to oop code scope example let' step through larger example that demonstrates scope ideas suppose we wrote the following code in module fileglobal scope def func( )local scope scopes and func assigned in moduleglobal and assigned in functionlocals is global |
1,060 | func( func in moduleresult= this module and the function it contains use number of names to do their business using python' scope ruleswe can classify the names as followsglobal namesxfunc is global because it' assigned at the top level of the module fileit can be referenced inside the function as simple unqualified variable without being declared global func is global for the same reasonthe def statement assigns function object to the name func at the top level of the module local namesyz and are local to the function (and exist only while the function runsbecause they are both assigned values in the function definitionz by virtue of the statementand because arguments are always passed by assignment the underlying rationale for this name-segregation scheme is that local variables serve as temporary names that you need only while function is running for instancein the preceding examplethe argument and the addition result exist only inside the functionthese names don' interfere with the enclosing module' namespace (or any other functionfor that matterin factlocal variables are removed from memory when the function call exitsand objects they reference may be garbage-collected if not referenced elsewhere this is an automaticinternal stepbut it helps minimize memory requirements the local/global distinction also makes functions easier to understandas most of the names function uses appear in the function itselfnot at some arbitrary place in module alsobecause you can be sure that local names will not be changed by some remote function in your programthey tend to make programs easier to debug and modify functions are self-contained units of software the built-in scope we've been talking about the built-in scope in the abstractbut it' bit simpler than you may think reallythe built-in scope is just built-in module called builtinsbut you have to import builtins to query built-ins because the name builtins is not itself built in noi' seriousthe built-in scope is implemented as standard library module named builtins in xbut that name itself is not placed in the built-in scopeso you have to import it in order to inspect it once you doyou can run dir call to see which names are predefined in python (see ahead for usage)import builtins dir(builtins['arithmeticerror''assertionerror''attributeerror''baseexception''blockingioerror''brokenpipeerror''buffererror''byteswarning'python scope basics |
1,061 | 'ord''pow''print''property''quit''range''repr''reversed''round''set''setattr''slice''sorted''staticmethod''str''sum''super''tuple''type''vars''zip'the names in this list constitute the built-in scope in pythonroughly the first half are built-in exceptionsand the second half are built-in functions also in this list are the special names nonetrueand falsethough they are treated as reserved words in because python automatically searches this module last in its legb lookupyou get all the names in this list "for free"--that isyou can use them without importing any modules thusthere are really two ways to refer to built-in function--by taking advantage of the legb ruleor by manually importing the builtins modulezip the normal way import builtins builtins zip the hard wayfor customizations zip is builtins zip true same objectdifferent lookups the second of these approaches is sometimes useful in advanced ways we'll meet in this sidebars redefining built-in namesfor better or worse the careful reader might also notice that because the legb lookup procedure takes the first occurrence of name that it findsnames in the local scope may override variables of the same name in both the global and built-in scopesand global names may override built-ins function canfor instancecreate local variable called open by assigning to itdef hider()open 'spamopen('data txt'local variablehides built-in here errorthis no longer opens file in this scopehoweverthis will hide the built-in function called open that lives in the built-in (outerscopesuch that the name open will no longer work within the function to open files-it' now stringnot the opener function this isn' problem if you don' need to open files in this functionbut triggers an error if you attempt to open through this name this can even occur more simply at the interactive promptwhich works as globalmodule scopeopen assign in global scopehides built-in here too nowthere is nothing inherently wrong with using built-in name for variables of your ownas long as you don' need the original built-in version after allif these were truly scopes |
1,062 | names as reserved with over names in this module in that would be far too restrictive and dauntinglen(dir(builtins))len([ for in dir(builtinsif not startswith('__')]( in factthere are times in advanced programming where you may really want to replace built-in name by redefining it in your code--to define custom open that verifies access attemptsfor instance (see this sidebar "breaking the universe in python xon page for more on this threadstillredefining built-in name is often bugand nasty one at thatbecause python will not issue warning message about it tools like pychecker (see the webcan warn you of such mistakesbut knowledge may be your best defense on this pointdon' redefine built-in name you need if you accidentally reassign built-in name at the interactive prompt this wayyou can either restart your session or run del name statement to remove the redefinition from your scopethereby restoring the original in the built-in scope note that functions can similarly hide global variables of the same name with localsbut this is more broadly usefuland in fact is much of the point of local scopes--because they minimize the potential for name clashesyour functions are self-contained namespace scopesx global def func() local xhides globalbut we want this here func(print(xprints unchanged herethe assignment within the function creates local that is completely different variable from the global in the module outside the function as one consequencethoughthere is no way to change name outside function without adding global (or nonlocaldeclaration to the defas described in the next section version skew noteactuallythe tongue twisting gets bit worse the python builtins module used here is named __builtin__ in python in additionthe name __builtins__ (with the sis preset in most global scopesincluding the interactive sessionto reference the module known as builtins in and __builtin__ in xso you can often use __builtins__ without an import but cannot run an import on that name itself--it' preset variablenot module' name that isin builtins is __builtins__ is true after you import buil tinsand in __builtin__ is __builtins__ is true after you import __builtin__ the upshot is that we can usually inspect the built-in scope by simply running dir(__builtins__with no import in both and python scope basics |
1,063 | in xand __builtin__ for the same in who said documenting this stuff was easybreaking the universe in python here' another thing you can do in python that you probably shouldn' --because the names true and false in are just variables in the built-in scope and are not reservedit' possible to reassign them with statement like true false don' worryyou won' actually break the logical consistency of the universe in so doingthis statement merely redefines the word true for the single scope in which it appears to return false all other scopes still find the originals in the built-in scope for more funthoughin python you could say __builtin__ true falseto reset true to false for the entire python process this works because there is only one builtin scope module in programshared by all its clients alasthis type of assignment has been disallowed in python xbecause true and false are treated as actual reserved wordsjust like none in xthoughit sends idle into strange panic state that resets the user code process (in other wordsdon' try this at homekidsthis technique can be usefulhoweverboth to illustrate the underlying namespace modeland for tool writers who must change built-ins such as open to customized functions by reassigning function' name in the built-in scopeyou reset it to your customization for every module in the process if you doyou'll probably also need to remember the original version to call from your customization--in factwe'll see one way to achieve this for custom open in the sidebar "why you will carecustomizing openon page after we've had chance to explore nested scope closures and state retention options alsonote again that third-party tools such as pycheckerand others such as pylintwill warn about common programming mistakesincluding accidental assignment to built-in names (this is usually known as "shadowinga built-in in such toolsit' not bad idea to run your first few python programs through tools like these to see what they point out the global statement the global statement and its nonlocal cousin are the only things that are remotely like declaration statements in python they are not type or size declarationsthoughthey are namespace declarations the global statement tells python that function plans to change one or more global names--that isnames that live in the enclosing module' scope (namespacewe've talked about global in passing already here' summaryglobal names are variables assigned at the top level of the enclosing module file scopes |
1,064 | global names may be referenced within function without being declared in other wordsglobal allows us to change names that live outside def at the top level of module file as we'll see laterthe nonlocal statement is almost identical but applies to names in the enclosing def' local scoperather than names in the enclosing module the global statement consists of the keyword globalfollowed by one or more names separated by commas all the listed names will be mapped to the enclosing module' scope when assigned or referenced within the function body for instancex global def func()global global xoutside def func(print(xprints we've added global declaration to the example heresuch that the inside the def now refers to the outside the defthey are the same variable this timeso changing inside the function changes the outside it here is slightly more involved example of global at workyz def all_global()global global variables in module declare globals assigned no need to declare yzlegb rule herexyand are all globals inside the function all_global and are global because they aren' assigned in the functionx is global because it was listed in global statement to map it to the module' scope explicitly without the global herex would be considered local by virtue of the assignment notice that and are not declared globalpython' legb lookup rule finds them in the module automatically alsonotice that does not even exist in the enclosing module before the function runsin this casethe first assignment in the function creates in the module program designminimize global variables functions in generaland global variables in particularraise some larger design questions how should our functions communicatealthough some of these will become more apparent when you begin writing larger functions of your owna few guidelines up front might spare you from problems later in generalfunctions should rely on arguments and return values instead of globalsbut need to explain why by defaultnames assigned in functions are localsso if you want to change names outside functions you have to write extra code ( global statementsthis is delibthe global statement |
1,065 | thing although there are times when globals are usefulvariables assigned in def are local by default because that is normally the best policy changing globals can lead to well-known software engineering problemsbecause the variablesvalues are dependent on the order of calls to arbitrarily distant functionsprograms can become difficult to debugor to understand at all consider this module filefor examplewhich is presumably imported and used elsewherex def func ()global def func ()global nowimagine that it is your job to modify or reuse this code what will the value of be herereallythat question has no meaning unless it' qualified with point of reference in time--the value of is timing-dependentas it depends on which function was called last (something we can' tell from this file alonethe net effect is that to understand this codeyou have to trace the flow of control through the entire program andif you need to reuse or modify the codeyou have to keep the entire program in your head all at once in this caseyou can' really use one of these functions without bringing along the other they are dependent on--that iscoupled with--the global variable this is the problem with globalsthey generally make code more difficult to understand and reuse than code consisting of self-contained functions that rely on locals on the other handshort of using tools like nested scope closures or object-oriented programming with classesglobal variables are probably the most straightforward way in python to retain shared state information--information that function needs to remember for use the next time it is called local variables disappear when the function returnsbut globals do not as we'll see laterother techniques can achieve thistooand allow for multiple copies of the retained informationbut they are generally more complex than pushing values out to the global scope for retention in simple use cases where this applies moreoversome programs designate single module to collect globalsas long as this is expectedit is not as harmful programs that use multithreading to do parallel processing in python also commonly depend on global variables--they become shared memory between functions running in parallel threadsand so act as communication device for nowthoughespecially if you are relatively new to programmingavoid the temptation to use globals whenever you can--they tend to make programs difficult to un scopes |
1,066 | enough try to communicate with passed-in arguments and return values instead six months from nowboth you and your coworkers may be happy you did program designminimize cross-file changes here' another scope-related design issuealthough we can change variables in another file directlywe usually shouldn' module files were introduced in and are covered in more depth in the next part of this book to illustrate their relationship to scopesconsider these two module filesfirst py this code doesn' know about second py second py import first print(first xfirst okreferences name in another file but changing it can be too subtle and implicit the first defines variable xwhich the second prints and then changes by assignment notice that we must import the first module into the second file to get to its variable at all--as we've learnedeach module is self-contained namespace (package of variables)and we must import one module to see inside it from another that' the main point about modulesby segregating variables on per-file basisthey avoid name collisions across filesin much the same way that local variables avoid name clashes across functions reallythoughin terms of this topicthe global scope of module file becomes the attribute namespace of the module object once it is imported--importers automatically have access to all of the file' global variablesbecause file' global scope morphs into an object' attribute namespace when it is imported after importing the first modulethe second module prints its variable and then assigns it new value referencing the module' variable to print it is fine--this is how modules are linked together into larger system normally the problem with the assignment to first xhoweveris that it is far too implicitwhoever' charged with maintaining or reusing the first module probably has no clue that some arbitrarily far-removed module on the import chain can change out from under him or her at runtime in factthe multithreading runs function calls in parallel with the rest of the program and is supported by python' standard library modules _threadthreadingand queue (threadthreadingand queue in python xbecause all threaded functions run in the same processglobal scopes often serve as one form of shared memory between them (threads may share both names in global scopesas well as objects in process' memory spacethreading is commonly used for long-running tasks in guisto implement nonblocking operations in general and to maximize cpu capacity it is also beyond this book' scopesee the python library manualas well as the follow-up texts listed in the preface (such as 'reilly' programming python)for more details the global statement |
1,067 | all although such cross-file variable changes are always possible in pythonthey are usually much more subtle than you will want againthis sets up too strong coupling between the two files--because they are both dependent on the value of the variable xit' difficult to understand or reuse one file without the other such implicit cross-file dependencies can lead to inflexible code at bestand outright bugs at worst here againthe best prescription is generally to not do this--the best way to communicate across file boundaries is to call functionspassing in arguments and getting back return values in this specific casewe would probably be better off coding an accessor function to manage the changefirst py def setx(new)global new second py import first first setx( accessor make external changes explit and can manage access in single place call the function instead of changing directly this requires more code and may seem like trivial changebut it makes huge difference in terms of readability and maintainability--when person reading the first module by itself sees functionthat person will know that it is point of interface and will expect the change to the in other wordsit removes the element of surprise that is rarely good thing in software projects although we cannot prevent cross-file changes from happeningcommon sense dictates that they should be minimized unless widely accepted across the program when we meet classes in part viwe'll see similar techniques for coding attribute accessors unlike modulesclasses can also intercept attribute fetches automatically with operator overloadingeven when accessors aren' used by their clients other ways to access globals interestinglybecause global-scope variables morph into the attributes of loaded module objectwe can emulate the global statement by importing the enclosing module and assigning to its attributesas in the following example module file code in this file imports the enclosing modulefirst by nameand then by indexing the sys modules loaded modules table (more on this table in and )thismod py var scopes global variable =module attribute |
1,068 | var change local var def glob ()global var var + declare global (normalchange global var def glob ()var import thismod thismod var + change local var import myself change global var def glob ()var import sys glob sys modules['thismod'glob var + change local var import system table get module object (or use __name__change global var def test()print(varlocal()glob ()glob ()glob (print(varwhen runthis adds to the global variable (only the first function does not impact it)import thismod thismod test( thismod var this worksand it illustrates the equivalence of globals to module attributesbut it' much more work than using the global statement to make your intentions explicit as we've seenglobal allows us to change names in module outside function it has close relative named nonlocal that can be used to change names in enclosing functionstoo--but to understand how that can be usefulwe first need to explore enclosing functions in general scopes and nested functions so fari've omitted one part of python' scope rules on purposebecause it' relatively uncommon to encounter it in practice howeverit' time to take deeper look at the letter in the legb lookup rule the layer was added in python it takes the form of the local scopes of any and all enclosing function' local scopes enclosing scopes are sometimes also called statically nested scopes reallythe nesting is lexical one-nested scopes correspond to physically and syntactically nested code structures in your program' source code text scopes and nested functions |
1,069 | with the addition of nested function scopesvariable lookup rules become slightly more complex within functiona reference (xlooks for the name first in the current local scope (function)then in the local scopes of any lexically enclosing functions in your source codefrom inner to outerthen in the current global scope (the module file)and finally in the built-in scope (the module builtinsglobal declarations make the search begin in the global (module filescope instead an assignment ( valuecreates or changes the name in the current local scopeby default if is declared global within the functionthe assignment creates or changes the name in the enclosing module' scope instead ifon the other handx is declared nonlocal within the function in (only)the assignment changes the name in the closest enclosing function' local scope notice that the global declaration still maps variables to the enclosing module when nested functions are presentvariables in enclosing functions may be referencedbut they require nonlocal declarations to be changed nested scope examples to clarify the prior section' pointslet' illustrate with some real code here is what an enclosing function scope looks like (type this into script file or at the interactive prompt to run it live) def () def ()print(xf ( (global scope namenot used enclosing def local reference made in nested def prints enclosing def local first offthis is legal python codethe def is simply an executable statementwhich can appear anywhere any other statement can--including nested in another def herethe nested def runs while call to the function is runningit generates function and assigns it to the name local variable within ' local scope in sensef is temporary function that lives only during the execution of (and is visible only to code inthe enclosing but notice what happens inside when it prints the variable xit refers to the that lives in the enclosing function' local scope because functions can access names in all physically enclosing def statementsthe in is automatically mapped to the in by the legb lookup rule scopes |
1,070 | for examplethe following code defines function that makes and returns another functionand represents more common usage patterndef () def ()print(xreturn remembers in enclosing def scope return but don' call it action (action(makereturn function call it nowprints in this codethe call to action is really running the function we named when ran this works because functions are objects in python like everything elseand can be passed back as return values from other functions most importantlyf remembers the enclosing scope' in even though is no longer active--which leads us to the next topic factory functionsclosures depending on whom you askthis sort of behavior is also sometimes called closure or factory function--the former describing functional programming techniqueand the latter denoting design pattern whatever the labelthe function object in question remembers values in enclosing scopes regardless of whether those scopes are still present in memory in effectthey have attached packets of memory ( state retention)which are local to each copy of the nested function createdand often provide simple alternative to classes in this role simple function factory factory functions ( closuresare sometimes used by programs that need to generate event handlers on the fly in response to conditions at runtime for instanceimagine gui that must define actions according to user inputs that cannot be anticipated when the gui is built in such caseswe need function that creates and returns another functionwith information that may vary per function made to illustrate this in simple termsconsider the following functiontyped at the interactive prompt (and shown here without the continuation-line promptsper the presentation note ahead)def maker( )def action( )return * return action make and return action action retains from enclosing scope this defines an outer function that simply generates and returns nested functionwithout calling it--maker makes actionbut simply returns action without running it if we call the outer functionscopes and nested functions |
1,071 | maker( pass to argument action at what we get back is reference to the generated nested function--the one created when the nested def runs if we now call what we got back from the outer functionf( ( pass to xn remembers * * we invoke the nested function--the one called action within maker in other wordswe're calling the nested function that maker created and passed back perhaps the most unusual part of thisthoughis that the nested function remembers integer the value of the variable in makereven though maker has returned and exited by the time we call action in effectn from the enclosing local scope is retained as state information attached to the generated actionwhich is why we get back its argument squared when it is later called just as importantif we now call the outer function againwe get back new nested function with different state information attached that iswe get the argument cubed instead of squared when calling the new functionbut the original still squares as beforeg maker( ( ( remembers remembers * * this works because each call to factory function like this gets its own set of state information in our casethe function we assign to name remembers and remembers because each has its own state information retained by the variable in maker this is somewhat advanced technique that you may not see very often in most codeand may be popular among programmers with backgrounds in functional programming languages on the other handenclosing scopes are often employed by the lambda function-creation expressions we'll expand on later in this -because they are expressionsthey are almost always nested within def for examplea lambda would serve in place of def in our exampledef maker( )return lambda xx * maker( ( lambda functions retain state too * again for more tangible example of closures at worksee the upcoming sidebar "why you will carecustomizing openon page it uses similar techniques to store information for later use in an enclosing scope scopes |
1,072 | appear in your interface (they do at the shellbut not in idlethis convention will be followed from this point on to make larger code examples bit easier to cut and paste from an ebook or other ' assuming that by now you understand indentation rules and have had your fair share of typing python codeand some functions and classes ahead may be too large for rote input ' also listing more and more code alone or in filesand switching between these and interactive input arbitrarilywhen you see "promptthe code is typed interactivelyand can generally be cut and pasted into your python shell if you omit the "itself if this failsyou can still run by pasting line by lineor editing in file closures versus classesround to someclassesdescribed in full in part vi of this bookmay seem better at state retention like thisbecause they make their memory more explicit with attribute assignments classes also directly support additional tools that closure functions do notsuch as customization by inheritance and operator overloadingand more naturally implement multiple behaviors in the form of methods because of such distinctionsclasses may be better at implementing more complete objects stillclosure functions often provide lighter-weight and viable alternative when retaining state is the only goal they provide for per-call localized storage for data required by single nested function this is especially true when we add the nonlocal statement described ahead to allow enclosing scope state changes (in xenclosing scopes are read-onlyand so have more limited usesfrom broader perspectivethere are multiple ways for python functions to retain state between calls although the values of normal local variables go away when function returnsvalues can be retained from call to call in global variablesin class instance attributesin the enclosing scope references we've met hereand in argument defaults and function attributes some might include mutable default arguments to this list too (though others may wish they didn'twe'll preview class-based alternatives and meet function attributes later in this and get the full story on arguments and defaults in to help us judge how defaults compete on state retentionthoughthe next section gives enough of an introduction to get us started scopes and nested functions |
1,073 | of the enclosing function' local names are retained by references within the classor one of its method functions see for more on nested classes as we'll see in later examples ( ' decorators)the outer def in such code serves similar roleit becomes class factoryand provides state retention for the nested class retaining enclosing scope state with defaults in early versions of python (prior to )the sort of code in the prior section failed because nested defs did not do anything about scopes-- reference to variable within in the following would search only the local ( )then global (the code outside )and then built-in scopes because it skipped the scopes of enclosing functionsan error would result to work around thisprogrammers typically used default argument values to pass in and remember the objects in an enclosing scopedef () def ( = )print(xf (remember enclosing scope with defaults (prints this coding style works in all python releasesand you'll still see this pattern in some existing python code in factit' still required for loop variablesas we'll see in momentwhich is why it remains worth studying today in shortthe syntax arg=val in def header means that the argument arg will default to the value val if no real value is passed to arg in call this syntax is used here to explicitly assign enclosing scope state to be retained specificallyin the modified herethe = means that the argument will default to the value of in the enclosing scope--because the second is evaluated before python steps into the nested defit still refers to the in in effectthe default argument remembers what was in the object that' fairly complexand it depends entirely on the timing of default value evaluations in factthe nested scope lookup rule was added to python to make defaults unnecessary for this role--todaypython automatically remembers any values required in the enclosing scope for use in nested defs of coursethe best prescription for much code is simply to avoid nesting defs within defsas it will make your programs much simpler--in the pythonic viewflat is generally better than nested the following is an equivalent of the prior example that avoids nesting altogether notice the forward reference in this code--it' ok to call function defined after the function that calls itas long as the second def runs before the first function is actually called code inside def is never evaluated until the function is actually called scopes |
1,074 | (xpass along instead of nesting forward reference ok def ( )print(xflat is still often better than nestedf ( if you avoid nesting this wayyou can almost forget about the nested scopes concept in python on the other handthe nested functions of closure (factoryfunctions are fairly common in modern python codeas are lambda functions--which almost naturally appear nested in defs and often rely on the nested scopes layeras the next section explains nested scopesdefaultsand lambdas although they see increasing use in defs these daysyou may be more likely to care about nested function scopes when you start coding or reading lambda expressions we've met lambda briefly and won' cover it in depth until but in shortit' an expression that generates new function to be called latermuch like def statement because it' an expressionthoughit can be used in places that def cannotsuch as within list and dictionary literals like defa lambda expression also introduces new local scope for the function it creates thanks to the enclosing scopes lookup layerlambdas can see all the variables that live in the functions in which they are coded thusthe following code-- variation on the factory we saw earlier--worksbut only because the nested scope rules are applieddef func() action (lambda nx *nreturn action func(print( ( ) remembered from enclosing def prints * prior to the introduction of nested function scopesprogrammers used defaults to pass values from an enclosing scope into lambdasjust as for defs for instancethe following works on all pythonsdef func() action (lambda nx=xx *nreturn action pass in manually because lambdas are expressionsthey naturally (and even normallynest inside enclosing defs hencethey were perhaps the biggest initial beneficiaries of the addition scopes and nested functions |
1,075 | to pass values into lambdas with defaults loop variables may require defaultsnot scopes there is one notable exception to the rule just gave (and reason why 've shown you the otherwise dated default argument technique we just saw)if lambda or def defined within function is nested inside loopand the nested function references an enclosing scope variable that is changed by that loopall functions generated within the loop will have the same value--the value the referenced variable had in the last loop iteration in such casesyou must still use defaults to save the variable' current value instead this may seem fairly obscure casebut it can come up in practice more often than you may thinkespecially in code that generates callback handler functions for number of widgets in gui--for instancehandlers for button-clicks for all the buttons in row if these are created in loopyou may need to be careful to save state with defaultsor all your buttonscallbacks may wind up doing the same thing here' an illustration of this phenomenon reduced to simple codethe following attempts to build up list of functions that each remember the current variable from the enclosing scopedef makeactions()acts [for in range( )acts append(lambda xi *xreturn acts tries to remember each but all remember same last iacts makeactions(acts[ at this doesn' quite workthough--because the enclosing scope variable is looked up when the nested functions are later calledthey all effectively remember the same valuethe value the loop variable had on the last loop iteration that iswhen we pass power argument of in each of the following callswe get back to the power of for each function in the listbecause is the same in all of them-- acts[ ]( acts[ ]( acts[ ]( acts[ ]( all are * =value of last this should be * ( this should be * ( only this should be * ( this is the one case where we still have to explicitly retain enclosing scope values with default argumentsrather than enclosing scope references that isto make this sort of code workwe must pass in the current value of the enclosing scope' variable with scopes |
1,076 | it' later called)each remembers its own value for idef makeactions()acts [for in range( )acts append(lambda xi=ii *xreturn acts acts makeactions(acts[ ]( acts[ ]( acts[ ]( acts[ ]( use defaults instead remember current * * * * this seems an implementation artifact that is prone to changeand may become more important as you start writing larger programs we'll talk more about defaults in and lambdas in so you may also want to return and review this section later arbitrary scope nesting before ending this discussionwe should note that scopes may nest arbitrarilybut only enclosing function def statements (not classesdescribed in part viare searched when names are referenceddef () def ()def ()print(xf ( (found in ' local scopef ( python will search the local scopes of all enclosing defsfrom inner to outerafter the referencing function' local scope and before the module' global scope or built-ins howeverthis sort of code is even less likely to pop up in practice againin pythonwe say flat is better than nestedand this still holds generally true even with the addition in the section "function gotchason page we'll also see that there is similar issue with using mutable objects like lists and dictionaries for default arguments ( def ( =[]))--because defaults are implemented as single objects attached to functionsmutable defaults retain state from call to callrather then being initialized anew on each call depending on whom you askthis is either considered feature that supports another way to implement state retentionor strange corner of the languagemore on this at the end of scopes and nested functions |
1,077 | coworkerswill generally be better if you minimize nested function definitions the nonlocal statement in in the prior section we explored the way that nested functions can reference variables in an enclosing function' scopeeven if that function has already returned it turns out thatin python (though not in )we can also change such enclosing scope variablesas long as we declare them in nonlocal statements with this statementnested defs can have both read and write access to names in enclosing functions this makes nested scope closures more usefulby providing changeable state information the nonlocal statement is similar in both form and role to globalcovered earlier like globalnonlocal declares that name will be changed in an enclosing scope unlike globalthoughnonlocal applies to name in an enclosing function' scopenot the global module scope outside all defs also unlike globalnonlocal names must already exist in the enclosing function' scope when declared--they can exist only in enclosing functions and cannot be created by first assignment in nested def in other wordsnonlocal both allows assignment to names in enclosing function scopes and limits scope lookups for such names to enclosing defs the net effect is more direct and reliable implementation of changeable state informationfor contexts that do not desire or need classes with attributesinheritanceand multiple behaviors nonlocal basics python introduces new nonlocal statementwhich has meaning only inside functiondef func()nonlocal name name ok here nonlocal syntaxerrornonlocal declaration not allowed at module level this statement allows nested function to change one or more names defined in syntactically enclosing function' scope in python xwhen one function def is nested in anotherthe nested function can reference any of the names defined by assignment in the enclosing def' scopebut it cannot change them in xdeclaring the enclosing scopesnames in nonlocal statement enables nested functions to assign and thus change such names as well this provides way for enclosing functions to provide writeable state informationremembered when the nested function is later called allowing the state to change makes it more useful to the nested function (imagine counter in the enclosing scopefor instancein xprogrammers usually achieve similar goals by using classes or scopes |
1,078 | for state retentionthoughnonlocal makes it more generally applicable besides allowing names in enclosing defs to be changedthe nonlocal statement also forces the issue for references--much like the global statementnonlocal causes searches for the names listed in the statement to begin in the enclosing defsscopesnot in the local scope of the declaring function that isnonlocal also means "skip my local scope entirely in factthe names listed in nonlocal must have been previously defined in an enclosing def when the nonlocal is reachedor an error is raised the net effect is much like globalglobal means the names reside in the enclosing moduleand nonlocal means they reside in an enclosing def nonlocal is even more strictthough--scope search is restricted to only enclosing defs that isnonlocal names can appear only in enclosing defsnot in the module' global scope or built-in scopes outside the defs the addition of nonlocal does not alter name reference scope rules in generalthey still work as beforeper the "legbrule described earlier the nonlocal statement mostly serves to allow names in enclosing scopes to be changed rather than just referenced howeverboth global and nonlocal statements do tighten up and even restrict the lookup rules somewhatwhen coded in functionglobal makes scope lookup begin in the enclosing module' scope and allows names there to be assigned scope lookup continues on to the built-in scope if the name does not exist in the modulebut assignments to global names always create or change them in the module' scope nonlocal restricts scope lookup to just enclosing defsrequires that the names already exist thereand allows them to be assigned scope lookup does not continue on to the global or built-in scopes in python xreferences to enclosing def scope names are allowedbut not assignment howeveryou can still use classes with explicit attributes to achieve the same changeable state information effect as nonlocals (and you may be better off doing so in some contexts)globals and function attributes can sometimes accomplish similar goals as well more on this in momentfirstlet' turn to some working code to make this more concrete nonlocal in action on to some examplesall run in references to enclosing def scopes work in as they do in --in the followingtester builds and returns the function nestedto be called laterand the state reference in nested maps the local scope of tester using the normal scope lookup rulesc:\codec:\python \python def tester(start)the nonlocal statement in |
1,079 | def nested(label)print(labelstatereturn nested referencing nonlocals works normally remembers state in enclosing scope tester( ('spam'spam ('ham'ham changing name in an enclosing def' scope is not allowed by defaultthoughthis is the normal case in as welldef tester(start)state start def nested(label)print(labelstatestate + return nested cannot change by default (never in xf tester( ('spam'unboundlocalerrorlocal variable 'statereferenced before assignment using nonlocal for changes nowunder xif we declare state in the tester scope as nonlocal within nestedwe get to change it inside the nested functiontoo this works even though tester has returned and exited by the time we call the returned nested function through the name fdef tester(start)state start def nested(label)nonlocal state print(labelstatestate + return nested tester( ('spam'spam ('ham'ham ('eggs'eggs each call gets its own state remembers state in enclosing scope allowed to change it if nonlocal increments state on each call as usual with enclosing scope referenceswe can call the tester factory (closurefunction multiple times to get multiple copies of its state in memory the state object in the enclosing scope is essentially attached to the nested function object returnedeach call makes newdistinct state objectsuch that updating one function' state won' impact the other the following continues the prior listing' interaction scopes |
1,080 | ('spam'spam make new tester that starts at ('eggs'eggs my state information updated to ('bacon'bacon but ' is where it left offat each call has different state information in this sensepython' nonlocals are more functional than function locals typical in some other languagesin closure functionnonlocals are per-callmultiple copy data boundary cases though usefulnonlocals come with some subtleties to be aware of firstunlike the global statementnonlocal names really must have previously been assigned in an enclosing def' scope when nonlocal is evaluatedor else you'll get an error--you cannot create them dynamically by assigning them anew in the enclosing scope in factthey are checked at function definition time before either an enclosing or nested function is calleddef tester(start)def nested(label)nonlocal state state print(labelstatereturn nested nonlocals must already exist in enclosing defsyntaxerrorno binding for nonlocal 'statefound def tester(start)def nested(label)global state state print(labelstatereturn nested globals don' have to exist yet when declared this creates the name in the module now tester( ('abc'abc state secondnonlocal restricts the scope lookup to just enclosing defsnonlocals are not looked up in the enclosing module' global scope or the built-in scope outside all defseven if they are already therespam def tester()def nested()nonlocal spam must be in defnot the moduleprint('current='spamspam + the nonlocal statement in |
1,081 | syntaxerrorno binding for nonlocal 'spamfound these restrictions make sense once you realize that python would not otherwise generally know which enclosing scope to create brand-new name in in the prior listingshould spam be assigned in testeror the module outsidebecause this is ambiguouspython must resolve nonlocals at function creation timenot function call time why nonlocalstate retention options given the extra complexity of nested functionsyou might wonder what the fuss is about although it' difficult to see in our small examplesstate information becomes crucial in many programs while functions can return resultstheir local variables won' normally retain other values that must live on between calls moreovermany applications require such values to differ per context of use as mentioned earlierthere are variety of ways to "rememberinformation across function and method calls in python while there are tradeoffs for allnonlocal does improve this story for enclosing scope references--the nonlocal statement allows multiple copies of changeable state to be retained in memory it addresses simple stateretention needs where classes may not be warranted and global variables do not applythough function attributes can often serve similar roles more portably let' review the options to see how they stack up state with nonlocal only as we saw in the prior sectionthe following code allows state to be retained and modified in an enclosing scope each call to tester creates self-contained package of changeable informationwhose names do not clash with any other part of the programdef tester(start)state start def nested(label)nonlocal state print(labelstatestate + return nested each call gets its own state remembers state in enclosing scope allowed to change it if nonlocal tester( ('spam'state visible within closure only spam state attributeerror'functionobject has no attribute 'statewe need to declare variables nonlocal only if they must be changed (other enclosing scope name references are automatically retained as usual)and nonlocal names are still not visible outside the enclosing function scopes |
1,082 | options are availabledepending on your goals the next three sections present some alternatives some of the code in these sections uses tools we haven' covered yet and is intended partially as previewbut we'll keep the examples simple here so that you can compare and contrast along the way state with globalsa single copy only one common prescription for achieving the nonlocal effect in and earlier is to simply move the state out to the global scope (the enclosing module)def tester(start)global state state start def nested(label)global state print(labelstatestate + return nested tester( ('spam'spam ('eggs'eggs move it out to the module to change it global allows changes in module scope each call increments shared global state this works in this casebut it requires global declarations in both functions and is prone to name collisions in the global scope (what if "stateis already being used? worseand more subtleproblem is that it only allows for single shared copy of the state information in the module scope--if we call tester againwe'll wind up resetting the module' state variablesuch that prior calls will see their state overwritteng tester( ('toast'toast resets state' single copy in global scope ('bacon'bacon ('ham'ham but my counter has been overwrittenas shown earlierwhen you are using nonlocal and nested function closures instead of globaleach call to tester remembers its own unique copy of the state object state with classesexplicit attributes (previewthe other prescription for changeable state information in and earlier is to use classes with attributes to make state information access more explicit than the implicit magic of scope lookup rules as an added benefiteach instance of class gets fresh why nonlocalstate retention options |
1,083 | also support inheritancemultiple behaviorsand other tools we haven' explored classes in detail yetbut as brief preview for comparisonthe following is reformulation of the earlier tester/nested functions as classwhich records state in objects explicitly as they are created to make sense of this codeyou need to know that def within class like this works exactly like normal defexcept that the function' self argument automatically receives the implied subject of the call (an instance object created by calling the class itselfthe function named __init__ is run automatically when the class is calledclass testerdef __init__(selfstart)self state start def nested(selflabel)print(labelself stateself state + tester( nested('spam'spam nested('ham'ham class-based alternative (see part vion object constructionsave state explicitly in new object reference state explicitly changes are always allowed create instanceinvoke __init__ is passed to self in classeswe save every attribute explicitlywhether it' changed or just referencedand they are available outside the class as for nested functions and nonlocalthe class alternative supports multiple copies of the retained datag tester( nested('toast'toast nested('bacon'bacon each instance gets new copy of state changing one does not impact others nested('eggs'eggs state ' state is where it left off state may be accessed outside class with just slightly more magic--which we'll delve into later in this book--we could also make our class objects look like callable functions using operator overloading __call__ intercepts direct calls on an instanceso we don' need to call named methodclass testerdef __init__(selfstart)self state start def __call__(selflabel)print(labelself stateself state + tester( ('juice'juice scopes intercept direct instance calls so nested(not required invokes __call__ |
1,084 | pancakes don' sweat the details in this code too much at this point in the bookit' mostly previewintended for general comparison to closures only we'll explore classes in depth in part viand will look at specific operator overloading tools like __call__ in the point to notice here is that classes can make state information more obviousby leveraging explicit attribute assignment instead of implicit scope lookups in additionclass attributes are always changeable and don' require nonlocal statementand classes are designed to scale up to implementing richer objects with many attributes and behaviors while using classes for state information is generally good rule of thumb to followthey might also be overkill in cases like thiswhere state is single counter such trivial state cases are more common than you might thinkin such contextsnested defs are sometimes more lightweight than coding classesespecially if you're not familiar with oop yet moreoverthere are some scenarios in which nested defs may actually work better than classes--stay tuned for the description of method decorators in for an example that is far beyond this already well-stretched scopestate with function attributes and as portable and often simpler state-retention optionwe can also sometimes achieve the same effect as nonlocals with function attributes--user-defined names attached to functions directly when you attach user-defined attributes to nested functions generated by enclosing factory functionsthey can also serve as per-callmultiple copyand writeable statejust like nonlocal scope closures and class attributes such user-defined attribute names won' clash with names python creates itselfand as for nonlocalneed be used only for state variables that must be changedother scope references are retained and work normally cruciallythis scheme is portable--like classesbut unlike nonlocalfunction attributes work in both python and in factthey've been available since much longer than ' nonlocal because factory functions make new function on each call anyhowthis does not require extra objects--the new function' attributes become percall state in much the same way as nonlocalsand are similarly associated with the generated function in memory moreoverfunction attributes allow state variables to be accessed outside the nested functionlike class attributeswith nonlocalstate variables can be seen directly only within the nested def if you need to access call counter externallyit' simple function attribute fetch in this model here' final version of our example based on this technique--it replaces nonlocal with an attribute attached to the nested function this scheme may not seem as intuitive to some at first glanceyou access state though the function' name instead of as simple why nonlocalstate retention options |
1,085 | state to be accessed externallyand saves line by not requiring nonlocal declarationdef tester(start)def nested(label)print(labelnested statenested state + nested state start return nested tester( ('spam'spam ('ham'ham state nested is in enclosing scope change attrnot nested itself initial state after func defined is 'nestedwith state attached can access state outside functions too because each call to the outer function produces new nested function objectthis scheme supports multiple copy per-call changeable data just like nonlocal closures and classes-- usage mode that global variables cannot provideg tester( ('eggs'eggs ('ham'ham has own statedoesn' overwrite ' state state is false state is accessible and per-call different function objects this code relies on the fact that the function name nested is local variable in the tester scope enclosing nestedas suchit can be referenced freely inside nested this code also relies on the fact that changing an object in place is not an assignment to namewhen it increments nested stateit is changing part of the object nested referencesnot the name nested itself because we're not really assigning name in the enclosing scopeno nonlocal declaration is required function attributes are supported in both python and xwe'll explore them further in importantlywe'll see there that python uses naming conventions in both and that ensure that the arbitrary names you assign as function attributes won' clash with names related to internal implementationmaking the namespace equivalent to scope subjective factors asidefunction attributesutility does overlap with the newer nonlocal in xmaking the latter technically redundant and far less portable scopes |
1,086 | on related noteit' also possible to change mutable object in the enclosing scope in and without declaring its name nonlocal the followingfor exampleworks the same as the previous versionis just as portableand provides changeable per-call statedef tester(start)def nested(label)print(labelstate[ ]state[ + state [startreturn nested leverage in-place mutable change extra syntaxdeep magicthis leverages the mutability of listsand like function attributesrelies on the fact that in-place object changes do not classify name as local this is perhaps more obscure than either function attributes or ' nonlocalthough-- technique that predates even function attributesand seems to lie today somewhere on the spectrum from clever hack to dark magicyou're probably better off using named function attributes than lists and numeric offsets this waythough this may show up in code you must use to summarizeglobalsnonlocalsclassesand function attributes all offer changeable state-retention options globals support only single-copy shared datanonlocals can be changed in onlyclasses require basic knowledge of oopand both classes and function attributes provide portable solutions that allow state to be accessed directly from outside the stateful callable object itself as usualthe best tool for your program depends upon your program' goals we'll revisit all the state options introduced here in in more realistic context--decoratorsa tool that by nature involves multilevel state retention state options have additional selection factors ( performance)which we'll have to leave unexplored here for space (we'll learn how to time code speed in for nowit' time to move on to explore argument passing modes why you will carecustomizing open for another example of closures at workconsider changing the built-in open call to custom versionas suggested in this earlier sidebar "breaking the universe in python xon page if the custom version needs to call the originalit must save it before changing itand retain it for later use-- classic state retention scenario moreoverif we wish to support multiple customizations to the same functionglobals won' dowe need per-customizer state the followingcoded for python in file makeopen pyis one way to achieve this (in xchange the built-in scope name and printsit uses nested scope closure to remember value for later usewithout relying on global variables--which can clash and allow just one valueand without using class--that may require more code than is warranted hereimport builtins why nonlocalstate retention options |
1,087 | original builtins open def custom(*kargs**pargs)print('custom open call % :id kargspargsreturn original(*kargs**pargsbuiltins open custom to change open for every module in processthis code reassigns it in the built-in scope to custom version coded with nested defafter it saving the original in the enclosing scope so the customization can call it later this code is also partially previewas it relies on starred-argument forms to collect and later unpack arbitrary positional and keyword arguments meant for open-- topic coming up in the next much of the magic herethoughis nested scope closuresthe custom open found by the scope lookup rules retains the original for later usef open('script py'call built-in open in builtins read('import sys\nprint(sys path)\nx \nprint( * )\nfrom makeopen import makeopen makeopen('spam'import open resetter function custom open calls built-in open open('script py'call custom open in builtins custom open call 'spam'('script py',{ read('import sys\nprint(sys path)\nx \nprint( * )\nbecause each customization remembers the former built-in scope version in its own enclosing scopethey can even be nested naturally in ways that global variables cannot support--each call to the makeopen closure function remembers its own versions of id and originalso multiple customizations may be runmakeopen('eggs'nested customizers work toof open('script py'because each retains own state custom open call 'eggs'('script py',{custom open call 'spam'('script py',{ read('import sys\nprint(sys path)\nx \nprint( * )\nas isour function simply adds possibly nested call tracing to built-in functionbut the general technique may have other applications class-based equivalent to this may require more code because it would need to save the id and original values explicitly in object attributes--but requires more background knowledge than we yet haveso consider this part vi preview onlyimport builtins class makeopensee part vicall catches self(def __init__(selfid)self id id self original builtins open builtins open self def __call__(self*kargs**pargs)print('custom open call % :self idkargspargsreturn self original(*kargs**pargs scopes |
1,088 | code when state retention is the only goal we'll see additional closure use cases laterespecially when exploring decorators in where we'll find the closures are actually preferred to classes in certain roles summary in this we studied one of two key concepts related to functionsscopeswhich determine how variables are looked up when used as we learnedvariables are considered local to the function definitions in which they are assignedunless they are specifically declared to be global or nonlocal we also explored some more advanced scope concepts hereincluding nested function scopes and function attributes finallywe looked at some general design ideassuch as the need to avoid globals and crossfile changes in the next we're going to continue our function tour with the second key function-related conceptargument passing as we'll findarguments are passed into function by assignmentbut python also provides tools that allow functions to be flexible in how items are passed before we move onlet' take this quiz to review the scope concepts we've covered here test your knowledgequiz what is the output of the following codeand whyx 'spamdef func()print(xfunc( what is the output of this codeand whyx 'spamdef func() 'ni!func(print( what does this code printand whyx 'spamdef func() 'niprint(xfunc(print(xtest your knowledgequiz |
1,089 | 'spamdef func()global 'nifunc(print( what about this code--what' the outputand whyx 'spamdef func() 'nidef nested()print(xnested(func( how about this examplewhat is its output in python xand whydef func() 'nidef nested()nonlocal 'spamnested(print(xfunc( name three or more ways to retain state information in python function test your knowledgeanswers the output here is 'spam'because the function references global variable in the enclosing module (because it is not assigned in the functionit is considered global the output here is 'spamagain because assigning the variable inside the function makes it local and effectively hides the global of the same name the print statement finds the variable unchanged in the global (modulescope it prints 'nion one line and 'spamon anotherbecause the reference to the variable within the function finds the assigned local and the reference in the print statement finds the global this time it just prints 'nibecause the global declaration forces the variable assigned inside the function to refer to the variable in the enclosing global scope the output in this case is again 'nion one line and 'spamon anotherbecause the print statement in the nested function finds the name in the enclosing function' local scopeand the print at the end finds the variable in the global scope scopes |
1,090 | but not xmeans that the assignment to inside the nested function changes in the enclosing function' local scope without this statementthis assignment would classify as local to the nested functionmaking it different variablethe code would then print 'niinstead although the values of local variables go away when function returnsyou can make python function retain state information by using shared global variablesenclosing function scope references within nested functionsor using default argument values function attributes can sometimes allow state to be attached to the function itselfinstead of looked up in scopes another alternativeusing classes and oopsometimes supports state retention better than any of the scope-based techniques because it makes it explicit with attribute assignmentswe'll explore this option in part vi test your knowledgeanswers |
1,091 | arguments explored the details behind python' scopes--the places where variables are defined and looked up as we learnedthe place where name is defined in our code determines much of its meaning this continues the function story by studying the concepts in python argument passing--the way that objects are sent to functions as inputs as we'll seearguments ( parametersare assigned to names in functionbut they have more to do with object references than with variable scopes we'll also find that python provides extra toolssuch as keywordsdefaultsand arbitrary argument collectors and extractors that allow for wide flexibility in the way arguments are sent to functionand we'll put them to work in examples argument-passing basics earlier in this part of the booki noted that arguments are passed by assignment this has few ramifications that aren' always obvious to newcomerswhich 'll expand on in this section here is rundown of the key points in passing arguments to functionsarguments are passed by automatically assigning objects to local variable names function arguments--references to (possiblyshared objects sent by the caller--are just another instance of python assignment at work because references are implemented as pointersall arguments arein effectpassed by pointer objects passed as arguments are never automatically copied assigning to argument names inside function does not affect the caller argument names in the function header become newlocal names when the function runsin the scope of the function there is no aliasing between function argument names and variable names in the scope of the caller changing mutable object argument in function may impact the caller on the other handas arguments are simply assigned to passed-in objectsfunctions can change passed-in mutable objects in placeand the results may affect the caller mutable arguments can be input and output for functions |
1,092 | to function argumentsthough the assignment to argument names is automatic and implicit python' pass-by-assignment scheme isn' quite the same as ++' reference parameters optionbut it turns out to be very similar to the argument-passing model of the language (and othersin practiceimmutable arguments are effectively passed "by value objects such as integers and strings are passed by object reference instead of by copyingbut because you can' change immutable objects in place anyhowthe effect is much like making copy mutable arguments are effectively passed "by pointer objects such as lists and dictionaries are also passed by object referencewhich is similar to the way passes arrays as pointers--mutable objects can be changed in place in the functionmuch like arrays of courseif you've never used cpython' argument-passing mode will seem simpler still--it involves just the assignment of objects to namesand it works the same whether the objects are mutable or not arguments and shared references to illustrate argument-passing properties at workconsider the following codedef ( ) is assigned to (referencesthe passed object changes local variable only (bprint( and both reference same initially is not changed in this example the variable is assigned the object at the moment the function is called with ( )but lives only within the called function changing inside the function has no effect on the place where the function is calledit simply resets the local variable to completely different object that' what is meant by lack of name aliasing--assignment to an argument name inside function ( = does not magically change variable like in the scope of the function call argument names may share passed objects initially (they are essentially pointers to those objects)but only temporarilywhen the function is first called as soon as an argument name is reassignedthis relationship ends at leastthat' the case for assignment to argument names themselves when arguments are passed mutable objects like lists and dictionarieswe also need to be aware that inplace changes to such objects may live on after function exitsand hence impact callers here' an example that demonstrates this behavior arguments |
1,093 | [ 'spamarguments assigned references to objects changes local name' value only changes shared object in place [ changer(xlxl ( ['spam' ]callerpass immutable and mutable objects is unchangedl is differentin this codethe changer function assigns values to argument itselfand to component of the object referenced by argument these two assignments within the function are only slightly different in syntax but have radically different resultsbecause is local variable name in the function' scopethe first assignment has no effect on the caller--it simply changes the local variable to reference completely different objectand does not change the binding of the name in the caller' scope this is the same as in the prior example argument is local variable nametoobut it is passed mutable object (the list that references in the caller' scopeas the second assignment is an in-place object changethe result of the assignment to [ in the function impacts the value of after the function returns reallythe second assignment statement in changer doesn' change --it changes part of the object that currently references this in-place change impacts the caller only because the changed object outlives the function call the name hasn' changed either --it still references the samechanged object--but it seems as though differs after the call because the value it references has been modified within the function in effectthe list name serves as both input to and output from the function figure - illustrates the name/object bindings that exist immediately after the function has been calledand before its code has run if this example is still confusingit may help to notice that the effect of the automatic assignments of the passed-in arguments is the same as running series of simple assignment statements in terms of the first argumentthe assignment has no effect on the callerx print( they share the same object resets 'aonly'xis still the assignment through the second argument does affect variable at the callthoughbecause it is an in-place object changel [ [ 'spamprint( ['spam' they share the same object in-place change'lsees the change too argument-passing basics |
1,094 | in the function may share objects with variables in the scope of the call hencein-place changes to mutable arguments in function can impact the caller herea and in the function initially reference the objects referenced by variables and when the function is first called changing the list through variable makes appear different after the call returns if you recall our discussions about shared mutable objects in and you'll recognize the phenomenon at workchanging mutable object in place can impact other references to that object herethe effect is to make one of the arguments work like both an input and an output of the function avoiding mutable argument changes this behavior of in-place changes to mutable arguments isn' bug--it' simply the way argument passing works in pythonand turns out to be widely useful in practice arguments are normally passed to functions by reference because that is what we normally want it means we can pass large objects around our programs without making multiple copies along the wayand we can easily update these objects as we go in factas we'll see in part vipython' class model depends upon changing passed-in "selfargument in placeto update object state if we don' want in-place changes within functions to impact objects we pass to themthoughwe can simply make explicit copies of mutable objectsas we learned in for function argumentswe can always copy the list at the point of callwith tools like listlist copy as of or an empty slicel [ changer(xl[:]pass copyso our 'ldoes not change we can also copy within the function itselfif we never want to change passed-in objectsregardless of how the function is called arguments |
1,095 | [: [ 'spamcopy input list so we don' impact caller changes our list copy only both of these copying schemes don' stop the function from changing the object--they just prevent those changes from impacting the caller to really prevent changeswe can always convert to immutable objects to force the issue tuplesfor exampleraise an exception when changes are attemptedl [ changer(xtuple( )pass tupleso changes are errors this scheme uses the built-in tuple functionwhich builds new tuple out of all the items in sequence (reallyany iterableit' also something of an extreme--because it forces the function to be written to never change passed-in argumentsthis solution might impose more limitations on the function than it shouldand so should generally be avoided (you never know when changing arguments might come in handy for other calls in the futureusing this technique will also make the function lose the ability to call any list-specific methods on the argumentincluding methods that do not change the object in place the main point to remember here is that functions might update mutable objects like lists and dictionaries passed into them this isn' necessarily problem if it' expectedand often serves useful purposes moreoverfunctions that change passed-in mutable objects in place are probably designed and intended to do so--the change is likely part of well-defined api that you shouldn' violate by making copies howeveryou do have to be aware of this property--if objects change out from under you unexpectedlycheck whether called function might be responsibleand make copies when objects are passed if needed simulating output parameters and multiple results we've already discussed the return statement and used it in few examples here' another way to use this statementbecause return can send back any sort of objectit can return multiple values by packaging them in tuple or other collection type in factalthough python doesn' support what some languages label "call by referenceargument passingwe can usually simulate it by returning tuples and assigning the results back to the original argument names in the callerdef multiple(xy) [ return xy [ xl multiple(xlchanges local names only return multiple new values in tuple assign results to caller' names argument-passing basics |
1,096 | xl ( [ ]it looks like the code is returning two values herebut it' really just one-- two-item tuple with the optional surrounding parentheses omitted after the call returnswe can use tuple assignment to unpack the parts of the returned tuple (if you've forgotten why this worksflip back to "tuplesin and and "assignment statementsin the net effect of this coding pattern is to both send back multiple results and simulate the output parameters of other languages by explicit assignments herex and change after the callbut only because the code said so unpacking arguments in python xthe preceding example unpacks tuple returned by the function with tuple assignment in python xit' also possible to automatically unpack tuples in arguments passed to function in (only) function defined by this headerdef (( (bc)))can be called with tuples that match the expected structuref(( ( ))assigns aband to and respectively naturallythe passed tuple can also be an object created before the call ( ( )this def syntax is no longer supported in python insteadcode this function asdef ( )( (bc) to unpack in an explicit assignment statement this explicit form works in both and argument unpacking is reportedly an obscure and rarely used feature in python (except in code that uses it!moreovera function header in supports only the tuple form of sequence assignmentmore general sequence assignments ( def (( [bc])):fail on syntax errors in as well and require the explicit assignment form mandated in converselyarbitrary sequences in the call successfully match tuples in the header ( (( [ ])) (( "ab"))tuple unpacking argument syntax is also disallowed by in lambda function argument listssee the sidebar "why you will carelist comprehensions and mapon page for lambda unpacking example somewhat asymmetricallytuple unpacking assignment is still automatic in for loops targetssee for examples special argument-matching modes as we've just seenarguments are always passed by assignment in pythonnames in the def header are assigned to passed-in objects on top of this modelthoughpython provides additional tools that alter the way the argument objects in call are matched with argument names in the header prior to assignment these tools are all arguments |
1,097 | by defaultarguments are matched by positionfrom left to rightand you must pass exactly as many arguments as there are argument names in the function header howeveryou can also specify matching by nameprovide default valuesand use collectors for extra arguments argument matching basics before we go into the syntactic detailsi want to stress that these special modes are optional and deal only with matching objects to namesthe underlying passing mechanism after the matching takes place is still assignment in factsome of these tools are intended more for people writing libraries than for application developers but because you may stumble across these modes even if you don' code them yourselfhere' synopsis of the available toolspositionalsmatched from left to right the normal casewhich we've mostly been using so faris to match passed argument values to argument names in function header by positionfrom left to right keywordsmatched by argument name alternativelycallers can specify which argument in the function is to receive value by using the argument' name in the callwith the name=value syntax defaultsspecify values for optional arguments that aren' passed functions themselves can specify default values for arguments to receive if the call passes too few valuesagain using the name=value syntax varargs collectingcollect arbitrarily many positional or keyword arguments functions can use special arguments preceded with one or two characters to collect an arbitrary number of possibly extra arguments this feature is often referred to as varargsafter variable-length argument list tool in the languagein pythonthe arguments are collected in normal object varargs unpackingpass arbitrarily many positional or keyword arguments callers can also use the syntax to unpack argument collections into separate arguments this is the inverse of in function header--in the header it means collect arbitrarily many argumentswhile in the call it means unpack arbitrarily many argumentsand pass them individually as discrete values keyword-only argumentsarguments that must be passed by name in python (but not )functions can also specify arguments that must be passed by name with keyword argumentsnot by position such arguments are typically used to define configuration options in addition to actual arguments special argument-matching modes |
1,098 | table - summarizes the syntax that invokes the special argument-matching modes table - function argument-matching forms syntax location interpretation func(valuecaller normal argumentmatched by position func(name=valuecaller keyword argumentmatched by name func(*iterablecaller pass all objects in iterable as individual positional arguments func(**dictcaller pass all key/value pairs in dict as individual keyword arguments def func(namefunction normal argumentmatches any passed value by position or name def func(name=valuefunction default argument valueif not passed in the call def func(*namefunction matches and collects remaining positional arguments in tuple def func(**namefunction matches and collects remaining keyword arguments in dictionary def func(*othernamefunction arguments that must be passed by keyword only in calls ( xdef func(*name=valuefunction arguments that must be passed by keyword only in calls ( xthese special matching modes break down into function calls and definitions as followsin function call (the first four rows of the table)simple values are matched by positionbut using the name=value form tells python to match by name to arguments insteadthese are called keyword arguments using *iterable or **dict in call allows us to package up arbitrarily many positional or keyword objects in sequences (and other iterablesand dictionariesrespectivelyand unpack them as separateindividual arguments when they are passed to the function in function header (the rest of the table) simple name is matched by position or name depending on how the caller passes itbut the name=value form specifies default value the *name form collects any extra unmatched positional arguments in tupleand the **name form collects extra keyword arguments in dictionary in python xany normal or defaulted argument names following *name or bare are keyword-only arguments and must be passed by keyword in calls of thesekeyword arguments and defaults are probably the most commonly used in python code we've informally used both of these earlier in this bookwe've already used keywords to specify options to the print functionbut they are more general--keywords allow us to label any argument with its nameto make calls more informational we met defaults earliertooas way to pass in values from the enclosing function' scopebut they are also more general--they allow us to make any argument optionalproviding its default value in function definition arguments |
1,099 | further allows us to pick and choose which defaults to override in shortspecial argument-matching modes let you be fairly liberal about how many arguments must be passed to function if function specifies defaultsthey are used if you pass too few arguments if function uses the variable argument list formsyou can seemingly pass too many argumentsthe names collect the extra arguments in data structures for processing in the function the gritty details if you choose to use and combine the special argument-matching modespython will ask you to follow these ordering rules among the modesoptional componentsin function callarguments must appear in this orderany positional arguments (value)followed by combination of any keyword arguments (name=valueand the *iterable formfollowed by the **dict form in function headerarguments must appear in this orderany normal arguments (name)followed by any default arguments (name=value)followed by the *name (or in xformfollowed by any name or name=value keyword-only arguments (in )followed by the **name form in both the call and headerthe **args form must appear last if present if you mix arguments in any other orderyou will get syntax error because the combinations can be ambiguous the steps that python internally carries out to match arguments before assignment can roughly be described as follows assign nonkeyword arguments by position assign keyword arguments by matching names assign extra nonkeyword arguments to *name tuple assign extra keyword arguments to **name dictionary assign default values to unassigned arguments in header after thispython checks to make sure each argument is passed just one valueif notan error is raised when all matching is completepython assigns argument names to the objects passed to them the actual matching algorithm python uses is bit more complex (it must also account for keyword-only arguments in xfor instance)so we'll defer to python' standard language manual for more exact description it' not required readingbut tracing python' matching algorithm may help you to understand some convoluted casesespecially when modes are mixed special argument-matching modes |
Subsets and Splits