class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.tm = 0
        self.cache = {}
        self.lru = {}

    def get(self, key):
        if key in self.cache:
            self.lru[key] = self.tm
            self.tm += 1
            return self.cache[key]

        return -1

    def set(self, key, value):
        if len(self.cache) >= self.capacity:
            # find the LRU entry
            old_key = min(self.lru.keys(), key = lambda k:self.lru[k])
            self.cache.pop(old_key)
            self.lru.pop(old_key)
        self.cache[key] = value
        self.lru[key] = self.tm
        self.tm += 1

import collections

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = collections.OrderedDict()

    def get(self, key):
        try:
            value = self.cache.pop(key)
            self.cache[key] = value
            return value
        except KeyError:
            return -1

    def set(self, key, value):
        try:
            self.cache.pop(key)
        except KeyError:
            if len(self.cache) >= self.capacity:
                self.cache.popitem(last=False)
        self.cache[key] = value

class Vehicle:
    def __init__(self):
        print "Vehicle init"
        pass

    def __open__(self):
        print "Vehicle open"
        pass

    def __new__(cls, *args, **kwargs):
        print "Vehicle new"
        return super(Vehicle, cls).__new__(cls)

    def __enter__(self):
        print "Vehicle enter"
        pass

    def __del__(self):
        print "Vehicle delete"
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        print "Vehicle exit"
        pass

Vehicle()

if __name__ == "__main__":

    v = Vehicle()

    with Vehicle() as vv:
       pass

my_list = ['apple', 'banana', 'grapes', 'pear']
>>> for c, value in enumerate(my_list, 2): print(c, value)
... 
(2, 'apple')
(3, 'banana')
(4, 'grapes')
(5, 'pear')
>>> for c, value in enumerate(my_list, -1): print(c, value)
... 
(-1, 'apple')
(0, 'banana')
(1, 'grapes')
(2, 'pear')

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

def is_palindrome(n):
    n=str(n)
    m=n[::-1]
    return n==m

output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('测试成功!')
else:
    print('测试失败!')

  1 class Widget:
  2     name_ = "Default"
  3     size_ = set([0, 0])
  4
  5     def __init__(self, name):
  6         self.name_ = name
  7
  8     def size(self):
  9         return self.size_
 10
 11     def resize(self, height, width):
 12         self.size_ = ([height, width])
 13
 14     def dispose(self):
 15         self.name_ = "Default"
 16         self.size_ = None

  1 import unittest
  2
  3
  4 class MyTestCase(unittest.TestCase):
  5
  6     def test_upper(self):
  7         self.assertEqual('foo'.upper(), 'FOO')
  8
  9     def test_isupper(self):
 10         self.assertTrue('FOO'.isupper())
 11         self.assertFalse('Foo'.isupper())
 12
 13     def test_split(self):
 14         s = 'hello world'
 15         self.assertEqual(s.split(), ['hello', 'world'])
 16
 17         with self.assertRaises(TypeError): # Exception
 18             s.split(2)                     # It should be exception here
 19
 20 if __name__ == '__main__':
 21     # unittest.main()
 22
 23     suite = unittest.TestLoader().loadTestsFromTestCase(MyTestCase)
 24     unittest.TextTestRunner(verbosity=2).run(suite)

  1 import unittest
  2 import sys
  3 import Widget
  4
  5 class WidgetTestCase(unittest.TestCase):
  6     @classmethod
  7     def setUpClass(cls):
  8         pass
  9
 10     @classmethod
 11     def tearDownClass(cls):
 12         pass
 13
 14     def setUp(self):
 15         self.widget = Widget.Widget("The widget")
 16
 17     def tearDown(self):
 18         self.widget.dispose()
 19         self.widget = None
 20
 21     def test_default_size(self):
 22         self.assertEqual(self.widget.size(), ([50, 50]),
 23                          'incorrect default size')
 24
 25     def test_resize(self):
 26         self.widget.resize(100, 150)
 27         self.assertEqual(self.widget.size(), ([100, 150]),
 28                          'wrong size after resize')
 29
 30     @unittest.skip("demostrating skipping")
 31     def test_nothing(self):
 32         pass
 33
 34     @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")
 35     def test_windows_support(self):
 36         # windows specific testing code
 37         pass
 38
 39     @unittest.expectedFailure
 40     def test_fail(self):
 41         self.assertEqual(1, 0, "broken")
 42
 43 if __name__ == '__main__':
 44
 45     """ No.1 Method """
 46     """
 47     widgetTestSuite = unittest.TestSuite()
 48     defaultSizeTestCase = WidgetTestCase('test_default_size')
 49     resizeTestCase = WidgetTestCase('test_resize')
 50
 51     widgetTestSuite.addTest(defaultSizeTestCase)
 52     widgetTestSuite.addTest(resizeTestCase)
 53     """
 54
 55     """ No.2 Method """
 56     widgetTestSuite = unittest.TestLoader().loadTestsFromTestCase(WidgetTestCase)
 57
 58     unittest.TextTestRunner(verbosity=2).run(widgetTestSuite)
 59     # unittest.main()