The basics of Python programming seven conditions and cycles

First, Introduction

Python's conditions and looping statements determine the program's control flow and reflect the diversity of the structure. It is important to understand if, while, for, and the else, elif, break, continue, and pass statements that match them.
Second, detailed 1, if statement

The IF clause in

        python consists of three parts: the keyword itself, the conditional expression used to determine the authenticity of the result, and a block of code that executes when the expression is true or not zero. The syntax for the IF statement is as follows:
If expression:
    expr_true_suite
        The Expr_true_suite code block of an IF statement executes only if the Boolean value of the result of the conditional expression is true, or the statement immediately following the code block is executed.
(1) Multiple conditional expressions
        A single If statement can implement multiple judgment conditions or negative judgment conditions by using Boolean operators and, or and not.
(2) a code block for a single statement
        if a compound statement (such as an IF clause, a while, or a For loop) contains only one line of code, Then it can be written on the same line as the preceding statement. If Make_hard_copy:send_data_to_printer (), such a single-line statement is legitimate, although it may be convenient, but this makes the code more difficult to read, so it is recommended to move this line of code to the next line and reasonably indent. Another reason is that if you need to add new code, you still have to move it to the next line.
2, Else statement        Python provides an else statement that is used in combination with an if statement. If the result boolean of the conditional expression of the If statement is false, then the program executes the code after the Else statement. The syntax is as follows:
If expression:
    expr_true_suite
Else:
    expr_false_suite

In C, the Else statement is not found outside the scope of the conditional statement, but unlike Python, you can use the Else statement in the while and for loops, and when used in a loop, the ELSE clause executes only after the loop completes, meaning that the break statement also skips the else block.
Example: Displays the maximum divisor of a number from 10 to 20

#!/usr/bin/env python

def showmaxfactor (num):
    count = num/2 while
    count > 1:
        if (num count = = 0): 
  print ' largest factor of%d of%d '% (num, count)
	    break
        count = count-1
    else:
	print eachnum, ' is prim E '

for Eachnum in range:
    showmaxfactor (Eachnum)

Largest factor the 5 is
prime
largest factor of 6 are prime largest factor an is
7
Largest factor of 5 largest factor an is 8-is
prime largest factor ' is 9 ' is
prime
Largest factor of 10

3, elif (ie else-if) statementElif is a Python else-if statement that checks if multiple expressions are true and executes code in a particular block of code when it is true. As with else, the Elif declaration is optional, but unlike the IF statement, there can be at most one else statement, but there may be any number of elif statements.

If expression1:
Expr1_true_suite
Elif expression2:
Expr2_true_suite
...
Elif Expressionn:
Exprn_true_suite
Else
None_of_the_above_suite

In the future, Python may support switch/case statements, but it can be emulated with other python constructs. In Python, a large number of IF-ELIF statements are not difficult to read.

if User.cmd = = ' Create ':
    action = ' Create item '
elif user.cmd = ' Delete ':
    action = ' Delete item '
elif use R.cmd = ' Update ':
    action = ' Update item '
else:
    action = ' Invalid choice ... try Again! '

The preceding statement can also be simplified with sequence and member-relational operators:

If User.cmd in (' Create ', ' delete ', ' Update '):
    action = '%s item '% user.cmd
else:
    action = ' Invalid choice ... . Try Again! '

You can also use a Python dictionary to give a more elegant solution, and one of the biggest benefits of using a mapped object, such as a dictionary, is that its search operation is much faster than a sequence query like a statement or a for loop.

msgs = {' Create ': ' Create item ',
        ' delete ': ' Delete item ',
        ' update ': ' Update item '
       }
default = ' Invalid ch Oice ... try Again! '
Action = Msgs.get (user.cmd, default)

4, the conditional expression (that is, "ternary operator") ternary operator Syntax: X if C else Y, only one line to complete the conditional judgment and assignment operations:

>>> x, y = 4, 3
>>> smaller = x if x < y else y
>>> smaller
3

5, while statementWhile is a conditional loop statement, and if the condition after if is true, the corresponding code block is executed once. The code block in the while loop executes until the loop condition is no longer true.
(1) General grammar
The syntax for the while loop is as follows:
While expression:
Suite_to_repeat
The suite_to_repeat clause of the while loop executes until the expression value is Boolean false.
(2) Counting cycle
Count = 0
while (Count < 9):
print ' The index is: ', count
Count + 1
The code block contains print and self-add statements that are repeated until count is no longer less than 9. The index count is printed and then increased by 1 per iteration.
(3) Infinite loop
While True:
Handle, Indata = Wait_for_client_connect ()
Outdata = Process_request (indata)
Ack_result_to_client (handle, Outdata)
The "Infinite" loop never ends, but it is not necessarily a bad thing, and many of the communication server's client/server systems work through it.
6, for statementAnother loop mechanism provided by Python is the For statement, which is the most powerful loop structure in Python. It can traverse a sequence member, can be used in list parsing and builder expressions, it automatically invokes the next () method of the iterator, captures the stopiteration exception, and ends the loop (all of which happen internally). The python for is more like a foreach loop in a shell or in a scripting language.

