Python学习笔记（7）-条件与循环语句

发表于 | 分类于
| 字数统计: 4,173 | 阅读时长 ≈ 19

条件与循环语句

条件与循环语句的表达式

在选择结构和循环结构中，都要根据条件表达式的值来确定下一步的执行流程，条件表达式的值只要不是False、0、0.0、0j、None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象，Python解释器都认为其与True等价，从这个意义上来讲，所有Python合法表达式都可以作为条件表达式，包括含有函数调用的表达式。

if语句

if条件语句的格式

1
2
3
4
5
6
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

参数解释：

  1. 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
  2. 如果 “condition_1” 为False，将判断 “condition_2”
  3. 如果”condition_2” 为 True 将执行 “statement_block_2” 块语句
  4. 如果 “condition_2” 为False，将执行”statement_block_3”块语句
  5. 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
  6. 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

if案例

简单的if语句案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
biotest@biotest-VirtualBox:~/python3/02condition$ cat if.py 
#!/usr/bin/python3
var1 =100
if var1:
    print("1 - if expression condition is true")
    print(var1)
var2 = 0
if var2:
    print("2 - if expression condition is true")
    print(var2)
print("Good bye")
biotest@biotest-VirtualBox:~/python3/02condition$ python3 if.py 
1 - if expression condition is true
100
Good bye

使用整数作为if条件表达式

如下所示：

1
2
3
4
>>> if 3:
... print(4)
...
4

if语句中判断相等是用“==”

如下所示：

1
2
3
4
5
>>> a = 8
>>> if a == 8:
... print(a)
...
8

代码解释：if a == 8表示：如果条件a==8返回的值是True，就执行下面的语句，此语句后面的冒号是必需的，下面一行语句print(a)前面要有4个空格的缩进。 如果if后面不放语句时，比如空出来用于后续补充，可以用pass语句，就是什么也不做，如下所示：

pass语句

1
2
if X < 0:
    pass

如果误用了等号作为判断条件，那么就会出错，如下所示：

1
2
3
4
5
>>> if (a = 3) and (b = 4)
  File "<stdin>", line 1
    if (a = 3) and (b = 4)
          ^
SyntaxError: invalid syntax

列表作为if条件表达式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 案例1，非空的列表
>>> a = [1, 2, 3]
>>> if a:
... print(a)
...
[1, 2, 3]
# 案例2，空列表
>>> a = []
>>> if a:
...     print(a)
... else:
...     print('Empty')
...
Empty
>>>

三元运算符

语法为value1 if condition else value2，当条件表达式condition的值与True等价时，表达式的值为value1，否则表达式的值为value2。value1和value2本身可以是复杂的表达式，也可以包括函数调用，如下所示：

1
2
3
4
5
6
7
8
9
>>> a = 5
>>> print(6) if a > 3 else print(5)
6
>>> print(6 if a > 3 else 5)
6
>>> b = 6 if a > 13 else 9 # 赋值运算符优先级低
>>> b
9

三元运算符案例第二：

1
2
3
4
5
6
7
8
name = "qiwsir" if "laoqi" else "github"
print(name)
 
name = "qiwsir" if "" else "github"
print(name)
 
name = "qiwsir" if "github" else ""
print(name)

这种操作的公式为： A = Y if X else Z 这表示为： 如果X为真，那么就执行Y。 如果X为假，那么就执行Z。 如下面的案例： 

1
2
3
4
5
6
7
8
9
10
11
>>> x = 2
>>> y = 8
>>> a = "python" if x > y else "qiwsir"
>>> print(a)
qiwsir
>>>
... x = 2
>>> y = 8
>>> a = "python" if x < y else "qiwsir"
>>> print(a)
python

代码解释：在第一步中，因为x>y是假，因此执行Z，即qiwsir，在第二步中，因为x <y 是真，执行Y，即python。其实可以这么理解，这一段代码是从左向右执行的，如果中间的判别式是对的，则就此执行结束，如果中间的判别式是错的，继续向右执行。

多分枝条件语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
print("请输入任意一个数字： ")
number = int(input())
 
if number == 10:
    print("您输入的数字是: %d" % number)
    print("Youare smart!")
