Python基础学习笔记（五）——选择结构与循环结构

程序的组织结构

  程序的组织结构主要有以下三种：

• 顺序结构：代码按照从上到下的顺序依次执行，没有条件判断或循环跳转，每一条语句都会被执行且只执行一次，是程序中最简单、最基础的结构。
• 选择（分支）结构：根据条件判断选择执行不同的代码块。
• 循环结构：重复执行一段代码，直到满足退出条件或者不满足循环条件。

条件

  通常指用于控制程序流程的逻辑表达式。

  这些表达式在条件语句中只取布尔值，所以常出现关系、身份、成员、逻辑这类返回bool类型的运算符，但这不意味着条件一定是结果为bool的表达式。

  Python是一门面向对象的编程语言，Python一切皆对象，而对象皆有布尔值。也就是说，条件不一定是布尔类型的。
  即数据类型篇提到过的 任何类型的数据都能转化为布尔型。以下用简单的选择语句进一步说明：

# 对象皆有布尔值
print(bool(1))
print(bool(0))

# 条件可以是任意对象
if 1 < 2:
    print('dandelion')
    
if 1:
    print('02')

True
False
dandelion
02

  绝大部分的对象的布尔值均为True，仅有一些特殊对象的布尔值为False，如：空值，没有元素的组合类型数据（空字符串、空列表、空元组、空字典、空集合）

False, 0, None, '', []/list(), ()/tuple(), {}/dict(), set()

选择结构

1. 单分支结构

  只通过if语句实现：当且仅当if后的条件的布尔值为True时，执行相应的代码块。

condition = 'dandelion'
if condition:
    print(condition)

dandelion

  代码块需要缩进，通常使用4个空格或1个制表符\t（即键盘上的TAB）进行缩进。

2. 双分支结构

  通过if...else...语句实现：若if后的条件的布尔值为True，执行if对应的代码块；若if后的条件的布尔值为False，执行else对应的代码块。

# 判断整数奇偶性
num = int(input('give an integer:\n'))
if num & 1:
    print('odd')
else:
    print('even')

  上面的代码通过双分支结构实现了奇偶性判断的功能：1的二进制只有最低位是1，其余位都是0，这意味着任何整数与1按位与的二进制结果只有一位，即0或1。而奇数与偶数的一个典型区别就是在于它们的二进制的最低位不同，奇数（odd）的最低位是1，偶数（even）的最低位是0。由于0和1的布尔值不同，即可实现。

3. 多分支结构

  通过if...elif...else...语句实现：从上至下依次判断if或elif后的条件，若有一个条件为True，便执行相应的代码块，不再判断后续的条件；若条件全为False，则执行else对应的代码块。

grade = float(input('give your score:\n'))
if 90 <= grade <= 100:
    print('A')
elif 80 <= grade < 90:
    print('B')
elif 70 <= grade < 80:
    print('C')
elif 60 <= grade < 70:
    print('D')
else:
    print('fail or valid')

  上面的代码通过多分支结构实现了成绩分级的功能。值得一提的是，这里使用了链式比较，比如说，下面给出两个条件是等价的：

90 <= grade <= 100
grade <= 100 and grade >= 90

4. 嵌套（分支）结构

  程序的结构允许多层嵌套。这意味着在一个条件语句的代码块中可以使用另一个条件语句，从而根据更复杂的条件组合执行不同的代码块。

membership = input('Are you a membership?	y/n\n')
fee = float(input('Input your spending:\n'))
# 外分支结构：判断用户是否为会员
if membership == 'y':
    # 内分支结构：判断消费额度
    if fee >= 2000:
        print('disbursement:', fee * 0.8)
    elif fee >= 1000:
        print('disbursement:', fee * 0.9)
    else:
        print('disbursement:', fee)
elif membership == 'n':
    print('disbursement:', fee * 1.1)
else:
    print('something is wrong')

  上面的代码通过嵌套分支结构实现了折扣计价的功能。

5. 无内容执行

  当执行内容未确定，或者不想要执行任何内容时，由于代码块不能为空，可以用pass命令让程序跳过该处得以正常运行。

if input('guess who I am?\n') == 'dandelion':
    print('you are right')
else:
    pass

6. 条件表达式

  条件语句的简化表达式：if执行语句 if 条件 else else执行语句

# 比较数值大小
num1 = float(input('num1 = '))
num2 = float(input('num2 = '))

print('num1 >= num2') if num1 >= num2 else print('num2 >= num1')

  当代码块的执行语句调用的函数相同时，则有：执行函数（if执行参数 if 条件 else else执行参数）

print('num1 >= num2' if num1 >= num2 else 'num2 >= num1')

循环结构

