Partager un résumé des fonctions de contrôle de processus Python

Cet article partage un résumé des fonctions de contrôle de processus Python

Un script shell est une combinaison de commandes système, de variables et de contrôle de processus
Analogue à un programme Python, c'est un système qui peut ; implémenter de nombreuses fonctions dans le shell Les commandes sont similaires. Python a de nombreux modules qui peuvent implémenter différentes fonctions
En termes de variables, les scripts shell ont des variables système, des variables ordinaires, des variables de position spéciales, des méthodes d'appel de variables spéciales, des variables uniques, et des tableaux. Python et Comme les langages généraux de haut niveau, les variables ont des noms, des types de données et des méthodes d'appel (opérateurs et fonctions intégrées)
En termes de contrôle de processus, les shells sont similaires à divers langages de haut niveau. Le contrôle de processus de base comprend des séquences, des conditions. Il existe trois façons de boucler, principalement si, pour, interrompre et continuer.
Les deux autres traitent du contenu de base, et ils doivent être plus approfondis et plus immédiats en termes de réflexion programmatique. Ce n'est qu'avec la pensée procédurale que vous pouvez écrire de bons programmes.

J'ai écrit un script qui résume le contrôle et les fonctions du processus Python. Le contenu du script est le suivant :

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
 
#################
#流程控制
#################
print '''
流程控制，是程序实现逻辑的重要方法，与程序的流程图对应。
一般的流程分为顺序、条件、循环三种方式，顺序执行比较简单，与自顶向下，面向过程的思路类似，条件判断和循环控制就需要专门的语句和格式来实现。
流程控制语句，用来实现对程序流程的选择、循环和返回等进行控制。
python中的主要流程控制包括 if判断，for循环，break跳出，continue继续等语句。
'''
print
print '''
程序要控制流程，就要对程序进行分块，对于代码来说，就有了“程序块”和“作用域”的概念，大多数高级程序中，程序块和作用域有不同的概念。
    程序块结构，是一种程序结构形式，使程序变得清晰，便于阅读和修改。比如C、C++允许程序员按照自己的习惯在不同行之间，采取任意对齐方式。
    作用域，是按照变量或者函数的可见性定义的程序子集。如果某个符号的名称在给定的点是可见的，则称该符号在作用域内。如C、C++采用大括号{}表达作用域。
python中用“缩进”这一种方式，同时表达程序块和作用域的概念，相同缩进范围内的代码在一个程序块和作用域，且同一个程序块和作用域不能有不同的缩进。
python中用冒号:作为程序块标记关键字，每个冒号:后面的程序块必须有相同的缩进，缩进不同就会报错。
高级语言允许定义空作用域，python必须有缩进，所以可以用pass来定义作用域，但不执行任何动作。
'''
print
#条件判断
print '''
条件判断，是依据指定的变量或表达式的结果，决定后续运行的程序，最常用的是if-else指令，可以根据条件是否成立来决定后续的程序。
if-else判断可以单个执行，也可以组合多个指令进行复杂的判断。
python中的if语句有3中语法形式。
#判断if格式一：if条件为真，则执行某个代码块
if expression1:
    block_for_True
#判断if格式二：if条件为真，则执行某块代码；如果为假，则执行else下的代码块
if expression1:
    block_for_True
else:
    block_for_False
#判断fi格式三：if条件为真，则执行某块代码；如果为假，则执行elif的条件判断
if expression1:
     block_for_expression1
elif expression2:
    block_for_expression2
elif expression3:
    block_for_expression3
else:
    block_for_False
复杂判断，每个if，elif，else块中都可以放入多条语句，也可以放入判断或循环.
'''
#条件判断 if-elfi-else 程序示例：
import sys
param = None
if len(sys.argv) > 1:
    param = int(sys.argv[1])
if param is None:
    print "Alert"
    print "The param is not set"
elif param < -10:
    print "The param is samll"
elif param > 10:
    print "The param is big"
else:
    print "The param is middle"
#循环控制
print &#39;&#39;&#39;
循环控制，是因为在实际程序开发中，有许多具有规律性的重复操作，因此程序中需要重复执行某些语句。
一组被重复执行的语句，叫循环体，能否继续重复，则取决于循环的终止条件。
循环语句有循环体和循环终止条件两部分组成。python中循环语句有while语句和for语句两种，while语句先循环，达到条件时终止循环，要避免死循环。
for循环先有条件判断，后面在执行循环体，容易避免死循环。
&#39;&#39;&#39;
print
print &#39;&#39;&#39;
while语句的语法,判断条件为真，则执行循环体，一直到表达式为假，终止执行，语法为：
while expression:
        repeat_block
