Python 数字猜测者：请复习一下，让它更像蟒蛇

我正在学习python，下面是一个简单的程序，我写道：

def guesser(var, num1,possible):
    if var == 'n':
        cutoff = len(possible)/2
        possible = possible[0:cutoff]
        cutoff = possible[len(possible)/2]
        #print possible

        if (len(possible) == 1):
             print "Your Number is:", possible
        else:
            var = raw_input("Is Your Number Bigger Than %s? (y/n): " %cutoff)
            guesser(var, cutoff,possible)


    elif var == 'y':
        cutoff = len(possible)/2
        possible = possible[cutoff:len(possible)]
        cutoff = possible[len(possible)/2]
        #print possible
        #print cutoff

       if (len(possible) == 1):
           print "Your Number is:", possible
       else:
            var = raw_input("Is Your Number Bigger Than %s? (y/n): " %cutoff)
            guesser(var, cutoff,possible)


    else:
        var = raw_input("Is Your Number Bigger Than 50? (y/n): ")
        guesser(var, 50, possible)

possible = []
possible = range(1,101)

guesser('a', 50, possible)

---

在做更多的pythonic之前，我可能会让它更简单。。。该算法比需要的复杂得多。当两个整数足够时，不需要使用列表

def guesser(low = 0, up = 100):
    print("Choose a number between %d and %d" % (low, up-1))
    while low < up - 1:
        mid = (low+up)//2
        yn = raw_input("Is Your Number Smaller Than %s? (y/n): " % mid)
        if yn not in ['y', 'n']: continue
        low, up =  (low, mid) if yn == 'y' else (mid, up)
    print "Your Number is:", low


guesser()

def猜测器（低=0，高=100）：
打印（“选择一个介于%d和%d之间的数字”%（低，高1））
低<高-1时：
中间=（低+高）//2
yn=原始输入（“您的数字是否小于%s？（y/n）：%mid）
如果yn不在['y'，'n']：继续
低，向上=（低，中）如果yn='y'其他（中，向上）
打印“您的号码是：”，低
猜

在做更多的pythonic之前，我可能会让它变得更简单。。。该算法比需要的复杂得多。当两个整数足够时，不需要使用列表

def guesser(low = 0, up = 100):
    print("Choose a number between %d and %d" % (low, up-1))
    while low < up - 1:
        mid = (low+up)//2
        yn = raw_input("Is Your Number Smaller Than %s? (y/n): " % mid)
        if yn not in ['y', 'n']: continue
        low, up =  (low, mid) if yn == 'y' else (mid, up)
    print "Your Number is:", low


guesser()

def猜测器（低=0，高=100）：
打印（“选择一个介于%d和%d之间的数字”%（低，高1））
低<高-1时：
中间=（低+高）//2
yn=原始输入（“您的数字是否小于%s？（y/n）：%mid）
如果yn不在['y'，'n']：继续
低，向上=（低，中）如果yn='y'其他（中，向上）
打印“您的号码是：”，低
猜

通常我会尝试帮助您编写代码，但您将代码变得过于复杂，我认为您可以更轻松地查看一些代码

def guesser( bounds ):
    a, b = bounds
    mid = ( a + b ) // 2

    if a == b: return a

    if input( "over {0}? ".format( mid ) ) == "y":
        new_bounds = ( mid, b )
    else:
        new_bounds = ( a, mid )

    return guesser( new_bounds )

在深入研究之前，你应该考虑一下你的算法在抽象术语中是如何工作的

---

编辑：以牺牲简洁性为代价简化了代码。

通常我会尝试帮助您编写代码，但您将代码变得过于复杂，我认为您可以更轻松地查看一些代码

def guesser( bounds ):
    a, b = bounds
    mid = ( a + b ) // 2

    if a == b: return a

    if input( "over {0}? ".format( mid ) ) == "y":
        new_bounds = ( mid, b )
    else:
        new_bounds = ( a, mid )

    return guesser( new_bounds )

在深入研究之前，你应该考虑一下你的算法在抽象术语中是如何工作的

---

编辑：以牺牲简洁性为代价简化了代码。

这不像Katrielex的递归那样优雅，但它演示了一个基本类

class guesser:
    def __init__(self, l_bound, u_bound):
        self.u_bound = u_bound
        self.l_bound = l_bound
        self.nextguess()

    def nextguess(self):
        self.guess = int((self.u_bound + self.l_bound)/2)
        print 'Higher or lower than %i?' % self.guess

    def mynumberishigher(self):
        self.l_bound = self.guess
        self.nextguess()

    def mynumberislower(self):
        self.u_bound = self.guess
        self.nextguess()

