“ while True” หมายความว่าอย่างไรใน Python

def play_game(word_list):
    hand = deal_hand(HAND_SIZE) # random init
    while True:
        cmd = raw_input('Enter n to deal a new hand, r to replay the last hand, or e to end game: ')
        if cmd == 'n':
            hand = deal_hand(HAND_SIZE)
            play_hand(hand.copy(), word_list)
            print
        elif cmd == 'r':
            play_hand(hand.copy(), word_list)
            print
        elif cmd == 'e':
            break
        else:
            print "Invalid command."

ในขณะที่อะไรคือความจริง?

ฉันคิดว่า 'ในขณะที่จริง' เป็นชวเลข แต่เพื่ออะไร? ในขณะที่ตัวแปร "มือ" กำลังกำหนดค่า? และจะเกิดอะไรขึ้นถ้าตัวแปร 'มือ' ไม่ได้รับการกำหนดค่า?

while Trueหมายถึงวนตลอดไป whileคำสั่งจะใช้เวลาการแสดงออกและดำเนินการม้วนตัวในขณะที่ประเมินการแสดงออกถึง (บูล) "จริง" Trueมักจะประเมินเป็นบูลีน "จริง" และดำเนินการวนซ้ำไปเรื่อย ๆ มันเป็นสำนวนที่คุณจะคุ้นเคยในที่สุด! ภาษาส่วนใหญ่ที่คุณน่าจะพบมีสำนวนที่เทียบเท่ากัน

โปรดทราบว่าภาษาส่วนใหญ่มักมีกลไกบางอย่างในการหลุดจากลูปในช่วงต้น ในกรณีของ Python มันเป็นbreakคำสั่งในcmd == 'e'กรณีของตัวอย่างในคำถามของคุณ

คำถามของฉัน: ในขณะที่อะไรคือความจริง?

ในขณะที่มีTrueTrue

Trueห่วงในขณะที่จะทำงานตราบเท่าที่ประเมินการแสดงออกเงื่อนไข

เนื่องจากTrueเสมอประเมินTrueเป็นลูปจะทำงานไปเรื่อย ๆ จนกว่าจะมีบางอย่างภายในลูปreturns หรือbreaks

คำถามของฉัน: ในขณะที่อะไรคือความจริง?

ทุกสิ่งที่อยู่ใน () ของคำสั่ง while จะได้รับการประเมินเป็นบูลีน ความหมายถูกแปลงเป็นจริงหรือเท็จ

พิจารณาในแถลงการณ์ while(6 > 5)

ขั้นแรกจะประเมินนิพจน์6 > 5ซึ่งtrueเหมือนกับการพูดwhile(true)

สิ่งใดก็ตามที่ไม่ใช่ FALSE, 0, สตริงว่างเปล่า "", ว่างหรือไม่ได้กำหนดมีแนวโน้มที่จะได้รับการประเมินเป็นจริง

เมื่อแรกเริ่มการเขียนโปรแกรมผมใช้ในการทำสิ่งต่างๆเช่นผมไม่ทราบว่าเป็นความจริงเป็นสิ่งเดียวกับif(foo == true)if(foo)

ดังนั้นเมื่อคุณพูดwhile(true)เหมือนกำลังพูดwhile(true == true)

ดังนั้นเพื่อตอบคำถามคุณ: ในขณะที่ TRUE เป็นจริง

ในขณะที่Trueเป็นจริง - เช่นเสมอ นี่คือการวนซ้ำที่ไม่มีที่สิ้นสุด

สังเกตความแตกต่างที่สำคัญที่นี่ระหว่างTrueคำหลักในภาษาที่แสดงถึงค่าคงที่ของประเภทเฉพาะและ 'จริง' ซึ่งเป็นแนวคิดทางคณิตศาสตร์

ในบริบทนี้ฉันคิดว่ามันสามารถตีความได้ว่า

do
...
while cmd  != 'e' 

Trueอยู่เสมอTrueดังนั้นwhile Trueจะวนซ้ำตลอดไป

whileคำหลักที่ใช้เวลาการแสดงออกและลูปในขณะที่การแสดงออกเป็นความจริง Trueเป็นการแสดงออกที่เป็นจริงเสมอ

เพื่อเป็นตัวอย่างที่ชัดเจนให้พิจารณาสิ่งต่อไปนี้:

a = 1
result = a == 1

ที่นี่a == 1จะกลับมาTrueและด้วยเหตุนี้ใส่ลงไปในTrue resultดังนั้น

a = 1
while a == 1:
  ...

เทียบเท่ากับ:

while True:
  ...

หากคุณไม่เปลี่ยนค่าของaภายในwhileลูป

ตามปกติเป็นค่าคงที่ในตัวของTrue Python ในตัวของประเภทบูล

