python %s - 파이썬의 간단한 총 생성기





엔터입력 나누기 (19)


def is_prime(num):
    """Returns True if the number is prime
    else False."""
    if num == 0 or num == 1:
        return False
    for x in range(2, num):
        if num % x == 0:
            return False
    else:
        return True

>> filter(is_prime, range(1, 20))
  [2, 3, 5, 7, 11, 13, 17, 19]

우리는 모든 소수를 20 개까지 목록으로 얻을 것입니다. 나는 에라 토 스테 네스 체를 사용할 수 있었지만, 당신은 매우 단순한 것을 원한다고 말했다. ;)

누군가이 코드로 내가 뭘 잘못하고 있는지 말해 줄 수 있습니까? 그것은 단지 '카운트'를 인쇄하는 것입니다. 나는 아주 단순한 소수 생성기를 원한다.

import math

def main():
    count = 3
    one = 1
    while one == 1:
        for x in range(2, int(math.sqrt(count) + 1)):
            if count % x == 0: 
                continue
            if count % x != 0:
                print count

        count += 1



import time

maxnum=input("You want the prime number of 1 through....")

n=2
prime=[]
start=time.time()

while n<=maxnum:

    d=2.0
    pr=True
    cntr=0

    while d<n**.5:

        if n%d==0:
            pr=False
        else:
            break
        d=d+1

    if cntr==0:

        prime.append(n)
        #print n

    n=n+1

print "Total time:",time.time()-start



몇 가지 문제가 있습니다.

  • 왜 x로 나눠지지 않았을 때 카운트를 출력합니까? 그것이 소수임을 의미하지는 않으며,이 특별한 x는 그것을 나눌 수 없다는 것을 의미합니다.
  • continue 다음 루프 반복으로 이동하지만 실제로 중단을 사용하여 break 하려는 경우

몇 가지 수정 사항이있는 코드는 다음과 같습니다.

import math

def main():
    count = 3
    
    while True:
        isprime = True
        
        for x in range(2, int(math.sqrt(count) + 1)):
            if count % x == 0: 
                isprime = False
                break
        
        if isprime:
            print count
        
        count += 1

훨씬 더 효율적인 총리 세대를 위해서, 다른 사람들이 제안한 것처럼, Erastothenes의 체를보십시오. 다음은 많은 주석이 포함 된 최적화되고 최적화 된 구현입니다.

# Sieve of Eratosthenes
# Code by David Eppstein, UC Irvine, 28 Feb 2002
# http://code.activestate.com/recipes/117119/

def gen_primes():
    """ Generate an infinite sequence of prime numbers.
    """
    # Maps composites to primes witnessing their compositeness.
    # This is memory efficient, as the sieve is not "run forward"
    # indefinitely, but only as long as required by the current
    # number being tested.
    #
    D = {}
    
    # The running integer that's checked for primeness
    q = 2
    
    while True:
        if q not in D:
            # q is a new prime.
            # Yield it and mark its first multiple that isn't
            # already marked in previous iterations
            # 
            yield q
            D[q * q] = [q]
        else:
            # q is composite. D[q] is the list of primes that
            # divide it. Since we've reached q, we no longer
            # need it in the map, but we'll mark the next 
            # multiples of its witnesses to prepare for larger
            # numbers
            # 
            for p in D[q]:
                D.setdefault(p + q, []).append(p)
            del D[q]
        
        q += 1

생성기를 반환합니다.




가능한 모든 약수가 당신이 검사하는 번호를 균등하게 나누지 않는지 확인해야합니다. 이 경우 언제든지 확인할 수있는 번호를 인쇄하여 가능한 약수 중 하나만 번호를 균등하게 나누지 않습니다.

또한 continue 문은 number가 소수가 아니라는 것을 이미 알아 냈을 때 continue가 다음 가능한 제수를 확인하게하기 때문에 continue 문을 사용하고 싶지 않습니다.




필자의 견해로는 항상 기능적 접근 방식을 취하는 것이 가장 좋습니다.

그래서 번호가 소수인지 아닌지를 먼저 알아내어 함수를 만들어 루프 나 다른 장소에서 필요에 따라 사용하십시오.

def isprime(n):
      for x in range(2,n):
        if n%x == 0:
            return False
    return True

그런 다음 간단한 목록 이해 또는 생성자 표현을 실행하여 소수 목록을 얻고,

[x for x in range(1,100) if isprime(x)]



프라임을 직접 계산하려면 다음과 같이하십시오.

def oprime(n):
counter = 0
b = 1
if n == 1:
    print 2
