循环 素数 嵌套循环 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)
- 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
使用循环打印菱形及闪电形
‘‘‘
*
***
*****
*******
*****
***
*
‘‘‘
规律思路:
首先来分析每行的个数、空格数、以及符号数
行数 | 符号个数 | 空格 |
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 次即可
来源: http://www.bubuko.com/infodetail-2313699.html