id
int64 0
25.6k
| text
stringlengths 0
4.59k
|
|---|---|
900 | like assignmentsprintsand function calls compound statements like if tests and while loops must still appear on lines of their own (otherwiseyou could squeeze an entire program onto one linewhich probably would not make you very popular among your coworkers!the other special rule for statements is essentially the inverseyou can make single statement span across multiple lines to make this workyou simply have to enclose part of your statement in bracketed pair--parentheses (())square brackets ([])or curly braces ({}any code enclosed in these constructs can cross multiple linesyour statement doesn' end until python reaches the line containing the closing part of the pair for instanceto continue list literalmylist [ because the code is enclosed in square brackets pairpython simply drops down to the next line until it encounters the closing bracket the curly braces surrounding dictionaries (as well as set literals and dictionary and set comprehensions in and allow them to span lines this way tooand parentheses handle tuplesfunction callsand expressions the indentation of the continuation lines does not matterthough common sense dictates that the lines should be aligned somehow for readability parentheses are the catchall device--because any expression can be wrapped in themsimply inserting left parenthesis allows you to drop down to the next line and continue your statementx ( dthis technique works with compound statementstooby the way anywhere you need to code large expressionsimply wrap it in parentheses to continue it on the next lineif ( = and = and = )print('spam an older rule also allows for continuation lines when the prior line ends in backslashx an error-prone older alternative this alternative technique is datedthoughand is frowned on today because it' difficult to notice and maintain the backslashes it' also fairly brittle and error-prone-there can be no spaces after the backslashand accidentally omitting it can have unexpected effects if the next line is mistaken to be new statement (in this example" dis valid statement by itself if it' not indentedthis rule is also another throwback to the languagewhere it is commonly used in "#definemacrosagainwhen in pythonlanddo as pythonistas donot as programmers do introducing python statements |
901 | as mentioned previouslystatements in nested block of code are normally associated by being indented the same amount to the right as one special case herethe body of compound statement can instead appear on the same line as the header in pythonafter the colonif yprint(xthis allows us to code single-line if statementssingle-line while and for loopsand so on here againthoughthis will work only if the body of the compound statement itself does not contain any compound statements that isonly simple statements-assignmentsprintsfunction callsand the like--are allowed after the colon larger statements must still appear on lines by themselves extra parts of compound statements (such as the else part of an ifwhich we'll meet in the next sectionmust also be on separate lines of their own compound statement bodies can also consist of multiple simple statements separated by semicolonsbut this tends to be frowned upon in generaleven though it' not always requiredif you keep all your statements on individual lines and always indent your nested blocksyour code will be easier to read and change in the future moreoversome code profiling and coverage tools may not be able to distinguish between multiple statements squeezed onto single line or the header and body of one-line compound statement it is almost always to your advantage to keep things simple in python you can use the special-case exceptions to write python code that' hard to readbut it takes lot of workand there are probably better ways to spend your time to see prime and common exception to one of these rules in actionhowever (the use of single-line if statement to break out of loop)and to introduce more of python' syntaxlet' move on to the next section and write some real code quick exampleinteractive loops we'll see all these syntax rules in action when we tour python' specific compound statements in the next few but they work the same everywhere in the python language to get startedlet' work through briefrealistic example that demonstrates the way that statement syntax and statement nesting come together in practiceand introduces few statements along the way simple interactive loop suppose you're asked to write python program that interacts with user in console window maybe you're accepting inputs to send to databaseor reading numbers to be used in calculation regardless of the purposeyou need to code loop that reads one or more inputs from user typing on keyboardand prints back result for each in other wordsyou need to write classic read/evaluate/print loop program quick exampleinteractive loops |
902 | while truereply input('enter text:'if reply ='stop'break print(reply upper()this code makes use of few new ideas and some we've already seenthe code leverages the python while looppython' most general looping statement we'll study the while statement in more detail laterbut in shortit consists of the word whilefollowed by an expression that is interpreted as true or false resultfollowed by nested block of code that is repeated while the test at the top is true (the word true here is considered always truethe input built-in function we met earlier in the book is used here for general console input--it prints its optional argument string as prompt and returns the user' typed reply as string use raw_input in insteadper the upcoming note single-line if statement that makes use of the special rule for nested blocks also appears herethe body of the if appears on the header line after the colon instead of being indented on new line underneath it this would work either waybut as it' codedwe've saved an extra line finallythe python break statement is used to exit the loop immediately--it simply jumps out of the loop statement altogetherand the program continues after the loop without this exit statementthe while would loop foreveras its test is always true in effectthis combination of statements essentially means "read line from the user and print it in uppercase until the user enters the word 'stop 'there are other ways to code such loopbut the form used here is very common in python code notice that all three lines nested under the while header line are indented the same amount--because they line up vertically in column this waythey are the block of code that is associated with the while test and repeated either the end of the source file or lesser-indented statement will suffice to terminate the loop body block when this code is runeither interactively or as script filehere is the sort of interaction we get--all of the code for this example is in interact py in the book' examples packageenter text:spam spam enter text: enter text:stop introducing python statements |
903 | working in python xthe code works the samebut you must use raw_input instead of input in all of this examplesand you can omit the outer parentheses in print statements (though they don' hurtin factif you study the interact py file in the examples packageyou'll see that it does this automatically--to support compatibilityit resets input if the running python' major version is ("inputwinds up running raw_input)import sys if sys version[ =' 'input raw_input compatible in xraw_input was renamed inputand print is built-in function instead of statement (more on prints in the next python has an input toobut it tries to evaluate the input string as though it were python codewhich probably won' work in this contexteval(input()can yield the same effect doing math on user inputs our script worksbut now suppose that instead of converting text string to uppercasewe want to do some math with numeric input--squaring itfor exampleperhaps in some misguided effort of an age-input program to tease its users we might try statements like these to achieve the desired effectreply ' reply * error text omitted typeerrorunsupported operand type(sfor *or pow()'strand 'intthis won' quite work in our scriptthoughbecause (as discussed in the prior part of the bookpython won' convert object types in expressions unless they are all numericand input from user is always returned to our script as string we cannot raise string of digits to power unless we convert it manually to an integerint(reply* armed with this informationwe can now recode our loop to perform the necessary math type the following in file to test itwhile truereply input('enter text:'if reply ='stop'break print(int(reply* print('bye'this script uses single-line if statement to exit on "stopas beforebut it also converts inputs to perform the required math this version also adds an exit message at the bottom because the print statement in the last line is not indented as much as the quick exampleinteractive loops |
904 | after the loop is exitedenter text: enter text: enter text:stop bye usage notefrom this point on 'll assume that this code is stored in and run from script filevia command lineidle menu optionor any of the other file launching techniques we met in againit' named interact py in the book' examples if you are entering this code interactivelythoughbe sure to include blank line ( press enter twicebefore the final print statementto terminate the loop this implies that you also can' cut and paste the code in its entirety into an interactive promptan extra blank line is required interactivelybut not in script files the final print doesn' quite make sense in interactive modethough--you'll have to code it after interacting with the loophandling errors by testing inputs so far so goodbut notice what happens when the input is invalidenter text:xxx error text omitted valueerrorinvalid literal for int(with base 'xxxthe built-in int function raises an exception here in the face of mistake if we want our script to be robustwe can check the string' content ahead of time with the string object' isdigit methods ' 'xxxs isdigit() isdigit((truefalsethis also gives us an excuse to further nest the statements in our example the following new version of our interactive script uses full-blown if statement to work around the exception on errorswhile truereply input('enter text:'if reply ='stop'break elif not reply isdigit()print('bad! elseprint(int(reply* print('bye' introducing python statements |
905 | tool for coding logic in scripts in its full formit consists of the word if followed by test and an associated block of codeone or more optional elif ("else if"tests and code blocksand an optional else partwith an associated block of code at the bottom to serve as default python runs the block of code associated with the first test that is trueworking from top to bottomor the else part if all tests are false the ifelifand else parts in the preceding example are associated as part of the same statement because they all line up vertically ( share the same level of indentationthe if statement spans from the word if to the start of the print statement on the last line of the script in turnthe entire if block is part of the while loop because all of it is indented under the loop' header line statement nesting like this is natural once you get the hang of it when we run our new scriptits code catches errors before they occur and prints an error message before continuing (which you'll probably want to improve in later release)but "stopstill gets us outand valid numbers are still squaredenter text: enter text:xyz bad!bad!bad!bad!bad!bad!bad!badenter text: enter text:stop handling errors with try statements the preceding solution worksbut as you'll see later in the bookthe most general way to handle errors in python is to catch and recover from them completely using the python try statement we'll explore this statement in depth in part vii of this bookbut as previewusing try here can lead to code that some would see as simpler than the prior versionwhile truereply input('enter text:'if reply ='stop'break trynum int(replyexceptprint('bad! elseprint(num * print('bye'this version works exactly like the previous onebut we've replaced the explicit error check with code that assumes the conversion will work and wraps it in an exception handler for cases when it doesn' in other wordsrather than detecting an errorwe simply respond if one occurs quick exampleinteractive loops |
906 | this try statement is another compound statementand follows the same pattern as if and while it' composed of the word tryfollowed by the main block of code (the action we are trying to run)followed by an except part that gives the exception handler code and an else part to be run if no exception is raised in the try part python first runs the try partthen runs either the except part (if an exception occursor the else part (if no exception occursin terms of statement nestingbecause the words tryexceptand else are all indented to the same levelthey are all considered part of the same single try statement notice that the else part is associated with the try herenot the if as we've seenelse can appear in if statements in pythonbut it can also appear in try statements and loops --its indentation tells you what statement it is part of in this casethe try statement spans from the word try through the code indented under the word elsebecause the else is indented the same as try the if statement in this code is one-liner and ends after the break supporting floating-point numbers againwe'll come back to the try statement later in this book for nowbe aware that because try can be used to intercept any errorit reduces the amount of error-checking code you have to writeand it' very general approach to dealing with unusual cases if we're sure that print won' failfor instancethis example could be even more concisewhile truereply input('enter text:'if reply ='stop'break tryprint(int(reply* exceptprint('bad! print('bye'and if we wanted to support input of floating-point numbers instead of just integersfor exampleusing try would be much easier than manual error testing--we could simply run float call and catch its exceptionswhile truereply input('enter text:'if reply ='stop'break tryprint(float(reply* exceptprint('bad! print('bye'there is no isfloat for strings todayso this exception-based approach spares us from having to analyze all possible floating-point syntax in an explicit error check when coding this waywe can enter wider variety of numbersbut errors and exits still work as before introducing python statements |
907 | enter text: enter text: - - enter text:spam bad!bad!bad!bad!bad!bad!bad!badenter text:stop bye python' eval callwhich we used in and to convert data in strings and fileswould work in place of float here tooand would allow input of arbitrary expressions (" * would be legalif curiousinputespecially if we're assuming the program is processing ages!this is powerful concept that is open to the same security issues mentioned in the prior if you can' trust the source of code stringuse more restrictive conversion tools like int and float python' execused in to run code read from fileis similar to eval (but assumes the string is statement instead of an expression and has no result)and its compile call precompiles frequently used code strings to bytecode objects for speed run help on any of these for more detailsas mentionedexec is statement in but function in xso see its manual entry in instead we'll also use exec to import modules by name string in --an example of its more dynamic roles nesting code three levels deep let' look at one last mutation of our code nesting can take us even further if we need it to--we couldfor exampleextend our prior integer-only script to branch to one of set of alternatives based on the relative magnitude of valid inputwhile truereply input('enter text:'if reply ='stop'break elif not reply isdigit()print('bad! elsenum int(replyif num print('low'elseprint(num * print('bye'this version adds an if statement nested in the else clause of another if statementwhich is in turn nested in the while loop when code is conditional or repeated like quick exampleinteractive loops |
908 | but we'll now print "lowfor numbers less than enter text: low enter text: enter text:spam bad!bad!bad!bad!bad!bad!bad!badenter text:stop bye summary that concludes our quick look at python statement syntax this introduced the general rules for coding statements and blocks of code as you've learnedin python we normally code one statement per line and indent all the statements in nested block the same amount (indentation is part of python' syntaxhoweverwe also looked at few exceptions to these rulesincluding continuation lines and single-line tests and loops finallywe put these ideas to work in an interactive script that demonstrated handful of statements and showed statement syntax in action in the next we'll start to dig deeper by going over each of python' basic procedural statements in depth as you'll seethoughall statements follow the same general rules introduced here test your knowledgequiz what three things are required in -like language but omitted in python how is statement normally terminated in python how are the statements in nested block of code normally associated in python how can you make single statement span multiple lines how can you code compound statement on single line is there any valid reason to type semicolon at the end of statement in python what is try statement for what is the most common coding mistake among python beginnerstest your knowledgeanswers -like languages require parentheses around the tests in some statementssemicolons at the end of each statementand braces around nested block of code the end of line terminates the statement that appears on that line alternativelyif more than one statement appears on the same linethey can be terminated with introducing python statements |
909 | closing bracketed syntactic pair the statements in nested block are all indented the same number of tabs or spaces you can make statement span many lines by enclosing part of it in parenthesessquare bracketsor curly bracesthe statement ends when python sees line that contains the closing part of the pair the body of compound statement can be moved to the header line after the colonbut only if the body consists of only noncompound statements only when you need to squeeze more than one statement onto single line of code even thenthis only works if all the statements are noncompoundand it' discouraged because it can lead to code that is difficult to read the try statement is used to catch and recover from exceptions (errorsin python script it' usually an alternative to manually checking for errors in your code forgetting to type the colon character at the end of the header line in compound statement is the most common beginner' mistake if you're new to python and haven' made it yetyou probably will soontest your knowledgeanswers |
910 | assignmentsexpressionsand prints now that we've had quick introduction to python statement syntaxthis begins our in-depth tour of specific python statements we'll begin with the basicsassignment statementsexpression statementsand print operations we've already seen all of these in actionbut here we'll fill in important details we've skipped so far although they're relatively simpleas you'll seethere are optional variations for each of these statement types that will come in handy once you begin writing realistic python programs assignment statements we've been using the python assignment statement for while to assign objects to names in its basic formyou write the target of an assignment on the left of an equals signand the object to be assigned on the right the target on the left may be name or object componentand the object on the right can be an arbitrary expression that computes an object for the most partassignments are straightforwardbut here are few properties to keep in mindassignments create object references as discussed in python assignments store references to objects in names or data structure components they always create references to objects instead of copying the objects because of thatpython variables are more like pointers than data storage areas names are created when first assigned python creates variable name the first time you assign it value ( an object reference)so there' no need to predeclare names ahead of time some (but not alldata structure slots are created when assignedtoo ( dictionary entriessome object attributesonce assigneda name is replaced with the value it references whenever it appears in an expression names must be assigned before being referenced it' an error to use name to which you haven' yet assigned value python raises an exception if you tryrather than returning some sort of ambiguous default value this turns out to be crucial in python because names are not predeclared--if python provided default |
911 | errorsit would be much more difficult for you to spot name typos in your code some operations perform assignments implicitly in this section we're concerned with the statementbut assignment occurs in many contexts in python for instancewe'll see later that module importsfunction and class definitionsfor loop variablesand function arguments are all implicit assignments because assignment works the same everywhere it pops upall these contexts simply bind names to object references at runtime assignment statement forms although assignment is general and pervasive concept in pythonwe are primarily interested in assignment statements in this table - illustrates the different assignment statement forms in pythonand their syntax patterns table - assignment statement forms operation interpretation spam 'spambasic form spamham 'yum''yumtuple assignment (positional[spamham['yum''yum'list assignment (positionalabcd 'spamsequence assignmentgeneralized * 'spamextended sequence unpacking (python xspam ham 'lunchmultiple-target assignment spams + augmented assignment (equivalent to spams spams the first form in table - is by far the most commonbinding name (or data structure componentto single object in factyou could get all your work done with this basic form alone the other table entries represent special forms that are all optionalbut that programmers often find convenient in practicetupleand list-unpacking assignments the second and third forms in the table are related when you code tuple or list on the left side of the =python pairs objects on the right side with targets on the left by position and assigns them from left to right for examplein the second line of table - the name spam is assigned the string 'yum'and the name ham is bound to the string 'yumin this case python internally may make tuple of the items on the rightwhich is why this is called tuple-unpacking assignment sequence assignments in later versions of pythontuple and list assignments were generalized into instances of what we now call sequence assignment--any sequence of names can be assigned to any sequence of valuesand python assigns the items one at time by position we can even mix and match the types of the sequences involved the assignmentsexpressionsand prints |
912 | charactersa is assigned ' ' is assigned ' 'and so on extended sequence unpacking in python (only) new form of sequence assignment allows us to be more flexible in how we select portions of sequence to assign the fifth line in table - for examplematches with the first character in the string on the right and with the resta is assigned ' 'and is assigned 'pamthis provides simpler alternative to assigning the results of manual slicing operations multiple-target assignments the sixth line in table - shows the multiple-target form of assignment in this formpython assigns reference to the same object (the object farthest to the rightto all the targets on the left in the tablethe names spam and ham are both assigned references to the same string object'lunchthe effect is the same as if we had coded ham 'lunchfollowed by spam hamas ham evaluates to the original string object ( not separate copy of that objectaugmented assignments the last line in table - is an example of augmented assignment-- shorthand that combines an expression and an assignment in concise way saying spam + for examplehas the same effect as spam spam but the augmented form requires less typing and is generally quicker to run in additionif the subject is mutable and supports the operationan augmented assignment may run even quicker by choosing an in-place update operation instead of an object copy there is one augmented assignment statement for every binary expression operator in python sequence assignments we've already used and explored basic assignments in this bookso we'll take them as given here are few simple examples of sequence-unpacking assignments in actionpython nudge wink ab nudgewink ab ( [cd[nudgewinkcd ( basic assignment tuple assignment like nudgeb wink list assignment notice that we really are coding two tuples in the third line in this interaction--we've just omitted their enclosing parentheses python pairs the values in the tuple on the right side of the assignment operator with the variables in the tuple on the left side and assigns the values one at time assignment statements |
913 | solution to the exercises at the end of part ii because python creates temporary tuple that saves the original values of the variables on the right while the statement runsunpacking assignments are also way to swap two variablesvalues without creating temporary variable of your own--the tuple on the right remembers the prior values of the variables automaticallynudge wink nudgewink winknudge nudgewink ( tuplesswaps values like nudgenudge winkwink in factthe original tuple and list assignment forms in python have been generalized to accept any type of sequence (reallyiterableon the right as long as it is of the same length as the sequence on the left you can assign tuple of values to list of variablesa string of characters to tuple of variablesand so on in all casespython assigns items in the sequence on the right to variables in the sequence on the left by positionfrom left to right[abc( ac ( (abc"abcac (' '' 'assign tuple of values to list of names assign string of characters to tuple technically speakingsequence assignment actually supports any iterable object on the rightnot just any sequence this is more general category that includes collections both physical ( listsand virtual ( file' lines)which was defined briefly in and has popped up in passing ever since we'll firm up this term when we explore iterables in and advanced sequence assignment patterns although we can mix and match sequence types around the symbolwe must generally have the same number of items on the right as we have variables on the leftor we'll get an error python allows us to be more general with extended unpacking syntaxdescribed in the next section but normally in --and always in --the number of items in the assignment target and subject must matchstring 'spamabcd string ad (' '' 'same number on both sides abc string error if not error text omitted valueerrortoo many values to unpack (expected assignmentsexpressionsand prints |
914 | employ slicing to make this last case workabc string[ ]string[ ]string[ :abc (' '' ''am'index and slice abc list(string[: ][string[ :]abc (' '' ''am'slice and concatenate ab string[: string[ :abc (' '' ''am'samebut simpler (ab) string[: ]string[ :abc (' '' ''am'nested sequences as the last example in this interaction demonstrateswe can even assign nested sequencesand python unpacks their parts according to their shapeas expected in this casewe are assigning tuple of two itemswhere the first item is nested sequence ( string)exactly as though we had coded it this waypaired by shape and position ((ab) ('sp''am'abc (' '' ''am'python pairs the first string on the right ('sp'with the first tuple on the left ((ab)and assigns one character at timebefore assigning the entire second string ('am'to the variable all at once in this eventthe sequence-nesting shape of the object on the left must match that of the object on the right nested sequence assignment like this is somewhat rare to seebut it can be convenient for picking out the parts of data structures with known shapes for examplewe'll see in that this technique also works in for loopsbecause loop items are assigned to the target given in the loop headerfor (abcin [( )( )]simple tuple assignment for ((ab)cin [(( ) )(( ) )]nested tuple assignment in note in we'll also see that this nested tuple (reallysequenceunpacking assignment form works for function argument lists in python (though not in )because function arguments are passed by assignment as welldef (((ab) )) ((( ) )for arguments too in python xbut not sequence-unpacking assignments also give rise to another common coding idiom in python--assigning an integer series to set of variablesassignment statements |
915 | redblue ( this initializes the three names to the integer codes and respectively (it' python' equivalent of the enumerated data types you may have seen in other languagesto make sense of thisyou need to know that the range built-in function generates list of successive integers (in onlyit requires list around it if you wish to display its values all at once like this)list(range( )[ list(required in python only this call was previewed briefly in because range is commonly used in for loopswe'll say more about it in another place you may see tuple assignment at work is for splitting sequence into its front and the rest in loops like thisl [ while lfrontl [ ] [ :print(frontl [ [ [ [see next section for alternative the tuple assignment in the loop here could be coded as the following two lines insteadbut it' often more convenient to string them togetherfront [ [ :notice that this code is using the list as sort of stack data structurewhich can often also be achieved with the append and pop methods of list objectsherefront pop( would have much the same effect as the tuple assignment statementbut it would be an in-place change we'll learn more about while loopsand other (often betterways to step through sequence with for loopsin extended sequence unpacking in python the prior section demonstrated how to use manual slicing to make sequence assignments more general in python (but not )sequence assignment has been generalized to make this easier in shorta single starred name*xcan be used in the assignment target in order to specify more general matching against the sequence-the starred name is assigned listwhich collects all items in the sequence not assigned to other names this is especially handy for common coding patterns such as splitting sequence into its "frontand "rest,as in the preceding section' last example assignmentsexpressionsand prints |
916 | let' look at an example as we've seensequence assignments normally require exactly as many names in the target on the left as there are items in the subject on the right we get an error if the lengths disagree in both and (unless we manually sliced on the rightas shown in the prior section) :\codec:\python \python seq [ abcd seq print(abcd ab seq valueerrortoo many values to unpack (expected in python xthoughwe can use single starred name in the target to match more generally in the following continuation of our interactive sessiona matches the first item in the sequenceand matches the resta* seq [ when starred name is usedthe number of items in the target on the left need not match the length of the subject sequence in factthe starred name can appear anywhere in the target for instancein the next interaction matches the last item in the sequenceand matches everything before the last*ab seq [ when the starred name appears in the middleit collects everything between the other names listed thusin the following interaction and are assigned the first and last itemsand gets everything in between thema*bc seq [ more generallywherever the starred name shows upit will be assigned list that collects every unassigned name at that positionab* seq assignment statements |
917 | [ naturallylike normal sequence assignmentextended sequence unpacking syntax works for any sequence types (reallyagainany iterable)not just lists here it is unpacking characters in string and range (an iterable in ) * 'spamab (' '[' '' '' '] *bc 'spamabc (' '[' '' ']' ' *bc range( abc ( [ ] this is similar in spirit to slicingbut not exactly the same-- sequence unpacking assignment always returns list for multiple matched itemswhereas slicing returns sequence of the same type as the object sliceds 'spams[ ] [ :(' ''pam'slices are type-specificassignment always returns list [ ] [ : ] [ (' ''pa'' 'given this extension in xas long as we're processing list the last example of the prior section becomes even simplersince we don' have to manually slice to get the first and rest of the itemsl [ while lfront* print(frontl [ [ [ [get firstrest without slicing boundary cases although extended sequence unpacking is flexiblesome boundary cases are worth noting firstthe starred name may match just single itembut is always assigned listseq [ assignmentsexpressionsand prints |
918 | print(abcd [ secondif there is nothing left to match the starred nameit is assigned an empty listregardless of where it appears in the followingabcand have matched every item in the sequencebut python assigns an empty list instead of treating this as an error caseabcd* seq print(abcde [ab*ecd seq print(abcde [finallyerrors can still be triggered if there is more than one starred nameif there are too few values and no star (as before)and if the starred name is not itself coded inside sequencea*bc* seq syntaxerrortwo starred expressions in assignment ab seq valueerrortoo many values to unpack (expected * seq syntaxerrorstarred assignment target must be in list or tuple *aseq [ useful convenience keep in mind that extended sequence unpacking assignment is just convenience we can usually achieve the same effects with explicit indexing and slicing (and in fact must in python )but extended unpacking is simpler to code the common "firstrestsplitting coding patternfor examplecan be coded either waybut slicing involves extra workseq [ * seq ab ( [ ]firstrest ab seq[ ]seq[ :ab ( [ ]firstresttraditional assignment statements |
919 | the new extended unpacking syntax requires noticeably fewer keystrokes*ab seq ab ([ ] restlast ab seq[:- ]seq[- ab ([ ] restlasttraditional because it is not only simpler butarguablymore naturalextended sequence unpacking syntax will likely become widespread in python code over time application to for loops because the loop variable in the for loop statement can be any assignment targetextended sequence assignment works here too we met the for loop iteration tool briefly in and will study it formally in in python xextended assignments may show up after the word forwhere simple variable name is more commonly usedfor ( *bcin [( )( )]when used in this contexton each iteration python simply assigns the next tuple of values to the tuple of names on the first loopfor exampleit' as if we' run the following assignment statementa*bc ( gets [ the names aband can be used within the loop' code to reference the extracted components in factthis is really not special case at allbut just an instance of general assignment at work as we saw earlier in this we can do the same thing with simple tuple assignment in both python and xfor (abcin [( )( )]abc ( )and we can always emulate ' extended assignment behavior in by manually slicingfor all in [( )( )]abc all[ ]all[ : ]all[ since we haven' learned enough to get more detailed about the syntax of for loopswe'll return to this topic in multiple-target assignments multiple-target assignment simply assigns all the given names to the object all the way to the right the followingfor exampleassigns the three variables aband to the string 'spam' assignmentsexpressionsand prints |
920 | abc ('spam''spam''spam'this form is equivalent to (but easier to code thanthese three assignmentsc 'spamb multiple-target assignment and shared references keep in mind that there is just one object hereshared by all three variables (they all wind up pointing to the same object in memorythis behavior is fine for immutable types--for examplewhen initializing set of counters to zero (recall that variables must be assigned before they can be used in pythonso you must initialize counters to zero before you can start adding to them) ab ( herechanging only changes because numbers do not support in-place changes as long as the object assigned is immutableit' irrelevant if more than one name references it as usualthoughwe have to be more cautious when initializing variables to an empty mutable object such as list or dictionarya [ append( ab ([ ][ ]this timebecause and reference the same objectappending to it in place through will impact what we see through as well this is really just another example of the shared reference phenomenon we first met in to avoid the issueinitialize mutable objects in separate statements insteadso that each creates distinct empty object by running distinct literal expressiona [ [ append( ab ([][ ] and do not share the same object tuple assignment like the following has the same effect--by running two list expressionsit creates two distinct objectsab [][ and do not share the same object assignment statements |
921 | beginning with python the set of additional assignment statement formats listed in table - became available known as augmented assignmentsand borrowed from the languagethese formats are mostly just shorthand they imply the combination of binary expression and an assignment for instancethe following two formats are roughly equivalenttraditional form newer augmented form + table - augmented assignment statements + & - | * ^ / >> % << ** // augmented assignment works on any type that supports the implied binary expression for examplehere are two ways to add to namex + traditional augmented when applied to sequence such as stringthe augmented form performs concatenation instead thusthe second line here is equivalent to typing the longer "spam" "spams +"spams 'spamspamimplied concatenation as shown in table - there are analogous augmented assignment forms for every python binary expression operator ( each operator with values on the left and right sidefor instancex * multiplies and assignsx >> shifts right and assignsand so on // (for floor divisionwas added in version augmented assignments have three advantages: there' less for you to type need say morethe left side has to be evaluated only once in +yx may be complicated object expression in the augmented formits code must be run only once howeverin / +programmers take notealthough python now supports statements like +yit still does not have ' auto-increment/decrement operators ( ++--xthese don' quite map to the python object model because python has no notion of in-place changes to immutable objects like numbers assignmentsexpressionsand prints |
922 | augmented assignments usually run faster the optimal technique is automatically chosen that isfor objects that support in-place changesthe augmented forms automatically perform in-place change operations instead of slower copies the last point here requires bit more explanation for augmented assignmentsinplace operations may be applied for mutable objects as an optimization recall that lists can be extended in variety of ways to add single item to the end of listwe can concatenate or call appendl [ [ [ append( [ concatenateslower fasterbut in place and to add set of items to the endwe can either concatenate again or call the list extend method: [ [ extend([ ] [ concatenateslower fasterbut in place in both casesconcatenation is less prone to the side effects of shared object references but will generally run slower than the in-place equivalent concatenation operations must create new objectcopy in the list on the leftand then copy in the list on the right by contrastin-place method calls simply add items at the end of memory block (it can be bit more complicated than that internallybut this description sufficeswhen we use augmented assignment to extend listwe can largely forget these details --python automatically calls the quicker extend method instead of using the slower concatenation operation implied by + +[ mapped to extend([ ] [ note howeverthat because of this equivalence +for list is not exactly the same as and in all cases--for lists +allows arbitrary sequences (just like extend)but concatenation normally does notl [ +'spam+and extend allow any sequencebut does not as suggested in we can also use slice assignment ( [len( ):[ , , ])but this works roughly the same as the simpler and more mnemonic list extend method assignment statements |
923 | [' '' '' '' ' 'spamtypeerrorcan only concatenate list (not "str"to list augmented assignment and shared references this behavior is usually what we wantbut notice that it implies that the +is an inplace change for liststhusit is not exactly like concatenationwhich always makes new object as for all shared reference casesthis difference might matter if other names reference the object being changedl [ [ lm ([ ][ ] [ +[ lm ([ ][ ] and reference the same object concatenation makes new object changes but not but +really means extend sees the in-place change toothis only matters for mutables like lists and dictionariesand it is fairly obscure case (at leastuntil it impacts your code!as alwaysmake copies of your mutable objects if you need to break the shared reference structure variable name rules now that we've explored assignment statementsit' time to get more formal about the use of variable names in pythonnames come into existence when you assign values to thembut there are few rules to follow when choosing names for the subjects of your programssyntax(underscore or letter(any number of lettersdigitsor underscoresvariable names must start with an underscore or letterwhich can be followed by any number of lettersdigitsor underscores _spamspamand spam_ are legal namesbut _spamspam$and @#are not case mattersspam is not the same as spam python always pays attention to case in programsboth in names you create and in reserved words for instancethe names and refer to two different variables for portabilitycase also matters in the names of imported module fileseven on platforms where the filesystems are case-insensitive that wayyour imports still work after programs are copied to differing platforms reserved words are off-limits names you define cannot be the same as words that mean special things in the python language for instanceif you try to use variable name like classpython assignmentsexpressionsand prints |
924 | that are currently reserved (and hence off-limits for names of your ownin python table - python reserved words false class finally is return none continue for lambda try true def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise table - is specific to python in python xthe set of reserved words differs slightlyprint is reserved wordbecause printing is statementnot built-in function (more on this later in this exec is reserved wordbecause it is statementnot built-in function nonlocal is not reserved word because this statement is not available in older pythons the story is also more or less the samewith few variationswith and as were not reserved until when context managers were officially enabled yield was not reserved until python when generator functions came online yield morphed from statement to expression in but it' still reserved wordnot built-in function as you can seemost of python' reserved words are all lowercase they are also all truly reserved--unlike names in the built-in scope that you will meet in the next part of this bookyou cannot redefine reserved words by assignment ( and results in syntax error besides being of mixed casethe first three entries in table - truefalseand noneare somewhat unusual in meaning--they also appear in the built-in scope of python described in and they are technically names assigned to objects in they are truly reserved in all other sensesthoughand cannot be used for any other purpose in your script other than that of the objects they represent all the other reserved words are hardwired into python' syntax and can appear only in the specific contexts for which they are intended in standard cpythonat least alternative implementations of python might allow user-defined variable names to be the same as python reserved words see for an overview of alternative implementationssuch as jython assignment statements |
925 | scriptsvariable name constraints extend to your module filenames too for instanceyou can code files called and py and my-code py and run them as top-level scriptsbut you cannot import themtheir names without the pyextension become variables in your code and so must follow all the variable rules just outlined reserved words are off-limitsand dashes won' workthough underscores will we'll revisit this module idea in part of this book python' deprecation protocol it is interesting to note how reserved word changes are gradually phased into the language when new feature might break existing codepython normally makes it an option and begins issuing "deprecationwarnings one or more releases before the feature is officially enabled the idea is that you should have ample time to notice the warnings and update your code before migrating to the new release this is not true for major new releases like (which breaks existing code freely)but it is generally true in other cases for exampleyield was an optional extension in python but is standard keyword as of it is used in conjunction with generator functions this was one of small handful of instances where python broke with backward compatibility stillyield was phased in over timeit began generating deprecation warnings in and was not enabled until similarlyin python the words with and as become new reserved words for use in context managers ( newer form of exception handlingthese two words are not reserved in unless the context manager feature is turned on manually with from__future__import (discussed later in this bookwhen used in with and as generate warnings about the upcoming change--except in the version of idle in python which appears to have enabled this feature for you (that isusing these words as variable names does generate errors in but only in its version of the idle guinaming conventions besides these rulesthere is also set of naming conventions--rules that are not required but are followed in normal practice for instancebecause names with two leading and trailing underscores ( __name__generally have special meaning to the python interpreteryou should avoid this pattern for your own names here is list of the conventions python followsnames that begin with single underscore (_xare not imported by from module import statement (described in names that have two leading and trailing underscores (__x__are system-defined names that have special meaning to the interpreter assignmentsexpressionsand prints |
926 | localized ("mangled"to enclosing classes (see the discussion of pseudoprivate attributes in the name that is just single underscore (_retains the result of the last expression when you are working interactively in addition to these python interpreter conventionsthere are various other conventions that python programmers usually follow for instancelater in the book we'll see that class names commonly start with an uppercase letter and module names with lowercase letterand that the name selfthough not reservedusually has special role in classes in we'll also study anotherlarger category of names known as the built-inswhich are predefined but not reserved (and so can be reassignedopen worksthough sometimes you might wish it didn' !names have no typebut objects do this is mostly reviewbut remember that it' crucial to keep python' distinction between names and objects clear as described in objects have type ( integerlistand may be mutable or not names ( variables)on the other handare always just references to objectsthey have no notion of mutability and have no associated type informationapart from the type of the object they happen to reference at given point in time thusit' ok to assign the same name to different kinds of objects at different timesx "hellox [ bound to an integer object now it' string and now it' list in later examplesyou'll see that this generic nature of names can be decided advantage in python programming in you'll also learn that names also live in something called scopewhich defines where they can be usedthe place where you assign name determines where it is visible for additional naming suggestionssee the discussion of naming conventions in python' semi-official style guideknown as pep this guide is available at web search for "python pep technicallythis document formalizes coding standards for python library code though usefulthe usual caveats about coding standards apply here for one thingpep comes with more detail than you are probably ready if you've used more restrictive language like ++you may be interested to know that there is no notion of ++' const declaration in pythoncertain objects may be immutablebut names can always be assigned python also has ways to hide names in classes and modulesbut they're not the same as ++' declarations (if hiding attributes matters to yousee the coverage of _x module names in __x class names in and the private and public class decorators example in assignment statements |
927 | rigidand subjective than it may need to be--some of its suggestions are not at all universally accepted or followed by python programmers doing real work moreoversome of the most prominent companies using python today have adopted coding standards of their own that differ pep does codify useful rule-of-thumb python knowledgethoughand it' great read for python beginnersas long as you take its recommendations as guidelinesnot gospel expression statements in pythonyou can use an expression as statementtoo--that ison line by itself but because the result of the expression won' be savedit usually makes sense to do so only if the expression does something useful as side effect expressions are commonly used as statements in two situationsfor calls to functions and methods some functions and methods do their work without returning value such functions are sometimes called procedures in other languages because they don' return values that you might be interested in retainingyou can call these functions with expression statements for printing values at the interactive prompt python echoes back the results of expressions typed at the interactive command line technicallythese are expression statementstoothey serve as shorthand for typing print statements table - lists some common expression statement forms in python calls to functions and methods are coded with zero or more argument objects (reallyexpressions that evaluate to objectsin parenthesesafter the function/method name table - common python expression statements operation interpretation spam(eggshamfunction calls spam ham(eggsmethod calls spam printing variables in the interactive interpreter print(abcsep=''printing operations in python yield * yielding expression statements the last two entries in table - are somewhat special cases--as we'll see later in this printing in python is function call usually coded on line by itselfand the yield operation in generator functions (discussed in is often coded as statement as well both are really just instances of expression statements assignmentsexpressionsand prints |
928 | statementit returns value like any other function call (its return value is nonethe default return value for functions that don' return anything meaningful) print('spam'spam print(xnone print is function call expression in but it is coded as an expression statement also keep in mind that although expressions can appear as statements in pythonstatements cannot be used as expressions statement that is not an expression must generally appear on line all by itselfnot nested in larger syntactic structure for examplepython doesn' allow you to embed assignment statements (=in other expressions the rationale for this is that it avoids common coding mistakesyou can' accidentally change variable by typing when you really mean to use the =equality test you'll see how to code around this restriction when you meet the python while loop in expression statements and in-place changes this brings up another mistake that is common in python work expression statements are often used to run list methods that change list in placel [ append( [ append is an in-place change howeverit' not unusual for python newcomers to code such an operation as an assignment statement insteadintending to assign to the larger listl append( print(lnone but append returns nonenot so we lose our listthis doesn' quite workthough calling an in-place change operation such as appendsortor reverse on list always changes the list in placebut these methods do not return the list they have changedinsteadthey return the none object thusif you assign such an operation' result back to the variable nameyou effectively lose the list (and it is probably garbage-collected in the process!the moral of the story isdon' do this--call in-place change operations without assigning their results we'll revisit this phenomenon in the section "common coding gotchason page because it can also appear in the context of some looping statements we'll meet in later expression statements |
929 | print operations in pythonprint prints things--it' simply programmer-friendly interface to the standard output stream technicallyprinting converts one or more objects to their textual representationsadds some minor formattingand sends the resulting text to either standard output or another file-like stream in bit more detailprint is strongly bound up with the notions of files and streams in pythonfile object methods in we learned about file object methods that write text ( file write(str)printing operations are similarbut more focused--whereas file write methods write strings to arbitrary filesprint writes objects to the stdout stream by defaultwith some automatic formatting added unlike with file methodsthere is no need to convert objects to strings when using print operations standard output stream the standard output stream (often known as stdoutis simply default place to send program' text output along with the standard input and error streamsit' one of three data connections created when your script starts the standard output stream is usually mapped to the window where you started your python programunless it' been redirected to file or pipe in your operating system' shell because the standard output stream is available in python as the stdout file object in the built-in sys module ( sys stdout)it' possible to emulate print with file write method calls howeverprint is noticeably easier to use and makes it easy to print text to other files and streams printing is also one of the most visible places where python and have diverged in factthis divergence is usually the first reason that most code won' run unchanged under specificallythe way you code print operations depends on which version of python you usein python xprinting is built-in functionwith keyword arguments for special modes in python xprinting is statement with specific syntax all its own because this book covers both and xwe will look at each form in turn here if you are fortunate enough to be able to work with code written for just one version of pythonfeel free to pick the section that is relevant to you because your needs may changehoweverit probably won' hurt to be familiar with both cases moreoverusers of recent python releases can also import and use ' flavor of printing in their pythons if desired--both for its extra functionality and to ease future migration to assignmentsexpressionsand prints |
930 | strictly speakingprinting is not separate statement form in insteadit is simply an instance of the expression statement we studied in the preceding section the print built-in function is normally called on line of its ownbecause it doesn' return any value we care about (technicallyit returns noneas we saw in the preceding sectionbecause it is normal functionthoughprinting in uses standard functioncall syntaxrather than special statement form and because it provides special operation modes with keyword argumentsthis form is both more general and supports future enhancements better by comparisonpython print statements have somewhat ad hoc syntax to support extensions such as end-of-line suppression and target files furtherthe statement does not support separator specification at allin xyou wind up building strings ahead of time more often than you do in rather than adding yet more ad hoc syntaxpython ' print takes singlegeneral approach that covers them all call format syntacticallycalls to the print function have the following form (the flush argument is new as of python )print([object][sep='][end='\ '][file=sys stdout][flush=false]in this formal notationitems in square brackets are optional and may be omitted in given calland values after give argument defaults in englishthis built-in function prints the textual representation of one or more objects separated by the string sep and followed by the string end to the stream fileflushing buffered output or not per flush the sependfileand (in and laterflush partsif presentmust be given as keyword arguments--that isyou must use special "name=valuesyntax to pass the arguments by name instead of position keyword arguments are covered in depth in but they're straightforward to use the keyword arguments sent to this call may appear in any left-to-right order following the objects to be printedand they control the print operationsep is string inserted between each object' textwhich defaults to single space if not passedpassing an empty string suppresses separators altogether end is string added at the end of the printed textwhich defaults to \ newline character if not passed passing an empty string avoids dropping down to the next output line at the end of the printed text--the next print will keep adding to the end of the current output line file specifies the filestandard streamor other file-like object to which the text will be sentit defaults to the sys stdout standard output stream if not passed any object with file-like write(stringmethod may be passedbut real files should be already opened for output print operations |
931 | flushed through the output stream immediately to any waiting recipients normallywhether printed output is buffered in memory or not is determined by filepassing true value to flush forcibly flushes the stream the textual representation of each object to be printed is obtained by passing the object to the str built-in call (or its equivalent inside python)as we've seenthis built-in returns "user friendlydisplay string for any object with no arguments at allthe print function simply prints newline character to the standard output streamwhich usually displays blank line the print function in action printing in is probably simpler than some of its details may imply to illustratelet' run some quick examples the following prints variety of object types to the default standard output streamwith the default separator and end-of-line formatting added (these are the defaults because they are the most common use case) :\codec:\python \python print( 'spamy ['eggs'print(xyzspam ['eggs'display blank line print three objects per defaults there' no need to convert objects to strings hereas would be required for file write methods by defaultprint calls add space between the objects printed to suppress thissend an empty string to the sep keyword argumentor send an alternative separator of your choosingprint(xyzsep=''spam ['eggs'print(xyzsep=''spam ['eggs'suppress separator custom separator also by defaultprint adds an end-of-line character to terminate the output line you can suppress this and avoid the line break altogether by passing an empty string to the end keyword argumentor you can pass different terminator of your own including \ character to break the line manually if desired (the second of the following is two statements on one lineseparated by semicolon) technicallyprinting uses the equivalent of str in the internal implementation of pythonbut the effect is the same besides this to-string conversion rolestr is also the name of the string data type and can be used to decode unicode strings from raw bytes with an extra encoding argumentas we'll learn in this latter role is an advanced usage that we can safely ignore here assignmentsexpressionsand prints |
932 | spam ['eggs'print(xyzend='')print(xyzspam ['eggs']spam ['eggs'print(xyzend=\ 'spam ['eggs'suppress line break two printssame output line custom line end you can also combine keyword arguments to specify both separators and end-of-line strings--they may appear in any order but must appear after all the objects being printedprint(xyzsep='end='!\ 'spam ['eggs']print(xyzend='!\ 'sep='spam ['eggs']multiple keywords order doesn' matter here is how the file keyword argument is used--it directs the printed text to an open output file or other compatible object for the duration of the single print (this is really form of stream redirectiona topic we will revisit later in this section)print(xyzsep='file=open('data txt'' ')print(xyzspam ['eggs'print(open('data txt'read()spam ['eggs'print to file back to stdout display file text finallykeep in mind that the separator and end-of-line options provided by print operations are just conveniences if you need to display more specific formattingdon' print this way insteadbuild up more complex string ahead of time or within the print itself using the string tools we met in and print the string all at oncetext '% % % ('result' print(textresult print('% % % ('result' )result as we'll see in the next sectionalmost everything we've just seen about the print function also applies directly to print statements--which makes sensegiven that the function was intended to both emulate and improve upon printing support the python print statement as mentioned earlierprinting in python uses statement with unique and specific syntaxrather than built-in function in practicethough printing is mostly variation on themewith the exception of separator strings (which are supported in but not xand flushes on prints (available as of only)everything we can do with the print function has direct translation to the print statement print operations |
933 | table - lists the print statement' forms in python and gives their python print function equivalents for reference notice that the comma is significant in print statements--it separates objects to be printedand trailing comma suppresses the end-of-line character normally added at the end of the printed text (not to be confused with tuple syntax!the >syntaxnormally used as bitwise right-shift operationis used here as wellto specify target output stream other than the sys stdout default table - python print statement forms python statement python equivalent interpretation print xy print(xyprint objectstextual forms to sys stdoutadd space between the items and an end-of-line at the end print xyprint(xyend=''samebut don' add end-of-line at end of text print >afilexy print(xyfile=afilesend text to afile writenot to sys stdout write the print statement in action although the print statement has more unique syntax than the functionit' similarly easy to use let' turn to some basic examples again the print statement adds space between the items separated by commas and by default adds line break at the end of the current output linec:\codec:\python \python 'ay 'bprint xy this formatting is just defaultyou can choose to use it or not to suppress the line break so you can add more text to the current line laterend your print statement with commaas shown in the second line of table - (the following uses semicolon to separate two statements on one line again)print xy,print xy to suppress the space between itemsagaindon' print this way insteadbuild up an output string using the string concatenation and formatting tools covered in and print the string all at onceprint ab print '% % (xya assignmentsexpressionsand prints |
934 | are roughly as simple to use as ' function the next section uncovers the way that files are specified in prints print stream redirection in both python and xprinting sends text to the standard output stream by default howeverit' often useful to send it elsewhere--to text filefor exampleto save results for later use or testing purposes although such redirection can be accomplished in system shells outside python itselfit turns out to be just as easy to redirect script' streams from within the script the python "hello worldprogram let' start off with the usual (and largely pointlesslanguage benchmark--the "hello worldprogram to print "hello worldmessage in pythonsimply print the string per your version' print operationprint('hello world'hello world print string object in print 'hello worldhello world print string object in because expression results are echoed on the interactive command lineyou often don' even need to use print statement there--simply type the expressions you' like to have printedand their results are echoed back'hello world'hello worldinteractive echoes this code isn' exactly an earth-shattering piece of software masterybut it serves to illustrate printing behavior reallythe print operation is just an ergonomic feature of python--it provides simple interface to the sys stdout objectwith bit of default formatting in factif you enjoy working harder than you mustyou can also code print operations this wayimport sys printing the hard way sys stdout write('hello world\ 'hello world this code explicitly calls the write method of sys stdout--an attribute preset when python starts up to an open file object connected to the output stream the print operation hides most of those detailsproviding simple tool for simple printing tasks manual stream redirection sowhy did just show you the hard way to printthe sys stdout print equivalent turns out to be the basis of common technique in python in generalprint and sys stdout are directly related as follows this statementprint operations |
935 | orin xprint xy is equivalent to the longerimport sys sys stdout write(str(xstr( '\ 'which manually performs string conversion with stradds separator and newline with +and calls the output stream' write method which would you rather code(he sayshoping to underscore the programmer-friendly nature of prints obviouslythe long form isn' all that useful for printing by itself howeverit is useful to know that this is exactly what print operations do because it is possible to reassign sys stdout to something different from the standard output stream in other wordsthis equivalence provides way of making your print operations send their text to other places for exampleimport sys sys stdout open('log txt'' 'print(xyxredirects prints to file shows up in log txt herewe reset sys stdout to manually opened file named log txtlocated in the script' working directory and opened in append mode (so we add to its current contentafter the resetevery print operation anywhere in the program will write its text to the end of the file log txt instead of to the original output stream the print operations are happy to keep calling sys stdout' write methodno matter what sys stdout happens to refer to because there is just one sys module in your processassigning sys stdout this way will redirect every print anywhere in your program in factas the sidebar "why you will careprint and stdouton page will explainyou can even reset sys stdout to an object that isn' file at allas long as it has the expected interfacea method named write to receive the printed text string argument when that object is classprinted text can be routed and processed arbitrarily per write method you code yourself this trick of resetting the output stream might be more useful for programs originally coded with print statements if you know that output should go to file to begin withyou can always call file write methods instead to redirect the output of print-based programthoughresetting sys stdout provides convenient alternative to changing every print statement or using system shell-based redirection syntax in other rolesstreams may be reset to objects that display them in pop-up windows in guiscolorize then in ides like idleand so on it' general technique automatic stream redirection although redirecting printed text by assigning sys stdout is useful toola potential problem with the last section' code is that there is no direct way to restore the original output stream should you need to switch back after printing to file because assignmentsexpressionsand prints |
936 | needed: :\codec:\python \python import sys temp sys stdout sys stdout open('log txt'' 'print('spam'print( sys stdout close(sys stdout temp print('back here'back here print(open('log txt'read()spam save for restoring later redirect prints to file prints go to filenot here flush output to disk restore original stream prints show up here again result of earlier prints as you can seethoughmanual saving and restoring of the original output stream like this involves quite bit of extra work because this crops up fairly oftena print extension is available to make it unnecessary in xthe file keyword allows single print call to send its text to the write method of file (or file-like object)without actually resetting sys stdout because the redirection is temporarynormal print calls keep printing to the original output stream in xa print statement that begins with >followed by an output file object (or other compatible objecthas the same effect for examplethe following again sends printed text to file named log txtlog open('log txt'' 'print(xyzfile=logprint(abc print to file-like object print to original stdout log open('log txt'' 'print >logxyz print abc print to file-like object print to original stdout these redirected forms of print are handy if you need to print to both files and the standard output stream in the same program if you use these formshoweverbe sure to give them file object (or an object that has the same write method as file object)not file' name string here is the technique in actionc:\codec:\python \python log open('log txt'' 'print( file=logprint( file=loglog close(print( for xprint >log for xprint in both and you may also be able to use the __stdout__ attribute in the sys modulewhich refers to the original value sys stdout had at program startup time you still need to restore sys stdout to sys __stdout__ to go back to this original stream valuethough see the sys module documentation for more details print operations |
937 | print(open('log txt'read() these extended forms of print are also commonly used to print error messages to the standard error streamavailable to your script as the preopened file object sys stderr you can either use its file write methods and format the output manuallyor print with redirection syntaximport sys sys stderr write(('bad! '\ 'bad!bad!bad!bad!bad!bad!bad!badprint('bad! file=sys stderrbad!bad!bad!bad!bad!bad!bad!badin xprint >sys stderr'bad! now that you know all about print redirectionsthe equivalence between printing and file write methods should be fairly obvious the following interaction prints both ways in xthen redirects the output to an external file to verify that the same text is printedx print(xy import sys sys stdout write(str(xstr( '\ ' print(xyfile=open('temp '' ')printthe easy way printthe hard way redirect text to file open('temp '' 'write(str(xstr( '\ 'send to file manually print(open('temp ''rb'read()binary mode for bytes ' \ \nprint(open('temp ''rb'read() ' \ \nas you can seeunless you happen to enjoy typingprint operations are usually the best option for displaying text for another example of the equivalence between prints and file writeswatch for print function emulation example in it uses this code pattern to provide general print function equivalent for use in python version-neutral printing finallyif you need your prints to work on both python linesyou have some options this is true whether you're writing code that strives for compatibilityor code that aims to support too to converter for oneyou can code print statements and let ' to conversion script translate them to function calls automatically see the python manuals for more details assignmentsexpressionsand prints |
938 | perhaps more than you want to make just your print operations version-neutral related tool named to attempts to do the inverseconvert code to run on xsee appendix for more information importing from __future__ alternativelyyou can code print function calls in code to be run by xby enabling the function call variant with statement like the following coded at the top of scriptor anywhere in an interactive sessionfrom __future__ import print_function this statement changes to support ' print functions exactly this wayyou can use print features and won' have to change your prints if you later migrate to two usage notes herethis statement is simply ignored if it appears in code run by --it doesn' hurt if included in code for compatibility this statement must appear at the top of each file that prints in --because it modifies that parser for single file onlyit' not enough to import another file that includes this statement neutralizing display differences with code also keep in mind that simple printslike those in the first row of table - work in either version of python--because any expression may be enclosed in parentheseswe can always pretend to be calling print function in by adding outer parentheses the main downside to this is that it makes tuple out of your printed objects if there are more than oneor none--they will print with extra enclosing parentheses in xfor exampleany number of objects may be listed in the call' parenthesesc:\codec:\python \python print('spam'spam print('spam''ham''eggs'spam ham eggs print function call syntax these are multiple arguments the first of these works the same in xbut the second generates tuple in the outputc:\codec:\python \python print('spam'spam print('spam''ham''eggs'('spam''ham''eggs' print statementenclosing parens this is really tuple objectthe same applies when there are no objects printed to force line-feed shows tupleunless you print an empty stringc:\codepy - >print(this is just line-feed on print operations |
939 | print(''this is line-feed in both and strictly speakingoutputs may in some cases differ in more than just extra enclosing parentheses in if you look closely at the preceding resultsyou'll notice that the strings also print with enclosing quotes in only this is because objects may print differently when nested in another object than they do as top-level items technicallynested appearances display with repr and top-level objects with str--the two alternative display formats we noted in here this just means extra quotes around strings nested in the tuple that is created for printing multiple parenthesized items in displays of nested objects can differ much more for other object typesthoughand especially for class objects that define alternative displays with operator overloading-- topic we'll cover in part vi in general and in particular to be truly portable without enabling prints everywhereand to sidestep display difference for nested appearancesyou can always format the print string as single object to unify displays across versionsusing the string formatting expression or method callor other string tools that we studied in print('% % % ('spam''ham''eggs')spam ham eggs print('{ { { }format('spam''ham''eggs')spam ham eggs print('answerstr( )answer of courseif you can use exclusively you can forget such mappings entirelybut many python programmers will at least encounterif not write code and systems for some time to come we'll use both __future__ and version-neutral code to achieve / portability in many examples in this book use python print function calls throughout this book 'll often make prints version-neutraland will usually warn you when the results may differ in xbut sometimes don'tso please consider this note blanket warning if you see extra parentheses in your printed text in xeither drop the parentheses in your print statementsimport prints from the __future__recode your prints using the version-neutral scheme outlined hereor learn to love superfluous text why you will careprint and stdout the equivalence between the print operation and writing to sys stdout is important it makes it possible to reassign sys stdout to any user-defined object that provides the same write method as files because the print statement just sends text to the sys stdout write methodyou can capture printed text in your programs by assigning sys stdout to an object whose write method processes the text in arbitrary ways assignmentsexpressionsand prints |
940 | destinationsby defining an object with write method that does the required routing you'll see an example of this trick when we study classes in part vi of this bookbut abstractlyit looks like thisclass filefakerdef write(selfstring)do something with printed text in string import sys sys stdout filefaker(print(someobjectssends to class write method this works because print is what we will call in the next part of this book polymorphic operation--it doesn' care what sys stdout isonly that it has method ( interfacecalled write this redirection to objects is made even simpler with the file keyword argument in and the >extended form of print in xbecause we don' need to reset sys stdout explicitly--normal prints will still be routed to the stdout streammyobj filefaker( xredirect to object for one print print(someobjectsfile=myobjdoes not reset sys stdout myobj filefaker(print >myobjsomeobjects xsame effect does not reset sys stdout python' ' built-in input function (named raw_input in xreads from the sys stdin fileso you can intercept read requests in similar wayusing classes that implement file-like read methods instead see the input and while loop example in for more background on this function notice that because printed text goes to the stdout streamit' also the way to print html reply pages in cgi scripts used on the weband enables you to redirect python script input and output at the operating system' shell command line as usualpython script py outputfile python script py filterprogram python' print operation redirection tools are essentially pure-python alternatives to these shell syntax forms see other resources for more on cgi scripts and shell syntax summary in this we began our in-depth look at python statements by exploring assignmentsexpressionsand print operations although these are generally simple to usethey have some alternative forms thatwhile optionalare often convenient in practice --augmented assignment statements and the redirection form of print operationsfor exampleallow us to avoid some manual coding work along the waywe also studied the syntax of variable namesstream redirection techniquesand variety of common mistakes to avoidsuch as assigning the result of an append method call back to variable summary |
941 | if statementpython' main selection tooltherewe'll also revisit python' syntax model in more depth and look at the behavior of boolean expressions before we move onthoughthe end-of-quiz will test your knowledge of what you've learned here test your knowledgequiz name three ways that you can assign three variables to the same value why might you need to care when assigning three variables to mutable object what' wrong with saying sort() how might you use the print operation to send text to an external filetest your knowledgeanswers you can use multiple-target assignments ( )sequence assignment (abc )or multiple assignment statements on three separate lines ( and with the latter techniqueas introduced in you can also string the three separate statements together on the same line by separating them with semicolons ( if you assign them this waya [all three names reference the same objectso changing it in place from one ( append( )will affect the others this is true only for in-place changes to mutable objects like lists and dictionariesfor immutable objects such as numbers and stringsthis issue is irrelevant the list sort method is like append in that it makes an in-place change to the subject list--it returns nonenot the list it changes the assignment back to sets to nonenot to the sorted list as discussed both earlier and later in this book ( ) newer built-in functionsortedsorts any sequence and returns new list with the sorting resultbecause this is not an in-place changeits result can be meaningfully assigned to name to print to file for single print operationyou can use ' print(xfile=fcall formuse ' extended print >filex statement formor assign sys stdout to manually opened file before the print and restore the original after you can also redirect all of program' printed text to file with special syntax in the system shellbut this is outside python' scope assignmentsexpressionsand prints |
942 | if tests and syntax rules this presents the python if statementwhich is the main statement used for selecting from alternative actions based on test results because this is our first in-depth look at compound statements--statements that embed other statements--we will also explore the general concepts behind the python statement syntax model here in more detail than we did in the introduction in because the if statement introduces the notion of teststhis will also deal with boolean expressionscover the "ternaryif expressionand fill in some details on truth tests in general if statements in simple termsthe python if statement selects actions to perform along with its expression counterpartit' the primary selection tool in python and represents much of the logic python program possesses it' also our first compound statement like all compound python statementsthe if statement may contain other statementsincluding other ifs in factpython lets you combine statements in program sequentially (so that they execute one after another)and in an arbitrarily nested fashion (so that they execute only under certain conditions such as selections and loopsgeneral format the python if statement is typical of if statements in most procedural languages it takes the form of an if testfollowed by one or more optional elif ("else if"tests and final optional else block the tests and the else part each have an associated block of nested statementsindented under header line when the if statement runspython executes the block of code associated with the first test that evaluates to trueor the else block if all tests prove false the general form of an if statement looks like thisif test statements elif test statements if test associated block optional elifs |
943 | statements optional else basic examples to demonstratelet' look at few simple examples of the if statement at work all parts are optionalexcept the initial if test and its associated statements thusin the simplest casethe other parts are omittedif print('true'true notice how the prompt changes to for continuation lines when you're typing interactively in the basic interface used herein idleyou'll simply drop down to an indented line instead (hit backspace to back upa blank line (which you can get by pressing enter twiceterminates and runs the entire statement remember that is boolean true (as we'll see laterthe word true is its equivalent)so this statement' test always succeeds to handle false resultcode the elseif not print('true'elseprint('false'false multiway branching now here' an example of more complex if statementwith all its optional parts presentx 'killer rabbitif ='roger'print("shave and haircut"elif ='bugs'print("what' up doc?"elseprint('run awayrun away!'run awayrun awaythis multiline statement extends from the if line through the block nested under the else when it' runpython executes the statements nested under the first test that is trueor the else part if all tests are false (in this examplethey arein practiceboth the elif and else parts may be omittedand there may be more than one statement nested in each section note that the words ifelifand else are associated by the fact that they line up verticallywith the same indentation if tests and syntax rules |
944 | is no switch or case statement in python that selects an action based on variable' value insteadyou usually code multiway branching as series of if/elif testsas in the prior exampleand occasionally by indexing dictionaries or searching lists because dictionaries and lists can be built at runtime dynamicallythey are sometimes more flexible than hardcoded if logic in your scriptchoice 'hamprint({'spam' dictionary-based 'switch'ham' use has_key or get for default 'eggs' 'bacon' }[choice] although it may take few moments for this to sink in the first time you see itthis dictionary is multiway branch--indexing on the key choice branches to one of set of valuesmuch like switch in an almost equivalent but more verbose python if statement might look like the followingif choice ='spam'print( elif choice ='ham'print( elif choice ='eggs'print( elif choice ='bacon'print( elseprint('bad choice' the equivalent if statement though it' perhaps more readablethe potential downside of an if like this is thatshort of constructing it as string and running it with tools like the prior eval or execyou cannot construct it at runtime as easily as dictionary in more dynamic programsdata structures offer added flexibility handling switch defaults notice the else clause on the if here to handle the default case when no key matches as we saw in dictionary defaults can be coded with in expressionsget method callsor exception catching with the try statement introduced in the preceding all of the same techniques can be used here to code default action in dictionary-based multiway branch as review in the context of this use casehere' the get scheme at work with defaultsbranch {'spam' 'ham' 'eggs' print(branch get('spam''bad choice') if statements |
945 | bad choice an in membership test in an if statement can have the same default effectchoice 'baconif choice in branchprint(branch[choice]elseprint('bad choice'bad choice and the try statement is general way to handle defaults by catching and handling the exceptions they' otherwise trigger (for more on exceptionssee ' overview and part vii' full treatment)tryprint(branch[choice]except keyerrorprint('bad choice'bad choice handling larger actions dictionaries are good for associating values with keysbut what about the more complicated actions you can code in the statement blocks associated with if statementsin part ivyou'll learn that dictionaries can also contain functions to represent more complex branch actions and implement general jump tables such functions appear as dictionary valuesthey may be coded as function names or inline lambdasand they are called by adding parentheses to trigger their actions here' an abstract samplerbut stay tuned for rehash of this topic in after we've learned more about function definitiondef function()def default()branch {'spam'lambda'ham'function'eggs'lambdaa table of callable function objects branch get(choicedefault)(although dictionary-based multiway branching is useful in programs that deal with more dynamic datamost programmers will probably find that coding an if statement is the most straightforward way to perform multiway branching as rule of thumb in codingwhen in doubterr on the side of simplicity and readabilityit' the "pythonicway if tests and syntax rules |
946 | introduced python' syntax model in now that we're stepping up to larger statements like ifthis section reviews and expands on the syntax ideas introduced earlier in generalpython has simplestatement-based syntax howeverthere are few properties you need to know aboutstatements execute one after anotheruntil you say otherwise python normally runs statements in file or nested block in order from first to last as sequencebut statements like if (as well as loops and exceptionscause the interpreter to jump around in your code because python' path through program is called the control flowstatements such as if that affect it are often called controlflow statements block and statement boundaries are detected automatically as we've seenthere are no braces or "begin/enddelimiters around blocks of code in pythoninsteadpython uses the indentation of statements under header to group the statements in nested block similarlypython statements are not normally terminated with semicolonsratherthe end of line usually marks the end of the statement coded on that line as special casestatements can span lines and be combined on line with special syntax compound statements header ":indented statements all python compound statements--those with nested statements--follow the same patterna header line terminated with colonfollowed by one or more nested statementsusually indented under the header the indented statements are called block (or sometimesa suitein the if statementthe elif and else clauses are part of the ifbut they are also header lines with nested blocks of their own as special caseblocks can show up on the same line as the header if they are simple noncompound code blank linesspacesand comments are usually ignored blank lines are both optional and ignored in files (but not at the interactive promptwhen they terminate compound statementsspaces inside statements and expressions are almost always ignored (except in string literalsand when used for indentationcomments are always ignoredthey start with character (not inside string literaland extend to the end of the current line docstrings are ignored but are saved and displayed by tools python supports an additional comment form called documentation strings (docstrings for short)whichunlike commentsare retained at runtime for inspection docstrings are simply strings that show up at the top of program files and some statements python ignores their contentsbut they are automatically attached to objects at runtime and may be displayed with documentation tools like pydoc docstrings are part of python' larger documentation strategy and are covered in the last in this part of the book python syntax revisited |
947 | and ends with either statement that is indented lessor the end of the file as you've seenthere are no variable type declarations in pythonthis fact alone makes for much simpler language syntax than what you may be used to howeverfor most new users the lack of the braces and semicolons used to mark blocks and statements in many other languages seems to be the most novel syntactic feature of pythonso let' explore what this means in more detail block delimitersindentation rules as introduced in python detects block boundaries automaticallyby line indentation--that isthe empty space to the left of your code all statements indented the same distance to the right belong to the same block of code in other wordsthe statements within block line up verticallyas in column the block ends when the end of the file or lesser-indented line is encounteredand more deeply nested blocks are simply indented further to the right than the statements in the enclosing block compound statement bodies can appear on the header' line in some cases we'll explore laterbut most are indented under it for instancefigure - demonstrates the block structure of the following codex if xy if yprint('block 'print('block 'print('block 'this code contains three blocksthe first (the top-level code of the fileis not indented at allthe second (within the outer if statementis indented four spacesand the third (the print statement under the nested ifis indented eight spaces if tests and syntax rules |
948 | in any columnindentation may consist of any number of spaces and tabsas long as it' the same for all the statements in given single block that ispython doesn' care how you indent your codeit only cares that it' done consistently four spaces or one tab per indentation level are common conventionsbut there is no absolute standard in the python world indenting code is quite natural in practice for examplethe following (arguably sillycode snippet demonstrates common indentation errors in python codex 'spamif 'rubberyin 'shrubbery'print( +'niif endswith('ni') * print(xerrorfirst line indented errorunexpected indentation errorinconsistent indentation the properly indented version of this code looks like the following--even for an artificial example like thisproper indentation makes the code' intent much more apparentx 'spamif 'rubberyin 'shrubbery'print( +'niif endswith('ni') * print(xprints "spamprints "spamnispamniit' important to know that the only major place in python where whitespace matters is where it' used to the left of your codefor indentationin most other contextsspace can be coded or not howeverindentation is really part of python syntaxnot just stylistic suggestionall the statements within any given single block must be indented to the same levelor python reports syntax error this is intentional--because you don' need to explicitly mark the start and end of nested block of codesome of the syntactic clutter found in other languages is unnecessary in python as described in making indentation part of the syntax model also enforces consistencya crucial component of readability in structured programming languages like python python' syntax is sometimes described as "what you see is what you get--the indentation of each line of code unambiguously tells readers what it is associated with this uniform and consistent appearance makes python code easier to maintain and reuse indentation is simpler in practice than its details might initially implyand it makes your code reflect its logical structure consistently indented code always satisfies python' rules moreovermost text editors (including idlemake it easy to follow python' indentation model by automatically indenting code as you type it python syntax revisited |
949 | one rule of thumbalthough you can use spaces or tabs to indentit' usually not good idea to mix the two within block--use one or the other technicallytabs count for enough spaces to move the current column number up to multiple of and your code will work if you mix tabs and spaces consistently howeversuch code can be difficult to change worsemixing tabs and spaces makes your code difficult to read completely apart from python' syntax rules--tabs may look very different in the next programmer' editor than they do in yours in factpython issues an errorfor these very reasonswhen script mixes tabs and spaces for indentation inconsistently within block (that isin way that makes it dependent on tab' equivalent in spacespython allows such scripts to runbut it has - command-line flag that will warn you about inconsistent tab usage and -tt flag that will issue errors for such code (you can use these switches in command line like python - main py in system shell windowpython ' error case is equivalent to ' -tt switch statement delimiterslines and continuations statement in python normally ends at the end of the line on which it appears when statement is too long to fit on single linethougha few special rules may be used to make it span multiple linesstatements may span multiple lines if you're continuing an open syntactic pair python lets you continue typing statement on the next line if you're coding something enclosed in (){}or [pair for instanceexpressions in parentheses and dictionary and list literals can span any number of linesyour statement doesn' end until the python interpreter reaches the line on which you type the closing part of the pair ( )}or ]continuation lines--lines and beyond of the statement --can start at any indentation level you likebut you should try to make them align vertically for readability if possible this open pairs rule also covers set and dictionary comprehensions in python and statements may span multiple lines if they end in backslash this is somewhat outdated feature that' not generally recommendedbut if statement needs to span multiple linesyou can also add backslash ( not embedded in string literal or commentat the end of the prior line to indicate you're continuing on the next line because you can also continue by adding parentheses around most constructsbackslashes are rarely used today this approach is also error-proneaccidentally forgetting usually generates syntax error and might even cause the next line to be silently mistaken ( without warningfor new statementwith unexpected results special rules for string literals as we learned in triple-quoted string blocks are designed to span multiple lines normally we also learned in that adjacent string literals are implicitly concatenatedwhen it' used in if tests and syntax rules |
950 | parentheses allows it to span multiple lines other rules there are few other points to mention with regard to statement delimiters although it is uncommonyou can terminate statement with semicolon--this convention is sometimes used to squeeze more than one simple (noncompoundstatement onto single line alsocomments and blank lines can appear anywhere in filecomments (which begin with characterterminate at the end of the line on which they appear few special cases here' what continuation line looks like using the open syntactic pairs rule just described delimited constructssuch as lists in square bracketscan span across any number of linesl ["good""bad""ugly"open pairs may span lines this also works for anything in parentheses (expressionsfunction argumentsfunction headerstuplesand generator expressions)as well as anything in curly braces (dictionaries andin and set literals and set and dictionary comprehensionssome of these are tools we'll study in later but this rule naturally covers most constructs that span lines in practice if you like using backslashes to continue linesyou canbut it' not common practice in pythonif = and = and = and =gprint('olde'backslashes allow continuations because any expression can be enclosed in parenthesesyou can usually use the open pairs technique instead if you need your code to span multiple lines--simply wrap part of your statement in parenthesesif ( = and = and = and = )print('new'but parentheses usually do tooand are obvious in factbackslashes are generally frowned on by most python developersbecause they're too easy to not notice and too easy to omit altogether in the followingx is assigned with the backslashas intendedif the backslash is accidentally omittedthoughx is assigned insteadand no error is reported (the + is valid expression statement by itselfin real program with more complex assignmentthis could be the source of very nasty bug: + omitting the makes this very differentpython syntax revisited |
951 | statement ( statements without nested statementson the same lineseparated by semicolons some coders use this form to save program file real estatebut it usually makes for more readable code if you stick to one statement per line for most of your workx print(xmore than one simple statement as we learned in triple-quoted string literals span lines too in additionif two string literals appear next to each otherthey are concatenated as if had been added between them--when used in conjunction with the open pairs rulewrapping in parentheses allows this form to span multiple lines for examplethe first of the following inserts newline characters at line breaks and assigns to '\naaaa\nbbbb \ncccc'and the second implicitly concatenates and assigns to 'aaaabbbbcccc'as we also saw in comments are ignored in the second formbut included in the string in the firsts ""aaaa bbbb cccc"" ('aaaa'bbbb'cccc'comments here are ignored finallypython lets you move compound statement' body up to the header lineprovided the body contains just simple (noncompoundstatements you'll most often see this used for simple if statements with single test and actionas in the interactive loops we coded in if print('hello'simple statement on header line you can combine some of these special cases to write code that is difficult to readbut don' recommend itas rule of thumbtry to keep each statement on line of its ownand indent all but the simplest of blocks six months down the roadyou'll be happy you did truth values and boolean tests the notions of comparisonequalityand truth values were introduced in because the if statement is the first statement we've looked at that actually uses test candidlyit was bit surprising that backslash continuations were not removed in python given the broad scope of its other changessee the changes tables in appendix for list of removalssome seem fairly innocuous in comparison with the dangers inherent in backslash continuations then againthis book' goal is python instructionnot populist outrageso the best advice can give is simplydon' do this you should generally avoid backslash continuations in new python codeeven if you developed the habit in your programming days if tests and syntax rules |
952 | all objects have an inherent boolean true or false value any nonzero number or nonempty object is true zero numbersempty objectsand the special object none are considered false comparisons and equality tests are applied recursively to data structures comparisons and equality tests return true or false (custom versions of and boolean and and or operators return true or false operand object boolean operators stop evaluating ("short circuit"as soon as result is known the if statement takes action on truth valuesbut boolean operators are used to combine the results of other tests in richer ways to produce new truth values more formallythere are three boolean expression operators in pythonx and is true if both and are true or is true if either or is true not is true if is false (the expression returns true or falseherex and may be any truth valueor any expression that returns truth value ( an equality testrange comparisonand so onboolean operators are typed out as words in python (instead of ' &&||and !alsoboolean and and or operators return true or false object in pythonnot the values true or false let' look at few examples to see how this works (truefalseless thanreturn true or false ( or magnitude comparisons such as these return true or false as their truth resultswhichas we learned in and are really just custom versions of the integers and (they print themselves differently but are otherwise the sameon the other handthe and and or operators always return an object--either the object on the left side of the operator or the object on the right if we test their results in if or other statementsthey will be as expected (rememberevery object is inherently true or false)but we won' get back simple true or false for or testspython evaluates the operand objects from left to right and returns the first one that is true moreoverpython stops at the first true operand it finds this is usually called short-circuit evaluationas determining result short-circuits (terminatesthe rest of the expression as soon as the result is known or or ( return left operand if true elsereturn right operand (true or falsetruth values and boolean tests |
953 | [or [or {{in the first line of the preceding exampleboth operands ( and are true ( are nonzero)so python always stops and returns the one on the left--it determines the result because true or anything is always true in the other two teststhe left operand is false (an empty object)so python simply evaluates and returns the object on the right--which may happen to have either true or false value when tested python and operations also stop as soon as the result is knownhoweverin this case python evaluates the operands from left to right and stops if the left operand is false object because it determines the result--false and anything is always false and and ( [and {[ and [[return left operand if false elsereturn right operand (true or falsehereboth operands are true in the first lineso python evaluates both sides and returns the object on the right in the second testthe left operand is false ([])so python stops and returns it as the test result in the last testthe left side is true ( )so python evaluates and returns the object on the right--which happens to be false [the end result of all this is the same as in and most other languages--you get value that is logically true or false if tested in an if or while according to the normal definitions of or and and howeverin python booleans return either the left or the right objectnot simple integer flag this behavior of and and or may seem esoteric at first glancebut see this sidebar "why you will carebooleanson page for examples of how it is sometimes used to advantage in coding by python programmers the next section also shows common way to leverage this behaviorand its more mnemonic replacement in recent versions of python the if/else ternary expression one common role for the prior section' boolean operators is to code an expression that runs the same as an if statement consider the following statementwhich sets to either or zbased on the truth value of xif xa elsea if tests and syntax rules |
954 | like overkill to spread them across four lines at other timeswe may want to nest such construct in larger statement instead of assigning its result to variable for these reasons (andfranklybecause the language has similar tool)python introduced new expression format that allows us to say the same thing in one expressiona if else this expression has the exact same effect as the preceding four-line if statementbut it' simpler to code as in the statement equivalentpython runs expression only if turns out to be trueand runs expression only if turns out to be false that isit short-circuitsjust like the boolean operators described in the prior sectionrunning just or but not both here are some examples of it in actiona 'tif 'spamelse 'fa 'ta 'tif 'else 'fa 'ffor stringsnonempty means true prior to python (and after if you insist)the same effect can often be achieved by careful combination of the and and or operatorsbecause they return either the object on the left side or the object on the right as the preceding section describeda (( and yor zthis worksbut there is catch--you have to be able to assume that will be boolean true if that is the casethe effect is the samethe and runs first and returns if is trueif if false the and skips yand the or simply returns in other wordswe get "if then else this is equivalent to the ternary forma if else the and/or combination form also seems to require "moment of great clarityto understand the first time you see itand it' no longer required as of --use the equivalent and more robust and mnemonic if/else expression when you need this structureor use full if statement if the parts are nontrivial as side noteusing the following expression in python is similar because the bool function will translate into the equivalent of integer or which can then be used as offsets to pick true and false values from lista [zy][bool( )for example[' '' '][bool('')' [' '' '][bool('spam')'thoweverthis isn' exactly the samebecause python will not short-circuit--it will always run both and yregardless of the value of because of such complexitiesyou're the if/else ternary expression |
955 | and later againthoughyou should use even that sparinglyand only if its parts are all fairly simpleotherwiseyou're better off coding the full if statement form to make changes easier in the future your coworkers will be happy you did stillyou may see the and/or version in code written prior to (and in python code written by ex- programmers who haven' quite let go of their dark coding pasts why you will carebooleans one common way to use the somewhat unusual behavior of python boolean operators is to select from set of objects with an or statement such as thisx or or or none assigns to the first nonempty (that istrueobject among aband cor to none if all of them are empty this works because the or operator returns one of its two objectsand it turns out to be fairly common coding paradigm in pythonto select nonempty object from among fixed-size setsimply string them together in an or expression in simpler formthis is also commonly used to designate default--the following sets to if is true (or nonempty)and to default otherwisex or default it' also important to understand the short-circuit evaluation of boolean operators and the if/elsebecause it may prevent actions from running expressions on the right of boolean operatorfor examplemight call functions that perform substantial or important workor have side effects that won' happen if the short-circuit rule takes effectif (or ()hereif returns true (or nonemptyvaluepython will never run to guarantee that both functions will be runcall them before the ortmp tmp () (if tmp or tmp you've already seen another application of this behavior in this because of the way booleans workthe expression (( and bor ccan be used to emulate an if statement--almost (see this discussion of this form for detailswe met additional boolean use cases in prior as we saw in because all objects are inherently true or falseit' common and easier in python to test an object directly if :than to compare it to an empty value (if !'':for stringthe two tests are equivalent as we also saw in the preset boolean values true and false are the same as the integers and and are useful for initializing variables in factpython' if else has slightly different order than ' zand uses more readable words its differing order was reportedly chosen in response to analysis of common usage patterns in python code according to the python folklorethis order was also chosen in part to discourage ex- programmers from overusing itremembersimple is better than complexin python and elsewhere if you have to work at packing logic into expressions like thisstatements are probably your better bet if tests and syntax rules |
956 | prompt also watch for related discussion in operator overloading in part viwhen we define new object types with classeswe can specify their boolean nature with either the __bool__ or __len__ methods (__bool__ is named __nonzero__ in the latter of these is tried if the former is absent and designates false by returning length of zero--an empty object is considered false finallyand as previewother tools in python have roles similar to the or chains at the start of this sidebarthe filter call and list comprehensions we'll meet later can be used to select true values when the set of candidates isn' known until runtime (though they evaluate all values and return all that are true)and the any and all built-ins can be used to test if any or all items in collection are true (though they don' select an item) [ 'spam''''ham'[]list(filter(booll)[ 'spam''ham'[ for in if [ 'spam''ham'any( )all( (truefalseget true values comprehensions aggregate truth as seen in the bool function here simply returns its argument' true or false valueas though it were tested in an if watch for more on these related tools in and summary in this we studied the python if statement additionallybecause this was our first compound and logical statementwe reviewed python' general syntax rules and explored the operation of truth values and tests in more depth than we were able to previously along the waywe also looked at how to code multiway branching in pythonlearned about the if/else expression introduced in python and explored some common ways that boolean values crop up in code the next continues our look at procedural statements by expanding on the while and for loops therewe'll learn about alternative ways to code loops in pythonsome of which may be better than others before thatthoughhere is the usual quiz test your knowledgequiz how might you code multiway branch in python how can you code an if/else statement as an expression in python how can you make single statement span many linestest your knowledgequiz |
957 | test your knowledgeanswers an if statement with multiple elif clauses is often the most straightforward way to code multiway branchthough not necessarily the most concise or flexible dictionary indexing can often achieve the same resultespecially if the dictionary contains callable functions coded with def statements or lambda expressions in python and laterthe expression form if else returns if is trueor otherwiseit' the same as four-line if statement the and/or combination ((( and yor )can work the same waybut it' more obscure and requires that the part be true wrap up the statement in an open syntactic pair (()[]or {})and it can span as many lines as you likethe statement ends when python sees the closing (righthalf of the pairand lines and beyond of the statement can begin at any indentation level backslash continuations work toobut are broadly discouraged in the python world true and false are just custom versions of the integers and respectivelythey always stand for boolean true and false values in python they're available for use in truth tests and variable initializationand are printed for expression results at the interactive prompt in all these rolesthey serve as more mnemonic and hence readable alternative to and if tests and syntax rules |
958 | while and for loops this concludes our tour of python procedural statements by presenting the language' two main looping constructs--statements that repeat an action over and over the first of thesethe while statementprovides way to code general loops the secondthe for statementis designed for stepping through the items in sequence or other iterable object and running block of code for each we've seen both of these informally alreadybut we'll fill in additional usage details here while we're at itwe'll also study few less prominent statements used within loopssuch as break and continueand cover some built-ins commonly used with loopssuch as rangezipand map although the while and for statements covered here are the primary syntax provided for coding repeated actionsthere are additional looping operations and concepts in python because of thatthe iteration story is continued in the next where we'll explore the related ideas of python' iteration protocol (used by the for loopand list comprehensions ( close cousin to the for looplater explore even more exotic iteration tools such as generatorsfilterand reduce for nowthoughlet' keep things simple while loops python' while statement is the most general iteration construct in the language in simple termsit repeatedly executes block of (normally indentedstatements as long as test at the top keeps evaluating to true value it is called "loopbecause control keeps looping back to the start of the statement until the test becomes false when the test becomes falsecontrol passes to the statement that follows the while block the net effect is that the loop' body is executed repeatedly while the test at the top is true if the test is false to begin withthe body never runs and the while statement is skipped |
959 | in its most complex formthe while statement consists of header line with test expressiona body of one or more normally indented statementsand an optional else part that is executed if control exits the loop without break statement being encountered python keeps evaluating the test at the top and executing the statements nested in the loop body until the test returns false valuewhile teststatements elsestatements loop test loop body optional else run if didn' exit loop with break examples to illustratelet' look at few simple while loops in action the firstwhich consists of print statement nested in while loopjust prints message forever recall that true is just custom version of the integer and always stands for boolean true valuebecause the test is always truepython keeps executing the body foreveror until you stop its execution this sort of behavior is usually called an infinite loop--it' not really immortalbut you may need ctrl- key combination to forcibly terminate onewhile trueprint('type ctrl- to stop me!'the next example keeps slicing off the first character of string until the string is empty and hence false it' typical to test an object directly like this instead of using the more verbose equivalent (while !'':later in this we'll see other ways to step through the items in string more easily with for loop 'spamwhile xprint(xend=' [ :spam pam am while is not empty in use print xstrip first character off note the end=keyword argument used here to place all outputs on the same line separated by spacesee if you've forgotten why this works as it does this may leave your input prompt in an odd state at the end of your outputtype enter to reset python readersalso remember to use trailing comma instead of end in the prints like this the following code counts from the value of up tobut not includingb we'll also see an easier way to do this with python for loop and the built-in range function latera= = while bprint(aend=' + while and for loops one way to code counter loops ora |
960 | finallynotice that python doesn' have what some languages call "do untilloop statement howeverwe can simulate one with test and break at the bottom of the loop bodyso that the loop' body is always run at least oncewhile trueloop body if exittest()break to fully understand how this structure workswe need to move on to the next section and learn more about the break statement breakcontinuepassand the loop else now that we've seen few python loops in actionit' time to take look at two simple statements that have purpose only when nested inside loops--the break and con tinue statements while we're looking at oddballswe will also study the loop else clause here because it is intertwined with breakand python' empty placeholder statementpass (which is not tied to loops per sebut falls into the general category of simple one-word statementsin pythonbreak jumps out of the closest enclosing loop (past the entire loop statementcontinue jumps to the top of the closest enclosing loop (to the loop' header linepass does nothing at allit' an empty statement placeholder loop else block runs if and only if the loop is exited normally ( without hitting breakgeneral loop format factoring in break and continue statementsthe general format of the while loop looks like thiswhile teststatements if testbreak if testcontinue elsestatements exit loop nowskip else if present go to top of loop nowto test run if we didn' hit 'breakbreak and continue statements can appear anywhere inside the while (or forloop' bodybut they are usually coded further nested in an if test to take action in response to some condition breakcontinuepassand the loop else |
961 | practice pass simple things firstthe pass statement is no-operation placeholder that is used when the syntax requires statementbut you have nothing useful to say it is often used to code an empty body for compound statement for instanceif you want to code an infinite loop that does nothing each time throughdo it with passwhile truepass type ctrl- to stop mebecause the body is just an empty statementpython gets stuck in this loop pass is roughly to statements as none is to objects--an explicit nothing notice that here the while loop' body is on the same line as the headerafter the colonas with if statementsthis only works if the body isn' compound statement this example does nothing forever it probably isn' the most useful python program ever written (unless you want to warm up your laptop computer on cold winter' day!)franklythoughi couldn' think of better pass example at this point in the book we'll see other places where pass makes more sense later--for instanceto ignore exceptions caught by try statementsand to define empty class objects with attributes that behave like "structsand "recordsin other languages pass is also sometime coded to mean "to be filled in later,to stub out the bodies of functions temporarilydef func ()pass add real code here later def func ()pass we can' leave the body empty without getting syntax errorso we say pass instead version skew notepython (but not xallows ellipses coded as (literallythree consecutive dotsto appear any place an expression can because ellipses do nothing by themselvesthis can serve as an alternative to the pass statementespecially for code to be filled in later-- sort of python "tbd"def func ()alternative to pass def func ()func (does nothing if called ellipses can also appear on the same line as statement header and may be used to initialize variable names if no specific type is requireddef func ()def func () while and for loops works on same line too |
962 | ellipsis alternative to none this notation is new in python --and goes well beyond the original intent of in slicing extensions--so time will tell if it becomes widespread enough to challenge pass and none in these roles continue the continue statement causes an immediate jump to the top of loop it also sometimes lets you avoid statement nesting the next example uses continue to skip odd numbers this code prints all even numbers less than and greater than or equal to remember means false and is the remainder of division (modulusoperatorso this loop counts down to skipping numbers that aren' multiples of --it prints while xx - if ! continue print(xend='orx - odd-skip print because continue jumps to the top of the loopyou don' need to nest the print statement here inside an if testthe print is only reached if the continue is not run if this sounds similar to "go toin other languagesit should python has no "go tostatementbut because continue lets you jump about in programmany of the warnings about readability and maintainability you may have heard about "go toapply con tinue should probably be used sparinglyespecially when you're first getting started with python for instancethe last example might be clearer if the print were nested under the ifx while xx - if = print(xend='even-print later in this bookwe'll also learn that raised and caught exceptions can also emulate "go tostatements in limited and structured waysstay tuned for more on this technique in where we will learn how to use it to break out of multiple nested loopsa feat not possible with the next section' topic alone break the break statement causes an immediate exit from loop because the code that follows it in the loop is not executed if the break is reachedyou can also sometimes avoid nesting by including break for examplehere is simple interactive loop ( variant breakcontinuepassand the loop else |
963 | raw_input in python xand exits when the user enters "stopfor the name requestwhile truename input('enter name:'use raw_input(in if name ='stop'break age input('enter age'print('hello'name'=>'int(age* enter name:bob enter age hello bob = enter name:sue enter age hello sue = enter name:stop notice how this code converts the age input to an integer with int before raising it to the second poweras you'll recallthis is necessary because input returns user input as string in you'll see that input also raises an exception at end-of-file ( if the user types ctrl- on windows or ctrl- on unix)if this matterswrap input in try statements loop else when combined with the loop else clausethe break statement can often eliminate the need for the search status flags used in other languages for instancethe following piece of code determines whether positive integer is prime by searching for factors greater than / while if = print( 'has factor'xbreak - elseprint( 'is prime'for some remainder skip else normal exit rather than setting flag to be tested when the loop is exitedit inserts break where factor is found this waythe loop else clause can assume that it will be executed only if no factor is foundif you don' hit the breakthe number is prime trace through this code to see how this works the loop else clause is also run if the body of the loop is never executedas you don' run break in that event eitherin while loopthis happens if the test in the header is false to begin with thusin the preceding example you still get the "is primemessage if is initially less than or equal to (for instanceif is while and for loops |
964 | than are not considered prime by the strict mathematical definition to be really pickythis code also fails for negative numbers and succeeds for floating-point numbers with no decimal digits also note that its code must use /instead of in python because of the migration of to "true division,as described in (we need the initial division to truncate remaindersnot retain them!if you want to experiment with this codebe sure to see the exercise at the end of part ivwhich wraps it in function for reuse more on the loop else because the loop else clause is unique to pythonit tends to perplex some newcomers (and go unused by some veteransi've met some who didn' even know there was an else on loops!in general termsthe loop else simply provides explicit syntax for common coding scenario--it is coding structure that lets us catch the "otherway out of loopwithout setting and checking flags or conditions supposefor instancethat we are writing loop to search list for valueand we need to know whether the value was found after we exit the loop we might code such task this way (this code is intentionally abstract and incompletex is sequence and match is tester function to be defined)found false while and not foundif match( [ ])print('ni'found true elsex [ :if not foundprint('not found'value at frontslice off front and repeat herewe initializesetand later test flag to determine whether the search succeeded or not this is valid python codeand it does workhoweverthis is exactly the sort of structure that the loop else clause is there to handle here' an else equivalentwhile xif match( [ ])print('ni'break [ :elseprint('not found'exit when empty exitgo around else only here if exhausted this version is more concise the flag is goneand we've replaced the if test at the loop end with an else (lined up vertically with the word whilebecause the break inside the main part of the while exits the loop and goes around the elsethis serves as more structured way to catch the search-failure case breakcontinuepassand the loop else |
965 | with test for an empty after the loop ( if not :although that' true in this examplethe else provides explicit syntax for this coding pattern (it' more obviously search-failure clause here)and such an explicit empty test may not apply in some cases the loop else becomes even more useful when used in conjunction with the for loop--the topic of the next section--because sequence iteration is not under your control why you will careemulating while loops the section on expression statements in stated that python doesn' allow statements such as assignments to appear in places where it expects an expression that iseach statement must generally appear on line by itselfnot nested in larger construct that means this common language coding pattern won' work in pythonwhile (( next(obj)!nullprocess assignments return the value assignedbut python assignments are just statementsnot expressions this eliminates notorious class of errorsyou can' accidentally type in python when you mean =if you need similar behaviorthoughthere are at least three ways to get the same effect in python while loops without embedding assignments in loop tests you can move the assignment into the loop body with breakwhile truex next(objif not xbreak process or move the assignment into the loop with testsx true while xx next(objif xprocess or move the first assignment outside the loopx next(objwhile xprocess next(objof these three coding patternsthe first may be considered by some to be the least structuredbut it also seems to be the simplest and is the most commonly used simple python for loop may replace such loops as well and be more pythonicbut doesn' have directly analogous toolfor in objprocess while and for loops |
966 | the for loop is generic iterator in pythonit can step through the items in any ordered sequence or other iterable object the for statement works on stringsliststuplesand other built-in iterablesas well as new user-defined objects that we'll learn how to create later with classes we met for briefly in and in conjunction with sequence object typeslet' expand on its usage more formally here general format the python for loop begins with header line that specifies an assignment target (or targets)along with the object you want to step through the header is followed by block of (normally indentedstatements that you want to repeatfor target in objectstatements elsestatements assign object items to target repeated loop bodyuse target optional else part if we didn' hit 'breakwhen python runs for loopit assigns the items in the iterable object to the target one by one and executes the loop body for each the loop body typically uses the assignment target to refer to the current item in the sequence as though it were cursor stepping through the sequence the name used as the assignment target in for header line is usually (possibly newvariable in the scope where the for statement is coded there' not much unique about this nameit can even be changed inside the loop' bodybut it will automatically be set to the next item in the sequence when control returns to the top of the loop again after the loop this variable normally still refers to the last item visitedwhich is the last item in the sequence unless the loop exits with break statement the for statement also supports an optional else blockwhich works exactly as it does in while loop--it' executed if the loop exits without running into break statement ( if all items in the sequence have been visitedthe break and continue statements introduced earlier also work the same in for loop as they do in while the for loop' complete format can be described this wayfor target in objectstatements if testbreak if testcontinue elsestatements assign object items to target exit loop nowskip else go to top of loop now if we didn' hit 'breakexamples let' type few for loops interactively nowso you can see how they are used in practice for loops |
967 | as mentioned earliera for loop can step across any kind of sequence object in our first examplefor instancewe'll assign the name to each of the three items in list in turnfrom left to rightand the print statement will be executed for each inside the print statement (the loop body)the name refers to the current item in the listfor in ["spam""eggs""ham"]print(xend='spam eggs ham the next two examples compute the sum and product of all the items in list later in this and later in the book we'll meet tools that apply operations such as and to items in list automaticallybut it' often just as easy to use forsum for in [ ]sum sum sum prod for item in [ ]prod *item prod other data types any sequence works in foras it' generic tool for examplefor loops work on strings and tupless "lumberjackt ("and"" ' ""okay"for in sprint(xend=' iterate over string for in tprint(xend='and ' okay iterate over tuple in factas we'll learn in the next when we explore the notion of "iterables,for loops can even work on some objects that are not sequences--files and dictionaries worktoo tuple assignment in for loops if you're iterating through sequence of tuplesthe loop target itself can actually be tuple of targets this is just another case of the tuple-unpacking assignment we studied while and for loops |
968 | to the targetand assignment works the same everywheret [( )( )( )for (abin tprint(ab tuple assignment at work herethe first time through the loop is like writing ( , ( , )the second time is like writing ( , ( , )and so on the net effect is to automatically unpack the current tuple on each iteration this form is commonly used in conjunction with the zip call we'll meet later in this to implement parallel traversals it also makes regular appearances in conjunction with sql databases in pythonwhere query result tables are returned as sequences of sequences like the list used here--the outer list is the database tablethe nested tuples are the rows within the tableand tuple assignment extracts columns tuples in for loops also come in handy to iterate through both keys and values in dictionaries using the items methodrather than looping through the keys and indexing to fetch the values manuallyd {' ' ' ' ' ' for key in dprint(key'=>' [key] = = = use dict keys iterator and index list( items()[(' ' )(' ' )(' ' )for (keyvaluein items()print(key'=>'valuea = = = iterate over both keys and values it' important to note that tuple assignment in for loops isn' special caseany assignment target works syntactically after the word for we can always assign manually within the loop to unpackt [( )( )( )for both in tab both print(abmanual assignment equivalent xprints with enclosing tuple "()for loops |
969 | but tuples in the loop header save us an extra step when iterating through sequences of sequences as suggested in even nested structures may be automatically unpacked this way in for((ab) (( ) abc ( nested sequences work too for ((ab)cin [(( ) )(( ) )]print(abc even this is not special casethough--the for loop simply runs the sort of assignment we ran just before iton each iteration any nested sequence structure may be unpacked this waysimply because sequence assignment is so genericfor ((ab)cin [([ ] )['xy' ]]print(abc python extended sequence assignment in for loops in factbecause the loop variable in for loop can be any assignment targetwe can also use python ' extended sequence-unpacking assignment syntax here to extract items and sections of sequences within sequences reallythis isn' special case eitherbut simply new assignment form in xas discussed in because it works in assignment statementsit automatically works in for loops consider the tuple assignment form introduced in the prior section tuple of values is assigned to tuple of names on each iterationexactly like simple assignment statementabc ( abc ( tuple assignment for (abcin [( )( )]print(abc used in for loop in python xbecause sequence can be assigned to more general set of names with starred name to collect multiple itemswe can use the same syntax to extract parts of nested sequences in the for loopa*bc ( abc while and for loops extended seq assignment |
970 | ( [ ] for ( *bcin [( )( )]print(abc [ [ in practicethis approach might be used to pick out multiple columns from rows of data represented as nested sequences in python starred names aren' allowedbut you can achieve similar effects by slicing the only difference is that slicing returns type-specific resultwhereas starred names always are assigned listsmanual slicing in for all in [( )( )]abc all[ ]all[ : ]all[ print(abc ( ( see for more on this assignment form nested for loops now let' look at for loop that' bit more sophisticated than those we've seen so far the next example illustrates statement nesting and the loop else clause in for given list of objects (itemsand list of keys (tests)this code searches for each key in the objects list and reports on the search' outcomeitems ["aaa" ( ) tests [( ) for key in testsfor item in itemsif item =keyprint(key"was found"break elseprint(key"not found!"( was found not founda set of objects keys to search for for all keys for all items check for match because the nested if runs break when match is foundthe loop else clause can assume that if it is reachedthe search has failed notice the nesting here when this code runsthere are two loops going at the same timethe outer loop scans the keys listand the inner loop scans the items list for each key the nesting of the loop else clause is criticalit' indented to the same level as the header line of the inner for loopso it' associated with the inner loopnot the if or the outer for this example is illustrativebut it may be easier to code if we employ the in operator to test membership because in implicitly scans an object looking for match (at least logically)it replaces the inner loopfor loops |
971 | if key in itemsprint(key"was found"elseprint(key"not found!"( was found not foundfor all keys let python check for match in generalit' good idea to let python do as much of the work as possible (as in this solutionfor the sake of brevity and performance the next example is similarbut builds list as it goes for later use instead of printing it performs typical data-structure task with for--collecting common items in two sequences (strings)--and serves as rough set intersection routine after the loop runsres refers to list that contains all the items found in seq and seq seq "spamseq "scamres [for in seq if in seq res append(xres [' '' '' 'start empty scan first sequence common itemadd to result end unfortunatelythis code is equipped to work only on two specific variablesseq and seq it would be nice if this loop could somehow be generalized into tool you could use more than once as you'll seethat simple idea leads us to functionsthe topic of the next part of the book this code also exhibits the classic list comprehension pattern--collecting results list with an iteration and optional filter test--and could be coded more concisely too[ for in seq if in seq [' '' '' 'let python collect results but you'll have to read on to the next for the rest of this story why you will carefile scanners in generalloops come in handy anywhere you need to repeat an operation or process something more than once because files contain multiple characters and linesthey are one of the more typical use cases for loops to load file' contents into string all at onceyou simply call the file object' read methodfile open('test txt'' 'print(file read()read contents into string but to load file in smaller piecesit' common to code either while loop with breaks on end-of-fileor for loop to read by characterseither of the following codings will suffice while and for loops |
972 | while truechar file read( if not charbreak print(charread by character empty string means end-of-file for char in open('test txt'read()print(charthe for loop here also processes each characterbut it loads the file into memory all at once (and assumes it fits!to read by lines or blocks insteadyou can use while loop code like thisfile open('test txt'while trueline file readline(if not linebreak print(line rstrip()read line by line file open('test txt''rb'while truechunk file read( if not chunkbreak print(chunkread byte chunksup to bytes line already has \ you typically read binary data in blocks to read text files line by linethoughthe for loop tends to be easiest to code and the quickest to runfor line in open('test txt'readlines()print(line rstrip()for line in open('test txt')print(line rstrip()use iteratorsbest for text input both of these versions work in both python and the first uses the file read lines method to load file all at once into line-string listand the last example here relies on file iterators to automatically read one line on each loop iteration the last example is also generally the best option for text files--besides its simplicityit works for arbitrarily large files because it doesn' load the entire file into memory all at once the iterator version may also be the quickestthough / performance may vary per python line and release file readlines calls can still be usefulthough--to reverse file' linesfor exampleassuming its content can fit in memory the reversed built-in accepts sequencebut not an arbitrary iterable that generates valuesin other wordsa list worksbut file object doesn'tfor line in reversed(open('test txt'readlines())in some python codeyou may also see the name open replaced with file and the file object' older xreadlines method used to achieve the same effect as the file' automatic line iterator (it' like readlines but doesn' load the file into memory all at onceboth file and xreadlines are removed in python xbecause they are redundant you should generally avoid them in new code too--use file iterators and open call in recent releases--but they may pop up in older code and resources for loops |
973 | line iterators also watch for the sidebar "why you will careshell commands and moreon page in this it applies these same file tools to the os popen command-line launcher to read program output there' more on reading files in tooas we'll see theretext and binary files have slightly different semantics in loop coding techniques the for loop we just studied subsumes most counter-style loops it' generally simpler to code and often quicker to run than whileso it' the first tool you should reach for whenever you need to step through sequence or other iterable in factas general ruleyou should resist the temptation to count things in python--its iteration tools automate much of the work you do to loop over collections in lower-level languages like stillthere are situations where you will need to iterate in more specialized ways for examplewhat if you need to visit every second or third item in listor change the list along the wayhow about traversing more than one sequence in parallelin the same for loopwhat if you need indexes tooyou can always code such unique iterations with while loop and manual indexingbut python provides set of built-ins that allow you to specialize the iteration in forthe built-in range function (available since python xproduces series of successively higher integerswhich can be used as indexes in for the built-in zip function (available since python returns series of parallelitem tupleswhich can be used to traverse multiple sequences in for the built-in enumerate function (available since python generates both the values and indexes of items in an iterableso we don' need to count manually the built-in map function (available since python can have similar effect to zip in python xthough this role is removed in because for loops may run quicker than while-based counter loopsthoughit' to your advantage to use tools like these that allow you to use for whenever possible let' look at each of these built-ins in turnin the context of common use cases as we'll seetheir usage may differ slightly between and xand some of their applications are more valid than others counter loopsrange our first loop-related functionrangeis really general tool that can be used in variety of contexts we met it briefly in although it' used most often to generate indexes in foryou can use it anywhere you need series of integers in while and for loops |
974 | on demandso we need to wrap it in list call to display its results all at once in onlylist(range( ))list(range( ))list(range( )([ ][ ][ ]with one argumentrange generates list of integers from zero up to but not including the argument' value if you pass in two argumentsthe first is taken as the lower bound an optional third argument can give stepif it is usedpython adds the step to each successive integer in the result (the step defaults to + ranges can also be nonpositive and nonascendingif you want them to belist(range(- )[- - - - - list(range( - - )[ - - - - we'll get more formal about iterables like this one in therewe'll also see that python has cousin named xrangewhich is like its range but doesn' build the result list in memory all at once this is space optimizationwhich is subsumed in by the generator behavior of its range although such range results may be useful all by themselvesthey tend to come in most handy within for loops for one thingthey provide simple way to repeat an action specific number of times to print three linesfor exampleuse range to generate the appropriate number of integersfor in range( )print( 'pythons' pythons pythons pythons note that for loops force results from range automatically in xso we don' need to use list wrapper here in (in we get temporary list unless we call xrange insteadsequence scanswhile and range versus for the range call is also sometimes used to iterate over sequence indirectlythough it' often not the best approach in this role the easiest and generally fastest way to step through sequence exhaustively is always with simple foras python handles most of the details for youx 'spamfor item in xprint(itemend=' simple iteration loop coding techniques |
975 | this way if you really need to take over the indexing logic explicitlyyou can do it with while loopi while len( )print( [ ]end=' + while loop iteration you can also do manual indexing with forthoughif you use range to generate list of indexes to iterate through it' multistep processbut it' sufficient to generate offsetsrather than the items at those offsetsx 'spamlen(xlength of string list(range(len( ))all legal offsets into [ for in range(len( ))print( [ ]end='manual range/len iteration note that because this example is stepping over list of offsets into xnot the actual items of xwe need to index back into within the loop to fetch each item if this seems like overkillthoughit' because it isthere' really no reason to work this hard in this example although the range/len combination suffices in this roleit' probably not the best option it may run slowerand it' also more work than we need to do unless you have special indexing requirementyou're better off using the simple for loop form in pythonfor item in xprint(itemend='use simple iteration if you can as general ruleuse for instead of while whenever possibleand don' use range calls in for loops except as last resort this simpler solution is almost always better like every good rulethoughthere are plenty of exceptions--as the next section demonstrates sequence shufflersrange and len though not ideal for simple sequence scansthe coding pattern used in the prior example does allow us to do more specialized sorts of traversals when required for examplesome algorithms can make use of sequence reordering--to generate alternatives in searchesto test the effect of different value orderingsand so on such cases may require offsets in order to pull sequences apart and put them back togetheras in the while and for loops |
976 | slicing in the seconds 'spamfor in range(len( )) [ : [: print(send='pams amsp mspa spam 'spamfor in range(len( )) [ : [:iprint(xend='spam pams amsp mspa for repeat counts move front item to end for positions rear part front part trace through these one iteration at time if they seem confusing the second creates the same results as the firstthough in different orderand doesn' change the original variable as it goes because both slice to obtain parts to concatenatethey also work on any type of sequenceand return sequences of the same type as that being shuffled-if you shuffle listyou create reordered listsl [ for in range(len( )) [ : [:iprint(xend='[ [ [ works on any sequence type we'll make use of code like this to test functions with different argument orderings in and will extend it to functionsgeneratorsand more complete permutations in --it' widely useful tool nonexhaustive traversalsrange versus slices cases like that of the prior section are valid applications for the range/len combination we might also use this technique to skip items as we gos 'abcdefghijklist(range( len( ) )[ for in range( len( ) )print( [ ]end=' herewe visit every second item in the string by stepping over the generated range list to visit every third itemchange the third range argument to be and so on in effectusing range this way lets you skip items in loops while still retaining the simplicity of the for loop construct loop coding techniques |
977 | today if you really mean to skip items in sequencethe extended three-limit form of the slice expressionpresented in provides simpler route to the same goal to visit every second character in sfor exampleslice with stride of 'abcdefghijkfor in [:: ]print(cend=' the result is the samebut substantially easier for you to write and for others to read the potential advantage to using range here instead is spaceslicing makes copy of the string in both and xwhile range in and xrange in do not create listfor very large stringsthey may save memory changing listsrange versus comprehensions another common place where you may use the range/len combination with for is in loops that change list as it is being traversed supposefor examplethat you need to add to every item in list (maybe you're giving everyone raise in an employee database listyou can try this with simple for loopbut the result probably won' be exactly what you wantl [ for in lx + [ changes xnot this doesn' quite work--it changes the loop variable xnot the list the reason is somewhat subtle each time through the loopx refers to the next integer already pulled out of the list in the first iterationfor examplex is integer in the next iterationthe loop body sets to different objectinteger but it does not update the list where originally came fromit' piece of memory separate from the list to really change the list as we march across itwe need to use indexes so we can assign an updated value to each position as we go the range/len combination can produce the required indexes for usl [ for in range(len( )) [ + [ while and for loops add one to each item in or [il[ |
978 | way to do the same with simple for in :-style loopbecause such loop iterates through actual itemsnot list positions but what about the equivalent while loopsuch loop requires bit more work on our partand might run more slowly depending on your python (it does on and though less so on --we'll see how to verify this in ) while len( ) [ + + [ here againthoughthe range solution may not be ideal either list comprehension expression of the form[ for in llikely runs faster today and would do similar workalbeit without changing the original list in place (we could assign the expression' new list object result back to lbut this would not update any other references to the original listbecause this is such central looping conceptwe'll save complete exploration of list comprehensions for the next and continue this story there parallel traversalszip and map our next loop coding technique extends loop' scope as we've seenthe range builtin allows us to traverse sequences with for in nonexhaustive fashion in the same spiritthe built-in zip function allows us to use for loops to visit multiple sequences in parallel--not overlapping in timebut during the same loop in basic operationzip takes one or more sequences as arguments and returns series of tuples that pair up parallel items taken from those sequences for examplesuppose we're working with two lists ( list of names and addresses paired by positionperhaps) [ , , , [ , , , to combine the items in these listswe can use zip to create list of tuple pairs like rangezip is list in python xbut an iterable object in where we must wrap it in list call to display all its results at once (againthere' more on iterables coming up in the next zip( list(zip( )[( )( )( )( )list(required in xnot such result may be useful in other contexts as wellbut when wedded with the for loopit supports parallel iterationsloop coding techniques |
979 | print(xy'--' + - - - - herewe step over the result of the zip call--that isthe pairs of items pulled from the two lists notice that this for loop again uses the tuple assignment form we met earlier to unpack each tuple in the zip result the first time throughit' as though we ran the assignment statement (xy( the net effect is that we scan both and in our loop we could achieve similar effect with while loop that handles indexing manuallybut it would require more typing and would likely run more slowly than the for/zip approach strictly speakingthe zip function is more general than this example suggests for instanceit accepts any type of sequence (reallyany iterable objectincluding files)and it accepts more than two arguments with three argumentsas in the following exampleit builds list of three-item tuples with items from each sequenceessentially projecting by columns (technicallywe get an -ary tuple for arguments) ( , , )( , , )( , , ( list(zip( )three tuples for three arguments [( )( )( )moreoverzip truncates result tuples at the length of the shortest sequence when the argument lengths differ in the followingwe zip together two strings to pick out characters in parallelbut the result has only as many tuples as the length of the shortest sequences 'abcs 'xyz list(zip( )[(' '' ')(' '' ')(' '' ')truncates at len(shortestmap equivalence in python in python onlythe related built-in map function pairs items from sequences in similar fashion when passed none for its function argumentbut it pads shorter sequences with none if the argument lengths differ instead of truncating to the shortest lengths 'abcs 'xyz map(nones onlypads to len(longest[(' '' ')(' '' ')(' '' ')(none' ')(none' ')(none,' ') while and for loops |
980 | in normallymap takes function and one or more sequence arguments and collects the results of calling the function with parallel items taken from the sequence(swe'll study map in detail in and but as brief examplethe following maps the built-in ord function across each item in string and collects the results (like zipmap is value generator in and so must be passed to list to collect all its results at once in only)list(map(ord'spam')[ this works the same as the following loop statementbut map is often quickeras will showres [for in 'spam'res append(ord( )res [ version skew notethe degenerate form of map using function argument of none is no longer supported in python xbecause it largely overlaps with zip (and wasfranklya bit at odds with map' functionapplication purposein xeither use zip or write loop code to pad results yourself in factwe'll see how to write such loop code in after we've had chance to study some additional iteration concepts dictionary construction with zip let' look at another zip use case suggested that the zip call used here can also be handy for generating dictionaries when the sets of keys and values must be computed at runtime now that we're becoming proficient with ziplet' explore more fully how it relates to dictionary construction as you've learnedyou can always create dictionary by coding dictionary literalor by assigning to keys over timed {'spam': 'eggs': 'toast': {'eggs' 'toast' 'spam' { ['spam' ['eggs' ['toast' what to dothoughif your program obtains dictionary keys and values in lists at runtimeafter you've coded your scriptfor examplesay you had the following keys and values listscollected from userparsed from fileor obtained from another dynamic sourceloop coding techniques |
981 | vals [ one solution for turning those lists into dictionary would be to zip the lists and step through them in parallel with for looplist(zip(keysvals)[('spam' )('eggs' )('toast' ) {for (kvin zip(keysvals) [kv {'eggs' 'toast' 'spam' it turns outthoughthat in python and later you can skip the for loop altogether and simply pass the zipped keys/values lists to the built-in dict constructor callkeys ['spam''eggs''toast'vals [ dict(zip(keysvals) {'eggs' 'toast' 'spam' the built-in name dict is really type name in python (you'll learn more about type namesand subclassing themin calling it achieves something like listto-dictionary conversionbut it' really an object construction request in the next we'll explore the related but richer conceptthe list comprehensionwhich builds lists in single expressionwe'll also revisit python and dictionary comprehensionsan alternative to the dict call for zipped key/value pairs{kv for (kvin zip(keysvals){'eggs' 'toast' 'spam' generating both offsets and itemsenumerate our final loop helper function is designed to support dual usage modes earlierwe discussed using range to generate the offsets of items in stringrather than the items at those offsets in some programsthoughwe need boththe item to useplus an offset as we go traditionallythis was coded with simple for loop that also kept counter of the current offsets 'spamoffset for item in sprint(item'appears at offset'offsetoffset + appears at offset appears at offset appears at offset appears at offset while and for loops |
982 | named enumerate does the job for us--its net effect is to give loops counter "for free,without sacrificing the simplicity of automatic iterations 'spamfor (offsetitemin enumerate( )print(item'appears at offset'offsets appears at offset appears at offset appears at offset appears at offset the enumerate function returns generator object-- kind of object that supports the iteration protocol that we will study in the next and will discuss in more detail in the next part of the book in shortit has method called by the next built-in functionwhich returns an (indexvaluetuple each time through the loop the for steps through these tuples automaticallywhich allows us to unpack their values with tuple assignmentmuch as we did for zipe enumerate(se next( ( ' 'next( ( ' 'next( ( ' 'we don' normally see this machinery because all iteration contexts--including list comprehensionsthe subject of --run the iteration protocol automatically[ for (icin enumerate( )[''' ''aa''mmm'for (ilin enumerate(open('test txt'))print('% % (il rstrip()) aaaaaa bbbbbb cccccc to fully understand iteration concepts like enumeratezipand list comprehensionsthoughwe need to move on to the next for more formal dissection why you will careshell commands and more an earlier sidebar showed loops applied to files as briefly noted in python' related os popen call also gives file-like interfacefor reading the outputs of spawned shell commands now that we've studied looping statements in fullhere' an example of this tool in action--to run shell command and read its standard output textpass the command as string to os popenand read text from the file-like object it returns loop coding techniques |
983 | of currency symbols may apply)import os os popen('dir'read line by line readline(volume in drive has no label \nf os popen('dir'read by sized blocks read( volume in drive has no label \ volume serial nuos popen('dir'readlines()[ read all linesindex volume in drive has no label \nos popen('dir'read()[: read all at onceslice volume in drive has no label \ volume serial nufor line in os popen('dir')print(line rstrip()volume in drive has no label volume serial number is - and so on file line iterator loop this runs dir directory listing on windowsbut any program that can be started with command line can be launched this way we might use this schemefor exampleto display the output of the windows systeminfo command--os system simply runs shell commandbut os popen also connects to its streamsboth of the following show the shell command' output in simple console windowbut the first might not in gui interface such as idleos system('systeminfo'output in consolepopup in idle for line in os popen('systeminfo')print(line rstrip()host namemark-vaio os namemicrosoft windows professional os versionservice pack build lots of system information text and once we have command' output in text formany string processing tool or technique applies--including display formatting and content parsingformattedlimited display for (ilinein enumerate(os popen('systeminfo'))if = break print('% % (iline rstrip()) host namemark-vaio os namemicrosoft windows professional os versionservice pack build parse for specific linescase neutral for line in os popen('systeminfo')parts line split(':'if parts and parts[ lower(='system type'print(parts[ strip() while and for loops |
984 | -based pc we'll see os popen in action again in where we'll deploy it to read the results of constructed command line that times code alternativesand in where it will be used to compare outputs of scripts being tested tools like os popen and os system (and the subprocess module not shown hereallow you to leverage every command-line program on your computerbut you can also write emulators with in-process code for examplesimulating the unix awk utility' ability to strip columns out of text files is almost trivial in pythonand can become reusable function in the processawk emulationextract column from whitespace-delimited file for val in [line split()[ for line in open('input txt')]print(valsamebut more explicit code that retains result col [for line in open('input txt')cols line split(col append(cols[ ]for item in col print(itemsamebut reusable function (see next part of bookdef awker(filecol)return [line rstrip(split()[col- for line in open(file)print(awker('input txt' )print(',join(awker('input txt' ))list of strings put commas between by itselfthoughpython provides file-like access to wide variety of data--including the text returned by websites and their pages identified by urlthough we'll have to defer to part for more on the package import used hereand other resources for more on such tools in general ( this works in xbut uses urllib instead of urlib requestand returns text strings)from urllib request import urlopen for line in urlopen(print(lineb'\nb'\nb'\nb"mark lutz' book support site\netc summary in this we explored python' looping statements as well as some concepts related to looping in python we looked at the while and for loop statements in depthand we learned about their associated else clauses we also studied the break and continue statementswhich have meaning only inside loopsand met several built-in summary |
985 | some of the details regarding their roles as iterables in python were intentionally cut short in the next we continue the iteration story by discussing list comprehensions and the iteration protocol in python--concepts strongly related to for loops therewe'll also give the rest of the picture behind the iterable tools we met heresuch as range and zipand study some of the subtleties of their operation as alwaysthoughbefore moving on let' exercise what you've picked up here with quiz test your knowledgequiz what are the main functional differences between while and for what' the difference between break and continue when is loop' else clause executed how can you code counter-based loop in python what can range be used for in for looptest your knowledgeanswers the while loop is general looping statementbut the for is designed to iterate across items in sequence or other iterable although the while can imitate the for with counter loopsit takes more code and might run slower the break statement exits loop immediately (you wind up below the entire while or for loop statement)and continue jumps back to the top of the loop (you wind up positioned just before the test in while or the next item fetch in for the else clause in while or for loop will be run once as the loop is exitingif the loop exits normally (without running into break statementa break exits the loop immediatelyskipping the else part on the way out (if there is one counter loops can be coded with while statement that keeps track of the index manuallyor with for loop that uses the range built-in function to generate successive integer offsets neither is the preferred way to work in pythonif you need to simply step across all the items in sequence insteaduse simple for loop insteadwithout range or counterswhenever possibleit will be easier to code and usually quicker to run the range built-in can be used in for to implement fixed number of repetitionsto scan by offsets instead of items at offsetsto skip successive items as you goand to change list while stepping across it none of these roles requires rangeand most have alternatives--scanning actual itemsthree-limit slicesand list comprehensions are often better solutions today (despite the natural inclinations of ex- programmers to want to count things! while and for loops |
986 | iterations and comprehensions in the prior we met python' two looping statementswhile and for although they can handle most repetitive tasks programs need to performthe need to iterate over sequences is so common and pervasive that python provides additional tools to make it simpler and more efficient this begins our exploration of these tools specificallyit presents the related concepts of python' iteration protocola methodcall model used by the for loopand fills in some details on list comprehensionswhich are close cousin to the for loop that applies an expression to items in an iterable because these tools are related to both the for loop and functionswe'll take two-pass approach to covering them in this bookalong with postscriptthis introduces their basics in the context of looping toolsserving as something of continuation of the prior revisits them in the context of function-based toolsand extends the topic to include built-in and user-defined generators also provides shorter final installment in this storywhere we'll learn about user-defined iterable objects coded with classes in this we'll also sample additional iteration tools in pythonand touch on the new iterables available in python --where the notion of iterables grows even more pervasive one note up frontsome of the concepts presented in these may seem advanced at first glance with practicethoughyou'll find that these tools are useful and powerful although never strictly requiredbecause they've become commonplace in python codea basic understanding can also help if you must read programs written by others |
987 | in the preceding mentioned that the for loop can work on any sequence type in pythonincluding liststuplesand stringslike thisfor in [ ]print( * end=' in xprint * for in ( )print( * end=' for in 'spam'print( end='ss pp aa mm actuallythe for loop turns out to be even more generic than this--it works on any iterable object in factthis is true of all iteration tools that scan objects from left to right in pythonincluding for loopsthe list comprehensions we'll study in this in membership teststhe map built-in functionand more the concept of "iterable objectsis relatively recent in pythonbut it has come to permeate the language' design it' essentially generalization of the notion of sequences--an object is considered iterable if it is either physically stored sequenceor an object that produces one result at time in the context of an iteration tool like for loop in senseiterable objects include both physical sequences and virtual sequences computed on demand terminology in this topic tends to be bit loose the terms "iterableand "iteratorare sometimes used interchangeably to refer to an object that supports iteration in general for claritythis book has very strong preference for using the term iterable to refer to an object that supports the iter calland iterator to refer to an object returned by an iterable on iter that supports the next(icall both these calls are defined ahead that convention is not universal in either the python world or this bookthough"iteratoris also sometimes used for tools that iterate extends this category with the term "generator"--which refers to objects that automatically support the iteration protocoland hence are iterable--even though all iterables generate resultsthe iteration protocolfile iterators one of the easiest ways to understand the iteration protocol is to see how it works with built-in type such as the file in this we'll be using the following input file to demonstrateprint(open('script py'read()import sys iterations and comprehensions |
988 | print( * open('script py'read('import sys\nprint(sys path)\nx \nprint( * )\nrecall from that open file objects have method called readlinewhich reads one line of text from file at time--each time we call the readline methodwe advance to the next line at the end of the filean empty string is returnedwhich we can detect to break out of the loopf open('script py' readline('import sys\nf readline('print(sys path)\nf readline(' \nf readline('print( * )\nf readline('read four-line script file in this directory readline loads one line on each call last lines may have \ or not returns empty string at end-of-file howeverfiles also have method named __next__ in (and next in xthat has nearly identical effect--it returns the next line from file each time it is called the only noticeable difference is that __next__ raises built-in stopiteration exception at end-of-file instead of returning an empty stringf open('script py'__next__ loads one line on each call too __next__(but raises an exception at end-of-file 'import sys\nf __next__(use next(in xor next(fin or 'print(sys path)\nf __next__(' \nf __next__('print( * )\nf __next__(traceback (most recent call last)file ""line in stopiteration this interface is most of what we call the iteration protocol in python any object with __next__ method to advance to next resultwhich raises stopiteration at the end of the series of resultsis considered an iterator in python any such object may also be stepped through with for loop or other iteration toolbecause all iteration tools normally work internally by calling __next__ on each iteration and catching the stopit eration exception to determine when to exit as we'll see in momentfor some objects the full protocol includes an additional first step to call iterbut this isn' required for files iterationsa first look |
989 | way to read text file line by line today is to not read it at all--insteadallow the for loop to automatically call __next__ to advance to the next line on each iteration the file object' iterator will do the work of automatically loading lines as you go the followingfor examplereads file line by lineprinting the uppercase version of each line along the waywithout ever explicitly reading from the file at allfor line in open('script py')print(line upper()end=''import sys print(sys pathx print( * use file iterators to read by lines calls __next__catches stopiteration notice that the print uses end='here to suppress adding \nbecause line strings already have one (without thisour output would be double-spacedin xa trailing comma works the same as the endthis is considered the best way to read text files line by line todayfor three reasonsit' the simplest to codemight be the quickest to runand is the best in terms of memory usage the olderoriginal way to achieve the same effect with for loop is to call the file readlines method to load the file' content into memory as list of line stringsfor line in open('script py'readlines()print(line upper()end=''import sys print(sys pathx print( * this readlines technique still works but is not considered the best practice today and performs poorly in terms of memory usage in factbecause this version really does load the entire file into memory all at onceit will not even work for files too big to fit into the memory space available on your computer by contrastbecause it reads one line at timethe iterator-based version is immune to such memory-explosion issues the iterator version might run quicker toothough this can vary per release as mentioned in the prior sidebar"why you will carefile scannerson page it' also possible to read file line by line with while loopf open('script py'while trueline readline(if not linebreak print(line upper()end=''same output howeverthis may run slower than the iterator-based for loop versionbecause iterators run at language speed inside pythonwhereas the while loop version runs python byte code through the python virtual machine anytime we trade python code for iterations and comprehensions |
990 | xwe'll see timing techniques later in for measuring the relative speed of alternatives like these version skew notein python xthe iteration method is named next(instead of __next__(for portabilitya next(xbuilt-in function is also available in both python and ( and later)and calls __next__(in and next(in apart from method namesiteration works the same in and in all other ways in and simply use next(or next(xfor manual iterations instead of ' __next__()prior to use next(calls instead of next(xmanual iterationiter and next to simplify manual iteration codepython also provides built-in functionnextthat automatically calls an object' __next__ method per the preceding notethis call also is supported on python for portability given an iterator object xthe call next(xis the same as __next__(on (and next(on )but is noticeably simpler and more version-neutral with filesfor instanceeither form may be usedf open('script py' __next__('import sys\nf __next__('print(sys path)\nf open('script py'next( 'import sys\nnext( 'print(sys path)\ncall iteration method directly the next(fbuilt-in calls __next__(in next( =[ xf __next__()][ xf next()technicallythere is one more piece to the iteration protocol alluded to earlier when the for loop beginsit first obtains an iterator from the iterable object by passing it to the iter built-in functionthe object returned by iter in turn has the required next method the iter function internally runs the __iter__ methodmuch like next and __next__ spoiler alertthe file iterator still appears to be slightly faster than readlines and at least faster than the while loop in both and on tests 've run with this code on , -line file (while is twice as slow on the usual benchmarking caveats apply--this is true only for my pythonsmy computerand my test fileand python complicates such analyses by rewriting / libraries to support unicode text and be less system-dependent covers tools and techniques you can use to time these loop statements on your own iterationsa first look |
991 | as more formal definitionfigure - sketches this full iteration protocolused by every iteration tool in pythonand supported by wide variety of object types it' really based on two objectsused in two distinct steps by iteration toolsthe iterable object you request iteration forwhose __iter__ is run by iter the iterator object returned by the iterable that actually produces values during the iterationwhose __next__ is run by next and raises stopiteration when finished producing results these steps are orchestrated automatically by iteration tools in most casesbut it helps to understand these two objectsroles for examplein some cases these two objects are the same when only single scan is supported ( files)and the iterator object is often temporaryused internally by the iteration tool moreoversome objects are both an iteration context tool (they iterateand an iterable object (their results are iterable)--including ' generator expressionsand map and zip in python as we'll see aheadmore tools become iterables in -including mapziprangeand some dictionary methods--to avoid constructing result lists in memory all at once figure - the python iteration protocolused by for loopscomprehensionsmapsand moreand supported by fileslistsdictionaries' generatorsand more some objects are both iteration context and iterable objectsuch as generator expressions and ' flavors of some tools (such as map and zipsome objects are both iterable and iteratorreturning themselves for the iter(callwhich is then no-op in actual codethe protocol' first step becomes obvious if we look at how for loops internally process built-in sequence types such as listsl [ iter(li __next__( iterations and comprehensions obtain an iterator object from an iterable call iterator' next to advance to next item |
992 | __next__( __next__( __next__(error text omitted stopiteration or use next(in xnext(iin either line this initial step is not required for filesbecause file object is its own iterator because they support just one iteration (they can' seek backward to support multiple active scans)files have their own __next__ method and do not need to return different object that doesf open('script py'iter(fis true iter(fis __iter__(true __next__('import sys\nlists and many other built-in objectsthoughare not their own iterators because they do support multiple open iterations--for examplethere may be multiple iterations in nested loops all at different positions for such objectswe must call iter to start iteratingl [ iter(lis false __next__(attributeerror'listobject has no attribute '__next__i iter(li __next__( next( same as __next__(manual iteration although python iteration tools call these functions automaticallywe can use them to apply the iteration protocol manuallytoo the following interaction demonstrates the equivalence between automatic and manual iteration: [ for in lprint( * end=' automatic iteration obtains itercalls __next__catches exceptions technically speakingthe for loop calls the internal equivalent of __next__instead of the next(iused herethough there is rarely any difference between the two your manual iterations can generally use either call scheme iterationsa first look |
993 | manual iterationwhat for loops usually do while truetrytry statement catches exceptions next(ior call __next__ in except stopiterationbreak print( * end=' to understand this codeyou need to know that try statements run an action and catch exceptions that occur while the action runs (we met exceptions briefly in but will explore them in depth in part viii should also note that for loops and other iteration contexts can sometimes work differently for user-defined classesrepeatedly indexing an object instead of running the iteration protocolbut prefer the iteration protocol if it' used we'll defer that story until we study class operator overloading in other built-in type iterables besides files and physical sequences like listsother types have useful iterators as well the classic way to step through the keys of dictionaryfor exampleis to request its keys list explicitlyd {' ': ' ': ' ': for key in keys()print(keyd[key] in recent versions of pythonthoughdictionaries are iterables with an iterator that automatically returns one key at time in an iteration contexti iter(dnext( 'anext( 'bnext( 'cnext(itraceback (most recent call last)file ""line in stopiteration the net effect is that we no longer need to call the keys method to step through dictionary keys--the for loop will use the iteration protocol to grab one key each time through iterations and comprehensions |
994 | print(keyd[key] we can' delve into their details herebut other python object types also support the iteration protocol and thus may be used in for loops too for instanceshelves (an access-by-key filesystem for python objectsand the results from os popen ( tool for reading the output of shell commandswhich we met in the preceding are iterable as wellimport os os popen('dir' __next__(volume in drive has no label \np __next__(volume serial number is - \nnext(ptypeerror_wrap_close object is not an iterator notice that popen objects themselves support next(method in python in xthey support the __next__(methodbut not the next(pbuilt-in since the latter is defined to call the formerthis may seem unusualthough both calls work correctly if we use the full iteration protocol employed automatically by for loops and other iteration contextswith its top-level iter call (this performs internal steps required to also support next calls for this object) os popen('dir' iter(pnext(ivolume in drive has no label \ni __next__(volume serial number is - \nalso in the systems domainthe standard directory walker in pythonos walkis similarly iterablebut we'll save an example until ' coverage of this tool' basis --generators and yield the iteration protocol also is the reason that we've had to wrap some results in list call to see their values all at once objects that are iterable return results one at timenot in physical listr range( range( iter(rnext( next( list(range( )[ ranges are iterables in use iteration protocol to produce results or use list to collect all results at once iterationsa first look |
995 | is not needed in for contexts where iteration happens automatically (such as within for loopsit is needed for displaying values here in xthoughand may also be required when list-like behavior or multiple scans are required for objects that produce results on demand in or (more on this aheadnow that you have better understanding of this protocolyou should be able to see how it explains why the enumerate tool introduced in the prior works the way it doese enumerate('spam'enumerate is an iterable too iter(enext(igenerate results with iteration protocol ( ' 'next(ior use list to force generation to run ( ' 'list(enumerate('spam')[( ' ')( ' ')( ' ')( ' ')we don' normally see this machinery because for loops run it for us automatically to step through results in facteverything that scans left to right in python employs the iteration protocol in the same way--including the topic of the next section list comprehensionsa first detailed look now that we've seen how the iteration protocol workslet' turn to one of its most common use cases together with for loopslist comprehensions are one of the most prominent contexts in which the iteration protocol is applied in the previous we learned how to use range to change list as we step across itl [ for in range(len( )) [ + [ this worksbut as mentioned thereit may not be the optimal "best practiceapproach in python todaythe list comprehension expression makes many such prior coding patterns obsolete herefor examplewe can replace the loop with single expression that produces the desired result listl [ for in ll [ iterations and comprehensions |
996 | substantially faster the list comprehension isn' exactly the same as the for loop statement version because it makes new list object (which might matter if there are multiple references to the original list)but it' close enough for most applications and is common and convenient enough approach to merit closer look here list comprehension basics we met the list comprehension briefly in syntacticallyits syntax is derived from construct in set theory notation that applies an operation to each item in setbut you don' have to know set theory to use this tool in pythonmost people find that list comprehension simply looks like backward for loop to get handle on the syntaxlet' dissect the prior section' example in more detaill [ for in llist comprehensions are written in square brackets because they are ultimately way to construct new list they begin with an arbitrary expression that we make upwhich uses loop variable that we make up ( that is followed by what you should now recognize as the header of for loopwhich names the loop variableand an iterable object (for in lto run the expressionpython executes an iteration across inside the interpreterassigning to each item in turnand collects the results of running the items through the expression on the left side the result list we get back is exactly what the list comprehension says-- new list containing for every in technically speakinglist comprehensions are never really required because we can always build up list of expression results manually with for loops that append results as we gores [for in lres append( res [ in factthis is exactly what the list comprehension does internally howeverlist comprehensions are more concise to writeand because this code pattern of building up result lists is so common in python workthey turn out to be very useful in many contexts moreoverdepending on your python and codelist comprehensions might run much faster than manual for loop statements (often roughly twice as fastbecause their iterations are performed at language speed inside the interpreterrather than with manual python code especially for larger data setsthere is often major performance advantage to using this expression list comprehensionsa first detailed look |
997 | let' work through another common application of list comprehensions to explore them in more detail recall that the file object has readlines method that loads the file into list of line strings all at oncef open('script py'lines readlines(lines ['import sys\ ''print(sys path)\ '' \ ''print( * )\ 'this worksbut the lines in the result all include the newline character (\nat the end for many programsthe newline character gets in the way--we have to be careful to avoid double-spacing when printingand so on it would be nice if we could get rid of these newlines all at oncewouldn' itanytime we start thinking about performing an operation on each item in sequencewe're in the realm of list comprehensions for exampleassuming the variable lines is as it was in the prior interactionthe following code does the job by running each line in the list through the string rstrip method to remove whitespace on the right side ( line[:- slice would worktoobut only if we can be sure all lines are properly \ terminatedand this may not always be the case for the last line in file)lines [line rstrip(for line in lineslines ['import sys''print(sys path)'' ''print( * )'this works as planned because list comprehensions are an iteration context just like for loop statementsthoughwe don' even have to open the file ahead of time if we open it inside the expressionthe list comprehension will automatically use the iteration protocol we met earlier in this that isit will read one line from the file at time by calling the file' next handler methodrun the line through the rstrip expressionand add it to the result list againwe get what we ask for--the rstrip result of linefor every line in the filelines [line rstrip(for line in open('script py')lines ['import sys''print(sys path)'' ''print( * )'this expression does lot implicitlybut we're getting lot of work for free here-python scans the file by lines and builds list of operation results automatically it' also an efficient way to code this operationbecause most of this work is done inside the python interpreterit may be faster than an equivalent for statementand won' load file into memory all at once like some other techniques againespecially for large filesthe advantages of list comprehensions can be significant besides their efficiencylist comprehensions are also remarkably expressive in our examplewe can run any string operation on file' lines as we iterate to illustratehere' the list comprehension equivalent to the file iterator uppercase example we met earlieralong with few other representative operations iterations and comprehensions |
998 | ['import sys\ ''print(sys path)\ '' \ ''print( * )\ '[line rstrip(upper(for line in open('script py')['import sys''print(sys path)'' ''print( * )'[line split(for line in open('script py')[['import''sys']['print(sys path)'][' ''='' ']['print( ''**'' )'][line replace(''!'for line in open('script py')['import!sys\ ''print(sys path)\ '' !=! \ ''print( !**! )\ '[('sysin lineline[: ]for line in open('script py')[(true'impor')(true'print')(false' ')(false'print')recall that the method chaining in the second of these examples works because string methods return new stringto which we can apply another string method the last of these shows how we can also collect multiple resultsas long as they're wrapped in collection like tuple or list one fine point hererecall from that file objects close themselves automatically when garbage-collected if still open hencethese list comprehensions will also automatically close the file when their temporary file object is garbage-collected after the expression runs outside cpythonthoughyou may want to code these to close manually if this is run in loopto ensure that file resources are freed immediately see for more on file close calls if you need refresher on this extended list comprehension syntax in factlist comprehensions can be even richer in practiceand even constitute sort of iteration mini-language in their fullest forms let' take quick look at their syntax tools here filter clausesif as one particularly useful extensionthe for loop nested in comprehension expression can have an associated if clause to filter out of the result items for which the test is not true for examplesuppose we want to repeat the prior section' file-scanning examplebut we need to collect only lines that begin with the letter (perhaps the first character on each line is an action code of some sortadding an if filter clause to our expression does the tricklines [line rstrip(for line in open('script py'if line[ =' 'lines ['print(sys path)''print( * )'list comprehensionsa first detailed look |
999 | is pif notthe line is omitted from the result list this is fairly big expressionbut it' easy to understand if we translate it to its simple for loop statement equivalent in generalwe can always translate list comprehension to for statement by appending as we go and further indenting each successive partres [for line in open('script py')if line[ =' 'res append(line rstrip()res ['print(sys path)''print( * )'this for statement equivalent worksbut it takes up four lines instead of one and may run slower in factyou can squeeze substantial amount of logic into list comprehension when you need to--the following works like the prior but selects only lines that end in digit (before the newline at the end)by filtering with more sophisticated expression on the right side[line rstrip(for line in open('script py'if line rstrip()[- isdigit()[' 'as another if filter examplethe first result in the following gives the total lines in text fileand the second strips whitespace on both ends to omit blank links in the tally in just one line of code (this filenot includedcontains lines describing typos found in the first draft of this book by my proofreader)fname ' :\books\ \lp \draft typos txtlen(open(fnamereadlines() len([line for line in open(fnameif line strip(!''] all lines nonblank lines nested loopsfor list comprehensions can become even more complex if we need them to--for instancethey may contain nested loopscoded as series of for clauses in facttheir full syntax allows for any number of for clauseseach of which can have an optional associated if clause for examplethe following builds list of the concatenation of for every in one string and every in another it effectively collects all the ordered combinations of the characters in two strings[ for in 'abcfor in 'lmn'['al''am''an''bl''bm''bn''cl''cm''cn'againone way to understand this expression is to convert it to statement form by indenting its parts the following is an equivalentbut likely sloweralternative way to achieve the same effect iterations and comprehensions |
Subsets and Splits