elif number > 10:
    print("您输入的数字是{}".format(number))
    print("This number is more than 10")
elif number < 10:
    print("您输入的数字是： %d" % number)
    print("This number is less than 10")
else:
    print("Are your a human")

运行结果如下所示：

1
2
3
4
请输入任意一个数字：
23
您输入的数字是23
This number is more than 10

代码解释：如果输入的是10，则输出You are smart，如果大于10，则执行下一条语句，如果小于10，执行第三条语句，这第一条到第三条一共有3种选择，称为分支。其中elif是else if的缩写。

if语句的嵌套

1
2
3
4
5
6
if x < y:
    print("x is less than y")
elif x > y:
    print("x is greater than y")
else:
    print("x and y are equal")

上述语句可以改写为嵌套语句，如下所示：

1
2
3
4
5
6
7
if x == y:
    print("x and y are equal")
else:
    if x < y:
         print("x is less than y")
    else:
        print("x is greater than y")

外部的条件判断包含两个分支。第一个分支只有一个简单的语句。第二个分支包含了另外一重条件判断，这个内部条件判断有两个分支。这两个分支都是简单的语句，他们的位置也可以继续放条件判断语句的。 逻辑运算符有时候对简化嵌套条件判断很有用。比如下面这个代码就能改写成更简单的版本: 

1
2
3
if 0 < x:
    if x < 10:
        print("x is a positive single-digit number.")

上面的例子中，只有两个条件都满足了才会运行print语句，所以就用逻辑运算符来实现同样的效果即可：

1
2
if 0 < x and x <10:
    print("x is a positive single-digit number.")

还可以更加简单：

1
2
if 0 < x < 10:
    print("x is a positive single-digit number.")

案例：if…else:面试资格确认

1
2
3
4
5
6
7
age = 24
subject = "计算机 "
college = "非重点"
if (age > 25 and subject =="电子信息工程 ") or (college =="重点" and subject =="电子信息工程") or (age<=28 and subject=="计算机"):
    print("恭喜，您已经获得我公司的面试机会！")
else:
    print("抱歉，您未达到面试要求")

案例if：判断今天是今年的第几天。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import time
date = time.localtime()
# 获取当前日期时间
year,month,day=date[:3]
day_month=[31,28,31,30,31,30,31,31,30,31,30,31]
if year%400 == 0 or (year%4==0 and year%100!=0):
# 判断是否为闰年
    day_month[1] = 29
    
if month ==1:
    print(day)
else:
    print(sum(day_month[:month-1])+day)

while语句

while语句的格式如下所示：

1
2
while 判断条件：
    语句

while语句案例

简单案例

以下实例使用了 while 来计算 1 到 100 的总和： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
biotest@biotest-VirtualBox:~/python3/02condition$ cat while.py 
#!/usr/bin/python3
n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter +=1
print("1 to %d sum up is: %d"%(n, sum))
biotest@biotest-VirtualBox:~/python3/02condition$ python3 while.py 
1 to 100 sum up is: 5050

常量作为while的条件表达式

1
2
3
4
5
6
7
i = s = 0
while i <= 10:
... s+=i
... i+=1
...
print(s)
55

break语句

在while循环语句，满足一定条件时，用break跳出循环：

1
2
3
4
5
6
7
8
9
>>> i =s=0
>>> while True:
...     s+=i
...     i+=1
...     if i > 10:
...         break
...
>>> print(s)
55

while案例

用户输入若干个成绩，求所有成绩的平均分。每输入一个成绩后询问是否继续输入下一个成绩，回答yes就继续输入下一个成绩，回答no就停止输入成绩。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
numbers = []
while True:
    x = input('请输入一个整数:')
    try:
        numbers.append(int(x))
    except:
        print('不是整数')
    while True:
        flag = input('继续输入吗？（yes/no）')
        if flag.lower() not in ('yes','no'):
            print("只能输入yes或no")
        else:
            break
    if flag.lower()=='no':
        break
print(sum(numbers)/len(numbers))

for语句

