初学python之循环

浅见池也

　　while
　　当满足条件则进入循环体
　　while condition:
　　block
　　例：
flag = 10　　
while flag:
　　
   print (flag)
　　
   flag -= 1
　　flag为真值，则为条件满足，当flag直接为0的时候则为假，则不满足while判断
　　如果是负数也为真，因为只有0为假
　　打印结果如下：
　　9
　　8
　　7
　　6
　　5
　　4
　　3
　　2
　　1
　　for循环
　　不做多介绍，for循环则是在一个可迭代的对象中进行迭代循环
　　每一次将集合中筛取，这个集合可能是顺序的 可能不是顺序的，但是每一次都是不同的
　　range 步长
　　首先来看一下步长的含义
　　python中使用help(关键字) 可以看到其帮助手册
>>>help(range)　　

　　
cla***ange(object)
　　
| range(stop) -> range object
　　
| range(start, stop[, step]) -> range object     从开始到结尾，中间跟其下一跳数
　　例：
>>>range(5,10)　　
[5, 6, 7, 8, 9]
　　
>>>range(5,10,2)
　　
[5, 7, 9]
　　以负数进行排序
>>> range(10,1,-1)　　
[10, 9, 8, 7, 6,5, 4, 3, 2]
　　使用for循环进行遍历：
In [3]: for i inrange(0,10,2):　　
  ...: if i& 1:
　　
  ...:continue
　　
  ...:print (i)
　　
  ...:
　　

　　
0
　　
2
　　
4
　　
6
　　
8
　　使用for循环计算1000以内能被7整除的前20个数：
count = 0　　
for i inrange(1,1000):
　　
    ifcount == 20:
　　
       break
　　
    ifi % 7 == 0: count += 1 ; print (i)
　　改进：使用range一次跨7个步长，这样可以减少步骤
count = 0　　
for i in range(0,1000,7):
　　
   print (i)
　　
   count += 1
　　
    ifcount >= 20: break
　　大于的作用是在不明确结果的时候怕出现判断错误，所以使用>=作为边界判断条件
　　使用while实现1000内能被7整除的前20个数
　　初步实现：
count = 0　　
x = 0
　　
a = True
　　
while a:
　　
    x+= 7
　　
    ifx % 7 == 0:
　　
       count += 1
　　
       print (x)
　　
    ifcount == 20:
　　
       a = False
　　改进：
　　首先，以上代码做了无用判断，代码在最初开始打印x，由于第一个数字是0，肯定是可以被其整除，
　　其次，每次循环+7 也就是每次都递增+7 依次为 714 21 28... 这样以来不需要进行判断if x % 7 == 0 的步骤，以节省效率
count = 0　　
x = 0
　　
a = True
　　
while a:
　　
   print (x)
　　
    x+= 7
　　
   count += 1
　　
    ifcount == 20:
　　
       a = False
　　使用循环打印个十百千分布的位数
val =input('>>>')　　
val = int(val)
　　
print(val)
　　

　　
if val >=1000:
　　
    ifval >= 10000:
　　
       num = 5
　　
   else:
　　
       num = 4
　　

　　
else:
　　
    ifval >= 100:
　　
       num = 3
　　
   elif val >= 10:
　　
       num = 2
　　
   else:
　　
       num = 1
　　

　　
# 拆分
　　
print (num)
　　
pre = 0
　　

　　
for i inrange(num,0,-1):
　　
    cur= val // (10 ** (i -1))
　　
   print (cur - pre * 10)
　　
   pre = cur
　　循环else字句
　　当循环执行完成后再进行执行else子句，如果中断循环则不再执行else
for i inrange(5):　　
   print(i)
　　
else:
　　
   print('ok')
　　如果加break则不会执行else字句
for i inrange(100):　　
    ifi > 50:
　　
       break
　　
else:
　　
   print ('ok')
　　求奇数和
a = 0　　
for i inrange(1,100,2):
　　
  a = a + i
　　
else:
　　
  print (a)
　　求阶乘
num = 0　　

　　
for i inrange(1,6):
　　
   sum = i
　　
   for j in range(1,i):
　　
       sum *= j
　　
   num += sum
　　
print(num)
　　改进：通过一个循环来进行阶乘
num = 1　　
num2 = 0
　　
for n inrange(1,6):
　　
   num = num * n
　　
   num2 = num2 + num
　　
print (num2)
　　使用while求阶乘
num = 0　　
num2 = 1
　　
num3 = 0
　　
while num <5:
　　
   num += 1
　　
   num2 = num2 * num
　　
   num3 += num2
　　
   print (num3)
