python学习笔记（二）流程控制

浅浅的花香味﹌ 2023-06-30 15:59 379阅读 0赞

### 文章目录 ###

*  （一）while循环
 *  （二）if-elif-else语句
 *  （三）for循环
 *   *  1.range函数
     *  2.用初值和步进值控制range函数
     *  3.for循环和元组拆包
     *  4.enumerate函数
     *  5.zip函数
     *  6.实例：
 *  （四）列表和字典推导式
 *   *  生成器表达式
 *  （五）语句、代码块和缩进
 *  （六）布尔值和布尔表达式
 *   *  大多数Python对象都能用作布尔类型
     *  Python常用操作符

**主要内容：**

*  用while循环重复执行代码
 *  用if-elif-else语句执行判断
 *  用for循环遍历列表
 *  使用列表和字典推导式
 *  用缩进标识语句和代码块
 *  对布尔值和布尔表达式求值

# （一）while循环 #

while循环结构如下：

while condition:
        body
    else:
        post-code

condition是一个布尔表达式，返回结果为True或False。如果condition返回结果为True，则循环执行body部分代码；如果返回结果为Flase，则while循环执行post-code代码，然后停止运行。Python解释器根据代码缩进的级别来识别这两个部分。

注意，这里的else部分是可选的。

continue语句：执行了continue语句，会导致body剩余的语句被跳过，进行下一次condition计算，循环继续进行。

break语句：执行了break语句，while循环立即终止。

# （二）if-elif-else语句 #

最通用的if-elif-else结构的形式如下;

if condition1:
        body1
    elif condition2:
        body2
    .
    .
    else:
        body(n)

如果condition1返回的结果为True，则执行body1语句；否则，如果condition2返回的结果为True，则执行body2语句，一次类推，最后没有返回True的condition，则执行else语句。

pass语句用作语句的占位符，但是它不执行任何操作。

if x < 5:
        pass
    else:
        x = 5

如下例：

''' 7.猜拳游戏 石头 剪刀 布 0 1 2 数据： unum 0 1 2 cnum 0 1 2 '''
    import random
    unum=int(input("石头(0),剪刀(1),布(2) 请选择："))
    cnum=random.randint(0,2) #[0,2)
     
    l = '石头， 剪刀， 布'.split()
     
    print("用户：%s"%l[unum])
    print("电脑：%s"%l[cnum])
    if unum==0 and cnum==1:
    	print("赢了！")
    elif unum==0 and cnum==2:
    	print("输了！")
    elif unum==1 and cnum==2:
    	print("赢了！")
    elif unum==1 and cnum==0:
    	print("输了！")
    elif unum==2 and cnum==0:
    	print("赢了！")
    elif unum==2 and cnum==1:
    	print("输了！")
    else:
        print('平局！')

# （三）for循环 #

for循环遍历的是任何可迭代对象的返回值，也就是任何可以生成值序列的对象。例如，for循环可以挨个遍历列表、元组或字符串的元素。这里可迭代的对象还可以是特殊的range函数，或者被称为生成器（generator），或生成器表达式的特殊类型函数。常见形式为：

for item in sequence:
        body
    else:
        post-code

对sequence的每个元素都会执行一次body部分的语句。一开始item会被设为sequence的第一个元素，并执行body部分；然后item会被设为sequence的第二个元素并执行body部分，等等，对sequence的其余元素会逐个一次处理。

else部分是可选的。像while循环的else部分一样，很少被用到。break和continue在for循环中的作用，和在while循环中是一样的。

以下循环将会打印出x中每个数字的倒数：

>>> x = [1,2,3,4,5,6]
    >>> for i in x:
    	print(1/i)
    
    	
    1.0
    0.5
    0.3333333333333333
    0.25
    0.2
    0.16666666666666666

在for循环体中，break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。  
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

## 1.range函数 ##

有时候循环需要显式的索引（如值在列表中出现的位置）。这是可以将range函数和len函数结合起来使用，生成供for循环使用的索引序列。

x = [1, 3, 5, 6, -7, 9, -6]
    
    for i in range(len(x)):
        if x[i] < 0:
            print('Found a negative number at index', i)

## 2.用初值和步进值控制range函数 ##

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，也可以使用range指定区间的值。

range函数有两个变体，可以对生成的值序列施以更多的控制。如果range函数带有两个数值参数，则第一个参数是结果序列的起始值，第二个参数是结果序列的结束值（不含）。

>>> for i in range(5):
    	print(i)
    
    	
    0
    1
    2
    3
    4
    >>> for i in range(3, 9):
    	print(i)
    
    	
    3
    4
    5
    6
    7
    8

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做’步长’):

>>> for i in range(0, 10, 3):
    	print(i)
    
    	
    0
    3
    6
    9