(1) General grammar
The For loop accesses all the elements in an iterated object, such as a sequence or iterator, and ends the loop after all entries have been processed. Its syntax is as follows:
For Iter_var in iterable:
Suite_to_repeat
Each loop, the Iter_var iteration variable is set to the current element of an iterative object (a sequence, iterator, or other object that supports iterations), and is provided to the SUITE_TO_REPEAT statement block for use.
(2) for sequence types
The For loop can iterate over different sequence objects, such as strings, lists, and tuples.
There are three basic methods of iterative sequences:
iterating through sequence items

>>> namelist = [' Walter ', ' Nicole ', ' Steven ', ' Henry ']
>>> for eachname in NameList:
...     Print Eachname, "Lim"
... 
Walter Lim
Nicole Lim
Steven Lim
Henry Lim

Iterate over a list ... Each iteration, the Eacgname variable is set to a specific element in the list.
iterating through a sequence index

>>> namelist = [' Cathy ', ' Terry ', ' Joe ', ' Heather ', ' Lucy ']
>>> for Nameindex in range (Len ( NameList)):     .. Print "Liu,", Namelist[nameindex]
... 
Liu, Cathy
Liu, Terry
Liu, Joe
Liu, Heather
Liu, Lucy

There is no iteration element, but an index iteration through the list. However, the direct iteration sequence is faster than the index iteration.
using Items and index iterations

>>> namelist = [' Donn ', ' Shirley ', ' Ben ', ' Janice ', ' David ', ' yen ', ' Wendy ']
>>> for I, Eachlee in EN Umerate (namelist): ...     print '%d%s Lee '% (i+1, Eachlee) ... 
1 Donn Lee
2 Shirley Lee
3 Ben Lee
4 Janice Lee
5 David Lee
6 Yen Lee
7 Wendy Lee