Python中主要有两种形式的循环结构，for循环和while循环。while循环一般用于循环次数难以提前确定的情况；而for循环一般用于循环次数可以提前确定的情况，尤其适用于枚举或遍历序列或迭代对象中元素的场合。当循环带有else子句时，如果循环因子条件因为条件青工达不成立或序列遍历结束而自然结束时则执行else结构中的语句，如果循环是因为执行了break语句而导致循环提前结束则不执行else中的语句，其完整语法形式为： 

1
2
3
4
while 条件表达式：
       循环体
else：
    else 子句代码块

或者是：

1
2
3
4
for 取值 in 序列或迭代对象：
    循环语句
else:
    else子句代码块

for循环中常用的操作符

操作符 描述
< 小于
<= 小于或等于
> 大于
>= 大于或等于
== 等于，比较对象是否相等
!= 不等于

for循环案例

简单案例

使用for循环遍历：

1
2
3
4
5
>>> for i in range(0, 11,1):
... s +=i
...
>>> print(s)
110

带有else子句的循环结构

1
2
3
4
5
6
7
>>> s = 0
>>> for i in range(1, 101):
... s +=i
... else:
... print(s)
...
5050

带有while的循环结构

1
2
3
4
5
6
7
8
>>> while i <= 100:
... s += i
... i += i
... else:
... print(s)
...
5150
>>>

显示元组中的每个元素

1
2
3
4
5
6
7
8
9
10
>>> for i in range(1, 5):
... print(i)
... else:
... print('The for loop is over')
...
1
2
3
4
The for loop is over

打印字符串中的每个元素

1
2
3
4
5
6
7
8
9
>>> hello = "world"
>>> for i in hello:
... print(i)
...
w
o
r
l
d

根据索引显示每个字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> for i in range(len(hello)):
... print(i)
...
0
1
2
3
4
>>> print("根据每个字符的索引显示每个字符")
根据每个字符的索引显示每个字符
>>> for i in range(len(hello)):
... print(hello[i])
...
w
o
r
l
d
>>>

range()函数的用法

range()函数经常与for循环配合使用，它的用法是range(a,b,c)，其中c为步长，a与b是范围，先看一个简单的案例：

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

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如: 

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

或者指定区间，如下所示：

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

range()函数控制循环次数。

1
2
3
4
5
6
def main(n):
    for i in range(n):
        print((' * '*i).center(n*3))
    for i in range(n, 0, -1):
        print((' * '*i).center(n*3))
main(6)

案例：找出100以内能被3整除的正整数

1
2
3
4
5
6
7
8
>>> aliquot = []
>>> for n in range(1,100):
... if n % 3 == 0:
... aliquot.append(n)
...
>>> print(aliquot)
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
>>>

for循环遍历序列类型对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
>>> name_str = "test" # 字符串
>>> print(type(name_str))
<class 'str'>
>>> for i in name_str:
... print(i)
... ##-----------##
...
t
e
s
t
>>> name_list = list(name_str) # 列表
>>> print(name_str)
test
>>>
>>> for i in name_list: # 列表的循环
... print(i)
... ##-----------##
...
t
e
s
t
>>> name_set = set(name_str) # 集合
>>> print(name_set)
{'e', 's', 't'}
>>> ##-----------##
...
>>> name_tuple = tuple(name_str) # 元组
>>> for i in name_tuple:
... print(i)
... ##-----------##
...
t
e
s
t
>>> name_dict = {"name": "qiwsir", "lang": "python", "website": "qiwsir.github.io"} # 字典
>>> for i in name_dict:
... print(i, "-->", name_dict[i])
...
name --> qiwsir
lang --> python
website --> qiwsir.github.io

遍历字典元素

1
2
3
4
5
6
7
8
9
10
11
>>> a_dict = {"name":"qiwsir","lang":"python","email":"qiwsir@gmail.com","website":"www.itdiffer.com"}
>>> print(a_dict)
{'name': 'qiwsir', 'lang': 'python', 'email': 'qiwsir@gmail.com', 'website': 'www.itdiffer.com'}
>>>
>>> for k,v in a_dict.items():
... print(k,v)
...
name qiwsir
lang python
email qiwsir@gmail.com
website www.itdiffer.com

案例：计算两个列表中对应元素的和

两个列表分别为：a = [1,2,3,4,5]和b = [9,8,7,6,5]，如下所示：

