blocks|key|246450|text|你可以对四舍五入的平方根进行二分搜索。将结果平方以查看它是否与原始值匹配。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246451|使用FogleBirds+answer可能会更好-但要注意，因为浮点算法是近似值，这可能会使这种方法失效。例如，由于失去精度，原则上你可以从一个比完美平方多一个的大整数中得到一个假阳性。|246452|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You could binary-search for the rounded square root. Square the result to see if it matches the original value.

You're probably better off with FogleBirds answer - though beware, as floating point arithmetic is approximate, which can throw this approach off. You could in principle get a false positive from a large integer which is one more than a perfect square, for instance, due to lost precision.

blocks|key|1453706|text|依赖任何浮点计算(math.sqrt(x)或x**0.5)的问题是，您不能真正确保它是准确的(对于足够大的整数x，它不会准确，甚至可能溢出)。幸运的是(如果你不着急；-)有很多纯整数方法，比如下面这样：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1453707|def+is_square(apositiveint):
++x+=+apositiveint+//+2
++seen+=+set([x])
++while+x+*+x+!=+apositiveint:
++++x+=+(x+%2B+(apositiveint+//+x))+//+2
++++if+x+in+seen:+return+False
++++seen.add(x)
++return+True

for+i+in+range(110,+130):
+++print+i,+is_square(i)|code-block|syntax|javascript|1453708|提示:它基于平方根的“巴比伦算法”，见wikipedia。它确实适用于任何正数，对于这些正数，您有足够的内存进行计算；-)。|1453709|编辑：让我们看一个例子...|BOLD|1453710|x+=+12345678987654321234567+**+2

for+i+in+range(x,+x%2B2):
+++print+i,+is_square(i)|1453711|这将根据需要打印(并在合理的时间内打印；-)：|1453712|152415789666209426002111556165263283035677489+True
152415789666209426002111556165263283035677490+False|1453713|在您提出基于浮点中间结果的解决方案之前，请确保它们在这个简单的示例中正确工作--+it's++hard+(您只需要额外检查几次，以防sqrt计算出的结果有一点偏差)，只是需要一点小心。|1453714|然后尝试使用x**7并找到解决问题的聪明方法，|1453715|OverflowError:+long+int+too+large+to+convert+to+float|1453716|当然，随着数字的不断增长，你必须变得越来越聪明。|1453717|如果我赶时间，当然，我会使用gmpy+--但是，我显然是有偏见的；-)。|1453718|>>>+import+gmpy
>>>+gmpy.is_square(x**7)
1
>>>+gmpy.is_square(x**7+%2B+1)
0|1453719|是的，我知道，这太容易了，感觉就像作弊(有点像我对Python的感觉；-)+--一点也不聪明，只是完美的直接和简单(在gmpy的情况下，纯粹的速度；-)……|1453720|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Methods_of_computing_square_roots|1|http://www.gmpy.org/^0|9|C|M|6|1J|1|0|0|J|9|0|0|0|2|0|0|0|0|0|6|4|0|0|0|E|4|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1R|8|@]|D|@$9|1S|A|1T|1|1U]]|E|$]]|$1|M|3|N|5|6|7|1V|8|@$9|1W|A|1X|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|H|7|1Y|8|@]|D|@]|E|$I|J]]|$1|R|3|S|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|T|3|U|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|21|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|11|3|12|5|6|7|26|8|@]|D|@]|E|$]]|$1|13|3|14|5|6|7|27|8|@]|D|@$9|28|A|29|1|2A]]|E|$]]|$1|15|3|16|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|17|3|18|5|6|7|2C|8|@]|D|@]|E|$]]|$1|19|3|-4|5|6|7|2D|8|@]|D|@]|E|$]]]|1A|$1B|$5|1C|1D|1E|E|$1F|1G]]|1H|$5|1C|1D|1E|E|$1F|1I]]]]

The problem with relying on any floating point computation (<code>math.sqrt(x)</code>, or <code>x**0.5</code>) is that you can't really be sure it's exact (for sufficiently large integers <code>x</code>, it won't be, and might even overflow). Fortunately (if one's in no hurry;-) there are many pure integer approaches, such as the following...:

<pre><code>def is_square(apositiveint):
 x = apositiveint // 2
 seen = set([x])
 while x * x != apositiveint:
 x = (x + (apositiveint // x)) // 2
 if x in seen: return False
 seen.add(x)
 return True

for i in range(110, 130):
 print i, is_square(i)
</code></pre>

Hint: it's based on the "Babylonian algorithm" for square root, see <a href="http://en.wikipedia.org/wiki/Methods_of_computing_square_roots" rel="noreferrer">wikipedia</a>. It does work for any positive number for which you have enough memory for the computation to proceed to completion;-).

Edit: let's see an example...

<pre><code>x = 12345678987654321234567 ** 2

for i in range(x, x+2):
 print i, is_square(i)
</code></pre>

this prints, as desired (and in a reasonable amount of time, too;-):

<pre><code>152415789666209426002111556165263283035677489 True
152415789666209426002111556165263283035677490 False
</code></pre>

Please, before you propose solutions based on floating point intermediate results, make sure they work correctly on this simple example -- it's not that hard (you just need a few extra checks in case the sqrt computed is a little off), just takes a bit of care.

And then try with <code>x**7</code> and find clever way to work around the problem you'll get,

<pre><code>OverflowError: long int too large to convert to float
</code></pre>

you'll have to get more and more clever as the numbers keep growing, of course.

If I was in a hurry, of course, I'd use <a href="http://www.gmpy.org/" rel="noreferrer">gmpy</a> -- but then, I'm clearly biased;-).

<pre><code>&gt;&gt;&gt; import gmpy
&gt;&gt;&gt; gmpy.is_square(x**7)
1
&gt;&gt;&gt; gmpy.is_square(x**7 + 1)
0
</code></pre>

Yeah, I know, that's just so easy it feels like cheating (a bit the way I feel towards Python in general;-) -- no cleverness at all, just perfect directness and simplicity (and, in the case of gmpy, sheer speed;-)...

blocks|key|2862600|text|使用牛顿的方法快速地将最接近的整数平方根归零，然后将其平方，看看它是否是你的数字。参见isqrt。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2862601|Python≥3.8有math.isqrt。如果使用的是较旧版本的Python，请查找"def+isqrt(n)“实现here。|style|CODE|2862602|import+math

def+is_square(i:+int)+->+bool:
++++return+i+==+math.isqrt(i)+**+2|code-block|syntax|javascript|2862603|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Integer_square_root|1|https://docs.python.org/3.8/library/math.html#module-math|2|https://github.com/python/cpython/blob/master/Modules/mathmodule.c^0|17|5|0|0|B|A|18|C|B|A|1|1N|4|2|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]|$A|15|B|16|F|G]]|9|@$A|17|B|18|1|19]|$A|1A|B|1B|1|1C]]|C|$]]|$1|H|3|I|5|J|7|1D|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

Use Newton's method to quickly zero in on the nearest integer square root, then square it and see if it's your number. See <a href="https://en.wikipedia.org/wiki/Integer_square_root" rel="noreferrer">isqrt</a>.

Python ≥ 3.8 has <a href="https://docs.python.org/3.8/library/math.html#module-math" rel="noreferrer"><code>math.isqrt</code></a>. If using an older version of Python, look for the "<code>def isqrt(n)</code>" implementation <a href="https://github.com/python/cpython/blob/master/Modules/mathmodule.c" rel="noreferrer">here</a>.

<pre><code>import math

def is_square(i: int) -&gt; bool:
 return i == math.isqrt(i) ** 2
</code></pre>

blocks|key|246567|text|由于在处理浮点计算(例如这些计算平方根的方法)时，您永远不能依赖精确的比较，因此一种不太容易出错的实现是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246568|import+math

def+is_square(integer):
++++root+=+math.sqrt(integer)
++++return+integer+==+int(root+%2B+0.5)+**+2|code-block|syntax|javascript|246569|假设integer是9。math.sqrt(9)可以是3.0，但也可以是2.99999或3.00001，所以直接平方结果并不可靠。知道int取底值，首先将浮点值增加0.5意味着，如果我们在一个范围内，float仍然有足够好的分辨率来表示接近我们要查找的数字，那么我们将得到我们要查找的值。|offset|length|style|CODE|246570|entityMap^0|0|0|2|7|A|1|C|C|R|3|10|7|18|7|1V|3|2A|3|2S|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|N|$]]

