判断与循环

# 判断与循环
判断与循环是我们在代码中最常见的部分，通过使用一些代码的语句，计算机可以进行判断，并不断地做某项重复性地工作。在这节里，
我们来学习判断与循环。
## 判断
判断主要是通过通过if...else...语句来执行的。例如如下的代码：
```
age = input('Input your name:')
a = int(age)
if a >= 20:
    print('You can drink alcohol')
else:
    print('You cannot drink alcohol')
```
当然在实际情况中，我们可能会遇到只用if进行一次判断，而不理会else的情况。这种情况下，也可以完整地写出else结构，
并在其中填入“pass”以完成完整的结构。
另外一种情况种，我们可能需要对一件事进行多个逻辑判断，那么，可能存在if...else...if...else...的情况，else和if并用，
在Python中可以使用elif，例如下面的代码：
```
score = input('Input your score:')
s = int(score)
if s >= 90:
    print('A class')
elif 90 > s >= 80:
    print('B class')
elif 80 > s >= 70:
    print('C class')
elif 70 > s >= 60:
    print('D class')
else:
    print('E class')
```
此外，我们还可以在if语句中进行嵌套操作，例如下面的代码：
```
age = input('Input your age:')
a = int(age)
gender = input('Input your gender')

if gender == 'male':
    if a >=16:
        print('You are a man')
    else:
        print('You are a boy')
else:
    if a >=16:
        print('You are a lady')
    else:
        print('You are a girl')
```
### 逻辑判断句
当我们需要进行多条件的判断时，也可以使用一些逻辑连接词来造出逻辑判断句，常用的逻辑判断词如下：

|逻辑连接词|逻辑意义|
|---|---|
|and|“且”|
|or|“或”|
|not|“非”|
|is|“是”|

这里需要特别注意的一点是，逻辑判断词中的“is”表示的是判断二者是否是同一object，这点与我们常用的另一符号“==”经常有同学会混淆。
“==”表达的是值的相等，我们看以下例子来体会其中的区别：
```
a = 1001
b = 1001
c = a
print(a is b)
print(a == b)
print(a is c)
```
运行这段代码的话，我们得到的结果是“False”“True”“True”。回想之前我们提到过的变量的重赋值与编辑的区别，体会其中的共通点。
## 循环
因为有循环语句，所以我们可以让计算机自动地进行一些重复性的工作。Python中的循环，我们一般认为有两种，遍历式循环（for循环）
和条件式循环（while）循环。下面我们会一一进行讲解。
### 遍历式循环（for循环）
所谓遍历式循环，就是对某个集合中的元素依次做某种操作。我们来看一个例子：
```
# 创建一个list a，容纳5个元素，为5个int，1，2，3，4，5
a = [1, 2, 3, 4, 5]
# 创建一个新的空list b, 用来容纳结果
b = list()
# 对list a中的每个元素进行遍历
for x in a:
# 将每个元素与自身相乘
    x = x * x
# 将运算结果放进list b
    b.append(x)
# 打印b，我们来看一下结果
print(b)
```
回忆以下我们在数据类型一节里面学过的内容，所有集合型的数据类型都是可以进行遍历循环的，例如下面的循环，就是针对set的：
```
# 创建一个set s，包含5个int， 1，2，3，4，5
s = {1, 2, 3, 4, 5}
# 创建一个空list l，用来容纳结果
l = list()
# 对set s中的每个元素进行遍历
for x in s:
# 将每个元素与自身相乘
    x = x * x
# 将运算结果放进list l
    l.append(x)
# 打印l，我们来看一下结果
print(l)
```
需要注意的是，我们在上面的代码中，打印的都是专门用来容纳运算结果的新列表，如果我们在代码后面添加一行代码，连同原来的集合也打印出来，
猜猜会是什么样的结果，然后看一下和你想的是不是一样的。例如：
```
# 创建一个list a，容纳5个元素，为5个int，1，2，3，4，5
a = [1, 2, 3, 4, 5]
# 创建一个新的空list b, 用来容纳结果
b = list()
# 对list a中的每个元素进行遍历
for x in a:
# 将每个元素与自身相乘
    x = x * x
# 将运算结果放进list b
    b.append(x)
# 打印b，我们来看一下结果
print(b)
# 打印a，我们来看a是否发生了变化
print(a)
```
这段代码最终打印a的输出结果是[1, 2, 3, 4, 5]，list a本身并没有发生什么变化。那么，我们可以知道，实际上在循环的过程中，
发生的应该是如下的过程：