　　使用循环打印9x9乘法表，要求如下：
　　1 * 1 = 1   1 * 2 = 2    1 * 3 = 3    1 * 4 = 4    1 *5 = 5    1 * 6 = 6    1 * 7 = 7    1 * 8 =8    1 * 9 = 9
　　2 * 2 = 4   2 * 3 = 6    2 * 4 = 8    2 * 5 = 10   2 *6 = 12   2 * 7 = 14   2 * 8 = 16   2 * 9 = 18
　　3 * 3 = 9   3 * 4 = 12   3 * 5 = 15   3 * 6 = 18   3 *7 = 21   3 * 8 = 24   3 * 9 = 27
　　4 * 4 = 16  4 * 5 = 20   4 * 6 = 24   4 * 7 = 28   4 *8 = 32   4 * 9 = 36
　　5 * 5 = 25  5 * 6 = 30   5 * 7 = 35   5 * 8 = 40   5 *9 = 45
　　6 * 6 = 36  6 * 7 = 42   6 * 8 = 48   6 * 9 = 54
　　7 * 7 = 49  7 * 8 = 56   7 * 9 = 63
　　8 * 8 = 64  8 * 9 = 72
　　9 * 9 = 81
　　代码如下：
for i inrange(1,10):　　
   for q in range(i,10):
　　
       num = i * q
　　
       print ('{0} * {1} = {2:<2}  '.format(i,q,num),end=' ')
　　
   print (' ')
　　进阶，要求打印如下图序列:
　　1x1=1
　　1x2=2    2x2=4
　　1x3=3   2x3=6    3x3=9
　　1x4=4   2x4=8  3x4=12   4x4=16
　　1x5=5   2x5=10  3x5=15  4x5=20  5x5=25
　　1x6=6   2x6=12  3x6=18  4x6=24  5x6=30  6x6=36
　　1x7=7   2x7=14 3x7=21  4x7=28  5x7=35  6x7=42  7x7=49
　　1x8=8   2x8=16  3x8=24  4x8=32  5x8=40 6x8=48  7x8=56  8x8=64
　　1x9=9  2x9=18  3x9=27  4x9=36  5x9=45  6x9=54 7x9=63  8x9=72  9x9=81
　　分析：
　　1.首先空格是与换行一起打印的，那么就是说空格只有9次打印，也就是说是需要在第一层循环中进行打印
　　2.空格都是有规律的
　　首先打印出来要求的格式
for i inrange(1,10):　　
   for q in range(1,i+1):
　　
       num = i * q
　　
       print ('{} x {}={:<2}'.format(i,q,num),end = ' ')
　　
   print(' ')
　　

　　
#如下：
　　

　　
1 x 1=1
　　
2 x 1=2  2x 2=4
　　
3 x 1=3  3x 2=6  3 x 3=9
　　
4 x 1=4  4x 2=8  4 x 3=12 4 x 4=16
　　
5 x 1=5  5x 2=10 5 x 3=15 5 x 4=20 5 x 5=25
　　
6 x 1=6  6x 2=12 6 x 3=18 6 x 4=24 6 x 5=30 6 x 6=36
　　
7 x 1=7  7x 2=14 7 x 3=21 7 x 4=28 7 x 5=35 7 x 6=42 7 x 7=49
　　
8 x 1=8  8x 2=16 8 x 3=24 8 x 4=32 8 x 5=40 8 x 6=48 8 x 7=56 8 x 8=64
　　
9 x 1=9  9x 2=18 9 x 3=27 9 x 4=36 9 x 5=45 9 x 6=54 9 x 7=63 9 x 8=72 9 x 9=81
　　
[Finished in0.1s]
　　接下来就是空格问题了，首先让其进行相乘，我们看到第一行是基于最右列，那么空格数量肯定是需要叠加的，那么我们改进如下：
print (' ' * (9- i),end = ' ' )　　效果如下：
　　1 x 1=1
　　2 x 1=2  2 x 2=4
　　3 x 1=3  3 x 2=6  3 x 3=9
　　以此类推，以这样方式，我们只需要当i每次循环的时候 使用最大数去减i，得出当前最少数，保证叠加的次数
　　最终如下：
for i inrange(1,10):　　
   print (' ' * (9 * (9 - i)),end = ' ')
　　
   for q in range(1,i+1):
　　
       num = i * q
　　
       print ('{} x {}={:<2}'.format(i,q,num),end = ' ')
　　
   print(' ')
　　1 x 1= 1
　　2 x 1= 2 2 x 2= 4
　　3 x 1= 3 3 x 2= 6 3 x 3= 9
　　4 x 1= 44 x 2= 8 4 x 3=12 4 x 4=16
　　使用循环打印菱形及闪电形
　　'''
　　*
　　***
　　*****
　　*******
　　*****
　　***
　　*
　　'''
　　规律思路：
　　首先来分析每行的个数、空格数、以及符号数
　　行数
　　符号个数
　　空格
　　1
　　1
　　3
　　2
　　3
　　2
　　3
　　5
　　1
　　4
　　7
　　0
　　5
　　5
　　1
　　6
　　3
　　2
　　7
　　1
　　3
　　涉及到上面的步长功能，行数为7，也就是说我们需要遍历7次，而符号和空格分别最多为3个，
　　那么：
In [20]:list(range(-3,4))　　
Out[20]: [-3,-2, -1, 0, 1, 2, 3]
　　当循环的过程，我们只需要用最大数进行减操作，最小数及逆行加操作即可
　　那么当执行到负数的时候，我们只需要正负切换即可
for i inrange(-3,4):　　
    ifi < 0:
　　
       p = -i
　　
   elif i > 0:
　　
       p = i
　　
   print (' '*p + '*' * (7-p*2))
