파이썬에서 숫자의 모든 요소를 찾는 가장 효율적인 방법은 무엇입니까?

파이썬에서 숫자의 모든 요소를 찾는 가장 효율적인 방법은 무엇입니까?

누가 파이썬(2.7)에서 숫자의 모든 요소를 찾는 효율적인 방법을 설명해 줄 수 있습니까?

이를 위한 알고리즘을 만들 수는 있지만, 코드화가 잘 되지 않고 많은 수에 대한 결과를 도출하는 데 시간이 너무 오래 걸린다고 생각합니다.

from functools import reduce

def factors(n):    
    return set(reduce(list.__add__, 
                ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))

의 모든 요인이 매우 빠르게 반환됩니다.n.

왜 제곱근이 상한입니까?

sqrt(x) * sqrt(x) = x따라서 두 요인이 동일하면 둘 다 제곱근입니다.한 요인을 더 크게 만들면 다른 요인도 더 작게 만들어야 합니다.은 둘 중 작거나 같을 것이라는 것을 합니다.sqrt(x)따라서 해당 지점까지만 검색하면 일치하는 두 요인 중 하나를 찾을 수 있습니다.그러면 다음을 사용할 수 있습니다.x / fac1갖기 위해fac2.

그reduce(list.__add__, ...)의 작은 목록을 차지하고 있습니다.[fac1, fac2]하나의 긴 목록에 그들을 함께 가입시키는 것.

그[i, n/i] for i in range(1, int(sqrt(n)) + 1) if n % i == 0분할할 때 나머지 요인이 있으면 요인 쌍을 반환합니다.n작은 것은 0입니다(큰 것도 확인할 필요가 없습니다; 그것은 단지 나누기를 통해 그것을 얻습니다.n더 작은 것으로.)

그set(...)겉으로는 중복을 제거하는 것인데, 이는 완벽한 사각형에서만 발생합니다.위해서n = 4이것은 돌아올 것입니다.2두 번, 그러니까set그들 중 하나를 제거합니다.

@agf가 제시한 솔루션은 훌륭하지만 패리티 검사를 통해 임의 홀수에 대해 실행 시간을 최대 50% 단축할 수 있습니다.홀수의 요인은 항상 홀수이기 때문에 홀수를 다룰 때는 이러한 요인을 확인할 필요가 없습니다.

저는 이제 막 오일러 프로젝트 퍼즐을 풀기 시작했습니다.일부 문제에서는 내포된 두 개의 내부에서 지수 검사를 호출합니다.for루프, 그리고 이 기능의 성능은 필수적입니다.

이 사실과 agf의 우수한 솔루션을 결합하여 저는 다음과 같은 기능을 갖게 되었습니다.

