while
当满足条件则进入循环体
while condition:
block
例：
|
1
2
3
4
|
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(关键字) 可以看到其帮助手册
|
1
2
3
4
5
|
>>>
help
(
range
)
classrange(
object
)
|
range
(stop)
-
>
range
object
|
range
(start, stop[, step])
-
>
range
object
从开始到结尾，中间跟其下一跳数
|
例：
|
1
2
3
4
|
>>>
range
(
5
,
10
)
[
5
,
6
,
7
,
8
,
9
]
>>>
range
(
5
,
10
,
2
)
[
5
,
7
,
9
]
|
以负数进行排序
|
1
2
|
>>>
range
(
10
,
1
,
-
1
)
[
10
,
9
,
8
,
7
,
6
,
5
,
4
,
3
,
2
]
|
使用for循环进行遍历：
|
1
2
3
4
5
6
7
8
9
10
11
|
In [
3
]:
for
i inrange(
0
,
10
,
2
):
...:
if
i&
1
:
...:
continue
...:
print
(i)
...:
0
2
4
6
8
|
使用for循环计算1000以内能被7整除的前20个数：
|
1
2
3
4
5
|
count
=
0
for
i inrange(
1
,
1000
):
ifcount
=
=
20
:
break
ifi
%
7
=
=
0
: count
+
=
1
;
print
(i)
|
改进：使用range一次跨7个步长，这样可以减少步骤
|
1
2
3
4
5
|
count
=
0
for
i
in
range
(
0
,
1000
,
7
):
print
(i)
count
+
=
1
ifcount >
=
20
:
break
|
大于的作用是在不明确结果的时候怕出现判断错误，所以使用>=作为边界判断条件
使用while实现1000内能被7整除的前20个数
初步实现：
|
1
2
3
4
5
6
7
8
9
10
|
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 的步骤，以节省效率
|
1
2
3
4
5
6
7
8
9
|
count
=
0
x
=
0
a
=
True
while
a:
print
(x)
x
+
=
7
count
+
=
1
ifcount
=
=
20
:
a
=
False
|
使用循环打印个十百千分布的位数
|
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
|
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
|
1
2
3
4
|
for
i inrange(
5
):
print
(i)
else
:
print
(
'ok'
)
|
如果加break则不会执行else字句
|
1
2
3
4
5
|
for
i inrange(
100
):
ifi >
50
:
break
else
:
print
(
'ok'
)
|
求奇数和
|
1
2
3
4
5
|
a
=
0
for
i inrange(
1
,
100
,
2
):
a
=
a
+
i
else
:
print
(a)
|
求阶乘
|
1
2
3
4
5
6
7
8
|
num
=
0
for
i inrange(
1
,
6
):
sum
=
i
for
j
in
range
(
1
,i):
sum
*
=
j
num
+
=
sum
print
(num)
|
改进：通过一个循环来进行阶乘
|
1
2
3
4
5
6
|
num
=
1
num2
=
0
for
n inrange(
1
,
6
):
num
=
num
*
n
num2
=
num2
+
num
print
(num2)
|
使用while求阶乘
|
1
2
3
4
5
6
7
8
|
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
代码如下：
|
1
2
3
4
5
|
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.空格都是有规律的
首先打印出来要求的格式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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
]
|
接下来就是空格问题了，首先让其进行相乘，我们看到第一行是基于最右列，那么空格数量肯定是需要叠加的，那么我们改进如下：
|
1
|
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，得出当前最少数，保证叠加的次数
最终如下：
|
1
2
3
4
5
6
|
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个，
那么：
|
1
2
|
In [
20
]:
list
(
range
(
-
3
,
4
))
Out[
20
]: [
-
3
,
-
2
,
-
1
,
0
,
1
,
2
,
3
]
|
当循环的过程，我们只需要用最大数进行减操作，最小数及逆行加操作即可
那么当执行到负数的时候，我们只需要正负切换即可
|
1
2
3
4
5
6
|
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为空格进行方便的打印
测试如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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的方式对其进行正负数字的切换
|
1
2
3
4
5
6
|
In [
30
]: a
=
-
3
In [
31
]: a
=
-
-
3
In [
32
]: a
Out[
32
]:
3
|
转为正数后，则进行打印如下：
|
1
2
3
4
|
In [
35
]: p
=
a
In [
36
]:
print
(
'space '
*
p )
space spacespace
|
那么，空格先出来， 接下来打印星号
星号的规律：
总数为7，头行为1，每行+2，以此类推，那么可以写为：
|
1
|
'*'
*
(
7
-
p
*
2
)
|
如下：
|
1
2
3
4
5
6
7
8
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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
))
*
|
最终代码如下：
|
1
2
3
4
5
6
|
for
i inrange(
-
3
,
4
):
ifi <
0
:
p
=
-
i
else
:
p
=
i
print
(
' '
*
p
+
'*'
*
(
7
-
p
*
2
))
|
拓展，打印如下闪电形：
*
**
***
*******
***
**
*
分析：也是空格问题，只需要控制输出打印空格的位置即可
|
1
2
3
4
5
6
7
8
9
|
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为准，
|
1
2
3
4
5
6
7
|
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 ...
|
1
2
3
4
5
6
7
8
9
|
a
=
0
b
=
1
c
=
0
for
i inrange(
10
):
c
=
a
a
=
b
b
=
c
+
a
print
(b)
|
求斐波那契第101项
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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万内所有素数
|
1
2
3
4
5
6
|
for
i inrange(
2
,
100000
):
for
x
in
range
(
2
,i):
if
i
%
x:
break
else
:
print
(x)
|
这样效率太低了
改进:
使用开根号+1进行分割
|
1
2
3
4
5
6
7
8
9
|
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
|
1
2
|
In [
82
]:
100
*
*
.
05
Out[
82
]:
1.2589254117941673
|
将其转为int型
|
1
2
|
In [
83
]:
int
(
100
*
*
.
05
)
Out[
83
]:
1
|
那么如果我们用传统的方式进行循环，则循环10w之后依次对每个再次进行遍历
如果使用开根号的方式的话，则可以折半进行运算，以提高其效率
也就是说最多只需要315 * 10000 次即可
本文转自zuzhou 51CTO博客，原文链接:http://blog.51cto.com/yijiu/1966115
