1、实现方法
方法一:使用标准库collections中的deque
from random import randint
from collections import deque
N = randint(0,100)
histroy = deque([],5) #建立一个空列表队列,队列容量为5
def guess(k):
if k==N:
print("right")
return True;
elif k<N:
print("%s is less than N" %k)
else:
print("%s is greater than N" %k)
return False
while True:
line = raw_input("please input a num:")
if line.isdigit(): #判断是否是数字
k = int(line)
histroy.append(k) #队列里添加
if guess(k):
break;
elif line == "histroy" or line == "h?" or lint == "H?":
print(list(histroy)) #将队列转为列表打印输出
View Code
测试实现的结果:
please input a num:15
15 is less than N
please input a num:50
50 is greater than N
please input a num:30
30 is greater than N
please input a num:20
20 is less than N
please input a num:25
25 is greater than N
please input a num:24
24 is greater than N
please input a num:23
23 is greater than N
please input a num:histroy
[30, 20, 25, 24, 23]
please input a num:18
18 is less than N
please input a num:histroy
[20, 25, 24, 23, 18]
please input a num:22
22 is greater than N
please input a num:21
right
>>>
方法二:pickle将对象保存到文件和从文件中读取
>>> from collections import deque
>>> dq = deque([1,3,2,4,5],5)
>>> dq
deque([1, 3, 2, 4, 5], maxlen=5)
>>> import pickle
>>> pickle.dump(dq,open('histroy.txt','w'))
>>> q2 = pickle.load(open('histroy.txt'))
>>> q2
deque([1, 3, 2, 4, 5], maxlen=5)
View Code
测试的结果为:
2、扩展知识:
2.1 deque
>>> help(deque)
Help on class deque in module collections:
class deque(__builtin__.object)
| deque([iterable[, maxlen]]) --> deque object
|
| Build an ordered collection with optimized access from its endpoints.
|
| Methods defined here:
|
| __copy__(...)
| Return a shallow copy of a deque.
|
| __delitem__(...)
| x.__delitem__(y) <==> del x[y]
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __iadd__(...)
| x.__iadd__(y) <==> x+=y
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| __iter__(...)
| x.__iter__() <==> iter(x)
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __len__(...)
| x.__len__() <==> len(x)
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __reduce__(...)
| Return state information for pickling.
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __reversed__(...)
| D.__reversed__() -- return a reverse iterator over the deque
|
| __setitem__(...)
| x.__setitem__(i, y) <==> x[i]=y
|
| __sizeof__(...)
| D.__sizeof__() -- size of D in memory, in bytes
|
| append(...)
| Add an element to the right side of the deque.
|
| appendleft(...)
| Add an element to the left side of the deque.
|
| clear(...)
| Remove all elements from the deque.
|
| count(...)
| D.count(value) -> integer -- return number of occurrences of value
|
| extend(...)
| Extend the right side of the deque with elements from the iterable
|
| extendleft(...)
| Extend the left side of the deque with elements from the iterable
|
| pop(...)
| Remove and return the rightmost element.
|
| popleft(...)
| Remove and return the leftmost element.
|
| remove(...)
| D.remove(value) -- remove first occurrence of value.
|
| reverse(...)
| D.reverse() -- reverse *IN PLACE*
|
| rotate(...)
| Rotate the deque n steps to the right (default n=1). If n is negative, rotates left.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| maxlen
| maximum size of a deque or None if unbounded
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
help(deque)
>>> from collections import deque
>>>
>>> dq = deque([],5)
>>> dq
deque([], maxlen=5)
>>> dq.append(1)
>>> dq
deque([1], maxlen=5)
>>> dq.append(2)
>>> dq
deque([1, 2], maxlen=5)
>>> dq[1]
2
>>> dq.append(3)
>>> dq.append(4)
>>> dq.append(5)
>>> dq
deque([1, 2, 3, 4, 5], maxlen=5)
>>> dq[0]
1
>>> dq.append(6)
>>> dq
deque([2, 3, 4, 5, 6], maxlen=5)
>>> dq[0]
2
使用list存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为list是线性存储,数据量大的时候,插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表,适合用于队列和栈:
>>> q = deque(['a','b','c'])
>>> q.append('d')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'd'])
deque除了实现list的append()和pop()外,还支持appendleft()和popleft(),这样就可以非常高效地往头部添加或删除元素。
2.2 isdigit()
>>> help(str.isdigit)
Help on method_descriptor:
isdigit(...)
S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
只有对象为数字时,返回True
2.3 pickle
把变量从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling。序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling。Python提供了pickle模块来实现序列化。
2.3.1 pickle.dumps()
>>> help(pickle.dumps)
Help on function dumps in module pickle:
dumps(obj, protocol=None)
pickle.dumps()方法把任意对象序列化成一个bytes,然后,就可以把这个bytes写入文件。
>>> d = dict(name = 'Bob',age=20,score =88)
>>> pickle.dumps(d)
Py2输出:
"(dp0\nS'age'\np1\nI20\nsS'score'\np2\nI88\nsS'name'\np3\nS'Bob'\np4\ns."
Py3输出
b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x14X\x05\x00\x00\x00scoreq\x02KXX\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Bobq\x04u.'
2.3.2 pickle.dump()和pickle.load()
如上面本例中
另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object:
看看写入的dump.txt文件,一堆乱七八糟的内容,这些都是Python保存的对象内部信息。
当我们要把对象从磁盘读到内存时,可以先把内容读到一个bytes,然后用pickle.loads()方法反序列化出对象,也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。我们打开另一个Python命令行来反序列化刚才保存的对象:
变量的内容又回来了!
当然,这个变量和原来的变量是完全不相干的对象,它们只是内容相同而已。
注意:Pickle的问题和所有其他编程语言特有的序列化问题一样,就是它只能用于Python,并且可能不同版本的Python彼此都不兼容,因此,只能用Pickle保存那些不重要的数据,不能成功地反序列化也没关系。