---

这不像Katrielex的递归那样优雅，但它演示了一个基本类

class guesser:
    def __init__(self, l_bound, u_bound):
        self.u_bound = u_bound
        self.l_bound = l_bound
        self.nextguess()

    def nextguess(self):
        self.guess = int((self.u_bound + self.l_bound)/2)
        print 'Higher or lower than %i?' % self.guess

    def mynumberishigher(self):
        self.l_bound = self.guess
        self.nextguess()

    def mynumberislower(self):
        self.u_bound = self.guess
        self.nextguess()

---

使用

bisect

模块更像pythonic——当然还有

类：）


下面是python库中的
bisect.bisect
的定义。如您所见，大部分算法都是在这里为您实现的

def bisect_right(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.

    The return value i is such that all e in a[:i] have e <= x, and all e in
    a[i:] have e > x.  So if x already appears in the list, a.insert(x) will
    insert just after the rightmost x already there.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if x < a[mid]: hi = mid
        else: lo = mid+1
    return lo

bisect = bisect_right   # backward compatibility

def bisect_right（a，x，lo=0，hi=None）：
“”“返回在列表a中插入项目x的索引，假设a已排序。
返回值i使得[：i]中的所有e都有ex。因此，如果x已经出现在列表中，a.insert（x）将
在最右边的x已经存在之后插入。
可选参数lo（默认值0）和hi（默认值len（a））绑定
要搜索的图像片段。
"""
如果lo<0：
raise VALUERROR（'lo必须为非负'）
如果hi为无：
hi=len（a）
当lo
使用
对分
模块更像pythonic——当然还有
类：）


下面是python库中的
bisect.bisect
的定义。如您所见，大部分算法都是在这里为您实现的

def bisect_right(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.

    The return value i is such that all e in a[:i] have e <= x, and all e in
    a[i:] have e > x.  So if x already appears in the list, a.insert(x) will
    insert just after the rightmost x already there.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if x < a[mid]: hi = mid
        else: lo = mid+1
    return lo

bisect = bisect_right   # backward compatibility

def bisect_right（a，x，lo=0，hi=None）：
“”“返回在列表a中插入项目x的索引，假设a已排序。
返回值i使得[：i]中的所有e都有ex。因此，如果x已经出现在列表中，a.insert（x）将
在最右边的x已经存在之后插入。
可选参数lo（默认值0）和hi（默认值len（a））绑定
要搜索的图像片段。
"""
如果lo<0：
raise VALUERROR（'lo必须为非负'）
如果hi为无：
hi=len（a）
当lo
此代码正确吗？您有两个
else
子句，并且
cutoff
未在这两个子句中的第一个中定义。请编辑代码段，使其正确。
回溯（最近一次调用）：文件“guess.py”，第22行：if（len（可能）==1）：缩进错误：未缩进与任何外部缩进级别不匹配
我修复了代码。我的缩进不太正确。这个代码正确吗？您有两个
else
子句，并且
cutoff
未在这两个子句中的第一个中定义。请编辑代码段，使其正确。
回溯（最近一次调用）：文件“guess.py”，第22行：if（len（可能）==1）：缩进错误：未缩进与任何外部缩进级别不匹配
我修复了代码。我的缩进不太正确。如果我还记得我的选票重新出现的话。只要
b-a<2**n
其中
n
是本地python的递归限制，这绝对是正确的答案。我认为默认值是1000，因此涵盖了相当广泛的范围。为了提高可读性，我建议显式地分配一个
新的\u范围
，并在递归步骤中将其传递给
猜测器
。我传递的是猜测器范围（1101），我得到的值太多，无法解包。@Katrielex:这不起作用，尝试用17表示范围0100（简单的stop case，这个例子很容易出错）。@NoahClark:你需要传递一个有边界的元组，而不是一个范围（参数名有误导性）@NoahClark:正确的调用应该像
guesser（（01100））
一个括号级别用于函数调用，另一个括号级别用于元组。您还必须通过原始输入更改输入以使其（接近）工作。正如我在其他评论中解释的那样，我写这篇文章几乎是因为stop case错误。如果我记得我的投票结果是一致的，那么+1。这绝对是正确的答案，只要
b-a<2**n
其中
n
是本地python的递归限制。我认为默认值是1000，因此涵盖了相当广泛的范围。我建议的一点是：可读性的gest是显式分配一个
新的\u范围