1
2
3
4
5
6
7
8
>>> a = [71,22,663,64,15] 
>>> b = [19,48,74,46,54]
>>> c = []
>>> for i in range(len(a)):
... c.append(a[i] + b[i])
...
>>> print(c)
[90, 70, 737, 110, 69]

案例：将值与键进行转换

1
2
3
4
5
6
7
8
9
>>> yinfor = {"name":"qiwsir","sit":"qiwsir.github.io","lang":"python"}
>>> print(yinfor)
{'name': 'qiwsir', 'sit': 'qiwsir.github.io', 'lang': 'python'}
>>> infor = {}
>>> for k,v in yinfor.items():
... infor[v] = k
...
>>> print(infor)
{'qiwsir': 'name', 'qiwsir.github.io': 'sit', 'python': 'lang'}

案例:字符的切片及循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> raw = "Do you love Python? Python is a good script"
>>> raw_list = raw.split(" ")
>>> print(raw_list)
['Do', 'you', 'love', 'Python?', 'Python', 'is', 'a', 'good', 'script']
>>> for i, string in enumerate(raw_list):
... if string == "Python":
... raw_list[i] = "Ruby"
...
>>> print(raw_list)
['Do', 'you', 'love', 'Python?', 'Ruby', 'is', 'a', 'good', 'script']
>>> # 发现有问题，继续修改：
...
>>> for i, string in enumerate(raw_list):
... if "Python" in string:
... raw_list[i] = "Ruby"
...
>>> print(raw_list)
['Do', 'you', 'love', 'Ruby', 'Ruby', 'is', 'a', 'good', 'script']
>>>
>>> print(" ".join(raw_list))
Do you love Ruby Ruby is a good script

for…else：求1到99中的整数根

1
2
3
4
5
6
7
8
9
10
11
>>> from math import sqrt
>>>
>>> for n in range(99,1,-1): # n是从99到1的整数
... root = sqrt(n) # root是对n开根号
... if root == int(root): # 如果root是整数，就打印n，并中断
... print(n)
... break
... else:
... print("Nothing")
...
81

案例(for…break)：求200以内能被17整除的最大正整数

1
2
3
4
5
6
>>> for i in range(200,0,-2):
... if i%17 ==0:
... print(i)
... break
...
170

案例：鸡兔同笼的问题

假设共有鸡、兔30只，脚90只，求鸡、兔各有多少只？

1
2
3
4
5
6
7
8
>>> for cock in range(1,30):
... rabbit = 30-cock
... if rabbit*4 + cock*2== 90:
... print('鸡的数量为',cock,'只')
... print('兔的数量为',rabbit,'只')
...
鸡的数量为 15 只
兔的数量为 15 只

案例4：求1~100之间能被7整除，但不能同时被5整除的所有整数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> for n in range(1,101):
... if (n%7 ==0) and n%5!=0:
... print(n)
...
7
14
21
28
42
49
56
63
77
84
91
98

案例：输出水仙花数

所谓水仙花数，是指一个3位的十进制数，其余各位数字的立方和恰好等于该数本身。例如，153是水仙花数，因为153=1^3+5^3+3^3。

1
2
3
4
5
6
7
8
9
10
11
>>> for i in range(100,1000):
... ge = i%10
... shi = i//10%10
... bai = i//100
... if ge**3 + shi**3 + bai**3 ==i:
... print(i)
...
153
370
371
407

案例：求200以内能被17整除的最大正整数。

1
2
3
4
5
6
>>> for i in range(200,0,-2):
... if i%17 ==0:
... print(i)
... break
...
170

案例9：while…break判断一个数字的奇偶数

1
2
3
4
5
6
7
8
9
10
>>> a = 8
>>> while a:
... if a % 2 == 0:
... break
... else:
... print("%d is olld number"%a)
... a = 0
...
>>> print("%d is even number"%a)
8 is even number

当a=8的时候，执行循环体中的break跳出循环，执行最后的打印语句，得到结果8 is even number，如果a=9，如下所示： 

1
2
3
4
5
6
7
8
9
>>> a = 9
>>> while a:
... if a % 2 == 0:
... break
... else:
... print("%d is odd number"%a)
... a = 0
...
9 is odd number