คุณสามารถใช้การดำเนินการบูลีนกับประเภทบูล (ที่พรอมต์ python แบบโต้ตอบเป็นต้น) และแปลงตัวเลขเป็นประเภทบูล:

>>> print not True
False
>>> print not False
True
>>> print True or False
True
>>> print True and False
False
>>> a=bool(9)
>>> print a
True
>>> b=bool(0)
>>> print b
False
>>> b=bool(0.000000000000000000000000000000000001)
>>> print b
True

และมี "gotcha" ที่อาจเกิดขึ้นกับสิ่งที่คุณเห็นและสิ่งที่คอมไพเลอร์ Python เห็น:

>>> n=0
>>> print bool(n)
False
>>> n='0'
>>> print bool(n)
True
>>> n=0.0
>>> print bool(n)
False
>>> n="0.0"
>>> print bool(n)
True

เพื่อเป็นการบอกใบ้ถึงวิธีที่ Python จัดเก็บประเภทบูลไว้ภายในคุณสามารถโยนประเภทบูลเป็นจำนวนเต็มและ True จะออกมาเป็น 1 และ False 0:

>>> print True+0
1
>>> print True+1
2
>>> print False+0
0
>>> print False+1
1

ในความเป็นจริงboolประเภทPython เป็นคลาสย่อยของประเภทของ Python int:

>>> type(True)
<type 'bool'>
>>> isinstance(True, int)
True

ส่วนที่สำคัญกว่าของคำถามของคุณคือ "What is while True?" คือ 'อะไรคือความจริง' และข้อสรุปที่สำคัญ: อะไรคือเท็จ?

ขั้นแรกสำหรับทุกภาษาที่คุณกำลังเรียนรู้ให้เรียนรู้สิ่งที่ภาษาถือว่า 'จริง' และ 'เท็จ' Python พิจารณาความจริงแตกต่างจากPerl Truthเล็กน้อย ภาษาอื่น ๆ มีแนวคิดเรื่องจริง / เท็จที่แตกต่างกันเล็กน้อย รู้ว่าภาษาของคุณถือว่าเป็นจริงและเท็จสำหรับการดำเนินการและการควบคุมการไหลที่แตกต่างกันเพื่อหลีกเลี่ยงความปวดหัวในภายหลัง!

มีอัลกอริทึมมากมายที่คุณต้องการประมวลผลบางอย่างจนกว่าคุณจะพบสิ่งที่คุณกำลังมองหา ดังนั้นลูปไม่มีที่สิ้นสุดหรือลูปไม่ จำกัด แต่ละภาษามักจะมีสำนวนของตัวเองสำหรับโครงสร้างเหล่านี้ ต่อไปนี้เป็นลูปแบบไม่มีที่สิ้นสุดของ C ทั่วไปซึ่งใช้ได้กับ Perl:

for(;;) { /* loop until break */ }

/* or */

while (1) {
   return if (function(arg) > 3);
}

while True:รูปแบบเป็นเรื่องธรรมดาในงูหลามลูปไม่แน่นอนด้วยวิธีการของการทำลายออกจากวงบาง เรียนรู้การควบคุมโฟลว์ Python เพื่อทำความเข้าใจว่าคุณแยกออกจากwhile Trueลูปอย่างไร ต่างจากภาษาส่วนใหญ่เช่น Python สามารถมีelseประโยคบนลูปได้ มีตัวอย่างในลิงค์สุดท้าย

whileห่วงจะเกิดการโต้แย้งที่มีเงื่อนไข (หมายถึงสิ่งที่เป็นเรื่องปกติจริงหรือเท็จหรือสามารถตีความได้ว่าเป็นเช่นนั้น) Trueและมีเพียงดำเนินการในขณะที่อัตราผลตอบแทนเงื่อนไข

สำหรับwhile True? เงื่อนไขที่แท้จริงที่ง่ายที่สุดก็คือTrueตัวมันเอง! ดังนั้นนี่คือการวนซ้ำที่ไม่มีที่สิ้นสุดโดยปกติจะดีในเกมที่ต้องใช้การวนซ้ำมาก (โดยทั่วไปมากขึ้นจากมุมมองของฉันคือการตั้งค่าตัวแปร "done" บางประเภทเป็น false แล้วทำให้เป็นจริงเพื่อจบเกมและลูปจะมีลักษณะเหมือนwhile not done:หรืออะไรก็ตาม)

ในบางภาษา True เป็นเพียงและนามแฝงสำหรับหมายเลข คุณสามารถเรียนรู้เพิ่มเติมว่าเหตุใดจึงเป็นเช่นนี้โดยอ่านเพิ่มเติมเกี่ยวกับตรรกะบูลีนตรรกะแบบบูล

เพื่อตอบคำถามของคุณโดยตรง: ในขณะที่เงื่อนไขการวนซ้ำเป็นจริง ซึ่งมันมักจะอยู่ในโค้ดนี้โดยเฉพาะ