负数

>>>for i in range(-10, -100, -30) :
        print(i)
     
        
    -10
    -40
    -70

还可以使用range()函数来创建一个列表，这里list（）函数的作用是把range函数生成的值强制转换为列表。

>>> list(range(5))
    [0, 1, 2, 3, 4]

## 3.for循环和元组拆包 ##

元组拆包操作可以让某些for循环变得简洁一些。以下代码将读取元组列表，每个元组中包含两个元素，计算每个元组中两个数的乘积并进行加和。

somelist = [(1,2), (3, 7), (9, 5)]
    result = 0
    for t in somelist:
        result = result + (t[0] * t[1])

以下代码效果相同但是更为简洁

somelist = [(1,2), (3, 7), (9, 5)]
    result = 0
    for x, y in somelist:
        result = result + (x * y)

元组的这种用法是Python提供的一种便利手段，表示列表的每个元素都应该是大小一致的元组，以便能拆包到for关键字后面跟着的元组变量中。

## 4.enumerate函数 ##

enumerate函数返回的是元组（索引，数据项）。这样可以不通过索引来访问列表的数据项。索引是可用的。

x = [1, 3, 5, 6, -7, 9, -6]
    
    for i, n in enumerate(x):
        if n < 0:
            print('Found a negative number at index', i)

## 5.zip函数 ##

zip函数可以从一个或多个可迭代对象中逐一读取对应元素，并合并为元组，直至长度最短的那个可迭代对象读取完毕。

>>> x = [1, 2, 3, 4]
    >>> y = 'a, b, c'.split()
    >>> z = zip(x, y)
    >>> list(z)
    [(1, 'a,'), (2, 'b,'), (3, 'c')]

## 6.实例： ##

通过for循环打印循环次数，i、j、k分别代表每一个for循环函数的循环次数：

total = 0
    
    for i in range(1, 5):
        for j in range(1, 5):
            for k in range(1, 5):
                if (i != k) and (i != j) and (j != k):
                    total += 1
                    print("{0}{1}{2}".format(i, j, k))
    
    print("Total: ", total)

# （四）列表和字典推导式 #

利用for循环遍历列表、修改或选中某个元素、新建列表或字典，这些都是十分常见的用法。

>>> x = [1, 2, 3, 4]
    >>> x_squared = []
    >>> for item in x:
    	x_squared.append(item * item)
    
    	
    >>> x_squared
    [1, 4, 9, 16]

推导式：

#列表推导式
    new_list = [expression1 for variable in old_list if expression2]
    #字典推导式
    new_dict = [expression: expression2 for variable in list if expression3]

上述例子可以用推导式

>>> x = [1, 2, 3, 4]
    >>> x_squared = [item * item for item in x]
    >>> x_squared
    [1, 4, 9, 16]

甚至可以用if语句来筛选列表的项

>>> x = [1, 2, 3, 4]
    >>> x_squared = [item * item for item in x if item > 2]
    >>> x_squared
    [9, 16]

字典推导式也类似，但是需要同时给出键和值。如果要实现类似上面的例子，需要把数字作为字典键，数字的平方作为字典值，就可以用字典推导式来实现。

>>> x = [1, 2, 3, 4]
    >>> x_squared_dict = { item: item * item for item in x}
    >>> x_squared_dict
    { 1: 1, 2: 4, 3: 9, 4: 16}

## 生成器表达式 ##

生成器表达式（generator expression）类似于列表推导式，看起来于列表推导式十分相像，只是用圆括号代替了方括号而已。

>>> x_squared = (item * item for item in x)
    >>> x_squared
    <generator object <genexpr> at 0x0000026799383660>
    >>> for squared in x_squared:
    	print(squared, )
    
    	
    4
    9
    16

注意，除方括号的变化之外，生成器表达式还不返回列表。如上所示，生成器表达式返回的是生成器对象，可用作for循环中的迭代器，这与range（）函数的用途非常类似。使用生成器表达式的优点是，不会在内存中生成整个列表。因此可以生成任意大小的值序列，内存开销也很小。

# （五）语句、代码块和缩进 #

Python用语句缩进来确定流程控制结构不同代码块（即语句体）的边界。一个代码块由一条或者多条语句组成，语句之间通常由换行符分隔。赋值语句、函数调用、print函数、占位用的pass语句和del语句都是Python语句。代码流程控制结构（if-elif-else、whlie和for循环）则属于复合语句。

复合语句由一条或多条子句组成，每条子句后面跟着缩进代码块。复合语句可以像任何其他语句一样出现在代码块中，这样就创建了嵌套代码块。

如果语句之间使用分号分隔，则可以在同一行放置多条语句。