&#39;&#39;&#39;
#while循环程序示例：
myList = [ &#39;English&#39;, &#39;Chinese&#39;, &#39;Japanese&#39;, &#39;German&#39;, &#39;France&#39; ]
while len(myList) > 0:
    print "pop element out:", myList.pop()
print &#39;&#39;&#39;
python中的for语句与C#,java中的foreach语句类似，语法结构为：
for element in iterable:
        repeat_block
含义为针对iterable中每个元素执行repeat_block，在循环体中可以以变量名element来访问当前元素。循环内容可以是序列类型，集合set，或迭代器等。
    在开发比较复杂的程序时，while或for循环语句的循环体，有时需要提前结束整个循环，或者在本轮尚未结束时提前开始下一轮循环，这就需要break或continue语句。
    break语句会提前结束整个循环；
    continue会在本轮循环体没有结束时，直接开始下一轮循环。
&#39;&#39;&#39;
#for循环程序示例
myList = [ &#39;English&#39;, &#39;Chinese&#39;, &#39;Japanese&#39;, &#39;German&#39;, &#39;France&#39; ]
for language in myList:
    print "Current element is :", language
#循环控制break和continue程序示例：
count=0
while True:
    #input = raw_input("Enter quit: ")
    input = "quit"
    # check for valid passwd
    if input == "quit":
        break
    count = count + 1
    if count%3 > 0:
        continue
    print "Please input quit!"
print "Quit loop successfully!"
 
#################
#函数
#################
print &#39;&#39;&#39;
从面向过程的编程方法，到函数式编程，就是函数在程序中起到的巨大作用。
在编程中使用函数，可以写出优雅的程序结构，模块化的结构，可以使程序简单化，提高可读性和可维护性。
函数有三个要素：函数名，参数，函数体；函数还可以根据需要，设置返回值。
python中函数定义的关键字是def，函数体这一程序块，还是用冒号：作为关键字。
    python中返回值可以是0个或多个，无需显示定义返回值的数量和类型，只需要用return关键字返回,返回值只有值，调用时需要重新定义变量才能使用；
    函数的参数可以是任意个，可以只定义参数名，也可以在定义参数名后，给参数定义默认值，但有默认值的参数一定要在后面；
    在调用函数，传入参数值时，可以按照参数定义顺序只传入值，也可以不按顺序，传入命名参数和值；
&#39;&#39;&#39;
#一般函数与返回值调用示例
def sum_01(x, y):
    return x+y
def total(x, y, z):
    sum_of_two = sum_01(x, y)
    sum_of_three = sum_01(sum_of_two, z)
    return sum_of_two, sum_of_three
def main_01():
    print "return of sum:", sum_01(4, 6)
    x, y = total(2, 6, 8)
    print "return of total:", x, ", ", y
main_01()
#带默认值的函数调用示例
def sum_02(x, y=10):
    return x+y
def main_02():
    print "return of sum(2, 3):", sum_02(2, 3)
    print "return of sum(-4)", sum_02(-4)
     
main_02()
#不同方式参数赋值的函数调用示例
def sum_03(x, y, z):
    return x + y + z
def main_03():
    #下面两种调用方式，意义相同
    ret1 = sum_03(1, 2, 3)
    ret2 = sum_03(y=2, z=3, x=1)
     
    print "return of sum_03(1, 2, 3):", ret1
    print "return of sum_03(y=2, z=3, x=1):", ret2
main_03()
print
print &#39;&#39;&#39;
变长参数的函数，就是参数个数可变、参数类型不定的函数。变长参数可以为函数设计提供更大的灵活性。
python中允许定义两种类型的函数变长参数：
    元组tuple变长参数：适用于未知参数的数量不固定，但在函数中使用这些参数无须知道参数名字的场合。在函数定义中用单星号*表示。
    字典dict变长参数： 适用于未知参数的数量不固定，而且在函数使用参数时需要知道参数名字的场合。在函数定义中，用双型号**表示。
&#39;&#39;&#39;
#使用元组tuple作为变长参数的示例
def show_message(message, *tupleName):
    for name in tupleName:
        print message, ", ", name
def main_tuple():
    show_message("Good Morring", "Jack", "Evans", "Rose Hasa", 893, "Zion" )
main_tuple()
#使用字典dict作为变长参数的示例
def check_book(**dictParam ):
    if dictParam.has_key(&#39;Price&#39;):
        price = int(dictParam[&#39;Price&#39;])
        if price > 100:
            print "*******I want buy this book!*******"
    print "The book information are as follow:"
    for key in dictParam.keys():
        print key, ": ", dictParam[key]
    print ""
     
def main_dict():
    check_book( author = &#39;James&#39;, Title = &#39;Economics Introduction&#39; )
    check_book( author = &#39;Linda&#39;, Title = &#39;Deepin in python&#39;, Date = &#39;2015-5-1&#39;, Price = 302 )
    check_book( Date = &#39;2002-3-19&#39;, Title = &#39;Cooking book&#39;, Price = 20 )
    check_book( author = &#39;Jinker Landy&#39;, Title = &#39;How to keep healthy&#39; )
    check_book( Category = &#39;Finance&#39;, Name = &#39;Enterprise Audit&#39;, Price = 105 )
main_dict()
print
print &#39;&#39;&#39;
匿名函数 Anonymous Function是一类无须定义函数名的函数或子程序，一般用于值在代码中存在一次函数引用的场合。
因为只需要引用一次，所以无须声明。python中用lambda语法定义匿名函数，只需表达式，而无须声明。
除了没有参数名，匿名函数定义和一般函数的定义都相同。
匿名函数定义格式如下：
lambda [arg1, arg2, ... ,argN]: expression
print (lambda x, y: x - y)(3, 4)
&#39;&#39;&#39;
#匿名函数示例如下
import datetime
def nameFunc(a):
    return " I&#39;m named function with param %s " % a
     
def call_func(func, param):
    print datetime.datetime.now()
    print func(param)
    print ""
def main_lambda():
    call_func(nameFunc, &#39;hello&#39;)
    call_func(lambda x: x*2, 9)
    call_func(lambda y: y*y, -4)
         
main_lambda()

Les résultats de l'exécution sont les suivants :

# python func.py
流程控制，是程序实现逻辑的重要方法，与程序的流程图对应。
一般的流程分为顺序、条件、循环三种方式，顺序执行比较简单，与自顶向下，面向过程的思路类似，条件判断和循环控制就需要专门的语句和格式来实现。
流程控制语句，用来实现对程序流程的选择、循环和返回等进行控制。
python中的主要流程控制包括 if判断，for循环，break跳出，continue继续等语句。
 
程序要控制流程，就要对程序进行分块，对于代码来说，就有了“程序块”和“作用域”的概念，大多数高级程序中，程序块和作用域有不同的概念。
    程序块结构，是一种程序结构形式，使程序变得清晰，便于阅读和修改。比如C、C++允许程序员按照自己的习惯在不同行之间，采取任意对齐方式。
    作用域，是按照变量或者函数的可见性定义的程序子集。如果某个符号的名称在给定的点是可见的，则称该符号在作用域内。如C、C++采用大括号{}表达作用域。
python中用“缩进”这一种方式，同时表达程序块和作用域的概念，相同缩进范围内的代码在一个程序块和作用域，且同一个程序块和作用域不能有不同的缩进。
python中用冒号:作为程序块标记关键字，每个冒号:后面的程序块必须有相同的缩进，缩进不同就会报错。
高级语言允许定义空作用域，python必须有缩进，所以可以用pass来定义作用域，但不执行任何动作。
 
条件判断，是依据指定的变量或表达式的结果，决定后续运行的程序，最常用的是if-else指令，可以根据条件是否成立来决定后续的程序。
if-else判断可以单个执行，也可以组合多个指令进行复杂的判断。
python中的if语句有3中语法形式。
#判断if格式一：if条件为真，则执行某个代码块
if expression1:
    block_for_True
#判断if格式二：if条件为真，则执行某块代码；如果为假，则执行else下的代码块
if expression1:
    block_for_True
else:
    block_for_False
#判断fi格式三：if条件为真，则执行某块代码；如果为假，则执行elif的条件判断
if expression1:
     block_for_expression1
elif expression2:
    block_for_expression2
elif expression3:
    block_for_expression3
else:
    block_for_False
复杂判断，每个if，elif，else块中都可以放入多条语句，也可以放入判断或循环.
Alert
The param is not set
循环控制，是因为在实际程序开发中，有许多具有规律性的重复操作，因此程序中需要重复执行某些语句。
一组被重复执行的语句，叫循环体，能否继续重复，则取决于循环的终止条件。
循环语句有循环体和循环终止条件两部分组成。python中循环语句有while语句和for语句两种，while语句先循环，达到条件时终止循环，要避免死循环。
for循环先有条件判断，后面在执行循环体，容易避免死循环。
 
while语句的语法,判断条件为真，则执行循环体，一直到表达式为假，终止执行，语法为：
while expression:
        repeat_block
pop element out: France
pop element out: German
pop element out: Japanese
pop element out: Chinese
pop element out: English
python中的for语句与C#,java中的foreach语句类似，语法结构为：
for element in iterable:
        repeat_block
含义为针对iterable中每个元素执行repeat_block，在循环体中可以以变量名element来访问当前元素。循环内容可以是序列类型，集合set，或迭代器等。
    在开发比较复杂的程序时，while或for循环语句的循环体，有时需要提前结束整个循环，或者在本轮尚未结束时提前开始下一轮循环，这就需要break或continue语句。
    break语句会提前结束整个循环；
    continue会在本轮循环体没有结束时，直接开始下一轮循环。
Current element is : English
Current element is : Chinese
Current element is : Japanese
Current element is : German
Current element is : France
Quit loop successfully!
从面向过程的编程方法，到函数式编程，就是函数在程序中起到的巨大作用。
在编程中使用函数，可以写出优雅的程序结构，模块化的结构，可以使程序简单化，提高可读性和可维护性。
函数有三个要素：函数名，参数，函数体；函数还可以根据需要，设置返回值。
python中函数定义的关键字是def，函数体这一程序块，还是用冒号：作为关键字。
    python中返回值可以是0个或多个，无需显示定义返回值的数量和类型，只需要用return关键字返回,返回值只有值，调用时需要重新定义变量才能使用；
    函数的参数可以是任意个，可以只定义参数名，也可以在定义参数名后，给参数定义默认值，但有默认值的参数一定要在后面；
    在调用函数，传入参数值时，可以按照参数定义顺序只传入值，也可以不按顺序，传入命名参数和值；
return of sum: 10
return of total: 8 ,  16
return of sum(2, 3): 5
return of sum(-4) 6
return of sum_03(1, 2, 3): 6
return of sum_03(y=2, z=3, x=1): 6
 
变长参数的函数，就是参数个数可变、参数类型不定的函数。变长参数可以为函数设计提供更大的灵活性。
python中允许定义两种类型的函数变长参数：
    元组tuple变长参数：适用于未知参数的数量不固定，但在函数中使用这些参数无须知道参数名字的场合。在函数定义中用单星号*表示。
    字典dict变长参数： 适用于未知参数的数量不固定，而且在函数使用参数时需要知道参数名字的场合。在函数定义中，用双型号**表示。
Good Morring ,  Jack
Good Morring ,  Evans
Good Morring ,  Rose Hasa
Good Morring ,  893
Good Morring ,  Zion
The book information are as follow:
Title :  Economics Introduction
author :  James
*******I want buy this book!*******
The book information are as follow:
Date :  2015-5-1
Price :  302
Title :  Deepin in python
author :  Linda
The book information are as follow:
Date :  2002-3-19
Price :  20
Title :  Cooking book
The book information are as follow:
Title :  How to keep healthy
author :  Jinker Landy
*******I want buy this book!*******
The book information are as follow:
Category :  Finance
Price :  105
Name :  Enterprise Audit
 
匿名函数 Anonymous Function是一类无须定义函数名的函数或子程序，一般用于值在代码中存在一次函数引用的场合。
因为只需要引用一次，所以无须声明。python中用lambda语法定义匿名函数，只需表达式，而无须声明。
除了没有参数名，匿名函数定义和一般函数的定义都相同。
匿名函数定义格式如下：
lambda [arg1, arg2, ... ,argN]: expression
print (lambda x, y: x - y)(3, 4)
2017-03-09 20:20:31.264415
 I'm named function with param hello
2017-03-09 20:20:31.264533
18
2017-03-09 20:20:31.264555
16

<.>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!