![1_遍历式循环步骤.png](https://i.loli.net/2019/10/03/mbuxQsch3XDNMnw.png)

所以，list a中的元素，没有发生任何改变。  
那么，如果我们偏要改变这一元素的值呢？也不是完全没有办法。例如，对于list，我们可以用序号来指定其中的某个元素。
在Python中，我们常用一个内建类型“range”来产生序列。例如下面的代码：
```
for i in range(10):
    print(i)
```
输出的结果是“0，1，2，3，4，5，6，7，8，9”。我们可以看到，“range(10)”产生了一个从0到9的序列。
利用range，我们可以用下面的方式来用序号指定list中的某个元素并对其自身进行操作：
```
# 创建一个list l，包含5个int，1，2，3，4，5
l = [1, 2, 3, 4, 5]
# 使用range对序号指定其中的元素, 注意，len()表示某个集合的长度
for i in range(len(l)):
# 使其中第i个元素，等于自身与自身的乘积
    l[i] = l[i] * l[i]
# 打印list l，我们来看这次的结果
print(l)
```
range()经常被用于for循环中，它不止可以产生一个从0开始的序列，还可以设置起点、重点与步长。相关的内容，请查阅官方文档，
学习这一内建type的作用，可以使你的代码更加灵活高效。
###条件式循环（while循环）
与for循环不同的是，for循环是对某一集合中的元素逐一遍历，从第一个元素开始，直到最后一个。完成这个循环的唯一条件就是这个集合中的最后一个元素也被遍历过了。
而while循环则是在每次循环开始之前，对某个条件进行判断，当得到的结果是True的时候，就进行循环中的操作，当条件不满足（判断的结果是False）
的时候，循环结束。  
我们通过以下的例子，来体会while循环工作的原理。我们有一个list l，其中包含5个int，1，2，3，4，5。我们现在从列表末尾开始，**取出**其中一个元素。
将其与自身相乘，结果放入另一个list a中，直到list l成为空集。
```
# 定义一个新list l，包含1，2，3，4，5
l = [1, 2, 3, 4, 5]
# 定义一个空list a，用来容纳运算结果
a = []
# 判断list l是否是空集
while l:
# 从l中取出一个元素，为x进行赋值
    x = l.pop()
# 为x进行重赋值，值为自身的乘积
    x = x * x
# 将x放入a中
    a.append(x)
# 打印a，查看结果
print(a)
```
可以看到，只要while后的判断得到的结果是True，这个循环就会进行下去，除非出现了error（例如超出集合边界）。
因而，有一种特殊情况是使用while True来进行无限的循环，例如，我们可以写一个程序，无限地生成斐波那契数列的下一项并打印出来。
```
# 设定初始项x1
x1 = 1
# 设定初始项x2
x2 = 1
# 循环条件为True，即永远循环下去
while True:
# 计算新一项的值，x3，为前两项之和
    x3 = x1 + x2
# 对x1和x2进行重赋值
    x1 = x2
    x2 = x3
# 打印出新的一项的值
    print(x3)
```
当我们运行这段代码的时候，会看到程序迅速地不断输出大量非常大的数字。我们在使用这样的循环的时候，一定要注意这一点。
而我们如果只想要1000以内的数，我们可以将这个条件添加进while的判断中，像下面的代码：
```
# 设定初始项x1为0
x1 = 0
# 设定初始项x2为1
x2 = 1
# 设定初始项x3，最开始为0
x3 = 0
# 循环条件为下一项小于或等于1000
while x1 + x2 <= 1000:
# 计算新一项的值，x3，为前两项之和
    x3 = x1 + x2
# 对x1和x2进行重赋值
    x1 = x2
    x2 = x3
# 打印出新的一项的值
    print(x3)
```
尽管for循环和while循环在逻辑上有很大的不同，但是，我们在很多情况下可以用for循环和while循环实现同一个功能。
请大家尝试用while循环来实现for循环中第一个例子，用for循环来实现while循环的第一个例子。
###pass和break
在循环中，我们可以插入if语句来进行判断，这时候，就会出现在某些条件下，在这个循环中“什么都不做”或者，达成某个条件，就终止循环的情况。
这两种情况，我们一般用pass和break来实现我们来用一个比较有趣的例子来学习这个pass的使用。  
有一种大家饮酒会时会玩的游戏，叫做“逢三不报”，它的规则是，所有人按照顺时针或者逆时针的顺序，从一开始，逐一报数。
但是，当一个人要叫出的数字是3的倍数，或者其中含有3（例如13，23， 35）， 那么，这个人就要跳过这个数，转而报出它的下一个数。现在，我们来写一小段程序，
也让这段程序“逢三不报”。
```
# 为n赋值1，从头开始
n = 1
# 以True为循环的执行条件，无限循环
while True:
# 如果n是3的倍数，那么什么都不做
    if not n%3:
        pass
# 如果n中“包含”有3，那么什么都不做（想一想，这里为什么要用字符串）
    elif '3' in str(n):
        pass
# 否则，就可以报出（打印）这个数
    else:
        print(n)
# n = n + 1， 进入下一轮
    n += 1
```
我们还可以为这段程序加入终止条件，例如，我们不想让这段程序永远持续下去，不然在我们敲下回车的瞬间，就会发现程序开始不断打印大量的“巨大数字”。
这种情况下，我们可以使用break来终止循环。当然，有的同学这时候想起来，我们可以在while循环中添加条件。这当然是正确的。
不过，我们同样可以用break语句来实现这一功能。例如，逢三不报的程序中，我们希望这个程序的输出最大到100为止。
```
# 为n赋值1，从头开始
n = 1
# 以True为循环的执行条件，无限循环
while True:
# 如果n大于100，循环终止
    if n > 100:
        break
# 如果n是3的倍数，那么什么都不做
    elif not n%3:
        pass
# 如果n中“包含”有3，那么什么都不做（想一想，这里为什么要用字符串）
    elif '3' in str(n):
        pass
# 否则，就可以报出（打印）这个数
    else:
        print(n)
# n = n + 1， 进入下一轮
    n += 1
```
###continue
Continue语句在循环中相对于pass和break稍微难理解一点。它的作用是，什么都不做，结束**这一次**循环，进入下一次。我们以下面这段代码为例。
在这段代码中，我们要完成的任务是从1遍历到1000，如果一个数是17的倍数，那么就将这个数各位的数字平方后相加，将所有结果放在一个list l中。
```
# 创建用于容纳结果的list l
l = list()
# 使用range来创造用于遍历的数列 （想一想，为什么上界是1001）
for i in range(1, 1001):
# 判断i是否被17整除
    if i % 17:
# i除以17，余数不为0的情况下，直接进入下一次循环
        continue
# 否则将各位数字平方后相加
    else:
# 每次做这一操作的时候，创建一个空的list a用来容纳各位数字
        a = list()
# 使用一个循环语句来遍历这一数中的各位数字（注意这里的数据类型转换）
        for n in str(i):
# 将这个数字与自身相乘（注意进行运算时，数据类型又转换回了int）
            n = int(n) * int(n)
# 将平方的结果放入list a
            a.append(n)
# 将list a中的所有数相加，并放入list l （注意这里的缩进位置！在循环中嵌套循环时，注意层次结构！）
        l.append(sum(a))
# 打印出结果list l
print(l)
```
我们可以注意到，在上面的任务中，我们每进行17次循环，才会遇到一次需要对数字处理的情况。那么，如果每次都对数字进行处理，而最终不放入结果list，
那么将占用大量的CPU时间进行无意义的运算，使得这个程序的运行效率非常低下。 因此，我们在每个循环的开始，进行一次判断，如果这个数根本不是17的倍数，
那么我们直接进入下一次循环，不进行无谓的运算导致CPU时间的浪费。

content