跟老齐学Python之用while来循环
在python中,它也有这个含义,不过有点区别的是,“当...时候”这个条件成立在一段范围或者时间间隔内,从而在这段时间间隔内让python做好多事情。就好比这样一段情景:
while 年龄大于60岁:-------->当年龄大于60岁的时候
退休 -------->凡是符合上述条件就执行的动作
展开想象,如果制作一道门,这道门就是用上述的条件调控开关的,假设有很多人经过这个们,报上年龄,只要年龄大于60,就退休(门打开,人可以出去),一个接一个地这样循环下去,突然有一个人年龄是50,那么这个循环在他这里就停止,也就是这时候他不满足条件了。
这就是while循环。写一个严肃点的流程,可以看下图:
再做猜数字游戏
本教程有一讲,是跟看官一同做一个小游戏,在里面做了一个猜数的游戏,当时遇到了一个问题,就是只能猜一两次,如果猜不到,程序就不能继续运行了。
前不久,有一个在校的大学生朋友(他叫李航),给我发邮件,让我看了他做的游戏,能够实现多次猜数,直到猜中为止。这是一个多么喜欢学习的大学生呀。
我在这里将他写的程序恭录于此,单元李航同学不要见怪,如果李航同学认为此举侵犯了自己的知识产权,可以告知我,我马上撤下此代码。
#! /usr/bin/env python
#coding:UTF-8
import random
i=0
while i
print'********************************'
num = input('请您输入0到9任一个数:') #李同学用的是python3
xnum = random.randint(0,9)
x = 3 - i
if num == xnum:
print'运气真好,您猜对了!'
break
elif num > xnum:
print'''您猜大了!\n哈哈,正确答案是:%s\n您还有%s次机会!''' %(xnum,x)
elif num
print'''您猜小了!\n哈哈,正确答案是:%s\n您还有%s次机会!''' %(xnum,x)
print'********************************'
i += 1
我们就用这段程序来分析一下,首先看while i
当bool(i
根据上述代码,看官看看是否可以修改?
为了让用户的体验更爽,不妨把输入的整数范围扩大,在1到100之间吧。
num_input = raw_input("please input one integer that is in 1 to 100:") #我用的是python2.7,在输入指令上区别于李同学
程序用num_input变量接收了输入的内容。但是,请列位看官一定要注意,看到这里想睡觉的要打起精神了,我要分享一个多年编程经验,请牢记:任何用户输入的内容都是不可靠的。这句话含义深刻,但是,这里不做过多的解释,需要各位在随后的编程生涯中体验了。为此,我们要检验用户输入的是否符合我们的要求,我们要求用户输入的是1到100之间的整数,那么就要做如下检验:
输入的是否是整数
如果是整数,是否在1到100之间。
为此,要做:
if not num_input.isdigit(): #str.isdigit()是用来判断字符串是否纯粹由数字组成
print "Please input interger."
elif int(num_input)=100:
print "The number should be in 1 to 100."
else:
pass #这里用pass,意思是暂时省略,如果满足了前面提出的要求,就该执行此处语句
再看看李航同学的程序,在循环体内产生一个随机的数字,这样用户每次输入,面对的都是一个新的随机数字。这样的猜数字游戏难度太大了。我希望是程序产生一个数字,直到猜中,都是这个数字。所以,要把产生随机数字这个指令移动到循环之前。
import random
number = random.randint(1,100)
while True: #不限制用户的次数了
...
观察李同学的程序,还有一点需要向列位显明的,那就是在条件表达式中,两边最好是同种类型数据,上面的程序中有:num>xnum样式的条件表达式,而一边是程序生成的int类型数据,一边是通过输入函数得到的str类型数据。在某些情况下可以运行,为什么?看官能理解吗?都是数字的时候,是可以的。但是,这样不好。
那么,按照这种思路,把这个猜数字程序重写一下:
#!/usr/bin/env python
#coding:utf-8
import random
number = random.randint(1,100)
guess = 0
while True:
num_input = raw_input("please input one integer that is in 1 to 100:")
guess +=1
if not num_input.isdigit():
print "Please input interger."
elif int(num_input)=100:
print "The number should be in 1 to 100."
else:
if number==int(num_input):
print "OK, you are good.It is only %d, then you successed."%guess
break
elif number>int(num_input):
print "your number is more less."
elif number
else:
print "There is something bad, I will not work"
以上供参考,看官还可改进。
break和continue
break,在上面的例子中已经出现了,其含义就是要在这个地方中断循环,跳出循环体。下面这个简要的例子更明显:
#!/usr/bin/env python
#coding:utf-8
a = 8
while a:
if a%2==0:
break
else:
print "%d is odd number"%a
a = 0
print "%d is even number"%a
a=8的时候,执行循环体中的break,跳出玄幻,执行最后的打印语句,得到结果:
8 is even number
如果a=9,则要执行else里面的的print,然后a=0,循环就在执行一次,又break了,得到结果:
9 is odd number
0 is even number
而continue则是要从当前位置(即continue所在的位置)跳到循环体的最后一行的后面(不执行最后一行),对一个循环体来讲,就如同首尾衔接一样,最后一行的后面是哪里呢?当然是开始了。
#!/usr/bin/env python
#coding:utf-8
a = 9
while a:
if a%2==0:
a -=1
continue #如果是偶数,就返回循环的开始
else:
print "%d is odd number"%a #如果是奇数,就打印出来
a -=1
其实,对于这两东西,我个人在编程中很少用到。我有一个固执的观念,尽量将条件在循环之前做足,不要在循环中跳来跳去,不仅可读性下降,有时候自己也糊涂了。
while...else
这两个的配合有点类似if ... else,只需要一个例子列为就理解了,当然,一遇到else了,就意味着已经不在while循环内了。
#!/usr/bin/env python
count = 0
while count
print count, " is less than 5"
count = count + 1
else:
print count, " is not less than 5"
执行结果:
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Nous savons qu'en langage C, le mot-clé 'while' est utilisé pour définir une boucle qui fonctionne en fonction de la condition passée à la boucle. Désormais, puisque la condition peut avoir deux valeurs, vraie ou fausse, le code à l'intérieur du bloc while sera exécuté à plusieurs reprises si la condition est vraie et ne sera pas exécuté si la condition est fausse. Maintenant, en passant des paramètres à la boucle while, nous pouvons faire la différence entre while(1) et while(0) car while(1) est une boucle où la condition est toujours considérée comme vraie et donc le code à l'intérieur du bloc commencera à s'exécuter à plusieurs reprises. De plus, nous pouvons affirmer que ce n'est pas 1 qui est passé à la boucle qui rend la condition vraie, mais si un entier non nul est passé à la boucle while, alors il sera considéré comme la condition vraie, donc

L'expression Lambda sort de la boucle, des exemples de code spécifiques sont nécessaires en programmation, la structure de boucle est une syntaxe importante qui est souvent utilisée. Cependant, dans certaines circonstances, nous pouvons vouloir sortir de la boucle entière lorsqu'une certaine condition est remplie dans le corps de la boucle, plutôt que de simplement terminer l'itération en cours de la boucle. À l'heure actuelle, les caractéristiques des expressions lambda peuvent nous aider à atteindre l'objectif de sortir de la boucle. L'expression Lambda est un moyen de déclarer une fonction anonyme, qui peut définir une logique de fonction simple en interne. C'est différent d'une déclaration de fonction ordinaire,

Remarque : Cet article compare les boucles et la récursivité du point de vue du langage Go. Lors de l'écriture de programmes, vous rencontrez souvent des situations dans lesquelles une série de données ou d'opérations doivent être traitées de manière répétée. Pour y parvenir, nous devons utiliser des boucles ou de la récursivité. Les boucles et les récursions sont toutes deux des méthodes de traitement couramment utilisées, mais dans les applications pratiques, elles présentent chacune des avantages et des inconvénients, c'est pourquoi la situation réelle doit être prise en compte lors du choix de la méthode à utiliser. Cet article mènera une étude comparative des boucles et de la récursivité dans le langage Go. 1. Boucle Une boucle est un mécanisme qui exécute de manière répétée un certain morceau de code. Il existe trois principaux types de langage Go

Cet article expliquera en détail comment PHP renvoie toutes les valeurs d'un tableau pour former un tableau. L'éditeur pense que c'est assez pratique, je le partage donc avec vous comme référence. J'espère que vous pourrez gagner quelque chose après avoir lu cet article. . Utilisation de la fonction array_values() La fonction array_values() renvoie un tableau de toutes les valeurs d'un tableau. Il ne conserve pas les clés du tableau d'origine. $array=["foo"=>"bar","baz"=>"qux"];$values=array_values($array);//$values sera ["bar","qux"]Utilisation une boucle peut utiliser une boucle pour obtenir manuellement toutes les valeurs du tableau et les ajouter à un nouveau

Interface Iterator L'interface Iterator est une interface utilisée pour parcourir les collections. Il fournit plusieurs méthodes, notamment hasNext(), next() et remove(). La méthode hasNext() renvoie une valeur booléenne indiquant s'il existe un élément suivant dans la collection. La méthode next() renvoie l'élément suivant de la collection et le supprime de la collection. La méthode Remove() supprime l'élément actuel de la collection. L'exemple de code suivant montre comment utiliser l'interface Iterator pour parcourir une collection : Listnames=Arrays.asList("John","Mary","Bob");Iterator

Remplacement des appels récursifs dans les fonctions Java par itération En Java, la récursivité est un outil puissant utilisé pour résoudre divers problèmes. Cependant, dans certains cas, l’utilisation de l’itération peut s’avérer une meilleure option car elle est plus efficace et moins sujette aux débordements de pile. Voici les avantages de l'itération : Plus efficace puisqu'elle ne nécessite pas la création d'un nouveau stack frame à chaque appel récursif. Les débordements de pile sont moins susceptibles de se produire car l'utilisation de l'espace de pile est limitée. Méthodes itératives comme alternative aux appels récursifs : Il existe plusieurs méthodes en Java pour convertir des fonctions récursives en fonctions itératives. 1. Utiliser la pile L'utilisation de la pile est le moyen le plus simple de convertir une fonction récursive en fonction itérative. La pile est une structure de données dernier entré, premier sorti (LIFO), similaire à une pile d'appels de fonction. publicintfa

Tous les langages de programmation sont indissociables des boucles. Ainsi, par défaut, nous commençons à exécuter une boucle chaque fois qu’il y a une opération répétitive. Mais lorsqu’il s’agit d’un grand nombre d’itérations (millions/milliards de lignes), utiliser des boucles est un crime. Vous pourriez rester bloqué pendant quelques heures, pour vous rendre compte plus tard que cela ne fonctionne pas. C'est là que l'implémentation de la vectorisation en python devient très critique. Qu’est-ce que la vectorisation ? La vectorisation est une technique permettant d'implémenter des opérations de tableau (NumPy) sur des ensembles de données. En coulisse, il applique l'opération à tous les éléments du tableau ou de la série à la fois (contrairement à une boucle "for" qui opère une ligne à la fois). Nous utilisons ensuite quelques cas d'utilisation pour démontrer ce qu'est la vectorisation. Trouver la somme des nombres##Utilisez la boucle importtimestart

Comment gérer les erreurs d'imbrication de boucles PHP et générer les messages d'erreur correspondants Pendant le développement, nous utilisons souvent des instructions de boucle pour gérer des tâches répétées, telles que le parcours de tableaux et le traitement des résultats des requêtes de base de données. Cependant, lors de l'utilisation de l'imbrication de boucles, vous rencontrez parfois des erreurs, telles que des boucles infinies ou un trop grand nombre de niveaux d'imbrication. Ce problème peut entraîner une dégradation des performances du serveur, voire un crash. Afin de mieux gérer ces erreurs et de générer les messages d'erreur correspondants, cet article présentera quelques méthodes de traitement courantes et donnera des exemples de code correspondants. 1. Utilisez des compteurs pour