(3) is used for iterator types
        similar to the method for iterating through iterators and accessing sequences, the iterator does not represent a collection of loop entries, and the iterator object has a next ( method, and returns the next entry after the call. After all entries have been iterated, the iterator throws a stopiteration exception to tell the program loop to end, the for statement internally calls next () and catches the exception.
        The code that uses an iterator for a for loop is almost exactly the same as using a sequence entry. In fact, in most cases, it is impossible to tell whether an iteration is a sequence or an iterator, so traversing an iterator may actually mean traversing a sequence, an iterator, or an object that supports iterations (it has the next () method). The
(4) range () built-in function
        range () can turn A for loop like foreach into a more familiar statement.
        Python provides two different ways to call range (), and the full syntax requires two or three integer parameters: Range (start, end, Step =1), range () returns a list that contains all K, where start <= K < end, from start through, K increments ste,step not zero, or an error occurs. &NBSP;&NBSP

>>> Range (3, 7)
[3, 4, 5, 6]
>>> for Eachval in range (2,, 3):
...     Print "value is:", eachval ... 
Value Is:2
value is:5 value
is:8 value
is:11
value is:14 value is:17

Range () also has two abbreviated syntax formats: Range (end) and range (start, end). Start defaults to 0, and step defaults to 1.
(5) xrange () built-in function
Xrange () is similar to range (), but when there is a large list of scopes, xrange () may be more appropriate because it does not create a full copy of the list in memory. It is only used in the For loop, and it does not make sense to use it outside of the for loop. Its performance is far higher than range () because it does not generate an entire list. In a future version of Python, Range () may be like xrange (), returning an iterative object (not a list or an iterator).

(6) Built-in functions related to sequences
        sequence-related functions: sorted (), reversed (), enumerate (), and zip (), called Sequence correlation "is because two functions (sorted () and zip ()) return a sequence (list), while the other two functions (reversed () and enumerate ()) return iterators (similar sequences). The break statements in
7, break, and Continue statements        Python can end the current loop and then jump to the next statement. Like a break in C. Commonly used when an external condition is triggered (generally through an if statement), you need to exit immediately from the loop ... The break statement can be used in a while and a For loop. The continue statements in the
       python are no different from the traditional continue in other high-level languages, and can be used in while and for loops. While loops are conditional
, and for loops are iterations, continue must meet some prerequisites before starting the next loop, otherwise the loop will end normally.
       Program When the continue statement is encountered, the program terminates the current loop, ignores the remaining statements, and then returns to the top of the loop. Before we begin the next iteration, if it is a conditional loop, we will validate the conditional expression. If it is an iterative loop, it verifies that there are still elements that can be iterated. The next iteration is only initiated if the validation succeeds.

#!/usr/bin/env python

valid = False
count = 3
passwdlist= (' abc ') while
count > 0 and valid = = False:
  input = raw_input ("Enter password:"). Strip ()
    # Check for valid passwd for
    eachpasswd in passwdlist:
        if Inpu t = = eachpasswd:
            valid = True break
            if not
        valid: # (or valid = 0)
            print ' Invalid input '
            count-= 1
            Continue
        else:
             break

A while, a for, if, a break, and a continue are used in conjunction to validate user input. The user has three chances to enter the correct password to prevent the user from guessing the password.

8. Pass Statement There is no corresponding empty brace or semicolon (;) in Python. To represent the words "do nothing" in C, and if you need a block of child statements without writing any statements, the interpreter prompts for a syntax error. As a result, Python provides a pass statement that does nothing, that is, NOP (no OPeration), and pass can also be used as a small technique in development to mark code that will be completed in the future.

Def foo_func ():
Pass

Such a code structure is useful for development and debugging, because it may be a good idea to write the code first, but you don't want it to interfere with other completed code, and place a pass without it doing anything. It is also used frequently in exception handling, such as when you track a non-fatal error and do not want to take any action.
9, Iterators and ITER () functions

(1) What is an iterator

The

        iterator provides a class sequence interface to a class sequence object, using their index to "iterate" from 0 to the last entry in the sequence, using the "count" The iterative sequence of the method is very simple. Python iterations seamlessly support sequence objects, and it also allows programmers to iterate over unordered types, including user-defined objects.
        iterators are smart to iterate over objects that are not sequential but exhibit sequence behavior, such as the key of a dictionary, the rows of a file, and so on. When using a loop to iterate over an object entry, you do not have to pay attention to whether it is an iterator or a sequence.
(2) Why iterator
         iterator definition: Provides an extensible iterator interface, performance enhancements to list iterations, and a. Performance improvement in dictionary iterations, you can create more concise, readable code when you create a true iterative interface instead of the original random object access, with all existing user-defined classes, and with extended mock sequences and mapped objects backwards-compatible, iterative, unordered collections such as mappings and files.
(3) How to iterate
       iterators have an object for the next () method, rather than counting by index. When a looping mechanism (for example, a for statement) requires the next item, the next () method of the iterator is invoked to obtain it. When the entry is all removed, a Stopiteration exception is thrown, which does not mean that the error occurred, but simply tells the external caller that the iteration is complete.
       However, iterators have some limitations. For example, you cannot move backwards, you cannot go back to the beginning, or you cannot copy an iterator. If you want to iterate over the same object again (or at the same time), you can only create another iterator object. However, there are other tools to help you use iterators. The
        reversed () built-in function returns an iterator with an inverse sequence access. The enumerate () built-in function also returns an iterator. Another two new BUILTIN functions: any () and all (), if the value of one or all of the entries in the iterator is Boolean true, they return the value true.
(4) using an iterator
sequence

>>> mytuple = (123, ' xyz ', 45.67)
>>> i = iter (mytuple)
>>> i.next ()
123
>>> i.next ()
' xyz '
>>> i.next ()
45.670000000000002
>>> i.next (
) Traceback (most recent):
  File "<stdin>", line 1, in <module>
stopiteration

In the For-loop seq:do_something_to (i), it automatically invokes the next () method of the iterator and monitors the stopiteration exception.
Dictionaries
Dictionaries and files are two other iterations of the Python data type. The dictionary iterator iterates through its keys (keys), and the statement for Eachkey in Mydict.keys () can be abbreviated to the for Eachkey in Mydict.
Python has also introduced three new built-in dictionary methods to define iterations: Mydict.iterkeys () (via the keys Iteration), Mydict.itervalues () (through values iterations), and Mydicit.iteritems () (Iterate through Key/value). Note: The in operator can also be used to check whether the key exists in the dictionary, and the Boolean expression Mydict.has_key (AnyKey) can be abbreviated to AnyKey in Mydict.
file
The ReadLine () method is automatically invoked by the iterator generated by the file object. This allows the loop to access all the lines of the text file. You can replace the for Eachline in Myfile.readlines () with a simpler for eachline in MyFile.
(5) Variable objects and iterators
It is not a good idea to modify them when iterating over mutable objects, which is a problem before the iterator emerges. The iterator of a sequence simply records the current arrival of the first few elements, so if the element is changed at the time of the iteration, the update is immediately reflected in the entry for your iteration. You cannot change this dictionary when iterating over the key of the dictionary. Using the dictionary's keys () method is possible because the keys () return a list that is independent of the dictionary, and the iterator is bound to the actual object, and it will not go on.
(6) How to create an iterator
Invoking ITER () on an object can get its iterator, and its syntax is as follows: ITER (obj) or ITER (func, Sentinel). If you pass a parameter to ITER (), it will check that you are passing a sequence, and if so, it will iterate from 0 to the end of the sequence according to the index. Another way to create iterators is to use classes, and a class that implements the __iter__ () and Next () methods can be used as iterators. If you pass two parameters to ITER (), it will repeatedly call Func until the next value of the iterator equals Sentinel.

10. List Resolution list resolution (comprehensions or shrink list comps) comes from the functional programming language Haskell. It is a very useful, simple, and flexible tool that can be used to create lists dynamically.
The functional programming features supported by Python, such as the Lambda, map (), and filter (), can be simplified to a list parsing formula through list parsing. Map () applies an action to all list members, filter () filters list members based on a conditional expression, and lambda () allows you to quickly create a function object with only one row.
List parsing syntax: [Expr for Iter_var in iterable], which iterates over all entries of the Iterable object. Expr is applied to each member of the sequence, and the final result value is the list produced by the expression, and the iteration variable does not need to be part of the expression.

>>> [x * * 2 for X in range (6)]
[0, 1, 4, 9, 16, 25]

List-parsed expressions can replace the built-in map () functions and lambda, and are more efficient. Combining the If statement, List parsing also provides an extended version of the syntax: [Expr for Iter_var in iterable if COND_EXPR], which filters/captures the sequence members that meet the conditional expression cond_expr during the iteration.
Pick out the odd number in a sequence:

>>> seq = [9, 9, 9, 8, 9, 7,, one, one]
>>> filter (lambda x:x% 2, seq) 
  [11, 9, 9, 9, 9, 7, one]
>>> [x for x in seq if x% 2]
[11, 9, 9, 9, 23, 9, 7, 11]

Even without the filter () and lambda, you can use list parsing to complete the operation and get the number you want.
Matrix Sample: Iterate over a matrix with three rows and five columns [(x+1,y+1) for x in range (3) for Y in range (5)].
Disk File Sample: If you have a data file text.txt, you need to calculate the number of all non-white characters, you can split each line (split) for the word, and then calculate the number of words:>>> f = open (' Hhga.txt ', ' R '); Len ([ Word for line in F for word in line.split ()]. Calculate file size quickly: >>>import os;os.stat (' Text.txt '). St_size. Add up the length of each word: >>>f.seek (0); sum ([Len (word) for line in F for word in line.split ()]).
11, Generator expression

A builder expression is an extension of list resolution that allows you to create a list containing specific content in just one line of code. Another important feature is the builder, which is a specific function that allows you to return a value and then "pause" the execution of the code and resume it later.
One disadvantage of list resolution is the need to generate all of the data to create the entire list. This may have a negative effect on an iterator with a large amount of data, and the builder expression solves the problem by combining the list resolution and the generator.
Builder expressions are very similar to list resolution, and their basic syntax is essentially the same. But instead of actually creating a list of numbers, it returns a generator that, after each calculation of an entry, "generates" (yield). The builder expression uses "deferred calculation" (lazy evaluation), so it is more efficient in using memory. The builder does not let the list resolve obsolete, it is just a more user-friendly structure for memory usage, and based on this, there are many uses for generator places.
List parsing Syntax:
[Expr for Iter_var in iterable if COND_EXPR]
Builder expression Syntax:
(Expr for Iter_var in iterable if cond_expr)
Disk File Sample: The sum of the non-white-space characters in the computed text file above, if the size of the file becomes large, the memory performance of this line of code is very low because you want to create a long list to hold the length of the word. To avoid creating a large list, using a builder expression to complete the summation operation, the optimized code:>>> sum (len (word) for lines in data for word in Line.split ()), is to remove the square brackets, less than two bytes, and more memory savings.
Cross-pairing example: The builder expression is like lazy list parsing (which is the main advantage), and it can also be used to process other lists or generators, such as: X_product_pairs = ((i, j) for I in rows for J-cols ()).
To refactor the sample, look for an example of the longest row in the file:
Previous methods:

#!/usr/bin/env python

def Fun ():
    f = open ('/ETC/MOTD ', ' R ')
    longest = 0
    alllines = [X.strip () for x in F.R Eadlines ()] #or alllinelens = [Len (X.strip ()) for x in F]
    F.close () to line in
    alllines:
        linelen = Len (line) C7/>if linelen > Longest:          #or longest = max (alllinelens)
            longest = Linelen return
    longest

The New approach:

Replaces the list resolution and Max () function with a builder expression and removes the file open mode (read by default): Return Max (Len (X.strip) for x in open ('/ETC/MOTD ')).
Iii. Summary (1) Itertools modules are added to support the application of iterators, and the contents of list parsing and generation expressions can be combined with instance analysis.
(2) If there is a shortage, please leave a message, thank you first.