Since you can never depend on exact comparisons when dealing with floating point computations (such as these ways of calculating the square root), a less error-prone implementation would be

<pre><code>import math

def is_square(integer):
 root = math.sqrt(integer)
 return integer == int(root + 0.5) ** 2
</code></pre>

Imagine <code>integer</code> is <code>9</code>. <code>math.sqrt(9)</code> could be <code>3.0</code>, but it could also be something like <code>2.99999</code> or <code>3.00001</code>, so squaring the result right off isn't reliable. Knowing that <code>int</code> takes the floor value, increasing the float value by <code>0.5</code> first means we'll get the value we're looking for if we're in a range where <code>float</code> still has a fine enough resolution to represent numbers near the one for which we are looking.

blocks|key|991213|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|991214|决定数字的长度。如果(|ordered-list-item|991215|(X))%5E2-x大于/等于增量，则|991216|取增量/smaller，并根据增量误差决定。|991217|991218|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|K|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|L|7|@]|8|@]|9|$]]|$1|D|3|E|4|5|6|M|7|@]|8|@]|9|$]]|$1|F|3|G|4|C|6|N|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|O|7|@]|8|@]|9|$]]|$1|I|3|-4|4|5|6|P|7|@]|8|@]|9|$]]]|J|$]]

<ol>
<li>Decide how long the number will be.</li>
<li>take a delta 0.000000000000.......000001</li>
<li>see if the (sqrt(x))^2 - x is greater / equal /smaller than delta and decide based on the delta error.</li>
</ol>

blocks|key|246615|text|这个回答不是针对你所说的问题，而是针对我在你发布的代码中看到的一个隐含的问题，即“如何检查某件事是否为整数？”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246616|你通常会得到的第一个答案是“不要！”确实，在Python中，类型检查通常不是正确的做法。|246617|然而，对于那些罕见的例外，不要在数字的字符串表示中查找小数点，而是使用isinstance函数：|246618|>>>+isinstance(5,int)
True
>>>+isinstance(5.0,int)
False|code-block|syntax|javascript|246619|当然，这适用于变量而不是值。如果我想确定该值是否为整数，我会这样做：|246620|>>>+x=5.0
>>>+round(x)+==+x
True|246621|但正如每个人都详细介绍过的那样，在这类事情的大多数非玩具示例中，都需要考虑浮点问题。|246622|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

This response doesn't pertain to your stated question, but to an implicit question I see in the code you posted, ie, "how to check if something is an integer?"

The first answer you'll generally get to that question is "Don't!" And it's true that in Python, typechecking is usually not the right thing to do.

For those rare exceptions, though, instead of looking for a decimal point in the string representation of the number, the thing to do is use the isinstance function:

<pre><code>&gt;&gt;&gt; isinstance(5,int)
True
&gt;&gt;&gt; isinstance(5.0,int)
False
</code></pre>

Of course this applies to the variable rather than a value. If I wanted to determine whether the value was an integer, I'd do this:

<pre><code>&gt;&gt;&gt; x=5.0
&gt;&gt;&gt; round(x) == x
True
</code></pre>

But as everyone else has covered in detail, there are floating-point issues to be considered in most non-toy examples of this kind of thing.

blocks|key|1454018|text|我只是在另一个线程(Finding+perfect+squares)上发布了上面的一些示例的微小变化，并认为我应该包含我在这里发布的一些轻微变化(使用nsqrt作为临时变量)，以备感兴趣/使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1454019|import+math

def+is_square(n):
++if+not+(isinstance(n,+int)+and+(n+>=+0)):
++++return+False+
++else:
++++nsqrt+=+math.sqrt(n)
++++return+nsqrt+==+math.trunc(nsqrt)|code-block|syntax|javascript|1454020|对于像152415789666209426002111556165263283035677490.这样的大型非方形，不正确的|style|BOLD|1454021|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1547196/finding-perfect-square/5750159#5750159^0|A|N|0|0|0|1M|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I just posted a slight variation on some of the examples above on another thread (<a href="https://stackoverflow.com/questions/1547196/finding-perfect-square/5750159#5750159">Finding perfect squares</a>) and thought I'd include a slight variation of what I posted there here (using nsqrt as a temporary variable), in case it's of interest / use:

<pre><code>import math

def is_square(n):
 if not (isinstance(n, int) and (n &gt;= 0)):
 return False 
 else:
 nsqrt = math.sqrt(n)
 return nsqrt == math.trunc(nsqrt)
</code></pre>

It is incorrect for a large non-square such as 152415789666209426002111556165263283035677490.