1. 可迭代对象

  所有可以用循环语句遍历的对象，例如：生成器、迭代器、所有的组合数据类型。判断一个对象是否为可迭代对象的代码如下：

from collections.abc import Iterable, Iterator
# 常见的可迭代对象包括字符串、列表、元组、集合、字典，以及range类对象
print(isinstance([], Iterable), isinstance({}, Iterable), isinstance((), Iterable))
print(isinstance(zip([]), Iterator), isinstance(map(lambda x: x, {1}), Iterator), isinstance((i for i in (1, 2)), Iterator))

True True True
True True True

  这部分内容将在类与方法篇中展开。

2. range()函数

  返回一个在指定区间上具有确定步长的整数序列。它有三个参数：

• start=0：可选参数，序列的起始值，区间的闭端点，默认为0
• stop ：必选参数，序列的结束值，区间的开端点
• step=1：可选参数，序列的每个数字之间的差值，默认为1

# range(stop) = [0,1,…,stop-1]
r = range(10)
print(r)
print(list(r))	# range对象可转化为列表

# range(start,stop) = [start,start+1,…,stop-1]
print(list(range(1, 10)))

# range(start,stop,step) = [start,start+step,…,start+(stop-start)//step*step]
print(list(range(1, 10, 2)))

# step<0：逆向生成序列
print(list(range(6, 3, -1)))

range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[1, 3, 5, 7, 9]

[6, 5, 4]

  需要注意的是，step = 0时会报错；而在正步长下start > stop，或在负步长下start < stop，则会返回空列表。

print(list(range(4, 3)))
print(list(range(4, 3, 0)))

[]
ValueError: range() arg 3 must not be zero

  range的优势是：不论创建的序列多长，占用的内存空间几乎相同，因为它返回的range类对象只存储了三个参数属性，调用时才开始计算序列元素。

3. for循环语句

  for循环格式为：for 变量 in 可迭代对象 : 循环体

  创建一个（或多个）局部变量，这个变量的作用域限制在for循环内。每轮循环开始时，先从可迭代对象中依序取出一个元素，将其值赋予变量，这个过程称为遍历。
  遍历成功后，则执行相应的代码块，然后进入下一轮循环。这个代码块称为循环体，该变量仅在循环体中可调用。循环条件为：可迭代对象中仍有下一个值；否则循环结束。

  以下为演示程序 输出100~999之间的水仙花数

水仙花数(Narcissistic number)：每个位上的数字的 n 次幂之和等于它本身的 n 位数(n≥3)。
例如，153 = 1^3 + 5^3 + 3^3。

# 规定区间
for i in range(100, 1000):
	# 个位
    a = i % 10
    # 十位
    b = i // 10 % 10
    # 百位
    c = i // 100
	# 嵌套：内分支结构
    if i == a**3+b**3+c**3:
        print(i)

153
370
371
407

  若声明的临时变量不被调用，则语句仅用于设置执行次数。这种情况下，也可以选择不创建变量，如：

# 无效变量
for item in range(3):
    print('重要的事情说三遍')

# 无变量 for循环
for _ in range(3):
    print('重要的事情说三遍')

重要的事情说三遍
重要的事情说三遍
重要的事情说三遍

4. while循环语句

  while循环格式为：while 循环条件 : 循环体
  先判断循环条件，条件为True则执行循环体，并进入下一轮循环；任一轮判断中，条件为False，则跳出循环。在这个过程中，判断N+1次，执行N次。

# 等差数列求和
start = 1
step = 1
stop = 10
sum_ = 0
while start <= stop:
    sum_ += start
    start += step
print(sum_)		# 55

  while循环是for循环的功能拓展，但在遍历取值上，for循环比while循环更简洁。

5. 结束语句

  break语句可以跳出本层循环，若存在外层循环，则会进入下一轮 外层 循环。
  continue语句可以结束本轮循环，进入下一轮 本层 循环。

# 判断列表中的字符串是否存在大写字母
lst = ['aSefgx', 'spoej', 'frQDxf']
# 判断结束标志
flag = 0
# 遍历列表
for i in lst:
    # 遍历字符串
    for j in i:
        # 大写字母的ascll码区间
        if 65 <= ord(j) <= 90:
            # 存在
            print(True)
            # 判断结束
            flag = 1
            # 跳出内层循环，结束对该字符串的遍历
            break
    # 判断已结束
    if flag:
        # 标志初始化
        flag = 0
        # 结束本轮外层循环，继续对列表的遍历
        continue
    # 不存在，本轮外层循环自然结束
    print(False)

  以上代码用嵌套循环分支结构实现了大写字母检测，并演示了如何使用结束语句，在合适的情况结束循环。