while counter < n-1:
    b = b + 2
    for a in range(2,b):
        if b % a == 0:
            break
    else:
        counter = counter + 1
        if counter == n-1:
            print b



여기에 내가 가진 것이있다.

def is_prime(num):
    if num < 2:         return False
    elif num < 4:       return True
    elif not num % 2:   return False
    elif num < 9:       return True
    elif not num % 3:   return False
    else:
        for n in range(5, int(math.sqrt(num) + 1), 6):
            if not num % n:
                return False
            elif not num % (n + 2):
                return False

    return True

숫자의 제수에 대한 이미 소수에 대해서만 검사하기 때문에 큰 숫자에 대해서는 꽤 빠릅니다.

이제 소수의리스트를 생성하려면 다음을 할 수 있습니다.

# primes up to 'max'
def primes_max(max):
    yield 2
    for n in range(3, max, 2):
        if is_prime(n):
            yield n

# the first 'count' primes
def primes_count(count):
    counter = 0
    num = 3

    yield 2

    while counter < count:
        if is_prime(num):
            yield num
            counter += 1
        num += 2

여기서 발전기를 사용하는 것이 효율성을 위해 필요할 수 있습니다.

참조 용으로 말하면서

one = 1
while one == 1:
    # do stuff

당신은 간단하게 말할 수 있습니다 :

while 1:
    #do stuff



홀수를 고려하는 단순한 최적화를 사용한 또 다른 간단한 예입니다. 모든 것이 게으른 스트림 (파이썬 생성기)에서 수행됩니다.

사용법 : 소수 = 목록 (create_prime_iterator (1, 30))

import math
import itertools

def create_prime_iterator(rfrom, rto):
    """Create iterator of prime numbers in range [rfrom, rto]"""
    prefix = [2] if rfrom < 3 and rto > 1 else [] # include 2 if it is in range separately as it is a "weird" case of even prime
    odd_rfrom = 3 if rfrom < 3 else make_odd(rfrom) # make rfrom an odd number so that  we can skip all even nubers when searching for primes, also skip 1 as a non prime odd number.
    odd_numbers = (num for num in xrange(odd_rfrom, rto + 1, 2))
    prime_generator = (num for num in odd_numbers if not has_odd_divisor(num))
    return itertools.chain(prefix, prime_generator)

def has_odd_divisor(num):
    """Test whether number is evenly divisable by odd divisor."""
    maxDivisor = int(math.sqrt(num))
    for divisor in xrange(3, maxDivisor + 1, 2):
        if num % divisor == 0:
            return True
    return False

def make_odd(number):
    """Make number odd by adding one to it if it was even, otherwise return it unchanged"""
    return number | 1



print [x for x in range(2,100) if not [t for t in range(2,x) if not x%t]]



다음은 OP의 원래 요청 (현재 6 개월 전)과 동일한 인스 트림 (파이썬 2.6.2) 솔루션입니다. 그리고 어떤 "프로그래밍 101"과정에서 완벽하게 수용할만한 솔루션이어야합니다 ... 따라서이 게시물.

import math

def isPrime(n):
    for i in range(2, int(math.sqrt(n)+1)):
        if n % i == 0: 
            return False;
    return n>1;

print 2
for n in range(3, 50):
    if isPrime(n):
        print n

이 간단한 "무차별 대항"방법은 현대 PC에서 약 16,000 개까지의 숫자에 대해 "충분히 빠름"입니다 (2GHz 상자에서 약 8 초 소요).

분명히 이것은 모든 짝수의 우수성을 계산하지 않고 모든 단일 숫자에 대해 3, 5, 7 등의 모든 배수를 재 계산하지 않아 훨씬 효율적으로 수행 할 수 있습니다 ... en.wikipedia.org/wiki/Sieve_of_Eratosthenesen.wikipedia.org/wiki/Sieve_of_Eratosthenes 보십시오 (위의 eliben의 구현 참조). 특히 용감하고 미친 듯이 느껴지더라도 Atkin시브 (Sieve of Atkin) .

경고 Emptor : 저는 파이썬 놈입니다. 제발 제가 복음으로 말하는 것을 가져 가지 마십시오.




List comprehensions을 사용하여 매우 우아한 방식으로 소수의리스트를 만들 수 있습니다. here: 에서 가져온 here:

>>> noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]
>>> primes = [x for x in range(2, 50) if x not in noprimes]
>>> print primes
>>> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]



def check_prime(x):
    if (x < 2): 
       return 0
    elif (x == 2): 
       return 1
    t = range(x)
    for i in t[2:]:
       if (x % i == 0):
            return 0
    return 1