　　[-3, -2, -1, 0, 1, 2, 3]
　　首先进行遍历
　　前三为小于0，那么需要将其转为正数，这里的3为空格进行方便的打印
　　测试如下：
In [25]: '*' *-3　　
Out[25]: ''
　　

　　
In [26]: '*' *-2
　　
Out[26]: ''
　　

　　
In [27]: '*' *-1
　　
Out[27]: ''
　　

　　
In [28]: '*' * 0
　　
Out[28]: ''
　　

　　
In [29]: '*' * 1
　　
Out[29]: '*'
　　那么，通过判断是否大于0的方式对其进行正负数字的切换
In [30]: a = -3　　

　　
In [31]: a = --3
　　

　　
In [32]: a
　　
Out[32]: 3
　　转为正数后，则进行打印如下：
In [35]: p = a　　

　　
In [36]: print('space ' * p )
　　
space spacespace
　　那么，空格先出来， 接下来打印星号
　　星号的规律：
　　总数为7，头行为1，每行+2，以此类推，那么可以写为：
'*' * (7 -p * 2)　　如下：
In [53]: 7 - 3 *2　　
Out[53]: 1
　　

　　
In [54]: 7 - 2 *2
　　
Out[54]: 3
　　

　　
In [55]: 7 - 1 *2
　　
Out[55]: 5
　　那么转为我们的代码为：
　　I
n [61]: total =7　　

　　
In [62]: i = -1
　　

　　
In [63]: p = -i
　　

　　
In [64]: p
　　
Out[64]: 1
　　

　　
In [65]: total -p * 2
　　
Out[65]: 5
　　

　　
p = 1
　　
In [67]: print(' ' * p +  '*' * (total -p * 2))
　　
*****
　　
p = 2
　　
In [75]: print(' ' * p +  '*' * (total -p * 2))
　　
  ***
　　
p = 3
　　
In [73]: print(' ' * p +  '*' * (total -p * 2))
　　
   *
　　最终代码如下：
for i inrange(-3,4):　　
    ifi < 0:
　　
       p = -i
　　
   else:
　　
       p = i
　　
   print (' '*p + '*' * (7-p*2))
　　拓展，打印如下闪电形：
　　*
　　**
　　***
　　*******
　　***
　　**
　　*
　　分析：也是空格问题，只需要控制输出打印空格的位置即可
for i inrange(-3,4):　　
    ifi < 0:
　　
       p = -i
　　
       print (' ' * p + '*' * (4-p))
　　
   elif i >0:
　　
       p = i
　　
       print (' ' * 4 + '*' * (4-p))
　　
   else:
　　
       print ('*' * 7)
　　改进：
　　首先空格最多为4个，所以都以4为准，
for i inrange(-3,4):　　
    ifi < 0:
　　
       print (' ' * (-i) + '*' * (4 + i))
　　
   elif i >0:
　　
       print (' ' * 4 + '*' * (4 - i))
　　
   else:
　　
       print ('*' * 7)
　　打印斐波那契数列
　　0 1 1 2 3 5 8 13 21 34 55  ...
a = 0　　
b = 1
　　
c = 0
　　

　　
for i inrange(10):
　　
    c= a
　　
    a= b
　　
    b= c + a
　　
   print (b)
　　求斐波那契第101项
a = 0　　
b = 1
　　
c = 0
　　
index = 0
　　
for i inrange(10):
　　
    c= a
　　
    a= b
　　
    b= c + a
　　
   index += 1
　　
    ifindex == 101:
　　
        print (b)
　　
        break
　　求10万内所有素数
for i inrange(2,100000):　　
   for x in range(2,i):
　　
       if i % x:
　　
           break
　　
   else:
　　
       print(x)
　　这样效率太低了
　　改进:
　　使用开根号+1进行分割
count = 0　　
for x inrange(2,100000):
　　
   for i in range(2,int(x ** 0.5) + 1):
　　
       if x % i == 0:
　　
           break
　　
   else:
　　
       count += 1
　　

　　
print (count)
　　开根号的目的：因为一个数的因数是成对出现的,其中一个因数在开方后的前面一个在开方后的后面,所以只需判断它前面的数就可以了
　　比如要判断17，k = sqrt（17） = 4.123；，k的平方就是17，设17能被a整除，b =17/a;
　　如果a<k;b就一定大于K，循环判断时候只需要让17除以从2到k之间的数，减少运算次数，提高程序效率
　　在python中计算根号的方式为 num ** num
In [82]: 100 **.05　　
Out[82]:1.2589254117941673
　　将其转为int型
In [83]: int(100** .05)　　
Out[83]: 1
　　那么如果我们用传统的方式进行循环，则循环10w之后依次对每个再次进行遍历
　　如果使用开根号的方式的话，则可以折半进行运算，以提高其效率
　　也就是说最多只需要315 * 10000 次即可