Mi columna del blog CSDN: https://blog.csdn.net/yty_7
Dirección de Github: https://github.com/yot777/
Resumen
En el uso combinado de bucles de Python y condiciones de juicio, se pueden agregar las palabras clave else, break, return, continue y pass, y las funciones son las siguientes:
1, otra declaración
Si el ciclo finaliza después de que se agota la lista (en un ciclo for) o si la condición se vuelve falsa (en un ciclo while)
2. Declaración de ruptura
Se usa para saltar de todo el cuerpo del bucle de for y while. Una vez saltado, los bloques de programa restantes (incluido el resto) en el bucle no se ejecutarán.
3. La declaración de devolución
Se utiliza para saltar de todo el cuerpo del bucle de for and while y toda la función que contiene este cuerpo del bucle.
4, continuar declaración
Se usa para omitir las declaraciones restantes en el bloque de bucle actual y luego continuar a la siguiente ronda de bucles.
5. Declaración de aprobación
Continuar el ciclo actual, que es equivalente a ningún efecto.
para combinación de bucle y ruptura
Supongamos que un Sr. cena en un restaurante, odia mucho la mostaza, pero no conoce los platos con anticipación, por lo que podemos escribir el siguiente programa:
def func():
foods = ["薯片","炸鸡","牛排","芥末","浓汤"]
for item in foods:
if item == "芥末":
print("我不喜欢吃芥末，用餐结束！")
break
else:
print("我喜欢吃"+str(item)+"，请继续！")
else:
print("太棒了，没有我不喜欢吃的菜！")
print("终于，我吃完了。")
if __name__ == '__main__':
func()
print("结束用餐函数！")
运行结果：
我喜欢吃薯片，请继续！
我喜欢吃炸鸡，请继续！
我喜欢吃牛排，请继续！
我不喜欢吃芥末，用餐结束！
终于，我吃完了。
结束用餐函数！Explique: si el programa Python encuentra si __name__ == '__main__': la declaración debajo de la solicitud se ejecutará primero
A través de item en alimentos en la función func (): recorre la lista de alimentos, la condición de juicio es si item == "mostaza"
Al pasar a "patata", "pollo frito", "filete", el resultado de la condición if es FALSO, por lo que la salida de ejecución: "Me gusta comer XX, ¡por favor continúe!"
Cuando se pasa a "Mostaza", el resultado de la condición if es VERDADERA, por lo que el resultado es: "No me gusta comer mostaza, ¡la comida ha terminado!"
Siguiendo la palabra clave break, todo el ciclo saltó sin atravesar la "sopa".
La función func () finalmente genera: "Finalmente, terminé mi comida".
Después de llamar a la función func (), también genera "¡Fin de la función de comida!"
Si no hay "mostaza" en el menú del caballero, como sigue:
def func():
foods = ["薯片","炸鸡","牛排","浓汤"]
for item in foods:
if item == "芥末":
print("我不喜欢吃芥末，用餐结束！")
break
else:
print("我喜欢吃"+str(item)+"，请继续！")
else:
print("太棒了，没有我不喜欢吃的菜！")
print("终于，我吃完了。")
if __name__ == '__main__':
func()
print("结束用餐函数！")
运行结果：
我喜欢吃薯片，请继续！
我喜欢吃炸鸡，请继续！
我喜欢吃牛排，请继续！
我喜欢吃浓汤，请继续！
太棒了，没有我不喜欢吃的菜！
终于，我吃完了。
结束用餐函数！"Wasabi" no aparece en la lista de alimentos, por lo que se ejecuta la instrucción else del bucle for y el resultado es "¡Genial, no hay platos que no me guste comer!"
porque ... más es una sintaxis característica del bucle Python, lo que significa que la declaración que debe ejecutarse cuando se completa el recorrido y no hay interrupción .
para combinación de bucle y retorno
La situación básica es la misma que la anterior, pero reemplazamos la palabra clave break con returen, de la siguiente manera:
def func():
foods = ["薯片","炸鸡","牛排","芥末","浓汤"]
for item in foods:
if item == "芥末":
print("我不喜欢吃芥末，用餐结束！")
return
else:
print("我喜欢吃"+str(item)+"，请继续！")
else:
print("太棒了，没有我不喜欢吃的菜！")
print("终于，我吃完了。")
if __name__ == '__main__':
func()
print("结束用餐函数！")
运行结果：
我喜欢吃薯片，请继续！
我喜欢吃炸鸡，请继续！
我喜欢吃牛排，请继续！
我不喜欢吃芥末，用餐结束！
结束用餐函数！Explique: si el programa Python encuentra si __name__ == '__main__': la declaración debajo de la solicitud se ejecutará primero
A través de item en alimentos en la función func (): recorre la lista de alimentos, la condición de juicio es si item == "mostaza"
Al pasar a "patata", "pollo frito", "filete", el resultado de la condición if es FALSO, por lo que la salida de ejecución: "Me gusta comer XX, ¡por favor continúe!"
Cuando se pasa a "Mostaza", el resultado de la condición if es VERDADERA, por lo que el resultado es: "No me gusta comer mostaza, ¡la comida ha terminado!"
Inmediatamente después de la palabra clave return, no solo saltó del ciclo completo , sino que también saltó de toda la función , no solo no atravesó la "sopa" e incluso otras declaraciones en la función "Finalmente, la terminé". No se ejecuta.
Finalmente, solo se emite la declaración final de todo el programa Python "¡función de fin de comida!".
Tenga en cuenta: Al aplicar el retorno en un bucle for, asegúrese de colocar el bucle en un cuerpo de función , de lo contrario, se informará un error.
para bucle y combinación continua
La situación básica es la misma que la anterior, pero reemplazamos la palabra clave break con continue, de la siguiente manera:
def func():
foods = ["薯片","炸鸡","牛排","芥末","浓汤"]
for item in foods:
if item == "芥末":
print("我不喜欢吃芥末，用餐结束！")
continue
else:
print("我喜欢吃"+str(item)+"，请继续！")
else:
print("太棒了，没有我不喜欢吃的菜！")
print("终于，我吃完了。")
if __name__ == '__main__':
func()
print("结束用餐函数！")
运行结果：
我喜欢吃薯片，请继续！
我喜欢吃炸鸡，请继续！
我喜欢吃牛排，请继续！
我不喜欢吃芥末，用餐结束！
我喜欢吃浓汤，请继续！
太棒了，没有我不喜欢吃的菜！
终于，我吃完了。
结束用餐函数！el artículo atraviesa la lista de alimentos, la condición de juicio es si el artículo == "mostaza"
Al pasar a "patata", "pollo frito", "filete", el resultado de la condición if es FALSO, por lo que la salida de ejecución: "Me gusta comer XX, ¡por favor continúe!"
Cuando se pasa a "Mostaza", el resultado de la condición if es VERDADERA, por lo que el resultado es: "No me gusta comer mostaza, ¡la comida ha terminado!"
Siguiendo la palabra clave continuar, salte del recorrido actual y continúe con el siguiente recorrido de "sopa", salida: "Me gusta comer sopa espesa, ¡por favor continúe!"
Como "sopa" es el último elemento del recorrido , también se alcanza la condición de que el recorrido se complete sin romperse , y la salida sigue siendo "¡Genial, no hay platos que no me guste comer!"
para combinación de bucle y pase
Reemplazamos la palabra clave continue con pass, de la siguiente manera:
def func():
foods = ["薯片","炸鸡","牛排","芥末","浓汤"]
for item in foods:
if item == "芥末":
print("我不喜欢吃芥末，用餐结束！")
pass
else:
print("我喜欢吃"+str(item)+"，请继续！")
else:
print("太棒了，没有我不喜欢吃的菜！")
print("终于，我吃完了。")
if __name__ == '__main__':
func()
print("结束用餐函数！")
运行结果：
我喜欢吃薯片，请继续！
我喜欢吃炸鸡，请继续！
我喜欢吃牛排，请继续！
我不喜欢吃芥末，用餐结束！
我喜欢吃浓汤，请继续！
太棒了，没有我不喜欢吃的菜！
终于，我吃完了。
结束用餐函数！La declaración de aprobación se puede entender como un marcador de posición, lo que no tiene sentido y no afecta la ejecución de ningún programa, por lo que
Cuando se pasa a "mostaza", el resultado de la condición if es VERDADERA, por lo que el resultado es: "No me gusta comer mostaza, ¡la comida ha terminado!"
Continúe con el siguiente recorrido de "sopa" y salida: "Me gusta comer sopa espesa, ¡por favor continúe!"
Como "sopa" es el último elemento del recorrido , también se alcanza la condición de que el recorrido se complete sin romperse , y la salida sigue siendo "¡Genial, no hay platos que no me guste comer!"
Resumen
En el uso combinado de bucles Python y condiciones de juicio, puede agregar más, romper, devolver, continuar y pasar palabras clave.
porque ... más es una sintaxis característica del bucle Python, lo que significa que la declaración que debe ejecutarse cuando se completa el recorrido y no hay interrupción .
El propósito de la palabra clave break es saltar fuera del ciclo completo .
La función de la palabra clave return no solo es saltar del ciclo completo , sino también saltar de la función completa , asegúrese de colocar el ciclo en el cuerpo de una función , de lo contrario, informará un error.
El papel de la palabra clave continuar es saltar del recorrido actual y continuar al siguiente recorrido.
La palabra clave pass en sí misma no tiene sentido y no afecta la ejecución de ningún programa.
Mi columna del blog CSDN: https://blog.csdn.net/yty_7
Dirección de Github: https://github.com/yot777/
Si crees que este capítulo es útil para ti, ¡bienvenido a seguir, comentar y dar me gusta! ¡Github le da la bienvenida a Follow and Star!