Python对缩进量没有限制，也不会报错。只要保持同一个代码块中的缩进量一致，缩进多少字符都没有关系，推荐标准是使用4个空格。

任何由空白字符分隔的字符串都会被Python解释器自动拼接起来。

# （六）布尔值和布尔表达式 #

Python有一种布尔对象类型，可以被赋为True或False。所有布尔操作表达式都返回True或False。

## 大多数Python对象都能用作布尔类型 ##

*  数字0、0.0、和0 + 0j都是False，其他数字均为True；
 *  空字符串" "是False，其他字符串均为True；
 *  空列表\[ \]是False，其他列表均为True；
 *  空字典\{ \}是False，其他字典均为True；
 *  空集合（）是False，其他集合均为True；
 *  Python的特殊值None始终为False。

通常情况下，Python的其他数据结构同样适用于上述规则。如果数据结构为空或0，则在布尔上下文中将被视为False，否则被视为True。某些对象（如文件对象和编码对象）对0或空元素没有明确的定义，这些对象也不应该在布尔上下文中使用。

## Python常用操作符 ##

用普通的<、<=、>、>=等操作符，就可以进行对象之间的比较。==是判断相等操作符，!=是判断不等操作符。in和not in操作符用于判断是否属于序列（列表、元组、字符串和字典）的成员，身份操作符is和is not用于判断判断两个对象是否为同一个对象。

**比较运算符**

以下实例演示了Python所有比较运算符的操作：

a = 21
    b = 10
    c = 0
     
    if ( a == b ):
       print ("1 - a 等于 b")
    else:
       print ("1 - a 不等于 b")
     
    if ( a != b ):
       print ("2 - a 不等于 b")
    else:
       print ("2 - a 等于 b")
     
    if ( a < b ):
       print ("3 - a 小于 b")
    else:
       print ("3 - a 大于等于 b")
     
    if ( a > b ):
       print ("4 - a 大于 b")
    else:
       print ("4 - a 小于等于 b")
     
    # 修改变量 a 和 b 的值
    a = 5;
    b = 20;
    if ( a <= b ):
       print ("5 - a 小于等于 b")
    else:
       print ("5 - a 大于 b")
     
    if ( b >= a ):
       print ("6 - b 大于等于 a")
    else:
       print ("6 - b 小于 a")

输出结果为：

1 - a 不等于 b
    2 - a 不等于 b
    3 - a 大于等于 b
    4 - a 大于 b
    5 - a 小于等于 b
    6 - b 大于等于 a

**布尔操作符**

通过and、or、not操作符，可以将返回布尔值的多个表达式组合成更为复杂的表达式。

a = 10
    b = 20
     
    if ( a and b ):
       print ("1 - 变量 a 和 b 都为 true")
    else:
       print ("1 - 变量 a 和 b 有一个不为 true")
     
    if ( a or b ):
       print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
    else:
       print ("2 - 变量 a 和 b 都不为 true")
     
    # 修改变量 a 的值
    a = 0
    if ( a and b ):
       print ("3 - 变量 a 和 b 都为 true")
    else:
       print ("3 - 变量 a 和 b 有一个不为 true")
     
    if ( a or b ):
       print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
    else:
       print ("4 - 变量 a 和 b 都不为 true")
     
    if not( a and b ):
       print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
    else:
       print ("5 - 变量 a 和 b 都为 true")

输出结果为：

1 - 变量 a 和 b 都为 true
    2 - 变量 a 和 b 都为 true，或其中一个变量为 true
    3 - 变量 a 和 b 有一个不为 true
    4 - 变量 a 和 b 都为 true，或其中一个变量为 true
    5 - 变量 a 和 b 都为 false，或其中一个变量为 false

**短路求值**

>>> def ReturnTrue():
    	print('ReturnTrue() was called')
    	return True
    
    >>> def ReturnFalse():
    	print('ReturnFalse() was called')
    	return False
    
    >>> ReturnTrue()
    ReturnTrue() was called
    True
    >>> ReturnFalse()
    ReturnFalse() was called
    False
    >>> ReturnFalse() or ReturnTrue()
    ReturnFalse() was called
    ReturnTrue() was called
    True
    >>> ReturnTrue() or ReturnFalse()
    ReturnTrue() was called
    True

**优先级**

优先级的规则有很多，如果不太确定，可以使用圆括号来确保Python按照要求解释表达式。如果表达式比较复杂，无论是否必要，用圆括号可能都是比较好的做法，因为这可以让以后维护代码的人确切地理解代码地意图。

**参考：**

1.  [菜鸟教程][Link 1]
2.  码云：https://gitee.com/luhuadong/Python\_Learning

[Link 1]: https://www.runoob.com/python3/python3-basic-operators.html#ysf5