精华内容
下载资源
问答
  • Python中 while 循环的用法

    千次阅读 2019-09-03 15:07:13
    #while循环,不断地运行,直到指定的条件不满足为止。 count = 1 while count <=5: print(count) count += 1 ''' 1 2 3 4 5 ''' #while 循环的退出可以使用标志flg退出,break退出等 #使用标志退出 count = 1 ...
    #while循环,不断地运行,直到指定的条件不满足为止。
    count = 1
    while count <=5:
        print(count)
        count += 1
    '''
    1
    2
    3
    4
    5
    '''
    
    #while 循环的退出可以使用标志flg退出,break退出等
    
    #使用标志退出
    count =  1
    active = True
    while active:
        print(count)
        if count >= 5:
            active =False
        else:
            count += 1
    '''
    1
    2
    3
    4
    5
    '''
    
    #break 退出
    count = 1
    while True:
        print(count)
        if count >= 5:
            break
        else:
            count += 1
    '''
    1
    2
    3
    4
    5
    '''
    
    #continue,返回到循环开头,并根据条件测试结果决定是否继续执行循环
    count = 1
    while count <= 5:
        if count % 2 ==0:
            count += 1
            continue
        else:
            print(count)
            count += 1
    '''
    1
    3
    5
    '''
    
    #在列表之间移动元素
    unconfirmed_users = ['alice', 'brian', 'candace']
    confirmed_users = []
    
    while unconfirmed_users:
        confirmed_user = unconfirmed_users.pop() #弹出列表末尾的元素
        print('confirmeduser:' + confirmed_user)
        confirmed_users.append(confirmed_user)  #在列表中添加元素
    print("\nThe following users have been confirmed:")
    for confirmed_user in confirmed_users:
        print(confirmed_user.title())
    '''
    confirmeduser:candace
    confirmeduser:brian
    confirmeduser:alice
    
    The following users have been confirmed:
    Candace
    Brian
    Alice
    '''
    
    #删除列表中包特定的元素
    pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'catt']
    print(pets)
    
    while 'cat' in pets:
        pets.remove('cat')
    print(pets)
    '''
    ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'catt']
    ['dog', 'dog', 'goldfish', 'rabbit', 'catt']
    '''
    展开全文
  • 主要介绍了python中while循环语句用法,以一个简单实例形式分析了Python使用while循环语句使用方法,需要朋友可以参考下
  • Python中while循环的基本用法

    万次阅读 多人点赞 2019-09-11 10:21:34
    文 | 天罡君 while和for都可以使程序重复执行某一段代码(又称作循环体),区别是for循环用于针对集合中每一个元素都一个代码块,而while循环在表达式为True情况...在Python中的语法是: while 表达式: 循环体...

    文 | 天罡君

    whilefor都可以使程序重复执行某一段代码(又称作循环体),区别是for循环用于针对集合中的每一个元素都一个代码块,而while循环在表达式为True的情况下会不断地执行,直到指定条件不满足为止。

    今天我们一起来学习下while关键字的使用。

    1.while循环简介

    while在英语中的解释是:当…时候。

    在Python中的语法是:

    while 表达式:
        循环体
    

    意味着,当表达式为True的时候,程序会一直执行循环体代码,直至表达式为False

    1.1使用while循环

    简单的while循环当属数数了。例如,下面的while循环从1数到5:

    num = 1
    while num <= 5:
        print(num)
        num += 1
    

    首先定义了变量num并给其初始值1。接下来的while循环被设置成这样:只要num小于或等于5,就接着运行循环体代码。

    循环体中的代码打印变量num的值,再使用代码num+=1(代码num=num+1的简写)将其值加1。

    只要满足条件num<=5,python就接着运行这个循环。由于1小于5,因此Python打印1,并将num加1,使其为2;由于2小于5,因此Python打印2,并将num加1,使其为3,以此类推。一旦num大于5,循环将停止,整个程序也将结束运行。

    运行结果:

    1
    2
    3
    4
    5
    

    有人可能看到这会有点懵:已经有for循环了,为啥又搞出个while循环?

    注:表情包中不是python代码

    可以简单的这样理解:for循环主要用于那些我们知道循环次数的循环,如,遍历整个列表,我们知道循环次数就是列表中元素的个数。而while循环主要用于那些我们不知道具体循环多少次的循环,人们常说人生就像一个程序,写成代码的话,我们人生中发生的所有事情都在while 活着:循环的循环体中,我们是不知道一个人到底能活多长时间的,只能用while

    当然,有些循环用forwhile都可以实现。

    其实,你每天使用的程序很可能就包含着while循环。例如,游戏程序就在一个大的while循环中,在玩家退出时停止运行。用while循环能让程序在用户没有让它停止之前一直运行,这点是for循环做不到的。

    1.2让用户选择何时退出

    可使用while循环让程序在用户愿意时不断地运行,当用户想退出时就可以随时退出:

    prompt = "\n输入一些内容,系统将原样返回给你:"
    prompt += "\n键入 'quit' 结束此程序运行。"
    message = ''
    while message != 'quit':
        message = input(prompt)
        print(message)
    

    我们定义了一条信息提示,告诉用户他有两个选择:要么输入一条消息,要么输入’quit’退出程序。

    接下来我们创建了变量message来接收用户输入的内容。Python执行while语句时,需要将message的值与’quit’进行比较。如果用户输入的不是’quit’,程序将打印出用户输入,否则将终止程序运行。

    [外链图片转存失败(img-GPEwzuTm-1568168463339)(https://liuwynn.github.io/images/20190829/图1-2.png)]

    我们向控制台输入的任何信息(除’quit’)都能得到一模一样的返回信息。

    当我们键入’quit’时,可以终止程序运行:

    图1-3

    输入’quit’以后确实终止了程序,但它将’quit’也打印了出来。这其实无关痛痒,然而精益求精的我们是不能忍受的,怎么能让它在输入’quit’时直接退出,输入其他信息时原样返回呢?

    prompt = "\n输入一些内容,系统将原样返回给你:"
    prompt += "\n键入 'quit' 结束此程序运行。"
    message = ''
    while message != 'quit':
        message = input(prompt)
        if message != 'quit':
            print(message)
    

    我们只要让程序在打印信息前做个简单的检查,仅在消息不是’quit’时才打印它:

    图1-4

    可以清楚地看到,这回输入’quit’之后程序没有返回’quit’给我们(可不是天罡君截图的时候故意没截下面噢)。

    1.3更优雅的退出方式

    前一个示例中,我们采用判断message!='quit'是否为True的方式来决定程序是否继续循环执行。可有时影响程序是否继续执行的条件不止一个,如用户输入’quit’或’退出’中的任意一个都可以终止程序运行。

    聪明的小伙伴会说那还不简单,我把判断条件换成:

    message != 'quit' or message != '退出'
    

    这样做到底可不可以呢?答案是可以的,但不是最好的或者说是不优雅的,我们写程序的偶尔可以追求下代码的品质嘛。

    [外链图片转存失败(img-0jLPo772-1568168463345)(https://liuwynn.github.io/images/20190829/mingxue.jpg)]

    更优雅的方式是使用标志。可能有小伙伴对这个名词感触不深,我们直接上新鲜滚烫的代码来感受一下。

    prompt = "\n输入一些内容,系统将原样返回给你:"
    prompt += "\n键入 'quit' 结束此程序运行。"
    active = True
    while active:
        message = input(prompt)
        if message == 'quit':
            active = False
        elif message == '退出':
            active = False
        else:
            print(message)
    

    我们把active作为标志位,并且初始值给它True,这里肯定得是True,不然程序无法进入循环,就更别提执行循环体代码了。

    然后使用两条if语句来检查变量message的值。如果用户输入的是’quit’,我们就把变量active设置成False,如果用户输入的是’退出’,我们也把变量active设置成False

    至于为什么不把两个if判断条件写在一起?

    其一,这样就和把message != 'quit' or message != '退出'直接写在while后面没啥区别了;

    其二,是想让小伙伴们认识到,在真实的项目中,只要有一个条件不满足,就可以直接把active置为False,程序会直接停止运行,因为不同的条件下逻辑可能会不一样,代码块自然也会不同,所以无法把两个if判断条件写在一起。

    如果用户输入的既不是’quit’又不是’退出’,则程序会将用户输入信息原样输出。

    图1-5

    1.4使用break退出循环

    如果你要立即退出while循环,不在运行循环体中余下的代码,也不管while后面跟的表达式是真是假,可以使用break语句。

    例如,我们写个点菜程序,让用户输入TA想吃的菜。在这个程序中,我们可以在用户输入’quit’后使用break语句立即退出while循环:

    prompt = "\n请输入您想吃的菜名:"
    prompt += "\n键入'quit'以退出程序。"
    
    while True:
        food = input(prompt)
    
        if food == 'quit':
            break
        else:
            print("我想吃", food)
    

    我们将True作为while的循环判断条件,因此这程序理论上会不断运行下去(在没有break语句的情况下)。

    图1-6

    这个程序不断让用户输入想吃的菜名,直到用户输入’quit’,程序执行break语句,退出循环。

    需要注意,break语句的作用就是跳出循环(一层循环),这在for循环体中也是适用的哦。

    1.5在循环体中使用continue

    continue的意思是继续。

    Python中使用continue语句跳过当前循环体中的剩余语句,然后继续进行下一轮循环。

    注意:continuebreak的区别在于,前者跳出当前(本次)循环,而后者跳出整个循环。二者既可用于while也可用于for

    举个栗子,我们来打印从1~10中的奇数。

    current_number = 0
    while current_number < 10:
        current_number += 1
        if current_number % 2 == 0:
            continue
        print(current_number)
    

    小伙伴们肯定有别的打印奇数的方法,这里主要是想用循环和continue来实现。

    先定义变量current_number并赋初值0,由于它小于10,Python进入while循环。

    进入循环后,变量current_number在原数字上加1。

    接下来,if语句检查current_number与2的求模运算结果(之前文章说过,结果为0说明是偶数,不为0说明是奇数)。

    如果结果为0(偶数),就执行continue语句,Python会忽略余下的代码,并返回到循环的开头。如果结果不为0(奇数),就执行循环体中剩余的代码,Python将会把这个数字打印出来。

    1.6无限循环

    初学者经常会把循环语句写成无限循环。

    比如1~5数数:

    x = 1
    while x <= 5:
        print(x)
        x += 1
    

    程序的循环终止条件是x<=5,在循环体中每次x+=1,循环体执行5次以后必然不满足循环条件,程序肯定是会正常终止的。

    但我们初学者特别容易遗漏掉代码行x+=1,导致程序进入死循环,没完没了的运行。

    # 这个循环将不会终止
    x = 1
    while x <= 5:
        print(x)
    

    上面代码x初始值是1,但根本不会变,所以while后面的循环条件永远成立,导致程序会一直打印1。

    **友情提示:**如果你不小心写了个无限循环程序(没人可以保证自己不会犯错),可以按Ctrl+C,也可关闭显示程序输出的终端来终止程序。

    2.结语

    这段时间忙着报道,没什么时间更新,请大家见谅啦。

    上面只是介绍了while的基本用法,没有涉及到对列表或字典的处理,要是大家喜欢看的话,可以扫码关注或私信给我留言,我们下期再见bye。

    展开全文
  • 参考链接: Python while循环 文 | 天罡君 while和for都可以使程序重复执行某一段代码(又称作循环体),区别是for循环用于...在Python中的语法是: while 表达式: 循环体 意味着,当表达式为True时候...

    参考链接: Python while循环

    文 | 天罡君 

     

    while和for都可以使程序重复执行某一段代码(又称作循环体),区别是for循环用于针对集合中的每一个元素都一个代码块,而while循环在表达式为True的情况下会不断地执行,直到指定条件不满足为止。 

    今天我们一起来学习下while关键字的使用。 

    1.while循环简介 

    while在英语中的解释是:当…时候。 

    在Python中的语法是: 

    while 表达式:

        循环体

     

    意味着,当表达式为True的时候,程序会一直执行循环体代码,直至表达式为False。 

    1.1使用while循环 

    最简单的while循环当属数数了。例如,下面的while循环从1数到5: 

    num = 1

    while num <= 5:

        print(num)

        num += 1

     

    首先定义了变量num并给其初始值1。接下来的while循环被设置成这样:只要num小于或等于5,就接着运行循环体代码。 

    循环体中的代码打印变量num的值,再使用代码num+=1(代码num=num+1的简写)将其值加1。 

    只要满足条件num<=5,python就接着运行这个循环。由于1小于5,因此Python打印1,并将num加1,使其为2;由于2小于5,因此Python打印2,并将num加1,使其为3,以此类推。一旦num大于5,循环将停止,整个程序也将结束运行。 

    运行结果: 

    1

    2

    3

    4

    5

     

    有人可能看到这会有点懵:已经有for循环了,为啥又搞出个while循环? 

     

     

     注:表情包中不是python代码 

     

    可以简单的这样理解:for循环主要用于那些我们知道循环次数的循环,如,遍历整个列表,我们知道循环次数就是列表中元素的个数。而while循环主要用于那些我们不知道具体循环多少次的循环,人们常说人生就像一个程序,写成代码的话,我们人生中发生的所有事情都在while 活着:循环的循环体中,我们是不知道一个人到底能活多长时间的,只能用while。 

    当然,有些循环用for和while都可以实现。 

    其实,你每天使用的程序很可能就包含着while循环。例如,游戏程序就在一个大的while循环中,在玩家退出时停止运行。用while循环能让程序在用户没有让它停止之前一直运行,这点是for循环做不到的。 

     

    1.2让用户选择何时退出 

    可使用while循环让程序在用户愿意时不断地运行,当用户想退出时就可以随时退出: 

    prompt = "\n输入一些内容,系统将原样返回给你:"

    prompt += "\n键入 'quit' 结束此程序运行。"

    message = ''

    while message != 'quit':

        message = input(prompt)

        print(message)

     

    我们定义了一条信息提示,告诉用户他有两个选择:要么输入一条消息,要么输入’quit’退出程序。 

    接下来我们创建了变量message来接收用户输入的内容。Python执行while语句时,需要将message的值与’quit’进行比较。如果用户输入的不是’quit’,程序将打印出用户输入,否则将终止程序运行。 

    [外链图片转存失败(img-GPEwzuTm-1568168463339)(https://liuwynn.github.io/images/20190829/图1-2.png)] 

    我们向控制台输入的任何信息(除’quit’)都能得到一模一样的返回信息。 

    当我们键入’quit’时,可以终止程序运行: 

     

    输入’quit’以后确实终止了程序,但它将’quit’也打印了出来。这其实无关痛痒,然而精益求精的我们是不能忍受的,怎么能让它在输入’quit’时直接退出,输入其他信息时原样返回呢? 

    prompt = "\n输入一些内容,系统将原样返回给你:"

    prompt += "\n键入 'quit' 结束此程序运行。"

    message = ''

    while message != 'quit':

        message = input(prompt)

        if message != 'quit':

            print(message)

     

    我们只要让程序在打印信息前做个简单的检查,仅在消息不是’quit’时才打印它: 

     

    可以清楚地看到,这回输入’quit’之后程序没有返回’quit’给我们(可不是天罡君截图的时候故意没截下面噢)。 

    1.3更优雅的退出方式 

    前一个示例中,我们采用判断message!='quit'是否为True的方式来决定程序是否继续循环执行。可有时影响程序是否继续执行的条件不止一个,如用户输入’quit’或’退出’中的任意一个都可以终止程序运行。 

    聪明的小伙伴会说那还不简单,我把判断条件换成: 

    message != 'quit' or message != '退出'

     

    这样做到底可不可以呢?答案是可以的,但不是最好的或者说是不优雅的,我们写程序的偶尔可以追求下代码的品质嘛。 

    [外链图片转存失败(img-0jLPo772-1568168463345)(https://liuwynn.github.io/images/20190829/mingxue.jpg)] 

    更优雅的方式是使用标志。可能有小伙伴对这个名词感触不深,我们直接上新鲜滚烫的代码来感受一下。 

    prompt = "\n输入一些内容,系统将原样返回给你:"

    prompt += "\n键入 'quit' 结束此程序运行。"

    active = True

    while active:

        message = input(prompt)

        if message == 'quit':

            active = False

        elif message == '退出':

            active = False

        else:

            print(message)

     

    我们把active作为标志位,并且初始值给它True,这里肯定得是True,不然程序无法进入循环,就更别提执行循环体代码了。 

    然后使用两条if语句来检查变量message的值。如果用户输入的是’quit’,我们就把变量active设置成False,如果用户输入的是’退出’,我们也把变量active设置成False。 

    至于为什么不把两个if判断条件写在一起? 

    其一,这样就和把message != 'quit' or message != '退出'直接写在while后面没啥区别了; 

    其二,是想让小伙伴们认识到,在真实的项目中,只要有一个条件不满足,就可以直接把active置为False,程序会直接停止运行,因为不同的条件下逻辑可能会不一样,代码块自然也会不同,所以无法把两个if判断条件写在一起。 

    如果用户输入的既不是’quit’又不是’退出’,则程序会将用户输入信息原样输出。 

     

    1.4使用break退出循环 

    如果你要立即退出while循环,不在运行循环体中余下的代码,也不管while后面跟的表达式是真是假,可以使用break语句。 

    例如,我们写个点菜程序,让用户输入TA想吃的菜。在这个程序中,我们可以在用户输入’quit’后使用break语句立即退出while循环: 

    prompt = "\n请输入您想吃的菜名:"

    prompt += "\n键入'quit'以退出程序。"

     

    while True:

        food = input(prompt)

     

        if food == 'quit':

            break

        else:

            print("我想吃", food)

     

    我们将True作为while的循环判断条件,因此这程序理论上会不断运行下去(在没有break语句的情况下)。 

     

    这个程序不断让用户输入想吃的菜名,直到用户输入’quit’,程序执行break语句,退出循环。 

    需要注意,break语句的作用就是跳出循环(一层循环),这在for循环体中也是适用的哦。 

    1.5在循环体中使用continue 

    continue的意思是继续。 

    Python中使用continue语句跳过当前循环体中的剩余语句,然后继续进行下一轮循环。 

    注意:continue和break的区别在于,前者跳出当前(本次)循环,而后者跳出整个循环。二者既可用于while也可用于for。 

    举个栗子,我们来打印从1~10中的奇数。 

    current_number = 0

    while current_number < 10:

        current_number += 1

        if current_number % 2 == 0:

            continue

        print(current_number)

     

    小伙伴们肯定有别的打印奇数的方法,这里主要是想用循环和continue来实现。 

     

    先定义变量current_number并赋初值0,由于它小于10,Python进入while循环。 

    进入循环后,变量current_number在原数字上加1。 

    接下来,if语句检查current_number与2的求模运算结果(之前文章说过,结果为0说明是偶数,不为0说明是奇数)。 

    如果结果为0(偶数),就执行continue语句,Python会忽略余下的代码,并返回到循环的开头。如果结果不为0(奇数),就执行循环体中剩余的代码,Python将会把这个数字打印出来。 

    1.6无限循环 

    初学者经常会把循环语句写成无限循环。 

    比如1~5数数: 

    x = 1

    while x <= 5:

        print(x)

        x += 1

     

    程序的循环终止条件是x<=5,在循环体中每次x+=1,循环体执行5次以后必然不满足循环条件,程序肯定是会正常终止的。 

    但我们初学者特别容易遗漏掉代码行x+=1,导致程序进入死循环,没完没了的运行。 

    # 这个循环将不会终止

    x = 1

    while x <= 5:

        print(x)

     

    上面代码x初始值是1,但根本不会变,所以while后面的循环条件永远成立,导致程序会一直打印1。 

    **友情提示:**如果你不小心写了个无限循环程序(没人可以保证自己不会犯错),可以按Ctrl+C,也可关闭显示程序输出的终端来终止程序。 

    2.结语 

    这段时间忙着报道,没什么时间更新,请大家见谅啦。 

    上面只是介绍了while的基本用法,没有涉及到对列表或字典的处理,要是大家喜欢看的话,可以扫码关注或私信给我留言,我们下期再见bye。

    展开全文
  • 主要介绍了在Pythonwhile循环中使用else以及循环嵌套的用法,是Python入门学习的基础知识,需要的朋友可以参考下
  • 这篇文章主要介绍了在Pythonwhile循环中使用else以及循环嵌套的用法,是Python入门学习的基础知识,需要的朋友可以参考下 循环使用 else 语句 在 python ,for … else 表示这样的意思,for 的语句和普通的...
  • python中while循环和for循环的用法

    千次阅读 2014-12-26 16:01:16
    一、while循环 1、一般格式 格式:首行以及测试表达式,有一列或多列缩进语句主体以及一个选用else部分(控制权离开循环时而没有碰到break语句时会执行) python会一直计算开投测试,然后执
    while语句,提供了编写通用循环的一种方法,而for语句是用来遍历序列对象内的元素,并对每个元素运行一个代码块。break,continue用在循环内,跳出整个循环或者跳出一次循环。
    一、while循环
    1、一般格式
    格式:首行以及测试表达式,有一列或多列缩进语句的主体以及一个选用的else部分(控制权离开循环时而没有碰到break语句时会执行)
    python会一直计算开投的测试,然后执行循环主体内的语句,直到测试返回假值为止。
    while <test>:
        <statements1>
    else:
        <statements2>
    2、例子
    >>> while True:
    ...  print "Type Ctrl+C to stop!"

    >>> while x:    
    ...     print x,
    ...     x=x[1:]
    ... 
    diege iege ege ge e
    注意 print末尾的逗号,会使所有输出都出现在同一行。
    >>> a,b=0,10 
    >>> while a<b:
    ...     print a,
    ...     a+=1
    ... 
    0 1 2 3 4 5 6 7 8 9
    Python并没有其他语言中所谓的"do until”循环语句,不过我们可以在循环主体底部以一个测试和break来实现类似的功能。
    while    True:
        do something
        if exitTest():break
    3、对比shell的while语句
    while 命令
    do
        命令1
        命令2
    done
    在系统管理时常用与逐行读取一个文件并处理。
    while read line
    do
            echo $line
    done < /etc/rc.conf
    shell中还有一个类似while的循环until
    until 条件
    do
            命令1
            命令2
    done 
    EG:
    IS_ROOT=`who |grep root`
    until [ "$IS_ROOT" ]
    do
            echo 'root online'
            sleep 2
    done             

    二、 break continue pass和循环的else
    break
        跳出最近所在的循环(跳出整个循环语句)
    continue
        跳到最近所在循环的开头处(来到循环的首行,跳过本次循环)
    pass
        什么事也不做,只是空占位语句
    循环else块
        只有当循环正常离开时才会执行(也就是没有碰到break语句)

    1、一般循环格式
    加入break和continue语句后,while循环的一般格式如下:
    while <test>:
        <statements1>
        if <test2>:break
        if <test3>:continue
        if <test4>:pass
    else:
        <statements2>
    break和continue可以出现在while(或for)循环主体的任何地方,但通常会进一步嵌套在if语句中,根据某些条件来采取对应的操作。

    2、列子
    pass
    >>> while 1:pass
    ... 
    pass可用于空类,有时有指的是"以后会填上”,只是暂时用于填充函数主体而已:
    >>> def func1():
    ...     pass
    continue
    continue语句会立即跳到循环的顶端,开始下一次循环。
    >>> while x:
    ...     x=x-1
    ...     if  x%2!=0:continue
    ...     print x,
    ... 
    8 6 4 2 0
    这个例子中,如果是奇数就返回循环顶部,不会打印.是偶数就打印。
    这个下面这个结果一样
    >>> while x:            
    ...     x=x-1           
    ...     if x%2==0:      
    ...             print x,
    ... 
    8 6 4 2 0
    注意这两个例子的print位置,第一个print是属于while块的,测试不通过下执行,测试通过就回到循环顶端,第二个是属于if块的,只有测试通过才打印
    >>> while x:            
    ...     x=x-1           
    ...     if x%2==0:      
    ...             print x,
    ...break
    break语句会立刻离开循环。碰到break,位于其后的循环代码都不会执行。
    while 1:
            name=raw_input("Enter name:")
            if name=='stop':break
            age=raw_input("Enter age:")
            print 'Hello',name,'=>',int(age)**2
    当age不输入任何值时会报错。可以使用try解决
    while 1:
            name=raw_input("Enter name:")
            if name=='stop':break
            age=raw_input("Enter age:")
            try:
                    print 'Hello',name,'=>',int(age)**2
            except:
                    print 'Please input age!'
    else 只有当循环正常离开时才会执行(也就是没有碰到break语句【break的条件不满足】)
    >>> while x:
    ...     x=x-1
    ...     print x
    ... else:
    ...     print "over"
    ... 
    9
    8
    7
    6
    5
    4
    3
    2
    1
    0
    over
    >>> x=10             
    >>> while x:         
    ...     x=x-1        
    ...     if x==5:break
    ...     print x
    ... else:
    ...     print "over"
    ... 
    9
    8
    7
    6

    三、for循环
    for循环在Python中是一个通用的序列迭代器:可以遍历任何有序的序列对象内的元素。for语句可用于字符串,列表,元组,其他内置可迭代对象以及之后我们能够通过类所创建的新对象。
    1、一般格式
    Python for循环的首行定义了一个赋值目标(或【一些目标】),以及你想遍历的对象,首行后面是你想重复的语句块(一般都有缩进)
    for <target> in <object>:
        <statements>
    else:
        <statements>
    当ptyhon运行for循环时,会逐个将序列对象中的元素赋值给目标,然后为每个元素执行循环主体。循环主体一般使用赋值的目标来引用序列中当前的元素,就好像那事遍历序列的游标。

    for首行中用作赋值目标的变量名通常是for语句所在作用于的变量(可能是新的)。这个变量名没有什么特别的,甚至可以在循环主体中修改。但是当控制权再次回到循环顶端时,就会自动被设成序列的下一个元素。循环之后,这个变量一般都还是引用了最近所用过的元素,也就是序列中最后的元素,除非通过一个break语句退出了循环。

    for语句也支持一个选用的else块,它的工作就像在while循环中一样:如果循环离开时没有碰到break语句,就会执行(也就是序列所有元素都被访问过了)
    break和continue语句也可用在for循环中,就像while循环那样。for循环完整的格式如下:
    for <target> in <object>:
        <statements>
        if <test>:break
        if <test>:conitnue
    else:
        <statements>

    对比shell的for循环
    for  变量名 in 列表
    do
        命令1
        命令1
    done

    for i in 1 2 3 
    do 
            echo $i 
    don

    for i in `ls -1 /root`
    do 
            echo $i 
    done

    2、例子
    1)基本应用
    >>> x=[1,2,3,4,5]
    >>> for i in x:
    ...     print i
    ... 
    1
    2
    3
    4
    5
    >>> for i in x:  
    ...     if i==3:break
    ...     print i
    ... 
    1
    2
    >>> for i in x:      
    ...     print i
    ...     if i==3:break
    ... 
    1
    2
    3
    注意if语句的位置
    > D={'name':['diege','lily','kelly'],'class':2012,'number':48}
    >>> for i in D:     
    ...     print i,'=>',D[i]  
    ... 
    number => 48
    name => ['diege', 'lily', 'kelly']
    class => 2012
    多层
    >>> for i in D:                      
    ...     if type(D[i])==list:         
    ...             for l in D[i]:       
    ...                     print l      
    ...     else:
    ...             print  D[i]
    ... 
    48
    diege
    lily
    kelly
    2012
    for元组赋值
    首行定义了一个赋值【一些目标】
    >>> T=[(1,2),(3,4),(5,6)]
    >>> for (a,b) in T:
    ...     print a,b
    ... 
    1 2
    3 4
    5 6

    for循环嵌套
    遍历一个字典(或列表)包括字典,列表,元组的的语句
    D={'game':'sjgame','version':[1.0,1.1,1.2,1.3],'useid':(1000,1001,1002,1003,1004),'character':{'WS':'wushi','FS':'fashi','MS':'moshi
    '},'CP':'ice'}

    for i in D:
            if type(D[i])==list:
                    for l in D[i]:
                            print l
            elif type(D[i])==tuple:
                    for t in D[i]:
                            print t
            elif type(D[i])==dict:
                     for d in D[i]:
                            print d
            else:
                    print   D[i]
    代替break的
    >>> items=['diege',999,(3,7),1.3]
    >>> tests=[(3,7),3.14]
    >>> for key in tests: 
    ...     for item in items:             
    ...             if key==item:      
    ...                     print key,'was found'
    ...                     break
    ...     else:
    ...             print key,'not found!' 
    ... 
    (3, 7) was found
    3.14 not found
    有点类似查找的功能。
    收集两个序列中相同元素
    >>> seq1='diege'
    >>> seq2='decgl'
    >>> res=[]                  
    >>> for x in seq1:          
    ...     if x in seq2:          
    ...             res.append(x)
    ... 
    >>> 
    >>> res
    ['d', 'e', 'g', 'e']
    准确的说是显示seq1和seq2都用的在seq1一次顺序。

    3、为什么要在意“文件扫描”
    循环读取文件:while在文件结尾时使用break
    >>> fl=open('/etc/rc.conf') 
    >>> while True:
    ...     char=fl.read(1)
    ...     if not char:break
    ...     print char,
    MS for循环打印出来的字体正常点,呵呵。
    >>> for char in open('/etc/rc.conf'):for char in open('/etc/rc.conf').read():的缩写
    ...     print char
    ... 

    使用while按行处理
    >>> fl=open('/etc/rc.conf')
    >>> while True:             
    ...     line=fl.readline()
    ...     if not line:break
    ...     print line,
    ... 
    按行读取文件文件时,for循环是最容易编写及执行最快的选择
    >>> for line in open('/etc/rc.conf'):#默认read()
    ...     print line
    ... 
    >>> for line in open('/etc/rc.conf').readlines():
    ...     print line
    ... 
    readlines会一次把文件载入到行字符串的列表
    >>> for line in open('/etc/rc.conf').xreadlines():
    ...     print line
    ... 
    xreadlines则是按需求加载文字列,从而避免大型文件导致内存溢出。
    每个步骤所读取的数据越多,程序会员越快。

    四、迭代器:初探
    for循环可以用在任何【可迭代的对象】。这些迭代工具包括了for循环,列表解析,in成员关系测试,以及map内置函数等。
    可迭代对象:如果对象是实际保存的序列,或者可以在迭代工具环境中(如for循环)一次产生一个对象的结果,就被看作是可迭代。
    总之,可迭代对象包括实际序列和按照需求而计算的虚拟序列。
    1、文件迭代器
    文件对象有个方法名为readline,可以一次从一个文件中读取一行文本,每次调用readline方法时,就会前进到下一列,到文件末尾时,就会返回空字符串,可以通过它来检查从而跳出循环。文件对象有另外一个方法next,差不多用有相同的效果。
    >>> fl=open('/etc/rc.conf')
    >>> fl.next()
    '#apache22_enable="YES"\n'
    >>> fl.next()
    '# -- sysinstall generated deltas -- # Tue Feb 14 10:08:27 2012\n'
    两者的区别在于,达到文件末尾时,next是引发内置的StopIteration异常,而不是返回空字符串。
    这个接口就是python所谓的迭代协议:有next方法的对象会前进到下一个结果,而在一些列结果的末尾时,则会引发StopIteration.
    在Python中,任何这类对象都认为是可迭代的。任何这类对象也能以for循环或其他迭代工具遍历,因为所有迭代工具内部工作起来都是在每次迭代中调用next,并且捕捉StopIteration异常来确定何时离开。
    逐行读取文本的最佳方式就是根本不要去读取,其替代的方法就是,让for循环在每轮自动调用next从而前进到下一行。
    >>> for line in open('/etc/rc.conf'):
    ...     print line.upper(),
    逐行读取文件并转换为大写,注意没有可以从文件中读取内容。
    这首读取文本文件的最佳方式,最简单,运行最快,内存使用情况最好。
    >>> for line in open('/etc/rc.conf').readlines:
    这种方式一次把文件都加载到内存。
    2、其他内置类型迭代器
    >>> D={'a':1,'b':2,'c':3}
    >>> for key in D.keys():
    ...     print key,D[key]
    ... 
    a 1
    c 3
    b 2
    新版无需使用keys方法
    >>> for key in D:       
    ...     print key,D[key]
    ... 
    a 1
    c 3
    b 2
    3、其他迭代环境
    列表解析,in成员关系,map内置函数以及其他内置工具(如sorted,sum)
    >>> [line.upper() for line in open('/etc/rc.conf')]
    >>> upper=[line.upper() for line in open('/etc/rc.conf')]  
    >>> map(str.upper,open('/etc/rc.conf'))
    map对迭代对象中每一个元素都应用一个函数调用,类似于列表解析,有局限性,因需要函数,而不是任意表达式。
    >>> sorted(open('/etc/rc.conf')) #这个工具排序了,较新的内置函数,采用了迭代协议。应用于任何可迭代的对象上。
    >>> sum([3,5,6,9]) #sum调用会计算任何可迭代对象内所有数字的和
    23
    而如果可迭代对象中的任何元素或者全部元素为True,内置函数就会返回True:all全部元素为True才返回True,有一个元素不为
    True,都会返回flase
    >>> any(['diege','','ni'])
    True
    >>> any(['diege','',''])   
    True
    >>> all(['diege','','ni'])   
    False
    >>> all(['diege','a','ni'])
    True
    其他工具:list和tuple内置函数(从可迭代对象创建新的对象),字符串join方法(在可迭代对象内字符串之间放入子字符串),以及序列赋值语句等。
    >>> list(open('/etc/rc.conf'))
    >>> tuple(open('/etc/rc.conf'))
    >>> '&&'.join(open('/etc/rc.conf'))
    >>> a,d,c,d=open('/etc/rc.conf') 
    4、用户定义的迭代器
    yield语句可以把用户定义的函数变成可迭代的对象。如果的列表解析也可以通过生成器表达式支持次协议,而用户定义的类
    也能通过__iter__或__getitem__运算符重载方法而变成迭代对象。用户定义的迭代器可以在这里的任何迭代环境中使用任意对象和运算。
    五、编写循环的技巧
    遍历序列时,首选for循环,for循环包括多数计数器式的循环,for比while容易写,执行时也比较快。
    Python提供了两个内置函数,在for循环内定制迭代:
    * 内置range函数返回连续整数列表,可作为for中的索引。
    >>> range(5)
    [0, 1, 2, 3, 4]
    >>> range(5,10)     
    [5, 6, 7, 8, 9]
    >>> range(5,10,2)
    [5, 7, 9]
    *内置 zip函数返回并行的元素元祖的列表,可用于在for中遍历数个序列
    1、循环计算器:while和range
    >>> range(5),range(2,5),range(3,10,2)
    ([0, 1, 2, 3, 4], [2, 3, 4], [3, 5, 7, 9])
    步进为负时候为递减,默认递增
    >>> range(5,-5,-1)
    [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
    range最常用于在for循环中,提供一种简单的方法,重复特定次数的动作。
    >>> for i in range(3):
    ...     print i,'pythons'
    ... 
    0 pythons
    1 pythons
    2 pythons
    >>> for i in range(0,10,2):             
    ...     print i
    ... 
    0
    2
    4
    6
    8
    如果真的要明确地掌控索引逻辑,可以用while循环来实现。
    >>> X='diege'
    >>> i=0
    >>> while i<len(X):     
    ...     print X[i];i+=1  
    ... 
    d
    i
    e
    g
    e
    也可以使用for进行手动索引,也就是用range产生用于迭代的索引的列表
    >>> range(len(X))
    [0, 1, 2, 3, 4]
    >>> for i in range(len(X)):print X[i],
    ... 
    d i e g e
    2、非完备遍历:range
    尽量使用简单的for循环,不要用while,并且不要在for循环中使用range调用,只将其视为最后的选择,更简单的办法总是更好。
    >>> for i in X:
    ...     print i
    ... 
    d
    i
    e
    g
    e
    使用range可以做更特殊的遍历种类。
    >>> S='rhrhrfxvlwsocv'
    >>> for i in range(0,len(S),2):print S[i]
    ... 
    r
    r
    r
    x
    l
    s
    c
    更好的办法
    >>> for x in S[::2]:print x
    ... 
    r
    r
    r
    x
    l
    s
    c
    3、修改列表:range
    可以使用range和for的组合的常见场合就是在循环中遍历列表时并对其进行修改。如某些原因某种理由要为列表中每个元素都加1.
    >>> L=[1,2,3,4,5]
    >>> L
    [1, 2, 3, 4, 5]
    >>> for i in range(len(L)):
    ...     L[i]+=1
    ... 
    >>> L
    [2, 3, 4, 5, 6]
    4、并行遍历:zip 和map
    >>> L1=[1,2,3,4] 
    >>> L2=[5,6,7,8]
    >>> zip(L1,L2)
    [(1, 5), (2, 6), (3, 7), (4, 8)]
    >>> for (x,y) in zip(L1,L2):
    ...     print x,y,'--',x+y   
    ... 
    1 5 -- 6
    2 6 -- 8
    3 7 -- 10
    4 8 -- 12
    zip从两列或者多列中提取出来元素配对。
    >>> T1,T2,T3=(1,2,3),(4,5,6),(7,8,9)
    >>> zip(T1,T2,T3)
    [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
    当参数长度不同时,zip会以最短序列的长度为准来截断所得到的元组:
    >>> S1='ABC'
    >>> S2='xyz123'
    >>> zip(S1,S2)
    [('A', 'x'), ('B', 'y'), ('C', 'z')]
    内置map函数,用类似的方式把序列的元素配对起来,但是如果参数长度,不同则会为较短的序列用None补齐。
    >>> map(None,S1,S2)   
    [('A', 'x'), ('B', 'y'), ('C', 'z'), (None, '1'), (None, '2'), (None, '3')]
    使用zip构造字典
    >>> keys=['name','age','class'] 
    >>> vals=['diege',18,2012]   
    >>> zip(keys,vals)
    [('name', 'diege'), ('age', 18), ('class', 2012)]
    前面学过dict()函数,可以将k:v组成元组按列表的形式传送给disc()产生字典。
    而zip可以掺产生这种格式的列表。故可以使用
    dict(zip(keys,vals)) 构造字典
    >>> dict(zip(keys,vals)) 
    {'age': 18, 'name': 'diege', 'class': 2012}
    >>> D5=dict(zip(keys,vals))
    5、产生偏移和元素:enumerate
    enumerate内置函数,同时产生偏移和元素
    >>> S='diege'
    >>> for (offset,item) in enumerate(S):
    ...     print item,offset
    ... 
    d 0
    i 1
    e 2
    g 3
    e 4
    这个方法有个next方法,每次遍历列表时,会返回一个(index,value)的元组,而我们能在for中通过元组赋值运算将其分解。
    >>> E=enumerate(S)
    >>> E.next()
    (0, 'd')
    >>> E.next()
    (1, 'i')
    >>> E.next()
    (2, 'e')
    >>> E.next()
    (3, 'g')
    >>> E.next()
    (4, 'e')
    >>> E.next()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration
    六、列表解析:
    >>> L=[1,2,3,4,5]
    >>> for i in range(len(L)):
    ...     L[I]+=10
    ... L 
    >>> L
    [1, 2, 3, 4, 5]
    这样解析方式已经过时,这里用单个表达式取代循环,来产生所需要的结果列表
    >>> L=[1,2,3,4,5]
    >>> L=[x+10 for x in L]
    >>> L
    [11, 12, 13, 14, 15]
    1、列表解析基础
    列表解析是写在方括号中的,因为它毕竟是一种创建新的列表的方式。它是我们编写的任何表达式开始,而该表达式中使用了一个我们所编写循环的变量(x+10)。后面所接的就是for循环的首行,指出循环变量的名称以及可迭代的对象(for x in L)
    [【表达式】 for x in L【for循环行首】]
    技术角度,列表解析绝不是必须要求。因为可以使用for循环,在遍历的过程中把表达式结果加在列表上。
    >>> res=[]
    >>> L
    [11, 12, 13, 14, 15]
    >>> for x in L:
    ...     res.append(x+10)
    ... 
    >>> L
    [11, 12, 13, 14, 15]
    不过列表解析写起来更简明,这种创建结果列表的编码模式在Python中是很常见的工作。而且运行更快,是以C语言的速度执行。
    2、对文件使用列表解析
    >>> f=open('/etc/rc.conf')
    >>> lines=f.readlines()
    >>> lines
    ['#apache22_enable="YES"\n', '# -- sysinstall generated deltas -- # Tue Feb 14 10:08:27 2012\n', 'ifconfig_em1="inet 192.168.1.200  netmask 255.255.255.0"\n', '#ifconfig_em0="DHCP"\n', '# -- sysinstall generated deltas -- # Tue Feb 14 10:09:24 2012\n', 'ifconfig_em1="inet 192.168.1.200  netmask 255.255.255.0"\n', '#hostname="ofreebsd.corp.icee.cn"\n', 'hostname="ofreebsd.skylog.cn"\n', '# -- sysinstall generated deltas -- # Tue Feb 14 10:12:04 2012\n', 'sshd_enable="YES"\n', '#mysql_enable="YES"\n']
    列表中包含的有换行符,如果想去掉换行符怎么办呢?
    想到字符串的rstrip方法,但是怎么应用呢?也可以使用(line[:-1]也可以
    >>> lines=[line.rstrip() for line in lines]
    >>> lines
    ['#apache22_enable="YES"', '# -- sysinstall generated deltas -- # Tue Feb 14 10:08:27 2012', 'ifconfig_em1="inet 192.168.1.200  netmask 255.255.255.0"', '#ifconfig_em0="DHCP"', '# -- sysinstall generated deltas -- # Tue Feb 14 10:09:24 2012', 'ifconfig_em1="inet 192.168.1.200  netmask 255.255.255.0"', '#hostname="ofreebsd.corp.icee.cn"', 'hostname="ofreebsd.skylog.cn"', '# -- sysinstall generated deltas -- # Tue Feb 14 10:12:04 2012', 'sshd_enable="YES"', '#mysql_enable="YES"']

    如果是打开文件读取文件,完全可以不用事先打开,可以在表达式内开启它。
    >>> lines=[line.rstrip() for line in open('/etc/rc.conf')]

    3、扩展列表解析语句
    列表解析在实际使用中可以更高级。表达式中嵌套的for循环可以结合一个if分句来过滤测试不为真的结果元素,这可是一项有用的扩展功能。
    重复上一个例子,但我们只需开头不为#的文字行。
    >>> lines=[line.rstrip() for line in open('/etc/rc.conf') if line[0]!='#']
    >>> lines
    ['ifconfig_em1="inet 192.168.1.200  netmask 255.255.255.0"', 'ifconfig_em1="inet 192.168.1.200  netmask 255.255.255.0"', 'hostname="ofreebsd.skylog.cn"', 'sshd_enable="YES"']
    更复杂的情况,列表解析也可以含有嵌套循环,写成一系列的for分句。实际上,其完整的语句可接纳任意数目的for分句,而每个分区都可以结合一个可选的if分句
    >>> [x+y for x in 'abc' for y in 'lmn']
    ['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']
    对一个字符串中的每个x,以及另一个字符串中的每个y,创建x+y合并的列表。收集两个字符串字符的排列组合
    展开全文
  • 主要介绍了python中循环语句while用法,实例分析了while语句使用方法,需要朋友可以参考下
  • Python程序中while循环用法详解

    万次阅读 2018-06-04 23:15:03
    Python程序中while循环用法详解用于编写通用迭代结构,顶端测试为真就会执行循环体,并会多次重复测试直到测试为假后才执行循环后其它语句。 1、while循环语法格式:1).while bool_expression: while_suite else:...
  • Python 中的循环语句有 2 种,分别是 while 循环和 for 循环,前面章节已经对 while 做了详细讲解,本节给大家介绍 for 循环,它常用于遍历字符串、列表、元组、字典、集合等序列类型,逐个获取序列中的各个元素。...
  • Python中while语句一般形式: while 判断条件:  statements 同样需要注意冒号和缩进。另外,在Python中没有do..while循环。 以下实例使用了 while 来计算 1 到 100 总和: #!/usr/bin/env python3 n = 100 ...
  • for 循环的语法格式如下: for 迭代变量 in 字符串|列表|元组|字典|集合: 代码块 ...下面的程序演示了 for 循环的具体用法: add = "http://www.baidu.com/python/" #for循环,遍历 add 字符串.

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 322
精华内容 128
关键字:

python中while循环的用法

python 订阅