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)
 
classrange(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

使用循環打印菱形及閃電形

‘‘‘

*

***

*****

*******

*****

***

*

‘‘‘

規律思路：

首先來分析每行的個數、空格數、以及符號數

涉及到上面的步長功能，行數為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 次即可

本文出自 “心情依舊” 博客，轉載請與作者聯系！

初學python之循環