Kayan değer tam sayı olup olmadığı nasıl kontrol edilir

Ben bir sayı, bu az 12.000 en büyük küp kök bulmaya çalışıyorum.

processing = True
n = 12000
while processing:
    n -= 1
    if n ** (1/3) == #checks to see if this has decimals or not

Tam sayı olup olmadığını nasıl kontrol edeceğimi bilmiyorum! Ben bir dizeye dönüştürmek sonra endeksleme kullanarak son değerleri kontrol etmek ve sıfır olup olmadığını görmek için bu oldukça hantal görünüyor. Daha basit bir yol var mı?

Bir kayan nokta değerinin tam sayı olup olmadığını kontrol etmek için şu float.is_integer()yöntemi kullanın :

>>> (1.0).is_integer()
True
>>> (1.555).is_integer()
False

Yöntem floatPython 2.6 tipine eklendi .

Python 2'de, dikkat edilmesi gerekenler, 1/3ise 0, (a (! Tamsayı işlenenler için zemin bölme) ve kayar nokta aritmetik kesin olmayan olabileceğini floatikili kesirler kullanarak yaklaşık bir değerdir değil kesin gerçek sayı). Ancak döngünüzü biraz ayarlamak bu sağlar:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

Bu da, yukarıda belirtilen kesinsizlik nedeniyle 3'den fazla küpün (10648 dahil) kaçırıldığı anlamına gelir:

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

Bunun yerine tam sayıya yakın sayıları kontrol etmeniz veya float()numaranızı bulmak için kullanmamanız gerekir. Küp kökü yuvarlamak gibi 12000:

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

Python 3.5 veya daha yenisini kullanıyorsanız, kayan nokta değerinin yapılandırılabilir kenar boşluğu içinde olup olmadığını görmek için math.isclose()işlevi kullanabilirsiniz :

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

Daha eski sürümler için, PEP485'te belirtildiği gibi bu işlevin naif uygulaması (hata kontrolünü ve sonsuzluğu ve NaN'yi atlamak) :

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

Modulo (%) operatörünü kullanabiliriz. Bu bize x'i y'ye böldüğümüzde kaç tane kalıntı kaldığımızı söyler - olarak ifade eder x % y. Her tam sayı 1'e bölünmelidir, bu nedenle bir kalan varsa tam sayı olmamalıdır.

Bu işlev bir boole döndürür Trueveya tam sayı Falseolup olmamasına bağlı olarak döner n.

def is_whole(n):
    return n % 1 == 0

Bunu kullanabilirsiniz:

if k == int(k):
    print(str(k) + " is a whole number!")

Döngüye veya herhangi bir şeyi kontrol etmenize gerek yoktur. Sadece 12.000 küp kökü alın ve yuvarlayın:

r = int(12000**(1/3.0))
print r*r*r # 10648

Bunun için bir modulo işlemi kullanabilirsiniz .

if (n ** (1.0/3)) % 1 != 0:
    print("We have a decimal number here!")

Küp köklerini test etmek daha kolay olmaz mıydı? 20 (20 ** 3 = 8000) ile başlayın ve 30'a kadar (30 ** 3 = 27000) gidin. O zaman 10'dan az tamsayıyı test etmelisiniz.

for i in range(20, 30):
    print("Trying {0}".format(i))
    if i ** 3 > 12000:
        print("Maximum integral cube root less than 12000: {0}".format(i - 1))
        break

Peki ya

if x%1==0:
    print "is integer"

Yukarıdaki cevaplar birçok vaka için işe yarıyor ama bazılarını kaçırıyorlar. Aşağıdakileri göz önünde bulundur:

fl = sum([0.1]*10)  # this is 0.9999999999999999, but we want to say it IS an int

Bunu bir karşılaştırma ölçütü olarak kullandığımızda, diğer bazı öneriler isteyebileceğimiz davranışı alamıyor:

fl.is_integer() # False

fl % 1 == 0     # False

Bunun yerine şunu deneyin:

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

def is_integer(fl):
    return isclose(fl, round(fl))

şimdi:

is_integer(fl)   # True

isclosePython 3.5+ ile birlikte gelir ve diğer Python'lar için bu çoğunlukla eşdeğer tanımı kullanabilirsiniz (ilgili PEP'te belirtildiği gibi )

Tüm cevaplar iyi ama kesin bir yangın yöntemi

def whole (n):
     return (n*10)%10==0

Eğer bir tam sayı yanlışsa fonksiyon True döndürür .... Biraz geç kaldığımı biliyorum ama işte yaptığım ilginç yöntemlerden biri ...

Düzenleme: aşağıdaki yorumda belirtildiği gibi, daha ucuz bir eşdeğer test şöyle olacaktır:

def whole(n):
    return n%1==0

Sadece bir yan bilgi, is_integerdahili olarak yapıyor:

import math
isInteger = (math.floor(x) == x)

Tam olarak python'da değil, cpython uygulaması yukarıda belirtildiği gibi uygulanır.

>>> def is_near_integer(n, precision=8, get_integer=False):
...     if get_integer:
...         return int(round(n, precision))
...     else:
...         return round(n) == round(n, precision)
...
>>> print(is_near_integer(10648 ** (1.0/3)))
True
>>> print(is_near_integer(10648 ** (1.0/3), get_integer=True))
22
>>> for i in [4.9, 5.1, 4.99, 5.01, 4.999, 5.001, 4.9999, 5.0001, 4.99999, 5.000
01, 4.999999, 5.000001]:
...     print(i, is_near_integer(i, 4))
...
4.9 False
5.1 False
4.99 False
5.01 False
4.999 False
5.001 False
4.9999 False
5.0001 False
4.99999 True
5.00001 True
4.999999 True
5.000001 True
>>>

Kullanmayı deneyin:

int(val) == val

Diğer yöntemlerden çok daha fazla hassasiyet verecektir.

roundDeğeri hesaplamak için işlevi kullanabilirsiniz .

Evet, bir küp kökü değerini hesaplarken birçok kişinin işaret ettiği gibi, python'da size biraz hata içeren bir çıktı verecektir. Değerin bir tam sayı olup olmadığını kontrol etmek için aşağıdaki işlevi kullanabilirsiniz:

def cube_integer(n):
    if round(n**(1.0/3.0))**3 == n:
        return True
    return False

Ama bunun int(n)eşdeğer olduğunu unutmayın math.floorve bu nedenle int(41063625**(1.0/3.0))345 yerine 344 alacaksınız.

intKüp kökleri kullanırken lütfen dikkatli olun .