此时会跳过break，进入else下面的语句。

enumerate函数

enumerate()是python的内置函数。

enumerate在字典上是枚举、列举的意思，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。enumerate多用于在for循环中得到计数。

同时得到一个元素的索引和内容

1
2
3
4
5
>>> seasons = ['Spring','Summer','Fall','Winter']
>>> print(seasons)
['Spring', 'Summer', 'Fall', 'Winter']
>>> print(list(enumerate(seasons)))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

使用案例

1
2
3
4
5
>>> seasons = ['Spring','Summer','Fall','Winter']
>>> print(seasons)
['Spring', 'Summer', 'Fall', 'Winter']
>>> print(list(enumerate(seasons,start=3)))
[(3, 'Spring'), (4, 'Summer'), (5, 'Fall'), (6, 'Winter')]

列表元素的提取

1
2
3
4
5
>>> mylist = ["qiwsir",703,'python']
>>> print(mylist)
['qiwsir', 703, 'python']
>>> print(list(enumerate(mylist)))
[(0, 'qiwsir'), (1, 703), (2, 'python')]

break语句

break语句和continue语句在while循环及for循环中都可以使用，并且一般常与选择结构结合使用。break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行，如下所示：

简单break案例

1
2
3
4
5
6
7
8
9
10
11
12
如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如: 
​```python
>>>for i in range(5):
...     print(i)
...
0
1
2
3
4
​

或者指定区间，如下所示：

​

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

range()函数控制循环次数。

​

1
2
3
4
5
6
7
def main(n):
    for i in range(n):
        print((' * '*i).center(n*3))
    for i in range(n, 0, -1):
        print((' * '*i).center(n*3))
main(6)
​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
### break案例2：计算小于100的最大素数
从下面的这个案例中就可以看出break语句在循环中的作用 。注：素质又叫质数，质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。
```python
>>> for n in range(100,1,-1):
... for i in range(2,n):
... if n%i == 0:
... break
... else:
... print(n)
... break
...
97

continue语句

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环，如下所示：

continue案例1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
biotest@biotest-VirtualBox:~/python3/02condition$ cat continue2.py 
#!/usr/bin/python3
for letter in 'Runoob':
    if letter == 'o':
        continue
    print('Currnet letter is: ',letter)
var = 10
while var > 0:
    var = var -1
    if var == 5:  # script will jump loop when var=5
        continue
    print('Currnet variable is: ',var)
print("Good bye!")
biotest@biotest-VirtualBox:~/python3/02condition$ python3 continue2.py 
Currnet letter is:  R
Currnet letter is:  u
Currnet letter is:  n
Currnet letter is:  b
Currnet variable is:  9
Currnet variable is:  8
Currnet variable is:  7
Currnet variable is:  6
Currnet variable is:  4
Currnet variable is:  3
Currnet variable is:  2
Currnet variable is:  1
Currnet variable is:  0
Good bye!

continue案例2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> a = 9
>>> while a:
... if a % 2 == 0:
... a = a-1
... continue #如果是偶数，就返回循环的开始
... else:
... print("%d is olld number"%a) #如果是奇数，就打印出来
... a = a-1
...
9 is olld number
7 is olld number
5 is olld number
3 is olld number
1 is olld number

pass语句

Python pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用做占位语句，如下所示：

1
2
>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

pass语句案例1

在面向对象的程序设计中，pass语句经常这么使用，如下所示：

1
2
class MyEmptyClass:
    pass

此时定义了一个类，只是现在没有具体想好怎么写它，先占一个空位。

pass语句案例2

以下代码在字母为o时执行pass语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
biotest@biotest-VirtualBox:~/python3/02condition$ cat pass.py 
#!/usr/bin/python3
for letter in 'Runoob':
    if letter == 'o':
        pass
        print("Execute pass block")
    print('Current letter is :',letter)
print("Good, bye")
biotest@biotest-VirtualBox:~/python3/02condition$ python3 pass.py 
Current letter is : R
Current letter is : u
Current letter is : n
Execute pass block
Current letter is : o
Execute pass block
Current letter is : o
Current letter is : b
Good, bye