Python 入门笔记10——循环结构

控制语句

  变量、数据类型（整数、浮点数、布尔）、序列（字符串、列表、元组、字典、集合），可以看做是数据的组织方式。数据可以看做是“砖块”！
  流程控制语句是代码的组织方式，可以看做是“混凝土”。
  一个完整的程序，离不开“砖块”，也离不开“混凝土”。他们的组合，才能让我们建立从小到“一个方法”，大到“操作系统”，这样各种各样的“软件”。

循环结构

  循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True，如果 为 True 则重复执行循环体里的语句。图示如下：

  循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；否则，就会变成一个死循环。

while 循环

  while 循环的语法格式如下：

  while 条件表达式：
     循环体语句

代码示例：利用 while 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和。

n = 0
sum = 0
sum_odd = 0
sum_even = 0
while n < 100:
    n += 1
    sum += n
    if n % 2 ==0:
        sum_even += n
    else:
        sum_odd += n

print("1-100所有数累加和{0}\n1-100所有偶数累加和{1}\n1-100所有奇数累加和{2}".format(sum,sum_even,sum_odd))

输出结果：

1-100所有数累加和5050
1-100所有偶数累加和2550
1-100所有奇数累加和2500

for 循环

  for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：

  for 变量 in 可迭代对象：
    循环体语句

代码示例：利用for循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和， 计算 1-100 之间奇数的累加和。

sum = 0
sum_odd = 0
sum_even = 0
for i in range(101):
    sum += i
    if i % 2 ==0:
        sum_even += i
    else:
        sum_odd += i

print("1-100所有数累加和{0}\n1-100所有偶数累加和{1}\n1-100所有奇数累加和{2}".format(sum,sum_even,sum_odd))

输出结果：

1-100所有数累加和5050
1-100所有偶数累加和2550
1-100所有奇数累加和2500

可迭代对象

  Python 包含以下几种可迭代对象：

1. 序列。包含：字符串、列表、元组
2. 字典
3. 迭代器对象（iterator）
4. 生成器函数（generator）
5. 文件对象

代码示例：遍历字符串中的字符

for x in "abxdfefada":
    print(x,end="")

输出结果：

abxdfefada

代码示例：遍历字典

c = {
     "name":"russell","age":18,"job":"datascientist"}
for x in c.items():
    print(x)

输出结果：

('name', 'russell')
('age', 18)
('job', 'datascientist')

range 对象

  range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：

range(start, end [,step])

  生成的数值序列从 start 开始到 end 结束（不包含 end）。若没有填写 start，则默认从 0 开始。step 是可选的步长，默认为 1。如下是几种典型示例：

>>> for i in range(10):
	print(i,end=" ")

0 1 2 3 4 5 6 7 8 9 

>>> for i in range(1,10,2):
	print(i,end=" ")

	
1 3 5 7 9 

嵌套循环

  一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。

代码示例：打印以下循环：

for i in range(5):
    for j in range(5):
        print(i,end=" ")
    print()

输出结果：

0 0 0 0 0 
1 1 1 1 1 
2 2 2 2 2 
3 3 3 3 3 
4 4 4 4 4 

代码示例：利用嵌套循环打印九九乘法表

for i in range(1,10):
    for j in range(1,10):
        if i >= j:
            print("{0}*{1}={2}".format(i,j,i*j),end=" ")
    print()

输出结果：

1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 

break 语句

  break 语句可用于 while 和 for 循环，用来结束整个循环。当有嵌套循环时，break 语句只能跳出最近一层的循环。

代码示例：使用 break 语句结束循环

n = 0
sum = 0
while True:
    n += 1
    sum += n
    if n // 10 == 10:
        break

print("1-100数加和",sum)

输出结果：

1-100数加和 5050

continue 语句

  continue 语句用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最近的一层循环。

代码示例：使用continue完成1-100偶数加和

sum_even = 0
for i in range(101):
    if i % 2 ==1:
        continue
    else:
        sum_even += i

print("1-100偶数加和",sum_even)

else 语句

  while、for 循环可以附带一个 else 语句（可选）。如果 for、while 语句没有被 break 语句结束，则会执行 else 子句，否则不执行。语法格式如下：

  while 条件表达式：
    循环体
  else:
    语句块
  或者：
  for 变量 in 可迭代对象
    循环体
  else:
    语句块

代码示例：else

sum_even = 0
for i in range(101):
    if i % 2 ==1:
        continue
    else:
        sum_even += i
else:
    print("1-100偶数加和",sum_even)

1-100偶数加和 2550

循环代码优化

  虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：

1. 尽量减少循环内部不必要的计算
2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
3. 局部变量查询较快，尽量使用局部变量

其他优化手段：

4. 连接多个字符串，使用 join()而不使用+
5. 列表进行元素插入和删除，尽量在列表尾部操作

代码示例：内层循环计算耗时与外层循环计算耗时对比

import time

start = time.time()
for i in range(10000):
    result = []
    for m in range(10000):
        result.append(i*1000+m*100)

end = time.time()
print("内层循环计算耗时：{0}".format((end-start)))

start2 = time.time()
for i in range(10000):
    result = []
    c = i*1000
    for m in range(10000):
        result.append(c+m*100)

end2 = time.time()
print("外层循环计算耗时：{0}".format((end2-start2)))

内层循环计算耗时：33.943952560424805
外层循环计算耗时：27.861899614334106