diff -r 2c30e000fbb4 Lib/test/test_enumerate.py
--- a/Lib/test/test_enumerate.py	Tue May 13 16:32:13 2014 +0000
+++ b/Lib/test/test_enumerate.py	Tue May 13 20:57:04 2014 -0700
@@ -100,7 +100,8 @@
     def test_argumentcheck(self):
         self.assertRaises(TypeError, self.enum) # no arguments
         self.assertRaises(TypeError, self.enum, 1) # wrong type (not iterable)
-        self.assertRaises(TypeError, self.enum, 'abc', 2) # too many arguments
+        self.assertRaises(TypeError, self.enum, 'abc', 'a') # wrong type
+        self.assertRaises(TypeError, self.enum, 'abc', 2, 3) # too many arguments
 
     def test_tuple_reuse(self):
         # Tests an implementation detail where tuple is reused
diff -r 2c30e000fbb4 Lib/test/test_enumerate_jy.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/test_enumerate_jy.py	Tue May 13 20:57:04 2014 -0700
@@ -0,0 +1,43 @@
+import unittest
+import sys
+
+from test import test_support
+
+
+class EnumerateJyTestCase(unittest.TestCase):
+
+    enum = enumerate
+    seq, start, res = 'abc', 5, [(5, 'a'), (6, 'b'), (7, 'c')]
+
+    def test_start_kwarg_1(self):
+        e = self.enum(self.seq, start=self.start)
+        self.assertEqual(iter(e), e)
+        self.assertEqual(list(e), self.res)
+
+    def test_start_kwarg_2(self):
+        e = self.enum(start=self.start, sequence=self.seq)
+        self.assertEqual(iter(e), e)
+        self.assertEqual(list(e), self.res)
+
+    def test_start_pos(self):
+        e = self.enum(self.seq, self.start)
+        self.assertEqual(iter(e), e)
+        self.assertEqual(list(e), self.res)
+
+
+def test_main(verbose=None):
+    testclasses = (EnumerateJyTestCase,)
+    test_support.run_unittest(*testclasses)
+
+    # verify reference counting
+    import sys
+    if verbose and hasattr(sys, "gettotalrefcount"):
+        counts = [None] * 5
+        for i in xrange(len(counts)):
+            test_support.run_unittest(*testclasses)
+            counts[i] = sys.gettotalrefcount()
+        print counts
+
+if __name__ == "__main__":
+    test_main(verbose=True)
+
diff -r 2c30e000fbb4 src/org/python/core/PyEnumerate.java
--- a/src/org/python/core/PyEnumerate.java	Tue May 13 16:32:13 2014 +0000
+++ b/src/org/python/core/PyEnumerate.java	Tue May 13 20:57:04 2014 -0700
@@ -23,14 +23,14 @@
         super(subType);
     }
 
-    public PyEnumerate(PyType subType, PyObject seq) {
+    public PyEnumerate(PyType subType, PyObject seq, long start) {
         super(subType);
-        index = 0;
+        index = start;
         sit = seq.__iter__();
     }
 
-    public PyEnumerate(PyObject seq) {
-        this(TYPE, seq);
+    public PyEnumerate(PyObject seq, long start) {
+        this(TYPE, seq, start);
     }
 
     public PyObject next() {
@@ -50,14 +50,19 @@
     @ExposedNew
     public final static PyObject enumerate_new(PyNewWrapper new_, boolean init, PyType subtype,
                                                PyObject[] args, String[] keywords) {
-        if (args.length != 1) {
+        if (args.length > 2 || args.length <= 0) {
             throw PyBuiltinCallable.DefaultInfo.unexpectedCall(args.length, false, "enumerate", 0,
                                                                1);
         }
+
+        ArgParser ap = new ArgParser("enumerate", args, keywords, new String[] {"sequence", "start"});
+        PyObject seq = ap.getPyObject(0);
+        long start = (long) ap.getInt(1, 0);
+
         if (new_.for_type == subtype) {
-            return new PyEnumerate(args[0]);
+            return new PyEnumerate(seq, start);
         } else {
-            return new PyEnumerateDerived(subtype, args[0]);
+            return new PyEnumerateDerived(subtype, seq, start);
         }
     }
 
diff -r 2c30e000fbb4 src/org/python/core/PyEnumerateDerived.java
--- a/src/org/python/core/PyEnumerateDerived.java	Tue May 13 16:32:13 2014 +0000
+++ b/src/org/python/core/PyEnumerateDerived.java	Tue May 13 20:57:04 2014 -0700
@@ -38,8 +38,8 @@
         dict=new PyStringMap();
     }
 
-    public PyEnumerateDerived(PyType subtype,PyObject seq) {
-        super(subtype,seq);
+    public PyEnumerateDerived(PyType subtype,PyObject seq,long start) {
+        super(subtype,seq,start);
         slots=new PyObject[subtype.getNumSlots()];
         dict=subtype.instDict();
     }