blocks|key|1454069|text|import+math

def+is_square(n):
++++sqrt+=+math.sqrt(n)
++++return+(sqrt+-+int(sqrt))+==+0|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1454070|完美正方形是一个可以表示为两个相等整数的乘积的数字。math.sqrt(number)返回一个float。int(math.sqrt(number))将结果传递给int。|unstyled|offset|length|style|CODE|1454071|如果平方根是一个整数，例如3，那么math.sqrt(number)+-+int(math.sqrt(number))将为0，if语句将为False。如果平方根是像3.2这样的实数，那么它将是True并打印"+it+'s+not+a+perfect+square“。|1454072|对于像152415789666209426002111556165263283035677490.这样的大型非方图，失败|1454073|entityMap^0|0|Q|H|1B|5|1H|M|29|3|0|H|16|1R|2|1X|5|2O|4|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@$G|S|H|T|I|J]|$G|U|H|V|I|J]|$G|W|H|X|I|J]|$G|Y|H|Z|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@$G|11|H|12|I|J]|$G|13|H|14|I|J]|$G|15|H|16|I|J]|$G|17|H|18|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|19|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|1A|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>import math

def is_square(n):
 sqrt = math.sqrt(n)
 return (sqrt - int(sqrt)) == 0
</code></pre>

A perfect square is a number that can be expressed as the product of two equal integers. <code>math.sqrt(number)</code> return a <code>float</code>. <code>int(math.sqrt(number))</code> casts the outcome to <code>int</code>.

If the square root is an integer, like 3, for example, then <code>math.sqrt(number) - int(math.sqrt(number))</code> will be 0, and the <code>if</code> statement will be <code>False</code>. If the square root was a real number like 3.2, then it will be <code>True</code> and print "it's not a perfect square".

It fails for a large non-square such as 152415789666209426002111556165263283035677490.

blocks|key|2862961|text|这可以使用the+decimal+module来解决，以获得任意精度的平方根，并轻松地检查“准确性”：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2862962|import+math
from+decimal+import+localcontext,+Context,+Inexact

def+is_perfect_square(x):
++++#+If+you+want+to+allow+negative+squares,+then+set+x+=+abs(x)+instead
++++if+x+<+0:
++++++++return+False

++++#+Create+localized,+default+context+so+flags+and+traps+unset
++++with+localcontext(Context())+as+ctx:
++++++++#+Set+a+precision+sufficient+to+represent+x+exactly;+`x+or+1`+avoids
++++++++#+math+domain+error+for+log10+when+x+is+0
++++++++ctx.prec+=+math.ceil(math.log10(x+or+1))+%2B+1++#+Wrap+ceil+call+in+int()+on+Py2
++++++++#+Compute+integer+square+root;+don't+even+store+result,+just+setting+flags
++++++++ctx.sqrt(x).to_integral_exact()
++++++++#+If+previous+line+couldn't+represent+square+root+as+exact+int,+sets+Inexact+flag
++++++++return+not+ctx.flags[Inexact]|code-block|syntax|javascript|2862963|对于具有真正巨大价值的演示：|2862964|#+I+just+kept+mashing+the+numpad+for+awhile+:-)
>>>+base+=+100009991439393999999393939398348438492389402490289028439083249803434098349083490340934903498034098390834980349083490384903843908309390282930823940230932490340983098349032098324908324098339779438974879480379380439748093874970843479280329708324970832497804329783429874329873429870234987234978034297804329782349783249873249870234987034298703249780349783497832497823497823497803429780324
>>>+sqr+=+base+**+2
>>>+sqr+**+0.5++#+Too+large+to+use+floating+point+math
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
OverflowError:+int+too+large+to+convert+to+float

>>>+is_perfect_power(sqr)
True
>>>+is_perfect_power(sqr-1)
False
>>>+is_perfect_power(sqr%2B1)
False|2862965|如果您增加要测试的值的大小，这最终会变得相当慢(对于200,000位的平方，需要接近一秒钟的时间)，但对于更中等的数字(例如，20,000位)，它仍然比人类注意到的单个值快(在我的机器上大约33毫秒)。但是，由于速度不是您主要关心的问题，因此这是使用Python标准库实现这一点的好方法。|2862966|当然，使用gmpy2并只测试gmpy2.mpz(x).is_square()会快得多，但是如果你不喜欢第三方包，上面的方法工作得很好。|2862967|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/decimal.html|1|https://pypi.python.org/pypi/gmpy2^0|9|7|5|I|0|0|0|0|0|0|5|5|E|O|5|5|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|S|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

This can be solved using <a href="https://docs.python.org/3/library/decimal.html" rel="noreferrer">the <code>decimal</code> module</a> to get arbitrary precision square roots and easy checks for "exactness":

<pre><code>import math
from decimal import localcontext, Context, Inexact

def is_perfect_square(x):
 # If you want to allow negative squares, then set x = abs(x) instead
 if x &lt; 0:
 return False

 # Create localized, default context so flags and traps unset
 with localcontext(Context()) as ctx:
 # Set a precision sufficient to represent x exactly; `x or 1` avoids
 # math domain error for log10 when x is 0
 ctx.prec = math.ceil(math.log10(x or 1)) + 1 # Wrap ceil call in int() on Py2
 # Compute integer square root; don't even store result, just setting flags
 ctx.sqrt(x).to_integral_exact()
 # If previous line couldn't represent square root as exact int, sets Inexact flag
 return not ctx.flags[Inexact]
</code></pre>

For demonstration with truly huge values:

<pre><code># I just kept mashing the numpad for awhile :-)
&gt;&gt;&gt; base = 100009991439393999999393939398348438492389402490289028439083249803434098349083490340934903498034098390834980349083490384903843908309390282930823940230932490340983098349032098324908324098339779438974879480379380439748093874970843479280329708324970832497804329783429874329873429870234987234978034297804329782349783249873249870234987034298703249780349783497832497823497823497803429780324
&gt;&gt;&gt; sqr = base ** 2
&gt;&gt;&gt; sqr ** 0.5 # Too large to use floating point math
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
OverflowError: int too large to convert to float

&gt;&gt;&gt; is_perfect_power(sqr)
True
&gt;&gt;&gt; is_perfect_power(sqr-1)
False
&gt;&gt;&gt; is_perfect_power(sqr+1)
False
</code></pre>

If you increase the size of the value being tested, this eventually gets rather slow (takes close to a second for a 200,000 bit square), but for more moderate numbers (say, 20,000 bits), it's still faster than a human would notice for individual values (~33 ms on my machine). But since speed wasn't your primary concern, this is a good way to do it with Python's standard libraries.