whileลูปยังคงวนซ้ำจนกว่าเงื่อนไขจะเป็นเท็จ ตัวอย่างเช่น (pseudocode):

i = 0
while i < 10
  i++

การวนซ้ำแต่ละครั้งiจะเพิ่มขึ้นทีละ 1 จนครบ 10 เมื่อถึงจุดนั้นเงื่อนไขi < 10จะไม่เป็นจริงอีกต่อไปและการวนซ้ำจะเสร็จสมบูรณ์

เนื่องจากเงื่อนไขในwhile Trueเป็นไปอย่างชัดเจนและตลอดเวลาtrueการวนซ้ำจะไม่สิ้นสุด (จนกว่าจะแตกออกจากทางอื่นโดยปกติจะเป็นโครงสร้างเช่นเดียวกับbreakภายในตัววง)

ไม่มีอะไรที่จะประเมินได้เร็วกว่าTrue Trueดังนั้นจึงเป็นการดีถ้าคุณใช้while Trueแทนwhile 1==1ฯลฯ

while True:
    ...

หมายถึงการวนซ้ำที่ไม่มีที่สิ้นสุด

คำสั่ง while มักใช้ของลูป จำกัด แต่การใช้ค่าคงที่ 'True' จะรับประกันการทำซ้ำของคำสั่ง while โดยไม่จำเป็นต้องควบคุมลูป (เช่นการตั้งค่าบูลีนในการวนซ้ำเป็นต้น) เว้นแต่คุณจะต้องการทำลายมัน

ในความเป็นจริง

True == (1 == 1)

ในขณะที่ True mean infinite loop โดยปกติจะใช้โดยกระบวนการที่ยาวนาน คุณสามารถเปลี่ยนแปลงได้

while True:

ด้วย

while 1:

แม้ว่าคำตอบเหล่านี้ส่วนใหญ่จะถูกต้องในระดับที่แตกต่างกัน แต่ก็ไม่มีคำตอบใดที่กระชับเท่าที่ฉันต้องการ

ใส่เพียงใช้while True:เป็นเพียงวิธีการของการทำงานห่วงว่าจะทำงานต่อไปจนกว่าคุณจะทำลายอย่างชัดเจนออกมาจากมันใช้หรือbreak returnเนื่องจาก True จะประเมินเป็น True เสมอคุณจึงต้องบังคับให้ลูปสิ้นสุดเมื่อคุณต้องการ

while True:
    # do stuff

    if some_condition:
        break

    # do more stuff - code here WILL NOT execute when `if some_condition:` evaluates to True

ในขณะที่ปกติลูปจะถูกตั้งค่าให้ทำงานจนกว่าเงื่อนไข while จะเป็นเท็จหรือถึงจุดสิ้นสุดที่กำหนดไว้ล่วงหน้า:

do_next = True

while do_next:

    # do stuff

    if some_condition:
        do_next = False

    # do more stuff - code here WILL execute even when `if some_condition:` evaluates to True

โค้ดทั้งสองชิ้นนั้นทำสิ่งเดียวกันได้อย่างมีประสิทธิภาพ

หากเงื่อนไขที่ลูปของคุณประเมินว่าเป็นไปได้ว่าเป็นค่าที่ไม่ได้อยู่ในการควบคุมของคุณโดยตรงเช่นค่าอินพุตของผู้ใช้การตรวจสอบความถูกต้องของข้อมูลและการแยกออกจากลูปอย่างชัดเจนจึงเป็นสิ่งที่จำเป็นดังนั้นคุณจึงต้องใช้วิธีใดวิธีหนึ่ง .

while Trueรูปแบบ pythonic มากขึ้นนับตั้งแต่ที่คุณรู้ว่าbreakจะทำลายห่วงที่ว่าจุดที่แน่นอนในขณะที่do_next = Falseสามารถทำสิ่งอื่น ๆ do_nextอีกก่อนที่จะมีการประเมินผลต่อไปของ

ทุกสิ่งสามารถเป็น True ได้จนกว่าจะมีการนำเสนอสิ่งที่ตรงกันข้าม นี่คือวิธีการทำงานของความเป็นคู่ มันเป็นวิธีที่เปรียบเทียบกัน สีดำสามารถเป็นจริงได้จนกว่าจะเป็นสีขาว ณ จุดที่เป็นเท็จ สีดำยังสามารถเป็นเท็จจนกว่าจะเป็นสีขาว ณ จุดที่เป็นจริง ไม่ใช่สถานะ แต่เป็นการเปรียบเทียบสถานะตรงกันข้าม ถ้าอย่างใดอย่างหนึ่งเป็นจริงอีกฝ่ายผิด True ไม่ได้หมายความว่าถูกต้องหรือได้รับการยอมรับ เป็นสถานะที่ตรงกันข้ามเสมอเป็นเท็จ มันเป็นความเป็นคู่