2

我正在努力完成一个数学问题，该问题使用 Python 中的牛顿猜测和检查方法来近似数字的平方根。用户应该输入一个数字，对该数字的初始猜测，以及他们想要在返回之前检查他们的答案多少次。为了让事情变得更容易并了解 Python（几个月前我才刚刚开始学习这门语言），我将它分解为许多较小的函数；但是，现在的问题是我无法调用每个函数并传递数字。

这是我的代码，带有帮助的注释（每个函数按使用顺序排列）：

# This program approximates the square root of a number (entered by the user)
# using Newton's method (guess-and-check). I started with one long function,
# but after research, have attempted to apply smaller functions on top of each
# other.
# * NEED TO: call functions properly; implement a counting loop so the
# goodGuess function can only be accessed the certain # of times the user
# specifies. Even if the - .001 range isn't reached, it should return.

# sqrtNewt is basically the main, which initiates user input.

def sqrtNewt():
    # c equals a running count initiated at the beginning of the program, to
    # use variable count.
    print("This will approximate the square root of a number, using a guess-and-check process.")
    x = eval(input("Please type in a positive number to find the square root of: "))
    guess = eval(input("Please type in a guess for the square root of the number you entered: "))
    count = eval(input("Please enter how many times would you like this program to improve your initial guess: ")) 
    avg = average(guess, x)
    g, avg = improveG(guess, x)
    final = goodGuess(avg, x)
    guess = square_root(guess, x, count)
    compare(guess, x)


# Average function is called; is the first step that gives an initial average,
# which implements through smaller layers of simple functions stacked on each
# other.
def average(guess, x) :
    return ((guess + x) / 2)

# An improvement function which builds upon the original average function.
def improveG(guess, x) :
    return average(guess, x/guess)

# A function which determines if the difference between guess X guess minus the
# original number results in an absolute vale less than 0.001. Not taking
# absolute values (like if guess times guess was greater than x) might result
# in errors
from math import *
def goodGuess(avg, x) :
    num = abs(avg * avg - x)
    return (num < 0.001)

# A function that, if not satisfied, continues to "tap" other functions for
# better guess outputs. i.e. as long as the guess is not good enough, keep
# improving the guess.
def square_root(guess, x, count) :
    while(not goodGuess(avg, x)):
        c = 0
        c = c + 1
        if (c < count):
            guess = improveG(guess, x)
        elif (c == count):
            return guess
        else :
            pass

# Function is used to check the difference between guess and the sqrt method
# applied to the user input.
import math
def compare(guess, x):
    diff = math.sqrt(x) - guess
    print("The following is the difference between the approximation") 
    print("and the Math.sqrt method, not rounded:", diff)

sqrtNewt()

目前，我收到此错误：g, avg = improveG(guess, x) TypeError: 'float' object is not iterable. 最终函数使用猜测的最终迭代从数学平方根方法中减去，并返回整体差异。我这样做对吗？如果您可以提供工作代码，我们将不胜感激，并提供建议。同样，我是新手，所以我为误解或盲目的明显错误道歉。

4

5 回答 5

9

牛顿法的实现：

在需要时添加一些小调整应该是相当容易的。尝试，并在遇到困难时告诉我们。

from math import *
def average(a, b):
    return (a + b) / 2.0
def improve(guess, x):
    return average(guess, x/guess)
def good_enough(guess, x):
    d = abs(guess*guess - x)
    return (d < 0.001)
def square_root(guess, x):
    while(not good_enough(guess, x)):
        guess = improve(guess, x)
    return guess
def my_sqrt(x):
    r = square_root(1, x)
    return r

>>> my_sqrt(16)
4.0000006366929393

注意：您会在 SO 或谷歌搜索中找到足够多的关于如何在此处使用原始输入的示例，但是，如果您正在计算循环，则c=0必须在循环之外，否则您将陷入无限循环。

Quiqk 和脏，有很多改进的方法：

from math import *
def average(a, b):
    return (a + b) / 2.0
def improve(guess, x):
    return average(guess, x/guess)
def square_root(guess, x, c):
    guesscount=0
    while guesscount < c :
        guesscount+=1
        guess = improve(guess, x)
    return guess
def my_sqrt(x,c):
    r = square_root(1, x, c)
    return r

number=int(raw_input('Enter a positive number'))
i_guess=int(raw_input('Enter an initial guess'))
times=int(raw_input('How many times would you like this program to improve your initial guess:'))    
answer=my_sqrt(number,times)

print 'sqrt is approximately ' + str(answer)
print 'difference between your guess and sqrt is ' + str(abs(i_guess-answer))
于 2012-10-11T23:37:26.057 回答
7

选择的答案有点令人费解……不尊重 OP。

对于将来使用谷歌搜索的任何人，这是我的解决方案：

def check(x, guess):
    return (abs(guess*guess - x) < 0.001)

def newton(x, guess):
    while not check(x, guess):
        guess = (guess + (x/guess)) / 2.0
    return guess

print newton(16, 1)
于 2013-03-08T02:13:40.480 回答
2

这是计算平方根的一个相当不同的函数；它假设n是非负的：

def mySqrt(n):
    if (n == 0):
        return 0
    if (n < 1):
        return mySqrt(n * 4) / 2
    if (4 <= n):
        return mySqrt(n / 4) * 2
    x = (n + 1.0) / 2.0
    x = (x + n/x) / 2.0
    x = (x + n/x) / 2.0
    x = (x + n/x) / 2.0
    x = (x + n/x) / 2.0
    x = (x + n/x) / 2.0
    return x

该算法类似于牛顿的算法，但并不完全相同。它是由一世纪（大约两千多年前）居住在埃及亚历山大港的一位名叫赫伦（他的名字有时拼写为英雄）的希腊数学家发明的。Heron 的递推公式比 Newton 的简单；苍鹭用x' = (x + n/x) / 2在牛顿用过的地方x' = x - (x^2 - n) / 2x。

第一个测试是零的特殊情况；没有它，(n < 1)测试会导致无限循环。接下来的两个测试将n标准化为范围1 < n <= 4; 使范围更小意味着我们可以轻松计算n的平方根的初始近似值，这是在x的第一次计算中完成的，然后“展开循环”并迭代递归方程固定次数，从而消除如果两个连续循环之间的差异太大，则需要测试和重复。

顺便说一句，Heron 是一个非常有趣的家伙。除了发明一种计算平方根的方法之外，他还建造了一个可以工作的喷气发动机、一台投币式自动售货机，以及许多其他巧妙的东西！

您可以在我的博客上阅读有关计算平方根的更多信息。

于 2012-10-12T02:11:11.877 回答
0

我写的不应该那么复杂

def squareroot(n,x):
final = (0.5*(x+(n/x)))
print (final)
for i in range(0,10):
    final = (0.5*(final+(n/final)))
    print (final)

或者你可以把它改成这样

n = float(input('What number would you like to squareroot?'))
x = float(input('Estimate your answer'))
final = (0.5*(x+(n/x)))
print (final)
for i in range(0,10):
    final = (0.5*(final+(n/final)))
    print (final)
于 2014-04-16T23:48:08.410 回答
0

您只需要知道序列中的第 n 个项。从莱布尼茨级数，我们知道这是 ((-1)**n)/((2*n)+1)。只需对所有 i 的初始条件为零的系列求和，就可以了。

def myPi(n):

pi=0
for i in range(0,n):
    pi=pi+((-1)**i)/((2*i)+1)
return 4*pi
print (myPi(10000))
于 2016-12-29T17:47:23.013 回答