Of course, it would be much faster to use <a href="https://pypi.python.org/pypi/gmpy2" rel="noreferrer"><code>gmpy2</code></a> and just test <code>gmpy2.mpz(x).is_square()</code>, but if third party packages aren't your thing, the above works quite well.

blocks|key|246017|text|如果你想遍历一个范围，并对每个不是完美平方的数字做一些事情，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246018|def+non_squares(upper):
++++next_square+=+0
++++diff+=+1
++++for+i+in+range(0,+upper):
++++++++if+i+==+next_square:
++++++++++++next_square+%2B=+diff
++++++++++++diff+%2B=+2
++++++++++++continue
++++++++yield+i|code-block|syntax|javascript|246019|如果你想对每一个完美平方的数字做一些事情，生成器就更简单了：|246020|(n+*+n+for+n+in+range(upper))|246021|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you want to loop over a range and do something for every number that is NOT a perfect square, you could do something like this:

<pre><code>def non_squares(upper):
 next_square = 0
 diff = 1
 for i in range(0, upper):
 if i == next_square:
 next_square += diff
 diff += 2
 continue
 yield i
</code></pre>

If you want to do something for every number that IS a perfect square, the generator is even easier:

<pre><code>(n * n for n in range(upper))
</code></pre>

blocks|key|991341|text|import+math

def+is_square(n):
++++sqrt+=+math.sqrt(n)
++++return+sqrt+==+int(sqrt)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|991342|对于像152415789666209426002111556165263283035677490.这样的大型非方图，失败|unstyled|991343|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import math

def is_square(n):
 sqrt = math.sqrt(n)
 return sqrt == int(sqrt)
</code></pre>

It fails for a large non-square such as 152415789666209426002111556165263283035677490.

blocks|key|246729|text|这是我的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246730|def+is_square(n)+->+bool:
++++return+int(n**0.5)**2+==+int(n)|code-block|syntax|javascript|246731|取数字的平方根。转换为整数。拿下正方形。如果两个数字相等，那么它就是一个完美的平方，否则就不是。|246732|对于像152415789666209426002111556165263283035677489.这样的大正方形，不正确的|offset|length|style|BOLD|246733|entityMap^0|0|0|0|1L|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is my method:

<pre><code>def is_square(n) -&gt; bool:
 return int(n**0.5)**2 == int(n)
</code></pre>

Take square root of number. Convert to integer. Take the square. If the numbers are equal, then it is a perfect square otherwise not.

It is incorrect for a large square such as 152415789666209426002111556165263283035677489.

blocks|key|2863132|text|如果你感兴趣，我在math+stackexchange,+"Detecting+perfect+squares+faster+than+by+extracting+square+root"上有一个类似问题的纯数学答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2863133|我自己的isSquare(n)实现可能不是最好的，但我喜欢它。我花了几个月的时间学习数学理论，数字计算和python编程，将自己与其他贡献者进行比较，等等，才真正点击了这种方法。不过，我喜欢它的简单和高效。我没见过比这更好的。告诉我你是怎么想的。|2863134|def+isSquare(n):
++++##+Trivial+checks
++++if+type(n)+!=+int:++##+integer
++++++++return+False
++++if+n+<+0:++++++##+positivity
++++++++return+False
++++if+n+==+0:++++++##+0+pass
++++++++return+True

++++##+Reduction+by+powers+of+4+with+bit-logic
++++while+n&3+==+0:++++
++++++++n=n>>2

++++##+Simple+bit-logic+test.+All+perfect+squares,+in+binary,
++++##+end+in+001,+when+powers+of+4+are+factored+out.
++++if+n&7+!=+1:
++++++++return+False

++++if+n==1:
++++++++return+True++##+is+power+of+4,+or+even+power+of+2


++++##+Simple+modulo+equivalency+test
++++c+=+n%2510
++++if+c+in+{3,+7}:
++++++++return+False++##+Not+1,4,5,6,9+in+mod+10
++++if+n+%25+7+in+{3,+5,+6}:
++++++++return+False++##+Not+1,2,4+mod+7
++++if+n+%25+9+in+{2,3,5,6,8}:
++++++++return+False++
++++if+n+%25+13+in+{2,5,6,7,8,11}:
++++++++return+False++

