python 2-7 如何实现用户的历史记录功能(最多n条)collections.deque/pickle持久存储
2-7 如何实现用户的历史记录功能(最多n条)collections.deque/pickle持久存储
使用collections deque,设定最大元素个数N,如果超过N,就会把最早进入队列的元素给挤掉
可以用pickle 对队列对象实现持久化存储，再次运行时候可以重新load
deque和pickle的用法
deque1 = deque([],5)
deque1.append(k)
f = open("save.data",'w')
pickle.dump(deque1, f)
deque1 = pickle.load(open("save.data")) 一个真实的例子
比如一个例子就是竞猜答案，我们可以把用户最近5次的猜的数字保留下来，多于5次的，就会把最早一次的挤出队列
同样程序如果重新启动时候也还要把历史数据给重新load进来,程序重新启动时候读到历史数据
from collections import deque
import pickle
from random import randint
import os
result = randint(1,100)
print "result is ",result
deque1 = deque([],5)
if os.path.isfile("save.data"):
deque1 = pickle.load(open("save.data"))
while True:
k = raw_input("\nplease input your guess number: ")
if k.isdigit():
k = int(k)
elif k == 'h' or k == 'H':
print "your input history is ",list(deque1)
else:
continue
if k != result:
if k > result:
print "your number is greater than result\n"
else:
print "your number is less than result\n"
deque1.append(k)
else:
print "It was good result..."
deque1.append(k)
break
f = open("save.data",'w')
pickle.dump(deque1, f)
deque的帮助信息
>>> help(collections.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...)
| 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
|
| 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__ = in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T pickle的帮助信息
>>> help(pickle)
Help on module pickle:
NAME
pickle - Create portable serialized representations of Python objects.
FILE
/opt/swe/tools/ext/gnu/python-2.7.3/lib/python2.7/pickle.py
DESCRIPTION
See module cPickle for a (much) faster implementation.
See module copy_reg for a mechanism for registering custom picklers.
See module pickletools source for extensive comments.
Classes:
Pickler
Unpickler
Functions:
dump(object, file)
dumps(object) -> string
load(file) -> object
loads(string) -> object
Misc variables:
__version__
format_version
compatible_formats
CLASSES
exceptions.Exception(exceptions.BaseException)
PickleError
PicklingError
UnpicklingError
Pickler
Unpickler
Functions:
dump(object, file)
dumps(object) -> string
load(file) -> object
loads(string) -> object
Misc variables:
__version__
format_version
compatible_formats
CLASSES
exceptions.Exception(exceptions.BaseException)
PickleError
PicklingError
UnpicklingError
Pickler
Unpickler
class PickleError(exceptions.Exception)
| A common base class for the other pickling exceptions.
|
| Method resolution order:
| PickleError
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.Exception:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.Exception:
|
| __new__ = )
| # Return a GET (BINGET, LONG_BINGET) opcode string, with argument i.
|
| memoize(self, obj)
| Store an object in the memo.
|
| persistent_id(self, obj)
|
| put(self, i, pack=)
| # Return a PUT (BINPUT, LONG_BINPUT) opcode string, with argument i.
|
| save(self, obj)
|
| save_bool(self, obj)
|
| save_dict(self, obj)
|
| save_empty_tuple(self, obj)
| # save_empty_tuple() isn't used by anything in Python 2.3. However, I
| # found a Pickler subclass in Zope3 that calls it, so it's not harmless
| # to remove it.
|
| save_float(self, obj, pack=)
|
| save_global(self, obj, name=None, pack=)
|
| save_inst(self, obj)
|
| save_int(self, obj, pack=)
|
| save_list(self, obj)
|
| save_long(self, obj, pack=)
|
| save_none(self, obj)
|
| save_pers(self, pid)
|
| save_reduce(self, func, args, state=None, listitems=None, dictitems=None, obj=None)
|
| save_string(self, obj, pack=)
|
| save_tuple(self, obj)
|
| save_unicode(self, obj, pack=)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| dispatch = {: ,
class PicklingError(PickleError)
| This exception is raised when an unpicklable object is passed to the
| dump() method.
|
| Method resolution order:
| PicklingError
| PickleError
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors inherited from PickleError:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.Exception:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.Exception:
|
| __new__ = )
|
| load_binget(self)
|
| load_binint(self)
|
| load_binint1(self)
|
| load_binint2(self)
|
| load_binpersid(self)
|
| load_binput(self)
|
| load_binstring(self)
|
| load_binunicode(self)
|
| load_build(self)
|
| load_dict(self)
|
| load_dup(self)
|
| load_empty_dictionary(self)
|
| load_empty_list(self)
|
| load_empty_tuple(self)
|
| load_eof(self)
|
| load_ext1(self)
|
| load_ext2(self)
|
| load_ext4(self)
|
| load_false(self)
|
| load_float(self)
|
| load_get(self)
|
| load_global(self)
|
| load_inst(self)
|
| load_int(self)
|
| load_list(self)
|
| load_long(self)
|
| load_long1(self)
|
| load_long4(self)
|
| load_long_binget(self)
|
| load_long_binput(self)
|
| load_mark(self)
|
| load_newobj(self)
|
| load_none(self)
|
| load_obj(self)
|
| load_persid(self)
|
| load_pop(self)
|
| load_pop_mark(self)
|
| load_proto(self)
|
| load_put(self)
|
| load_reduce(self)
|
| load_setitem(self)
|
| load_setitems(self)
|
| load_short_binstring(self)
|
| load_stop(self)
|
| load_string(self)
|
| load_true(self)
|
| load_tuple(self)
|
| load_tuple1(self)
|
| load_tuple2(self)
|
| load_tuple3(self)
|
| load_unicode(self)
|
| marker(self)
| # Return largest index k such that self.stack[k] is self.mark.
| # If the stack doesn't contain a mark, eventually raises IndexError.
| # This could be sped by maintaining another stack, of indices at which
| # the mark appears. For that matter, the latter stack would suffice,
| # and we wouldn't need to push mark objects on self.stack at all.
| # Doing so is probably a good thing, though, since if the pickle is
| # corrupt (or hostile) we may get a clue from finding self.mark embedded
| # in unpickled objects.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| dispatch = {'': , '(': , ')': <...
class UnpicklingError(PickleError)
| This exception is raised when there is a problem unpickling an object,
| such as a security violation.
|
| Note that other exceptions may also be raised during unpickling, including
| (but not necessarily limited to) AttributeError, EOFError, ImportError,
| and IndexError.
|
| Method resolution order:
| UnpicklingError
| PickleError
| exceptions.Exception
| exceptions.BaseException
| __builtin__.object
|
| Data descriptors inherited from PickleError:
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from exceptions.Exception:
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from exceptions.Exception:
|
| __new__ =