def genPrimes():
    primes = []   # primes generated so far
    last = 1      # last number tried
    while True:
        last += 1
        for p in primes:
            if last % p == 0:
                break
        else:
            primes.append(last)
            yield last



나에게있어 아래의 솔루션은 간단하고 쉽게 따라 할 수 있습니다.

import math

def is_prime(num):

    if num < 2:
        return False

    for i in range(2, int(math.sqrt(num) + 1)):
        if num % i == 0:
            return False

return True



SymPy 는 상징적 인 수학을위한 Python 라이브러리입니다. 프라임 숫자를 생성하는 몇 가지 함수를 제공합니다.

isprime(n)              # Test if n is a prime number (True) or not (False).

primerange(a, b)        # Generate a list of all prime numbers in the range [a, b).
randprime(a, b)         # Return a random prime number in the range [a, b).
primepi(n)              # Return the number of prime numbers less than or equal to n.

prime(nth)              # Return the nth prime, with the primes indexed as prime(1) = 2. The nth prime is approximately n*log(n) and can never be larger than 2**n.
prevprime(n, ith=1)     # Return the largest prime smaller than n
nextprime(n)            # Return the ith prime greater than n

sieve.primerange(a, b)  # Generate all prime numbers in the range [a, b), implemented as a dynamically growing sieve of Eratosthenes. 

여기 몇 가지 예가 있어요.

>>> import sympy
>>> 
>>> sympy.isprime(5)
True
>>> list(sympy.primerange(0, 100))
[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]
>>> sympy.randprime(0, 100)
83
>>> sympy.randprime(0, 100)
41
>>> sympy.prime(3)
5
>>> sympy.prevprime(50)
47
>>> sympy.nextprime(50)
53
>>> list(sympy.sieve.primerange(0, 100))
[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]



re는 강력합니다.

import re


def isprime(n):
    return re.compile(r'^1?$|^(11+)\1+$').match('1' * n) is None

print [x for x in range(100) if isprime(x)]

###########Output#############
[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]



  • continue 문이 잘못되었습니다.

  • 2가 첫 번째 소수이므로 2부터 시작하고 싶습니다.

  • 무한 루프를 만들려면 "while True :"라고 쓸 수 있습니다.




범위 내의 모든 소수를 찾으려면 다음을 할 수 있습니다.

def is_prime(num):
"""Returns True if the number is prime
else False."""
if num == 0 or num == 1:
    return False
for x in range(2, num):
    if num % x == 0:
        return False
else:
    return True
num = 0
itr = 0
tot = ''
while itr <= 100:
    itr = itr + 1
    num = num + 1
    if is_prime(num) == True:
        print(num)
        tot = tot + ' ' + str(num)
print(tot)

while its <= 및 해당 범위의 번호를 추가하십시오.
산출:
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




나는 C ++, Java, 그리고 Python으로 프로그래밍 언어를 배우기 시작했다. 그래서이 질문은 각각의 간단한 사용법을 이해할 때까지 나를 괴롭혔다.

클래스 메소드 : 파이썬은 Java와는 달리 C ++에는 생성자 오버로딩이 없습니다. 그리고 이것을 성취하기 위해 당신은 classmethod 사용할 수 있습니다. 다음 예제는 이것을 설명 할 것입니다.

first_namelast_name 이라는 두 개의 인자를 취하고 Person의 인스턴스를 생성하는 Person 클래스가 있다고 가정 해 봅시다.

class Person(object):

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

이제 요구 사항이 하나의 이름 만 사용하는 클래스를 만들 필요가있을 때 (단지 first_name , 파이썬에서 이와 같이 할 수 없습니다 .

이렇게하면 개체 (인스턴스)를 만들려고 할 때 오류가 발생합니다.

class Person(object):

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def __init__(self, first_name):
        self.first_name = first_name

그러나, 당신은 아래에 언급 된 @classmethod 를 사용하여 같은 것을 얻을 수있다.

class Person(object):

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    @classmethod
    def get_person(cls, first_name):
        return cls(first_name, "")

정적 메서드 : 이것은 다소 단순합니다. 인스턴스 나 클래스에 바인딩되지 않으며 클래스 이름을 사용하여 간단하게 호출 할 수 있습니다.

위의 예에서 first_name 이 20자를 넘지 않아야한다는 검증이 필요하다고 가정 해 봅시다. 간단히 이것을 할 수 있습니다.

@staticmethod  
def validate_name(name):
    return len(name) <= 20

클래스 이름을 사용하여 간단히 호출 할 수 있습니다.

Person.validate_name("Gaurang Shah")




python primes