++++##+Other+patterns
++++if+c+==+5:++##+if+it+ends+in+a+5
++++++++if+(n//10)%2510+!=+2:
++++++++++++return+False++++##+then+it+must+end+in+25
++++++++if+(n//100)%2510+not+in+{0,2,6}:+
++++++++++++return+False++++##+and+in+025,+225,+or+625
++++++++if+(n//100)%2510+==+6:
++++++++++++if+(n//1000)%2510+not+in+{0,5}:
++++++++++++++++return+False++++##+that+is,+0625+or+5625
++++else:
++++++++if+(n//10)%254+!=+0:
++++++++++++return+False++++##+(4k)*10+%2B+(1,9)


++++##+Babylonian+Algorithm.+Finding+the+integer+square+root.
++++##+Root+extraction.
++++s+=+(len(str(n))-1)+//+2
++++x+=+(10**s)+*+4

++++A+=+{x,+n}
++++while+x+*+x+!=+n:
++++++++x+=+(x+%2B+(n+//+x))+>>+1
++++++++if+x+in+A:
++++++++++++return+False
++++++++A.add(x)
++++return+True|code-block|syntax|javascript|2863135|非常直截了当。首先，它检查我们是否有一个整数，以及一个正整数。否则就没有意义了。它让0作为True通过(必需的，否则下一个块是无限循环)。|2863136|下一段代码使用位移位和位逻辑操作在一个非常快的子算法中系统地去除4的幂。如果可能的话，我们最终找到的不是原始n的isSquare，而是缩小了4的幂的k|2863137|第三段代码执行简单的布尔位逻辑测试。任何完美平方的二进制最低有效三位数都是001。一直都是。除了从4的幂得到的前导零，无论如何，这已经被考虑到了。如果它没有通过测试，你马上就知道它不是正方形。如果它通过了，你就不能确定。|2863138|
|2863139|此外，如果我们最终以1作为测试值，那么测试数字最初是4的幂，可能包括1本身。|2863140|2863141|与第三个代码块类似，第四个代码块使用简单的模运算符测试十进制数的一位数，并倾向于捕获通过前一次测试的值。还有mod+7、mod+8、mod+9和mod+13测试。|2863142|2863143|第五个代码块检查一些著名的完美正方形图案。以1或9结尾的数字前面是4的倍数。以5结尾的数字必须以5625、0625、225或025结尾。我已经包括了其他的，但意识到它们是多余的，或者从来没有实际使用过。|2863144|2863145|最后，第六个代码块非常类似于顶级回答者Alex+Martelli+answer。基本上使用古巴比伦算法查找平方根，但将其限制为整数值，而忽略浮点。这样做既是为了提高速度，也是为了扩展可测试的值的大小。我使用集合而不是列表，因为它花费的时间要少得多，我使用位移位而不是除以2，并且我聪明地选择了一个更有效率的初始值。|2863146|2863147|顺便说一句，我确实测试了Alex+Martelli推荐的测试数字，以及一些数量级更大的数字，例如：|2863148|2863149|x=1000199838770766116385386300483414671297203029840113913153824086810909168246772838680374612768821282446322068401699727842499994541063844393713189701844134801239504543830737724442006577672181059194558045164589783791764790043104263404683317158624270845302200548606715007310112016456397357027095564872551184907513312382763025454118825703090010401842892088063527451562032322039937924274426211671442740679624285180817682659081248396873230975882215128049713559849427311798959652681930663843994067353808298002406164092996533923220683447265882968239141724624870704231013642255563984374257471112743917655991279898690480703935007493906644744151022265929975993911186879561257100479593516979735117799410600147341193819147290056586421994333004992422258618475766549646258761885662783430625+**+2
for+i+in+range(x,+x%2B2):
++++print(i,+isSquare(i))|2863150|2863151|打印了以下结果：|2863152|2863153|1000399717477066534083185452789672211951514938424998708930175541558932213310056978758103599452364409903384901149641614494249195605016959576235097480592396214296565598519295693079257885246632306201885850365687426564365813280963724310434494316592041592681626416195491751015907716210235352495422858432792668507052756279908951163972960239286719854867504108121432187033786444937064356645218196398775923710931242852937602515835035177768967470757847368349565128635934683294155947532322786360581473152034468071184081729335560769488880138928479829695277968766082973795720937033019047838250608170693879209655321034310764422462828792636246742456408134706264621790736361118589122797268261542115823201538743148116654378511916000714911467547209475246784887830649309238110794938892491396597873160778553131774466638923135932135417900066903068192088883207721545109720968467560224268563643820599665232314256575428214983451466488658896488012211237139254674708538347237589290497713613898546363590044902791724541048198769085430459186735166233549186115282574626012296888817453914112423361525305960060329430234696000121420787598967383958525670258016851764034555105019265380321048686563527396844220047826436035333266263375049097675787975100014823583097518824871586828195368306649956481108708929669583308777347960115138098217676704862934389659753628861667169905594181756523762369645897154232744410732552956489694024357481100742138381514396851789639339362228442689184910464071202445106084939268067445115601375050153663645294106475257440167535462278022649865332161044187890625+True
1000399717477066534083185452789672211951514938424998708930175541558932213310056978758103599452364409903384901149641614494249195605016959576235097480592396214296565598519295693079257885246632306201885850365687426564365813280963724310434494316592041592681626416195491751015907716210235352495422858432792668507052756279908951163972960239286719854867504108121432187033786444937064356645218196398775923710931242852937602515835035177768967470757847368349565128635934683294155947532322786360581473152034468071184081729335560769488880138928479829695277968766082973795720937033019047838250608170693879209655321034310764422462828792636246742456408134706264621790736361118589122797268261542115823201538743148116654378511916000714911467547209475246784887830649309238110794938892491396597873160778553131774466638923135932135417900066903068192088883207721545109720968467560224268563643820599665232314256575428214983451466488658896488012211237139254674708538347237589290497713613898546363590044902791724541048198769085430459186735166233549186115282574626012296888817453914112423361525305960060329430234696000121420787598967383958525670258016851764034555105019265380321048686563527396844220047826436035333266263375049097675787975100014823583097518824871586828195368306649956481108708929669583308777347960115138098217676704862934389659753628861667169905594181756523762369645897154232744410732552956489694024357481100742138381514396851789639339362228442689184910464071202445106084939268067445115601375050153663645294106475257440167535462278022649865332161044187890626+False|2863154|2863155|它在0.33秒内完成了这一过程。|2863156|2863157|在我看来，我的算法与Alex+Martelli的算法工作相同，并具有所有好处，但具有额外的好处高效的简单测试拒绝，这节省了大量的时间，更不用说将测试数字的大小减少4的幂，这提高了速度，效率，准确性和可测试的数字的大小。在非Python实现中可能尤其如此。|2863158|2863159|在巴比伦根提取甚至被实现之前，大约99%25的整数被拒绝为非平方数，而在巴比伦人拒绝该整数所需的时间为2/3。虽然这些测试不会显著地加快测试过程，但通过除以所有4的幂，将所有测试数量减少到奇数，确实会加速巴比伦测试。|2863160|2863161|我做了个时间比对测试。我连续测试了从1到1000万的所有整数。仅使用巴比伦方法(使用我特别定制的初始猜测)，我的Surface+3平均花费165秒(+100%25准确率)。仅使用我的算法中的逻辑测试(不包括巴比伦)，它花了127秒，它拒绝所有整数的99%25作为非平方，而没有错误地拒绝任何完美的平方。在通过的整数中，只有3%25是完美平方(更高的密度)。使用上面使用逻辑测试和巴比伦根提取的完整算法，我们有100%25的准确率，并且只需14秒就能完成测试。前一亿个整数大约需要2分45秒来测试。|2863162|2863163|编辑:我已经能够进一步减少时间。我现在可以在1分40秒内测试0到1亿的整数。大量时间被浪费在检查数据类型和正性上。去掉前两个检查，我把实验时间缩短了一分钟。必须假设用户足够聪明，知道负数和浮点数不是完美正方形。|2863164|2863165|2863166|entityMap|0|LINK|mutability|MUTABLE|url|https://math.stackexchange.com/questions/131330/detecting-perfect-squares-faster-than-by-extracting-square-root/712818#712818^0|9|2D|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@$A|25|B|26|1|27]]|C|$]]|$1|D|3|E|5|6|7|28|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|29|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|2A|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|2B|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|2C|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|2D|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|2E|8|@]|9|@]|C|$]]|$1|U|3|R|5|6|7|2F|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|2G|8|@]|9|@]|C|$]]|$1|X|3|R|5|6|7|2H|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|2I|8|@]|9|@]|C|$]]|$1|10|3|R|5|6|7|2J|8|@]|9|@]|C|$]]|$1|11|3|12|5|6|7|2K|8|@]|9|@]|C|$]]|$1|13|3|R|5|6|7|2L|8|@]|9|@]|C|$]]|$1|14|3|15|5|6|7|2M|8|@]|9|@]|C|$]]|$1|16|3|R|5|6|7|2N|8|@]|9|@]|C|$]]|$1|17|3|18|5|H|7|2O|8|@]|9|@]|C|$I|J]]|$1|19|3|R|5|6|7|2P|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|1C|3|R|5|6|7|2R|8|@]|9|@]|C|$]]|$1|1D|3|1E|5|H|7|2S|8|@]|9|@]|C|$I|J]]|$1|1F|3|R|5|6|7|2T|8|@]|9|@]|C|$]]|$1|1G|3|1H|5|6|7|2U|8|@]|9|@]|C|$]]|$1|1I|3|R|5|6|7|2V|8|@]|9|@]|C|$]]|$1|1J|3|1K|5|6|7|2W|8|@]|9|@]|C|$]]|$1|1L|3|R|5|6|7|2X|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|6|7|2Y|8|@]|9|@]|C|$]]|$1|1O|3|R|5|6|7|2Z|8|@]|9|@]|C|$]]|$1|1P|3|1Q|5|6|7|30|8|@]|9|@]|C|$]]|$1|1R|3|R|5|6|7|31|8|@]|9|@]|C|$]]|$1|1S|3|1T|5|6|7|32|8|@]|9|@]|C|$]]|$1|1U|3|R|5|6|7|33|8|@]|9|@]|C|$]]|$1|1V|3|-4|5|6|7|34|8|@]|9|@]|C|$]]|$1|1W|3|-4|5|6|7|35|8|@]|9|@]|C|$]]]|1X|$1Y|$5|1Z|20|21|C|$22|23]]]]

If youre interested, I have a pure-math response to a similar question at <a href="https://math.stackexchange.com/questions/131330/detecting-perfect-squares-faster-than-by-extracting-square-root/712818#712818" title="Detecting perfect squares faster than by extracting square root">math stackexchange, "Detecting perfect squares faster than by extracting square root"</a>.

My own implementation of isSquare(n) may not be the best, but I like it. Took me several months of study in math theory, digital computation and python programming, comparing myself to other contributors, etc., to really click with this method. I like its simplicity and efficiency though. I havent seen better. Tell me what you think.

<pre><code>def isSquare(n):
 ## Trivial checks
 if type(n) != int: ## integer
 return False
 if n &lt; 0: ## positivity
 return False
 if n == 0: ## 0 pass
 return True

 ## Reduction by powers of 4 with bit-logic
 while n&amp;3 == 0: 
 n=n&gt;&gt;2

 ## Simple bit-logic test. All perfect squares, in binary,
 ## end in 001, when powers of 4 are factored out.
 if n&amp;7 != 1:
 return False

 if n==1:
 return True ## is power of 4, or even power of 2


 ## Simple modulo equivalency test
 c = n%10
 if c in {3, 7}:
 return False ## Not 1,4,5,6,9 in mod 10
 if n % 7 in {3, 5, 6}:
 return False ## Not 1,2,4 mod 7
 if n % 9 in {2,3,5,6,8}:
 return False 
 if n % 13 in {2,5,6,7,8,11}:
 return False 

 ## Other patterns
 if c == 5: ## if it ends in a 5
 if (n//10)%10 != 2:
 return False ## then it must end in 25
 if (n//100)%10 not in {0,2,6}: 
 return False ## and in 025, 225, or 625
 if (n//100)%10 == 6:
 if (n//1000)%10 not in {0,5}:
 return False ## that is, 0625 or 5625
 else:
 if (n//10)%4 != 0:
 return False ## (4k)*10 + (1,9)


 ## Babylonian Algorithm. Finding the integer square root.
 ## Root extraction.
 s = (len(str(n))-1) // 2
 x = (10**s) * 4

 A = {x, n}
 while x * x != n:
 x = (x + (n // x)) &gt;&gt; 1
 if x in A:
 return False
 A.add(x)
 return True
</code></pre>

Pretty straight forward. First it checks that we have an integer, and a positive one at that. Otherwise there is no point. It lets 0 slip through as True (necessary or else next block is infinite loop).

The next block of code systematically removes powers of 4 in a very fast sub-algorithm using bit shift and bit logic operations. We ultimately are not finding the isSquare of our original n but of a k&lt;n that has been scaled down by powers of 4, if possible. This reduces the size of the number we are working with and really speeds up the Babylonian method, but also makes other checks faster too.

The third block of code performs a simple Boolean bit-logic test. The least significant three digits, in binary, of any perfect square are 001. Always. Save for leading zeros resulting from powers of 4, anyway, which has already been accounted for. If it fails the test, you immediately know it isnt a square. If it passes, you cant be sure.

Also, if we end up with a 1 for a test value then the test number was originally a power of 4, including perhaps 1 itself.

Like the third block, the fourth tests the ones-place value in decimal using simple modulus operator, and tends to catch values that slip through the previous test. Also a mod 7, mod 8, mod 9, and mod 13 test.

The fifth block of code checks for some of the well-known perfect square patterns. Numbers ending in 1 or 9 are preceded by a multiple of four. And numbers ending in 5 must end in 5625, 0625, 225, or 025. I had included others but realized they were redundant or never actually used.

Lastly, the sixth block of code resembles very much what the top answerer - Alex Martelli - answer is. Basically finds the square root using the ancient Babylonian algorithm, but restricting it to integer values while ignoring floating point. Done both for speed and extending the magnitudes of values that are testable. I used sets instead of lists because it takes far less time, I used bit shifts instead of division by two, and I smartly chose an initial start value much more efficiently.

By the way, I did test Alex Martelli's recommended test number, as well as a few numbers many orders magnitude larger, such as:

<pre><code>x=1000199838770766116385386300483414671297203029840113913153824086810909168246772838680374612768821282446322068401699727842499994541063844393713189701844134801239504543830737724442006577672181059194558045164589783791764790043104263404683317158624270845302200548606715007310112016456397357027095564872551184907513312382763025454118825703090010401842892088063527451562032322039937924274426211671442740679624285180817682659081248396873230975882215128049713559849427311798959652681930663843994067353808298002406164092996533923220683447265882968239141724624870704231013642255563984374257471112743917655991279898690480703935007493906644744151022265929975993911186879561257100479593516979735117799410600147341193819147290056586421994333004992422258618475766549646258761885662783430625 ** 2
for i in range(x, x+2):
 print(i, isSquare(i))
</code></pre>

printed the following results:

<pre><code>1000399717477066534083185452789672211951514938424998708930175541558932213310056978758103599452364409903384901149641614494249195605016959576235097480592396214296565598519295693079257885246632306201885850365687426564365813280963724310434494316592041592681626416195491751015907716210235352495422858432792668507052756279908951163972960239286719854867504108121432187033786444937064356645218196398775923710931242852937602515835035177768967470757847368349565128635934683294155947532322786360581473152034468071184081729335560769488880138928479829695277968766082973795720937033019047838250608170693879209655321034310764422462828792636246742456408134706264621790736361118589122797268261542115823201538743148116654378511916000714911467547209475246784887830649309238110794938892491396597873160778553131774466638923135932135417900066903068192088883207721545109720968467560224268563643820599665232314256575428214983451466488658896488012211237139254674708538347237589290497713613898546363590044902791724541048198769085430459186735166233549186115282574626012296888817453914112423361525305960060329430234696000121420787598967383958525670258016851764034555105019265380321048686563527396844220047826436035333266263375049097675787975100014823583097518824871586828195368306649956481108708929669583308777347960115138098217676704862934389659753628861667169905594181756523762369645897154232744410732552956489694024357481100742138381514396851789639339362228442689184910464071202445106084939268067445115601375050153663645294106475257440167535462278022649865332161044187890625 True
1000399717477066534083185452789672211951514938424998708930175541558932213310056978758103599452364409903384901149641614494249195605016959576235097480592396214296565598519295693079257885246632306201885850365687426564365813280963724310434494316592041592681626416195491751015907716210235352495422858432792668507052756279908951163972960239286719854867504108121432187033786444937064356645218196398775923710931242852937602515835035177768967470757847368349565128635934683294155947532322786360581473152034468071184081729335560769488880138928479829695277968766082973795720937033019047838250608170693879209655321034310764422462828792636246742456408134706264621790736361118589122797268261542115823201538743148116654378511916000714911467547209475246784887830649309238110794938892491396597873160778553131774466638923135932135417900066903068192088883207721545109720968467560224268563643820599665232314256575428214983451466488658896488012211237139254674708538347237589290497713613898546363590044902791724541048198769085430459186735166233549186115282574626012296888817453914112423361525305960060329430234696000121420787598967383958525670258016851764034555105019265380321048686563527396844220047826436035333266263375049097675787975100014823583097518824871586828195368306649956481108708929669583308777347960115138098217676704862934389659753628861667169905594181756523762369645897154232744410732552956489694024357481100742138381514396851789639339362228442689184910464071202445106084939268067445115601375050153663645294106475257440167535462278022649865332161044187890626 False
</code></pre>

And it did this in 0.33 seconds.

In my opinion, my algorithm works the same as Alex Martelli's, with all the benefits thereof, but has the added benefit highly efficient simple-test rejections that save a lot of time, not to mention the reduction in size of test numbers by powers of 4, which improves speed, efficiency, accuracy and the size of numbers that are testable. Probably especially true in non-Python implementations.

Roughly 99% of all integers are rejected as non-Square before Babylonian root extraction is even implemented, and in 2/3 the time it would take the Babylonian to reject the integer. And though these tests dont speed up the process that significantly, the reduction in all test numbers to an odd by dividing out all powers of 4 really accelerates the Babylonian test.

I did a time comparison test. I tested all integers from 1 to 10 Million in succession. Using just the Babylonian method by itself (with my specially tailored initial guess) it took my Surface 3 an average of 165 seconds (with 100% accuracy). Using just the logical tests in my algorithm (excluding the Babylonian), it took 127 seconds, it rejected 99% of all integers as non-Square without mistakenly rejecting any perfect squares. Of those integers that passed, only 3% were perfect Squares (a much higher density). Using the full algorithm above that employs both the logical tests and the Babylonian root extraction, we have 100% accuracy, and test completion in only 14 seconds. The first 100 Million integers takes roughly 2 minutes 45 seconds to test.

EDIT: I have been able to bring down the time further. I can now test the integers 0 to 100 Million in 1 minute 40 seconds. A lot of time is wasted checking the data type and the positivity. Eliminate the very first two checks and I cut the experiment down by a minute. One must assume the user is smart enough to know that negatives and floats are not perfect squares.

blocks|key|246101|text|我认为这是可行的，而且非常简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246102|import+math

def+is_square(num):
++++sqrt+=+math.sqrt(num)
++++return+sqrt+==+int(sqrt)|code-block|syntax|javascript|246103|对于像152415789666209426002111556165263283035677490.这样的大型非方形，不正确的|offset|length|style|BOLD|246104|entityMap^0|0|0|1M|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I think that this works and is very simple: 

<pre><code>import math

def is_square(num):
 sqrt = math.sqrt(num)
 return sqrt == int(sqrt)
</code></pre>

It is incorrect for a large non-square such as 152415789666209426002111556165263283035677490.

blocks|key|2863240|text|我的答案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2863241|def+is_square(x):
++++return+x**.5+%25+1+==+0|code-block|syntax|javascript|2863242|它基本上做一个平方根，然后以1取模，去掉整数部分，如果结果是0，则返回True，否则返回False。在本例中，x可以是任意大的数字，只是不能大于python可以处理的最大浮点数:+1.7976931348623157e%2B308|offset|length|style|CODE|2863243|对于像152415789666209426002111556165263283035677490.这样的大型非方形，不正确的|BOLD|2863244|entityMap^0|0|0|Z|4|18|5|0|1M|4|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@$I|U|J|V|K|L]|$I|W|J|X|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Y|8|@$I|Z|J|10|K|O]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|Q|$]]

My answer is:

<pre><code>def is_square(x):
 return x**.5 % 1 == 0
</code></pre>

It basically does a square root, then modulo by 1 to strip the integer part and if the result is 0 return <code>True</code> otherwise return <code>False</code>. In this case x can be any large number, just not as large as the max float number that python can handle: 1.7976931348623157e+308

It is incorrect for a large non-square such as 152415789666209426002111556165263283035677490.

blocks|key|995500|text|如果除以平方根后的模数(余数)是0，那么它就是一个完美的平方。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|995501|def+is_square(num:+int)+->+bool:
++++return+num+%25+math.sqrt(num)+==+0|code-block|syntax|javascript|995502|我将其与完美方块列表进行了对比，最高可达1000。|995503|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If the modulus (remainder) leftover from dividing by the square root is 0, then it is a perfect square.
<pre><code>def is_square(num: int) -&gt; bool:
 return num % math.sqrt(num) == 0
</code></pre>
I checked this against a list of perfect squares going up to 1000.

blocks|key|246177|text|@Alex+Martelli的不带set的解决方案的变体|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|246178|当x+in+seen为True时|246179|在大多数情况下，它是最后一个相加的，例如，1022产生完全正方形序列511,256,129，68，41，32，31，在某些情况下(即，对于完美正方形的前身)，它是倒数第二个相加的，例如，1023产生511,256,129，68，41，32，31，|BOLD|246180|，31，x|unordered-list-item|246181|246182|因此，只要当前x大于或等于前一个one，就可以立即停止：|246183|def+is_square(n):
++++assert+n+>+1
++++previous+=+n
++++x+=+n+//+2
++++while+x+*+x+!=+n:
++++++++x+=+(x+%2B+(n+//+x))+//+2
++++++++if+x+>=+previous:
++++++++++++return+False
++++++++previous+=+x
++++return+True

x+=+12345678987654321234567+**+2
assert+not+is_square(x-1)
assert+is_square(x)
assert+not+is_square(x%2B1)|code-block|syntax|javascript|246184|与原始算法的等价性测试为1|246185|246186|entityMap^0|H|3|0|1|9|B|4|0|39|2|1|4|1|1|0|7|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@$9|19|A|1A|B|J]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1I|8|@]|D|@]|E|$T|U]]|$1|V|3|W|5|6|7|1J|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|Z|$]]

<h1>A variant of @Alex Martelli's solution without <code>set</code></h1>

When <code>x in seen</code> is <code>True</code>:

<ul>
<li>In most cases, it is the last one added, e.g. 1022 produces the <code>x</code>'s sequence 511, 256, 129, 68, 41, 32, 31, 31;</li>
<li>In some cases (i.e., for the predecessors of perfect squares), it is the second-to-last one added, e.g. 1023 produces 511, 256, 129, 68, 41, 32, 31, 32.</li>
</ul>

Hence, it suffices to stop as soon as the current <code>x</code> is greater than or equal to the previous one:

<pre><code>def is_square(n):
 assert n &gt; 1
 previous = n
 x = n // 2
 while x * x != n:
 x = (x + (n // x)) // 2
 if x &gt;= previous:
 return False
 previous = x
 return True

x = 12345678987654321234567 ** 2
assert not is_square(x-1)
assert is_square(x)
assert not is_square(x+1)
</code></pre>

Equivalence with the original algorithm tested for 1 &lt; n &lt; 10**7. On the same interval, this slightly simpler variant is about 1.4 times faster.

blocks|key|1454487|text|a=int(input('enter+any+number'))
flag=0
for+i+in+range(1,a):
++++if+a==i*i:
++++++++print(a,'is+perfect+square+number')
++++++++flag=1
++++++++break
if+flag==1:
++++pass
else:
++++print(a,'is+not+perfect+square+number')|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1454488|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>a=int(input('enter any number'))
flag=0
for i in range(1,a):
 if a==i*i:
 print(a,'is perfect square number')
 flag=1
 break
if flag==1:
 pass
else:
 print(a,'is not perfect square number')
</code></pre>

blocks|key|246910|text|其思想是运行一个从i=1到floor(sqrt(+n+))的循环，然后检查它是否平方为n。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246911|bool+isPerfectSquare(int+n)+
{+
++++for+(int+i+=+1;+i+*+i+<=+n;+i%2B%2B)+{+

++++++++//+If+(i+*+i+=+n)+
++++++++if+((n+%25+i+==+0)+&&+(n+/+i+==+i))+{+
++++++++++++return+true;+
++++++++}+
++++}+
++++return+false;+
}+|code-block|syntax|javascript|246912|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The idea is to run a loop from i = 1 to floor(sqrt(n)) then check if squaring it makes n.

<pre><code>bool isPerfectSquare(int n) 
{ 
 for (int i = 1; i * i &lt;= n; i++) { 

 // If (i * i = n) 
 if ((n % i == 0) &amp;&amp; (n / i == i)) { 
 return true; 
 } 
 } 
 return false; 
} 
</code></pre>

blocks|key|1454569|text|可以通过观察到如果从n的平方根开始，连续项形成递减序列来改进巴比伦方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1454570|def+is_square(n):
++++assert+n+>+1
++++a+=+n
++++b+=+(a+%2B+n+//+a)+//+2
++++while+b+<+a:
++++++++a+=+b
++++++++b+=+(a+%2B+n+//+a)+//+2
++++return+a+*+a+==+n|code-block|syntax|javascript|1454571|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It is possible to improve the Babylonian method by observing that the successive terms form a decreasing sequence if one starts above the square root of n.
<pre class="lang-py prettyprint-override"><code>def is_square(n):
 assert n &gt; 1
 a = n
 b = (a + n // a) // 2
 while b &lt; a:
 a = b
 b = (a + n // a) // 2
 return a * a == n
</code></pre>

blocks|key|1454608|text|如果它是一个完全平方，它的平方根将是一个整数，小数部分将是0，我们可以使用模运算符来检查小数部分，并检查它是否为0，对于某些数字，它确实失败了，所以，为了安全起见，我们还将检查它是否是平方根，即使小数部分是0。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1454609|import+math

def+isSquare(n):
++++root+=+math.sqrt(n)
++++if+root+%25+1+==+0:
++++++++if+int(root)+*+int(root)+==+n:
++++++++++++return+True
++++return+False

isSquare(4761)|code-block|syntax|javascript|1454610|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If it's a perfect square, its square root will be an integer, the fractional part will be 0, we can use modulus operator to check fractional part, and check if it's 0, it does fail for some numbers, so, for safety, we will also check if it's square of the square root even if the fractional part is 0.
<pre class="lang-py prettyprint-override"><code>import math

def isSquare(n):
 root = math.sqrt(n)
 if root % 1 == 0:
 if int(root) * int(root) == n:
 return True
 return False

isSquare(4761)
</code></pre>

How could I check if a number is a perfect square?

Speed is of no concern, for now, just working.

Check if a number is a perfect square

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我如何检查一个数字是否是一个完美的平方？就目前而言，速度并不重要，只关心工作。

问检查数字是否为完全平方
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查数字是否为完全平方EN