初学python之循环

简介:

 

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  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
=  0
=  True
while  a:
     x + =  7
     ifx  %  7  = =  0 :
        count  + =  1
        print  (x)
     ifcount  = =  20 :
        =  False


 

改进:

首先,以上代码做了无用判断,代码在最初开始打印x,由于第一个数字是0,肯定是可以被其整除,

其次,每次循环+7 也就是每次都递增+7 依次为 714 21 28... 这样以来不需要进行判断if x % 7 == 0 的步骤,以节省效率

1
2
3
4
5
6
7
8
9
count  =  0
=  0
=  True
while  a:
    print  (x)
     x + =  7
    count  + =  1
     ifcount  = =  20 :
        =  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
=  0
for  i inrange( 1 , 100 , 2 ):
   =  +  i
else :
   print  (a)


 

求阶乘

 

 

1
2
3
4
5
6
7
8
num  =  0
  
for  i inrange( 1 , 6 ):
    sum  =  i
    for  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  in  range (i, 10 ):
        num  =  *  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  in  range ( 1 ,i + 1 ):
        num  =  *  q
        print  ( '{} x {}={:<2}' . format (i,q,num),end  =  ' ' )
    print ( ' ' )
  
#如下:
  
1  1 = 1
2  1 = 2   2x  2 = 4
3  1 = 3   3x  2 = 6   3  3 = 9
4  1 = 4   4x  2 = 8   4  3 = 12  4  4 = 16
5  1 = 5   5x  2 = 10  5  3 = 15  5  4 = 20  5  5 = 25
6  1 = 6   6x  2 = 12  6  3 = 18  6  4 = 24  6  5 = 30  6  6 = 36
7  1 = 7   7x  2 = 14  7  3 = 21  7  4 = 28  7  5 = 35  7  6 = 42  7  7 = 49
8  1 = 8   8x  2 = 16  8  3 = 24  8  4 = 32  8  5 = 40  8  6 = 48  8  7 = 56  8  8 = 64
9  1 = 9   9x  2 = 18  9  3 = 27  9  4 = 36  9  5 = 45  9  6 = 54  9  7 = 63  9  8 = 72  9  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  in  range ( 1 ,i + 1 ):
        num  =  *  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 :
        =  - i
    elif  i >  0 :
        =  i
    print  ( ' ' * +  '*'  *  ( 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  - *  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  - *  2
Out[ 65 ]:  5
  
=  1
In [ 67 ]:  print ( ' '  *  +   '*'  *  (total  - *  2 ))
  * * * * *
=  2
In [ 75 ]:  print ( ' '  *  +   '*'  *  (total  - *  2 ))
   * * *
=  3
In [ 73 ]:  print ( ' '  *  +   '*'  *  (total  - *  2 ))
    *


 

最终代码如下:

 

1
2
3
4
5
6
for  i inrange( - 3 , 4 ):
     ifi <  0 :
        =  - i
    else :
        =  i
    print  ( ' ' * +  '*'  *  ( 7 - p * 2 ))


 

 

拓展,打印如下闪电形:

 

*

**

***

*******

   ***

    **

    *

分析:也是空格问题,只需要控制输出打印空格的位置即可

 

1
2
3
4
5
6
7
8
9
for  i inrange( - 3 , 4 ):
     ifi <  0 :
        =  - i
        print  ( ' '  *  +  '*'  *  ( 4 - p))
    elif  i > 0 :
        =  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
=  0
=  1
=  0
  
for  i inrange( 10 ):
     c =  a
     a =  b
     b =  +  a
    print  (b)


 

求斐波那契第101项

 

1
2
3
4
5
6
7
8
9
10
11
12
=  0
=  1
=  0
index  =  0
for  i inrange( 10 ):
     c =  a
     a =  b
     b =  +  a
    index  + =  1
     ifindex  = =  101 :
         print  (b)
         break


 

 

求10万内所有素数

 

 

1
2
3
4
5
6
for  i inrange( 2 , 100000 ):
    for  in  range ( 2 ,i):
        if  %  x:
            break
    else :
        print (x)


这样效率太低了

 

改进:

使用开根号+1进行分割

1
2
3
4
5
6
7
8
9
count  =  0
for  x inrange( 2 , 100000 ):
    for  in  range ( 2 , int (x  * *  0.5 +  1 ):
        if  %  = =  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


相关文章
|
2月前
|
大数据 Python
Python中for循环的嵌套应用
Python中for循环的嵌套应用
33 1
|
18天前
|
索引 Python
Python循环怎么给enumerate和for做对比
**Python中的`for`循环遍历集合,而`enumerate`函数在迭代时提供元素的索引。
|
1月前
|
Python
掌握Python中循环语句的精髓:基础用法与高级技巧
掌握Python中循环语句的精髓:基础用法与高级技巧
|
2月前
|
大数据 Python
Python中while循环的嵌套应用详解
Python中while循环的嵌套应用详解
29 0
|
8天前
|
设计模式 开发者 Python
Python中循环依赖问题及其解决方案
循环依赖是 Python 开发中需要特别注意的问题。通过重新设计模块结构、延迟导入、依赖注入、利用 Python 的动态特性以及代码重构等方法,可以有效地解决循环依赖问题。这些策略不仅有助于提高代码的可维护性和可读性,还能避免潜在的运行时错误。在实际开发中,开发者应该根据具体情况选择合适的解决方案。
|
19天前
|
设计模式 算法 Python
Python回调函数中的循环艺术:深入探索for循环的回调应用
Python回调函数中的循环艺术:深入探索for循环的回调应用
12 1
|
24天前
|
Python
Python教程:一文了解Python的条件、循环语句
条件语句(Conditional Statements)是编程中用于根据条件执行特定代码块的结构。在 Python 中,条件语句通常使用 if、elif 和 else 关键字来实现。通过条件语句,程序可以根据不同的条件选择性地执行不同的代码块。 循环语句(Loop Statements)则是一种重复执行特定代码块的结构。在 Python 中,常见的循环语句有 while 循环和 for 循环。循环语句允许程序根据特定的条件或者对一个序列进行迭代,重复执行一段代码,直到满足退出循环的条件为止。
13 1
|
24天前
|
Python
在Python中,`range()`函数生成一个整数序列,用于循环迭代。
【6月更文挑战第19天】`Python`的`range()`函数生成整数序列,用于迭代。它接受`start`(默认0)、`stop`(不包含,右开)和`step`(默认1)参数。在`for`循环中,`range(5)`会输出0到4。若要包含结束值,需将`stop`设为`end+1`,如`range(1, 6)`将输出1到5。
32 1
|
25天前
|
Python
【随手记】python语言的else语句在for、while等循环语句中的运用
【随手记】python语言的else语句在for、while等循环语句中的运用
25 2
|
25天前
|
开发者 Python
Python基础第三篇(Python逻辑判断与循环)
Python基础第三篇(Python逻辑判断与循环)