Python 即使I'；我要[0]？

所以我最近做了一段代码，它应该能猜出你脑子里想的数字

from random import shuffle

def guess(start,limit):
    nl = []
    for i in range(start,limit+1):
        nl.append(i)
    shuffle(nl)
    return nl[0]

def logic(start,limit):
    p = False
    while p == False:
        j = guess(start,limit)
        print 'Is your number %i?' % (j)
        a = raw_input('Too High (h) or Too Low (l) or True (t)?\n')
        if a.lower() == 'h':
            limit = j - 1
        elif a.lower() == 'l':
            start = j + 1
        elif a.lower() == 't':
            p = True
    return 'You\'re number was %i' % (j)

出于某种原因，即使在一开始 猜（） 在请求nl[0]时，当start为54，limit为56时，Python会给出以下错误：

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 13, in logic
  File "<stdin>", line 8, in guess
IndexError: list index out of range

回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
文件“”，第13行，在逻辑中
文件“”，第8行，在guess中
索引器：列表索引超出范围

---

为什么会发生这种情况？我如何阻止这种情况发生？

如果nl数组为空，则得不到nl[0]。

如果nl数组为空，则得不到nl[0]。

如果nl数组为空，则得不到nl[0]。

如果nl数组为空，则得不到nl[0]。

列表为空；如果

限制

低于

开始

，则它将为空：

>>> from random import shuffle
>>> guess(1, 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in guess
IndexError: list index out of range
>>> guess(1, 1)
1

您需要在循环中测试这一点；如果玩家撒谎说猜测值太高，而猜测值确实正确或太低，那么你最终可能会发现

limit

低于

start

请注意，您可以使用从序列中选择一个值，而不是

random.shuffle（）

：

import random

def guess(start,limit):
    return random.choice(range(start, limit + 1))

但如果它是一个范围内的值，只需使用：

很好的一点是，

randint（）

在可以选择的值中包含了结束值，因此您不必在这里使用

limit+1

稍微简化一下

logic（）

函数，完全消除

guess（）

，并添加

start

和

limit

的测试：

import random

def logic(start, limit):
    while True:
        guess = random.randint(start, limit)
        print 'Is your number %i?' % guess
        answer = raw_input('Too high (h), too low (l) or true (t)?\n')
        if answer.lower() == 'h':
            limit = guess - 1
            if limit < start:
                print "I give up, I've run out of options"
                return
        elif answer.lower() == 'l':
            start = guess + 1
            if start > limit:
                print "I give up, I've run out of options"
                return
        elif answer.lower() == 't':
            return 'Your number was %i' % guess

随机导入
def逻辑（启动、限制）：
尽管如此：
guess=random.randint（开始，限制）
打印“您的号码是%i吗？”%
回答=原始输入（'太高（h）、太低（l）或真（t）？\n'）
如果answer.lower（）
极限=猜测-1
如果限制<开始：
打印“我放弃，我没有选择”
返回
elif answer.lower（）
开始=猜测+1
如果开始>限制：
打印“我放弃，我没有选择”
返回
elif answer.lower（）=“t”：
return“我猜您的号码是%1”

您的列表为空；如果

限制

低于

开始

，则它将为空：

>>> from random import shuffle
>>> guess(1, 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in guess
IndexError: list index out of range
>>> guess(1, 1)
1

您需要在循环中测试这一点；如果玩家撒谎说猜测值太高，而猜测值确实正确或太低，那么你最终可能会发现

limit

低于

start

请注意，您可以使用从序列中选择一个值，而不是

random.shuffle（）

：

import random

def guess(start,limit):
    return random.choice(range(start, limit + 1))

但如果它是一个范围内的值，只需使用：

很好的一点是，

randint（）

在可以选择的值中包含了结束值，因此您不必在这里使用

limit+1

稍微简化一下

logic（）

函数，完全消除

guess（）

，并添加

start

和

limit

的测试：

import random

def logic(start, limit):
    while True:
        guess = random.randint(start, limit)
        print 'Is your number %i?' % guess
        answer = raw_input('Too high (h), too low (l) or true (t)?\n')
        if answer.lower() == 'h':
            limit = guess - 1
            if limit < start:
                print "I give up, I've run out of options"
                return
        elif answer.lower() == 'l':
            start = guess + 1
            if start > limit:
                print "I give up, I've run out of options"
                return
        elif answer.lower() == 't':
            return 'Your number was %i' % guess

随机导入
def逻辑（启动、限制）：
尽管如此：
guess=random.randint（开始，限制）
打印“您的号码是%i吗？”%
回答=原始输入（'太高（h）、太低（l）或真（t）？\n'）
如果answer.lower（）
极限=猜测-1
如果限制<开始：
打印“我放弃，我没有选择”
返回
elif answer.lower（）
开始=猜测+1
如果开始>限制：
打印“我放弃，我没有选择”
返回
elif answer.lower（）=“t”：
return“我猜您的号码是%1”

您的列表为空；如果

限制

低于

开始

，则它将为空：

>>> from random import shuffle
>>> guess(1, 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in guess
IndexError: list index out of range
>>> guess(1, 1)
1

您需要在循环中测试这一点；如果玩家撒谎说猜测值太高，而猜测值确实正确或太低，那么你最终可能会发现

limit

低于

start

请注意，您可以使用从序列中选择一个值，而不是

random.shuffle（）

：

import random

def guess(start,limit):
    return random.choice(range(start, limit + 1))

但如果它是一个范围内的值，只需使用：

很好的一点是，

randint（）

在可以选择的值中包含了结束值，因此您不必在这里使用

limit+1

稍微简化一下

logic（）

函数，完全消除

guess（）

，并添加

start

和

limit

的测试：

import random

def logic(start, limit):
    while True:
        guess = random.randint(start, limit)
        print 'Is your number %i?' % guess
        answer = raw_input('Too high (h), too low (l) or true (t)?\n')
        if answer.lower() == 'h':
            limit = guess - 1
            if limit < start:
                print "I give up, I've run out of options"
                return
        elif answer.lower() == 'l':
            start = guess + 1
            if start > limit:
                print "I give up, I've run out of options"
                return
        elif answer.lower() == 't':
            return 'Your number was %i' % guess

随机导入
def逻辑（启动、限制）：
尽管如此：
guess=random.randint（开始，限制）
打印“您的号码是%i吗？”%
回答=原始输入（'太高（h）、太低（l）或真（t）？\n'）
如果answer.lower（）
极限=猜测-1
如果限制<开始：
打印“我放弃，我没有选择”
返回
elif answer.lower（）
开始=猜测+1
如果开始>限制：
打印“我放弃，我没有选择”
返回
elif answer.lower（）=“t”：
return“我猜您的号码是%1”

您的列表为空；如果

限制

低于

开始

，则它将为空：

>>> from random import shuffle
>>> guess(1, 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in guess
IndexError: list index out of range
>>> guess(1, 1)
1

您需要在循环中测试这一点；如果玩家撒谎说猜测值太高，而猜测值确实正确或太低，那么你最终可能会发现

limit

低于

start

请注意，您可以使用从序列中选择一个值，而不是

random.shuffle（）

：

import random

def guess(start,limit):
    return random.choice(range(start, limit + 1))

但如果它是一个范围内的值，只需使用：

很好的一点是，

randint（）

在可以选择的值中包含了结束值，因此您不必在这里使用

limit+1

简化您的<