一个关于课程的愚蠢问题 [英] A dumb question about a class
问题描述
我还在努力理解课程。我已经取得了一些进展，我想，但是我不知道如何使用这个。我怎么称呼它，
或它的任何功能？这是来自Cookbook，
< http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/523048>。
谢谢，
Dick Moores
==================== ============================== ===
类PrimeList：
def __init __（self，initial = 0）：
self.primelist = [2,3]
self.primelookup = [0,0,1,1]
self.max_prime = 3
self.grow_primelist（初始）
def grow_primelist（self，number）：
newprimes = []
而self.max_prime< = number：
next = self.nextprime（）
newprimes .append（下）
self.max_prime = next
size_difference = self.max_prime - len（self.primelookup）+ 1
self。 primelookup.extend（[0] * size_difference）
for i in newprimes：
self.primelookup [i] = 1
def包含（self，number）：
如果数字< 2：
返回0
如果是数字len（self.primelookup） - 1：
self.grow_primelist（数字）
返回self.primelookup [编号]
返回self.primelookup [编号]
def nextprime（个体经营）：
i = self.max_prime + 2
而1：
isprime = True
for self.primelist：
if i％prime == 0：
isprime = False
i + = 2
break
if isprime：
self.primelist.append（i）
返回（i）
============ ====================================== ====
I''m still trying to understand classes. I''ve made some progress, I
think, but I don''t understand how to use this one. How do I call it,
or any of its functions? It''s from the Cookbook, at
<http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/523048>.
Thanks,
Dick Moores
================================================== ===
class PrimeList:
def __init__(self, initial=0):
self.primelist = [2,3]
self.primelookup = [0,0,1,1]
self.max_prime = 3
self.grow_primelist(initial)
def grow_primelist(self,number):
newprimes = []
while self.max_prime <= number:
next = self.nextprime()
newprimes.append(next)
self.max_prime = next
size_difference = self.max_prime - len(self.primelookup) + 1
self.primelookup.extend([0] * size_difference)
for i in newprimes:
self.primelookup[i]=1
def contains(self,number):
if number < 2:
return 0
if number len(self.primelookup) - 1:
self.grow_primelist(number)
return self.primelookup[number]
return self.primelookup[number]
def nextprime(self):
i = self.max_prime + 2
while 1:
isprime = True
for prime in self.primelist:
if i % prime == 0:
isprime = False
i += 2
break
if isprime:
self.primelist.append(i)
return(i)
================================================== ====
推荐答案
Dick Moores写道：
Dick Moores wrote:
我还在努力理解课程。我已经取得了一些进展，我想，但是我不知道如何使用这个。我如何调用它，或者
它的任何功能？这是来自Cookbook，
< http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/523048>。
I''m still trying to understand classes. I''ve made some progress, I
think, but I don''t understand how to use this one. How do I call it, or
any of its functions? It''s from the Cookbook, at
<http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/523048>.
简短的回答是使用应该类似::
The short answer is that use should look something like::
>> plist = PrimeList（）
plist.contains（32）
>>plist = PrimeList()
plist.contains(32)
错误
False
>> plist.contains（23）
>>plist.contains(23)
True
但这似乎不是一个特别好的食谱。好像你一样
真的宁愿写代码::
True
But this doesn''t seem like a particularly good recipe. Seems like you
would really rather be writing code like::
>> plist = PrimeList（）
1 in plist
>>plist = PrimeList()
1 in plist
False
False
>> 2 in plist
>>2 in plist
True
True
>> 22 in plist
>>22 in plist
False
False
>> 23 in plist
>>23 in plist
True
True
>> 782 in plist
>>782 in plist
False
False
>> 787 in plist
>>787 in plist
True
这就是我怎么写的食谱::
import itertools
def iter_primes （）：
＃2和+无穷大之间所有数字的迭代器
numbers = itertools.count（2）
#start primes forever
而True：
＃从迭代器中获取第一个数字（总是素数）
prime = numbers.next（）
收益素数
＃从（无限）迭代器中删除所有数字
＃divisible by我们刚生成的素数
numbers = itertools.ifilter（prime .__ rmod __，数字）
class PrimeList（object）：
def __init __（自我）：
＃in素数的有限迭代器
self._prime_iter = iter_primes（）
＃我们见过的最后一个素数
self。 _last_prime =无
＃到目前为止看到的所有素数
self._prime_set = set（）
#add第一个素数（所以设置了_last_prime）
self._add_prime（）
def __contains __（self，n）：
＃将素数添加到列表中，直到我们超过n
而n self._last_prime：
self._add_prime（）
如果n是我们的素数之一，则返回True
在self._prime_set中返回n
def _add_prime（个体经营）：
＃从迭代器中取一个素数并更新素数集
self._last_prime = self._prime_iter.next（）
self._prime_set.add（self._last_prime）
STeVe
True
Here''s how I''d write the recipe::
import itertools
def iter_primes():
# an iterator of all numbers between 2 and +infinity
numbers = itertools.count(2)
# generate primes forever
while True:
# get the first number from the iterator (always a prime)
prime = numbers.next()
yield prime
# remove all numbers from the (infinite) iterator that are
# divisible by the prime we just generated
numbers = itertools.ifilter(prime.__rmod__, numbers)
class PrimeList(object):
def __init__(self):
# infinite iterator of primes
self._prime_iter = iter_primes()
# the last prime we''ve seen
self._last_prime = None
# all primes seen so far
self._prime_set = set()
# add the first prime (so that _last_prime is set)
self._add_prime()
def __contains__(self, n):
# add primes to the list until we exceed n
while n self._last_prime:
self._add_prime()
# return True if n is one of our primes
return n in self._prime_set
def _add_prime(self):
# take a prime off the iterator and update the prime set
self._last_prime = self._prime_iter.next()
self._prime_set.add(self._last_prime)
STeVe
2007年12月7日下午03:09，Steven Bethard写道：
At 03:09 PM 8/12/2007, Steven Bethard wrote:
>这就是我写的食谱::
import itertools
def iter_primes（）：
＃2和+无穷大之间所有数字的迭代器
numbers = itertools.count（2）
＃永久生成素数
而True：
＃从迭代器中获取第一个数字（总是一个素数）
prime = numbers.next（）
收益素数
＃删除（无限）迭代器中的所有数字
＃可以被我们刚生成的素数整除
numbers = itertools.ifilter（prime .__ rmod__，数字）
类PrimeList（对象）：
def __init __（self）：
＃primes的无限迭代器
self._prime_iter = iter_primes（）
＃我们见过的最后一个素数
self._last_prime =无
＃到目前为止看到的所有素数
self._prime_set = set（）
＃添加第一个素数（所以设置_last_prime）
self._add_prime（）
def __contains __（self，n）：
＃将素数添加到列表，直到我们超过n
而n self._last_prime：
self._add_prime（）
＃return如果n是我们的素数之一
返回n in self._prime_set
def _add_prime（个体经营）：
＃取消黄金迭代器并更新素数集
self._last_prime = self._prime_iter.next（）
self._prime_set.add（self._last_prime）
>Here''s how I''d write the recipe::
import itertools
def iter_primes():
# an iterator of all numbers between 2 and +infinity
numbers = itertools.count(2)
# generate primes forever
while True:
# get the first number from the iterator (always a prime)
prime = numbers.next()
yield prime
# remove all numbers from the (infinite) iterator that are
# divisible by the prime we just generated
numbers = itertools.ifilter(prime.__rmod__, numbers)
class PrimeList(object):
def __init__(self):
# infinite iterator of primes
self._prime_iter = iter_primes()
# the last prime we''ve seen
self._last_prime = None
# all primes seen so far
self._prime_set = set()
# add the first prime (so that _last_prime is set)
self._add_prime()
def __contains__(self, n):
# add primes to the list until we exceed n
while n self._last_prime:
self._add_prime()
# return True if n is one of our primes
return n in self._prime_set
def _add_prime(self):
# take a prime off the iterator and update the prime set
self._last_prime = self._prime_iter.next()
self._prime_set.add(self._last_prime)
我担心我的下一个问题是我该如何运行？
Dick
I''m afraid my next question is "How do I run this"?
Dick
Dick Moores写道：
Dick Moores wrote:
2007年8月12日03:09，Steven Bethard写道：
At 03:09 PM 8/12/2007, Steven Bethard wrote:
>这是怎么回事我会写食谱::
导入itertools
＃一个介于2和+无穷大之间的所有数字的迭代器
numbers = itertools.count（2）
＃永远生成素数
而True：
＃从迭代器中获取第一个数字（总是素数）
prime = numbers.next（）
产生素数
＃删除（无限）迭代器中的所有数字
＃可被我们刚生成的素数整除
numbers = itertools.ifilter（prime .__ rmod __，数字）
类PrimeList（对象）：
def __init __（self）：
＃无限的iterator of primes
self._prime_iter = iter_primes（）
＃我们见过的最后一个素数
self._last_prime =无
＃到目前为止看到的所有素数
self._prime_set = set（）
＃添加第一个素数（以便设置_last_prime）
self__add_prime（）
def __contains __（self，n）：
＃将素数添加到列表中直到我们超过n
而n self._last_prime：
self._add_prime（）
＃return如果n是我们的素数之一，则返回True
在self._prime_set中返回n
def _add_prime（self）：
＃取消迭代器并更新素数集
self._last_prime = self._prime_iter.next（）
自我。 _prime_set.add（self._last_prime）
>Here''s how I''d write the recipe::
import itertools
def iter_primes():
# an iterator of all numbers between 2 and +infinity
numbers = itertools.count(2)
# generate primes forever
while True:
# get the first number from the iterator (always a prime)
prime = numbers.next()
yield prime
# remove all numbers from the (infinite) iterator that are
# divisible by the prime we just generated
numbers = itertools.ifilter(prime.__rmod__, numbers)
class PrimeList(object):
def __init__(self):
# infinite iterator of primes
self._prime_iter = iter_primes()
# the last prime we''ve seen
self._last_prime = None
# all primes seen so far
self._prime_set = set()
# add the first prime (so that _last_prime is set)
self._add_prime()
def __contains__(self, n):
# add primes to the list until we exceed n
while n self._last_prime:
self._add_prime()
# return True if n is one of our primes
return n in self._prime_set
def _add_prime(self):
# take a prime off the iterator and update the prime set
self._last_prime = self._prime_iter.next()
self._prime_set.add(self._last_prime)
我担心我的下一个问题是如何运行此？
I''m afraid my next question is "How do I run this"?
我在顶部显示的方式（你在回复中剪断）的方式相同::
The same way I showed at the top (which you snipped in your reply)::
>> plist = PrimeList（）
1 in plist
>>plist = PrimeList()
1 in plist
False
False
>> 2 in plist
>>2 in plist
True
True
>> 22 in plist
>>22 in plist
False
False
>> 23 in plist
>>23 in plist
True
True
>> 784 in plist
>>782 in plist
False
False
>> 787 in plist
>>787 in plist
正确
第一行，``plist = PrimeList（）``创建一个PrimeList对象，
命名为``plist` `。然后你可以检查一个素数是否在那个
PrimeList对象，就像你可能检查一个普通的``list``或``set``
对象一样 - 使用如上所述的``in``运算符。
请注意，如果你只想迭代所有素数，那么就没有需要
了这个班级。只需在iter_primes（）中写下::
为素数：
...
HTH，
STeVe
True
The first line, ``plist = PrimeList()`` creates a PrimeList object and
names it ``plist``. You can then check whether a prime is in that
PrimeList object much like you might check a normal ``list`` or ``set``
object -- using the ``in`` operator as above.
Note that if you just want to iterate over all the primes, there''s no
need for the class at all. Simply write::
for prime in iter_primes():
...
HTH,
STeVe
这篇关于一个关于课程的愚蠢问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