from functools import reduce
from math import sqrt
def factors(n):
        step = 2 if n%2 else 1
        return set(reduce(list.__add__,
                    ([i, n//i] for i in range(1, int(sqrt(n))+1, step) if n % i == 0)))

그러나 작은 숫자(~ < 100)에서는 이 변경으로 인한 추가 오버헤드로 인해 기능이 더 오래 걸릴 수 있습니다.

저는 속도를 확인하기 위해 몇 가지 테스트를 했습니다.아래는 사용된 코드입니다.다른 플롯을 생성하기 위해, 저는 다음을 변경했습니다.X = range(1,100,1)따라서.

import timeit
from math import sqrt
from matplotlib.pyplot import plot, legend, show

def factors_1(n):
    step = 2 if n%2 else 1
    return set(reduce(list.__add__,
                ([i, n//i] for i in range(1, int(sqrt(n))+1, step) if n % i == 0)))

def factors_2(n):
    return set(reduce(list.__add__,
                ([i, n//i] for i in range(1, int(sqrt(n)) + 1) if n % i == 0)))

X = range(1,100000,1000)
Y = []
for i in X:
    f_1 = timeit.timeit('factors_1({})'.format(i), setup='from __main__ import factors_1', number=10000)
    f_2 = timeit.timeit('factors_2({})'.format(i), setup='from __main__ import factors_2', number=10000)
    Y.append(f_1/f_2)
plot(X,Y, label='Running time with/without parity check')
legend()
show()

X = 범위(1,100,1)

여기서 큰 차이는 없지만 숫자가 클수록 이점은 분명합니다.

X = 범위(1,100000,1000)(홀수만)

X = 범위(2,100000,100)(짝수만)

X = 범위(1,100000,1001)(교대 패리티)

은 정말 꽤. agf 대답정말꽤멋집다니은의다멋▁ag.사용하지 않도록 다시 작성할 수 있는지 확인하고 싶었습니다.reduce()제가 생각해낸 것은 다음과 같습니다.

import itertools
flatten_iter = itertools.chain.from_iterable
def factors(n):
    return set(flatten_iter((i, n//i) 
                for i in range(1, int(n**0.5)+1) if n % i == 0))

저는 까다로운 제너레이터 기능을 사용하는 버전도 시도했습니다.

def factors(n):
    return set(x for tup in ([i, n//i] 
                for i in range(1, int(n**0.5)+1) if n % i == 0) for x in tup)

계산을 통해 시간을 측정했습니다.

start = 10000000
end = start + 40000
for n in range(start, end):
    factors(n)

파이썬이 컴파일할 수 있도록 한 번 실행한 다음 time(1) 명령으로 세 번 실행하여 최적의 시간을 유지했습니다.

• 버전 축소: 11.58초
• iter 도구 버전: 11.49초
• 까다로운 버전: 11.12초

iiterools 버전은 튜플을 작성하여 flatform_iter()에 전달하고 있습니다.대신 코드를 변경하여 목록을 작성하면 속도가 약간 느려집니다.

• iterools (리스트) 버전: 11.62초

까다로운 제너레이터 기능 버전이 파이썬에서 가장 빠르다고 생각합니다.하지만 축소 버전보다 훨씬 빠르지는 않습니다. 제가 측정한 바에 따르면 약 4% 더 빠릅니다.

SymPy에는 다음과 같은 산업 강도 알고리즘이 있습니다.

>>> from sympy import factorint
>>> factorint(2**70 + 3**80) 
{5: 2,
 41: 1,
 101: 1,
 181: 1,
 821: 1,
 1597: 1,
 5393: 1,
 27188665321L: 1,
 41030818561L: 1}

1분도 안 걸렸어요그것은 여러 가지 방법으로 전환됩니다.위에 링크된 설명서를 참조하십시오.

모든 주요 요인을 고려할 때, 다른 모든 요인은 쉽게 구축될 수 있습니다.

---

승인된 답변이 위의 숫자를 인수할 수 있을 정도로 충분히 오래(즉, 영구) 실행되도록 허용되더라도 일부 큰 숫자의 경우 다음과 같은 예에서 실패합니다. 것은엉기때다니문입하성 입니다.int(n**0.5)예를 들어, 다음과 같은 경우n = 10000000000000079**2,우리는 가지고 있다.

>>> int(n**0.5)
10000000000000078L

10000000000000079는 소수이기 때문에 승인된 답변의 알고리즘은 이 요인을 찾지 못합니다.이것은 단순히 하나씩만 일어나는 것이 아닙니다. 더 큰 숫자의 경우에는 더 많이 할인됩니다.이러한 이유로 이러한 종류의 알고리즘에서는 부동 소수점 숫자를 피하는 것이 좋습니다.

다음은 동일한 알고리즘을 보다 파이썬 스타일로 구현하는 @agf의 솔루션에 대한 대안입니다.

def factors(n):
    return set(
        factor for i in range(1, int(n**0.5) + 1) if n % i == 0
        for factor in (i, n//i)
    )

이 솔루션은 Python 2와 Python 3 모두에서 작동하며 가져오기 없이 훨씬 읽기 쉽습니다.이 접근 방식의 성능을 테스트하지는 않았지만, 점근적으로 동일해야 하며, 성능이 심각한 문제라면 두 솔루션 모두 최적의 솔루션이 아닙니다.

최대 n개의 10**16(약간 더)을 위한 고속 순수 Python 3.6 솔루션이 있습니다.

from itertools import compress

def primes(n):
    """ Returns  a list of primes < n for n > 2 """
    sieve = bytearray([True]) * (n//2)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = bytearray((n-i*i-1)//(2*i)+1)
    return [2,*compress(range(3,n,2), sieve[1:])]

def factorization(n):
    """ Returns a list of the prime factorization of n """
    pf = []
    for p in primeslist:
      if p*p > n : break
      count = 0
      while not n % p:
        n //= p
        count += 1
      if count > 0: pf.append((p, count))
    if n > 1: pf.append((n, 1))
    return pf

def divisors(n):
    """ Returns an unsorted list of the divisors of n """
    divs = [1]
    for p, e in factorization(n):
        divs += [x*p**k for k in range(1,e+1) for x in divs]
    return divs

n = 600851475143
primeslist = primes(int(n**0.5)+1) 
print(divisors(n))

agf의 답변에 대한 대안적 접근법:

def factors(n):    
    result = set()
    for i in range(1, int(n ** 0.5) + 1):
        div, mod = divmod(n, i)
        if mod == 0:
            result |= {i, div}
    return result

숫자의 요인을 찾는 가장 간단한 방법:

def factors(x):
    return [i for i in range(1,x+1) if x%i==0]

저는 대부분의 멋진 답변들을 시간이 지남에 따라 그들의 효율성과 제 단순한 기능을 비교해 보았지만, 저는 제가 여기에 나열된 것들을 계속해서 능가하는 것을 봅니다.저는 그것을 공유하고 여러분이 어떻게 생각하는지 보려고 했습니다.

def factors(n):
    results = set()
    for i in xrange(1, int(math.sqrt(n)) + 1):
        if n % i == 0:
            results.add(i)
            results.add(int(n/i))
    return results

작성된 대로 테스트하려면 수학을 가져와야 하지만 math.sqrt(n)를 n**.5로 대체하는 것도 마찬가지입니다.중복이 세트에 존재할 수 없기 때문에 중복을 확인하는 데 시간을 낭비하지 않습니다.

afg & ryksun 솔루션의 추가 개선.다음 코드는 런타임 점근 복잡도를 변경하지 않고 모든 요인의 정렬된 목록을 반환합니다.

    def factors(n):    
        l1, l2 = [], []
        for i in range(1, int(n ** 0.5) + 1):
            q,r = n//i, n%i     # Alter: divmod() fn can be used.
            if r == 0:
                l1.append(i) 
                l2.append(q)    # q's obtained are decreasing.
        if l1[-1] == l2[-1]:    # To avoid duplication of the possible factor sqrt(n)
            l1.pop()
        l2.reverse()
        return l1 + l2

아이디어: list.sort() 함수를 사용하여 nlog(n) 복잡성을 주는 정렬된 목록을 얻는 대신, O(n) 복잡성을 갖는 l2에서 list.reverse()를 사용하는 것이 훨씬 빠릅니다. (그것이 파이썬이 만들어지는 방법입니다.)l2.reverse() 뒤에 l2를 l1에 추가하여 정렬된 요인 리스트를 가져올 수 있습니다.

l1에는 증가하는 i-s가 포함되어 있습니다.l2는 감소하는 q-s를 포함합니다.그것이 위의 아이디어를 사용하는 이유입니다.

다음은 큰 숫자를 사용할 때 성능이 우수한 축소 없는 다른 대안입니다.그것은 사용합니다.sum목록을 평평하게 하기 위해.

def factors(n):
    return set(sum([[i, n//i] for i in xrange(1, int(n**0.5)+1) if not n%i], []))

다▁than보다 큰 숫자를 합니다.sqrt(number_to_factor)과 3*3*을 갖는 99와 floor sqrt(99)+1 == 10.

import math

def factor(x):
  if x == 0 or x == 1:
    return None
  res = []
  for i in range(2,int(math.floor(math.sqrt(x)+1))):
    while x % i == 0:
      x /= i
      res.append(i)
  if x != 1: # Unusual numbers
    res.append(x)
  return res

다음은 소수 번호를 사용하여 훨씬 더 빠르게 이동하려는 경우의 예입니다.이 목록들은 인터넷에서 쉽게 찾을 수 있습니다.코드에 댓글을 달았습니다.

# http://primes.utm.edu/lists/small/10000.txt
# First 10000 primes

_PRIMES = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 
        31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 
        73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 
        127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 
        179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 
        233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 
        283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 
        353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 
        419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 
        467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 
        547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 
        607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 
        661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 
        739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 
        811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 
        877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 
        947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 
# Mising a lot of primes for the purpose of the example
)


from bisect import bisect_left as _bisect_left
from math import sqrt as _sqrt


def get_factors(n):
    assert isinstance(n, int), "n must be an integer."
    assert n > 0, "n must be greather than zero."
    limit = pow(_PRIMES[-1], 2)
    assert n <= limit, "n is greather then the limit of {0}".format(limit)
    result = set((1, n))
    root = int(_sqrt(n))
    primes = [t for t in get_primes_smaller_than(root + 1) if not n % t]
    result.update(primes)  # Add all the primes factors less or equal to root square
    for t in primes:
        result.update(get_factors(n/t))  # Add all the factors associted for the primes by using the same process
    return sorted(result)


def get_primes_smaller_than(n):
    return _PRIMES[:_bisect_left(_PRIMES, n)]

에 이미 제시된 알고리즘보다 더 효율적인 ▁fact▁primeons▁than▁a▁there▁ines▁are▁small▁already▁the▁if잠재▁potential▁algorithmpecially▁efficient▁here).n). 여기서 요령은 주요 요인이 발견될 때마다 시행 분할이 필요한 한도까지 조정하는 것입니다.

def factors(n):
    '''
    return prime factors and multiplicity of n
    n = p0^e0 * p1^e1 * ... * pk^ek encoded as
    res = [(p0, e0), (p1, e1), ..., (pk, ek)]
    '''

    res = []

    # get rid of all the factors of 2 using bit shifts
    mult = 0
    while not n & 1:
        mult += 1
        n >>= 1
    if mult != 0:
        res.append((2, mult))

    limit = round(sqrt(n))
    test_prime = 3
    while test_prime <= limit:
        mult = 0
        while n % test_prime == 0:
            mult += 1
            n //= test_prime
        if mult != 0:
            res.append((test_prime, mult))
            if n == 1:              # only useful if ek >= 3 (ek: multiplicity
                break               # of the last prime) 
            limit = round(sqrt(n))  # adjust the limit
        test_prime += 2             # will often not be prime...
    if n != 1:
        res.append((n, 1))
    return res

물론 이것은 여전히 시험 분할이고 더 이상 화려하지 않습니다. 따라서 효율성이 여전히 매우 제한적입니다(특히 작은 분할자가 없는 큰 숫자의 경우).

은 python3, 나는 python3입니다.//2에 . (: 파에썬 2추야합다니적 (가이해응from __future__ import division).

파이썬에서 사이파리 라이브러리를 이용한 간단한 해결책을 찾았습니다.여기 링크가 있습니다!

import cypari
def get_divisors(n):
   divisors = cypari.pari('divisors({})'.format(n))
   return divisors
print(get_divisors(24))

산출량

[1, 2, 3, 4, 6, 8, 12, 24]

라이브러리를 사용하지 않으려면 이 방법이 가장 쉬운 방법이라고 생각합니다.

def factors(n):
    l = [] # empty list
    # appending the factors in the list
    for i in range(1,n+1):
        if n%i==0:
            l.append(i)
    return l

질문에 Python(2.7)이라고 나와 있지만, 사람들은 Numpy를 사용하는 이 간단한 솔루션에 관심이 있을 수 있습니다.

import numpy as np

t=np.arange(2,n,1)
t[n%t==0]

은 반되지않다니습을 반환하지 .1숫자 자체도 아닌n따라서 다음과 같은 경우 빈 배열을 반환합니다.n프라임입니다.

용사를 합니다.set(...)에서는 코드 속도가 약간 느려지며 제곱근을 확인하는 경우에만 필요합니다.제 버전은 다음과 같습니다.

def factors(num):
    if (num == 1 or num == 0):
        return []
    f = [1]
    sq = int(math.sqrt(num))
    for i in range(2, sq):
        if num % i == 0:
            f.append(i)
            f.append(num/i)
    if sq > 1 and num % sq == 0:
        f.append(sq)
        if sq*sq != num:
            f.append(num/sq)
    return f

그if sq*sq != num:조건은 제곱근이 정수가 아닌 제곱근의 바닥이 요인인 12와 같은 숫자에 필요합니다.

이 버전에서는 번호 자체를 반환하지 않지만, 원하는 경우 쉽게 수정할 수 있습니다.출력도 정렬되지 않습니다.

저는 그것을 1-200번의 모든 번호에서 10000번, 1-5000번의 모든 번호에서 100번 실행하는 시간을 측정했습니다.그것은 단살모, 제이슨 쇼른, 옥스록, agf, steveha 및 ericksun의 솔루션을 포함하여 내가 테스트한 다른 모든 버전보다 성능이 우수하지만 옥스록이 훨씬 가깝습니다.

저는 이 질문을 보고 깜짝 놀랐습니다. numpy가 python 루프보다 훨씬 빠르더라도 numpy를 사용하는 사람이 아무도 없다는 것입니다.@agf의 솔루션을 numpy와 함께 구현함으로써 평균 8배 더 빠른 결과를 얻었습니다.다른 솔루션을 numpy로 구현하면 놀라운 시간을 얻을 수 있다고 생각합니다.

제 기능은 다음과 같습니다.

import numpy as np
def b(n):
    r = np.arange(1, int(n ** 0.5) + 1)
    x = r[np.mod(n, r) == 0]
    return set(np.concatenate((x, n / x), axis=None))   

x축의 숫자는 함수에 대한 입력이 아닙니다.함수에 대한 입력은 x축에서 1을 뺀 숫자에 대해 2입니다.그래서 10은 입력값이 2**10-1 = 1023일 것입니다.

당신의 최대 요인이 당신의 숫자보다 크지 않다고 가정해 봅시다.

def factors(n):
    factors = []
    for i in range(1, n//2+1):
        if n % i == 0:
            factors.append (i)
    factors.append(n)

    return factors

voilah!

 import math

    '''
    I applied finding prime factorization to solve this. (Trial Division)
    It's not complicated
    '''


    def generate_factors(n):
        lower_bound_check = int(math.sqrt(n))  # determine lowest bound divisor range [16 = 4]
        factors = set()  # store factors
        for divisors in range(1, lower_bound_check + 1):  # loop [1 .. 4]
            if n % divisors == 0:
                factors.add(divisors)  # lower bound divisor is found 16 [ 1, 2, 4]
                factors.add(n // divisors)  # get upper divisor from lower [ 16 / 1 = 16, 16 / 2 = 8, 16 / 4 = 4]
        return factors  # [1, 2, 4, 8 16]


    print(generate_factors(12)) # {1, 2, 3, 4, 6, 12} -> pycharm output

 Pierre Vriens hopefully this makes more sense. this is an O(nlogn) solution. 

다음 람다 함수를 사용할 수 있습니다.

factor = lambda x:[(ele,x/ele) for ele in range(1,x//2+1) if x%ele==0 ]

인자(10)

출력: [(1, 10.0), (2, 5.0), (5, 2.0)]

이 함수는 리스트에 있는 지정된 숫자의 모든 요인을 반환합니다.

정수 소수 인수 분해를 위한 간단한 구현을 형태에서 찾을 수 없다는 것이 조금 놀랍습니다.(p1 ** e1) * (p2 ** e2) ...그래서 나는 나의 것을 쓰기로 결심했습니다.

from collections import defaultdict
from itertools import count

def factorize(n):
    factors = defaultdict(int)
    for i in count(2):
        while n % i == 0:
            factors[i] += 1
            n /= i

        if n == 1:
            return factors

이 함수는 키가 주 요인이고 값이 지수인 사전을 반환합니다.예를 들어 다음과 같습니다.

>>> factorize(608)
defaultdict(<class 'int'>, {2: 5, 19: 1})
>>> factorize(1152)
defaultdict(<class 'int'>, {2: 7, 3: 2})
>>> factorize(1088)
defaultdict(<class 'int'>, {2: 6, 17: 1})

이것은 분명히 가장 효율적인 구현이 아닙니다. 소수를 위해 직진하는 대신 전체 자연수 집합에 걸쳐 반복됩니다. 하지만 상대적으로 작은 값에도 충분하고 쉽게 이해할 수 있을 정도로 간단합니다.

다음 목록 이해와 같이 간단한 것을 사용합니다. 1과 찾으려는 숫자를 테스트할 필요가 없습니다.

def factors(n):
    return [x for x in range(2, n//2+1) if n%x == 0]

제곱근의 사용과 관련하여 10의 요인을 찾고 싶다고 가정합니다. 부분의 .sqrt(10) = 4range(1, int(sqrt(10))) = [1, 2, 3, 4]최대 4개의 테스트는 5개를 놓친 것이 분명합니다.

만약 내가 무언가를 놓치고 있지 않다면, 만약 당신이 이런 식으로 해야 한다면, 사용하는 것을 제안합니다.int(ceil(sqrt(x)))물론 이것은 기능에 대한 불필요한 호출을 많이 생성합니다.

가독성과 속도를 위해서는 @oxrock의 솔루션이 최고라고 생각합니다. 그래서 여기 python 3+용으로 다시 작성된 코드가 있습니다.

def num_factors(n):
    results = set()
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0: results.update([i,int(n/i)])
    return results

튜플의 x 또는 v에서 중복을 찾을 때까지 반복합니다. 여기서 x는 분모이고 v는 결과입니다.

number=30
tuple_list=[]
for i in np.arange(1,number):
    if number%i==0:
         other=int(number/i)
         if any([(x,v) for (x,v) in tuple_list if (i==x) or (i==v)])==True:
             break
         tuple_list.append((i,other))
    
 flattened = [item for sublist in tuple_list for item in sublist]              
 print(sorted(flattened))

산출량

 [1, 2, 3, 5, 6, 10, 15, 30]

숫자가 양의 정수인 경우 다음 방법을 사용할 수 있습니다.

number = int(input("Enter a positive number to find factors: "))
factor = [num for num in range(1,number+1) if number % num == 0]
for fac in factor: print(f"{fac} is a factor of {number}")

import 'dart:math';
generateFactorsOfN(N){
  //determine lowest bound divisor range
  final lowerBoundCheck = sqrt(N).toInt();
  var factors = Set<int>(); //stores factors
  /**
   * Lets take 16:
   * 4 = sqrt(16)
   * start from 1 ...  4 inclusive
   * check mod 16 % 1 == 0?  set[1, (16 / 1)]
   * check mod 16 % 2 == 0?  set[1, (16 / 1) , 2 , (16 / 2)]
   * check mod 16 % 3 == 0?  set[1, (16 / 1) , 2 , (16 / 2)] -> unchanged
   * check mod 16 % 4 == 0?  set[1, (16 / 1) , 2 , (16 / 2), 4, (16 / 4)]
   *
   *  ******************* set is used to remove duplicate
   *  ******************* case 4 and (16 / 4) both equal to 4
   *  return factor set<int>.. this isn't ordered
   */

  for(var divisor = 1; divisor <= lowerBoundCheck; divisor++){
    if(N % divisor == 0){
      factors.add(divisor);
      factors.add(N ~/ divisor); // ~/ integer division 
    }
  }
  return factors;
}

저는 이것이 그렇게 하는 가장 간단한 방법이라고 생각합니다.

    x = 23

    i = 1
    while i <= x:
      if x % i == 0:
        print("factor: %s"% i)
      i += 1

언급URL : https://stackoverflow.com/questions/6800193/what-is-the-most-efficient-way-of-finding-all-the-factors-of-a-number-in-python