@@ -344,6 +344,11 @@ Miscellaneous improvements
 
 * Renamed sheet_name of LArray.to_excel to sheet since it can also be an index (closes :issue:580).
 
+* allowed to create axes with zero padded string labels (closes :issue:`533`):
+
+    >>> Axis('zero_padding=01,02,03,10,11,12')
+    Axis(['01', '02', '03', '10', '11', '12'], 'zero_padding')
+
 
 Fixes
 -----
@@ -392,3 +397,13 @@ Fixes
     b0    0   3
     b1    1   4
     b2    2   5
+
+* fixed aggregation on arrays containing zero padded string labels (closes :issue:`522`):
+
+    >>> arr = ndtest('zero_padding=01,02,03,10,11,12')
+    >>> arr
+    zero_padding  01  02  03  10  11  12
+                   0   1   2   3   4   5
+    >>> arr.sum('01,02,03 >> 01_03; 10')
+    zero_padding  01_03  10
+                      3   3
@@ -184,20 +184,7 @@ def labels(self, labels):
             labels = np.arange(length)
             iswildcard = True
         else:
-            # TODO: move this to _to_ticks????
-            # we convert to an ndarray to save memory for scalar ticks (for
-            # LGroup ticks, it does not make a difference since a list of LGroup
-            # and an ndarray of LGroup are both arrays of pointers)
-            ticks = _to_ticks(labels, parse_single_int=True)
-            if _contain_group_ticks(ticks):
-                # avoid getting a 2d array if all LGroup have the same length
-                labels = np.empty(len(ticks), dtype=object)
-                # this does not work if some values have a length (with a valid __len__) and others not
-                # labels[:] = ticks
-                for i, tick in enumerate(ticks):
-                    labels[i] = tick
-            else:
-                labels = np.asarray(ticks)
+            labels = _to_ticks(labels, parse_single_int=True)
             length = len(labels)
             iswildcard = False
 
 
@@ -223,6 +223,10 @@ def _range_str_to_range(s, stack_depth=1):
     >>> list(_range_str_to_range('2..6 step 2'))
     [2, 4, 6]
 
+    0 padding
+    >>> list(_range_str_to_range('01..12'))
+    ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12']
+
     any special character except . and spaces should work
     >>> _range_str_to_range('a|+*@-b .. a|+*@-d')
     ['a|+*@-b', 'a|+*@-c', 'a|+*@-d']
@@ -236,6 +240,8 @@ def _range_str_to_range(s, stack_depth=1):
     if stop is None:
         raise ValueError("no stop bound provided in range: %r" % s)
     stop = _parse_bound(stop, stack_depth + 1)
+    if isinstance(start, basestring) or isinstance(stop, basestring):
+        start, stop = str(start), str(stop)
     # TODO: use parse_bound
     step = int(step) if step is not None else 1
     return generalized_range(start, stop, step)
@@ -365,6 +371,7 @@ def _to_tick(v):
         return str(v)
 
 
+# TODO: remove the conversion to list in doctests once Python 2 is dropped
 def _to_ticks(s, parse_single_int=False):
     """
     Makes a (list of) value(s) usable as the collection of labels for an Axis (ie hashable).
@@ -378,53 +385,52 @@ def _to_ticks(s, parse_single_int=False):
 
     Returns
     -------
-    collection of labels
-
-    Notes
-    -----
-    This function is only used in Axis.__init__ and union().
+    Numpy 1D array containing labels
 
     Examples
     --------
-    >>> _to_ticks('M , F')
+    >>> list(_to_ticks('M , F'))
     ['M', 'F']
-    >>> _to_ticks('A,C..E,F..G,Z')
+    >>> list(_to_ticks('A,C..E,F..G,Z'))
     ['A', 'C', 'D', 'E', 'F', 'G', 'Z']
-    >>> _to_ticks('U')
+    >>> list(_to_ticks('U'))
     ['U']
     >>> list(_to_ticks('..3'))
     [0, 1, 2, 3]
+    >>> list(_to_ticks('01..12'))
+    ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12']
+    >>> list(_to_ticks('01,02,03,10,11,12'))
+    ['01', '02', '03', '10', '11', '12']
     """
     if isinstance(s, ABCAxis):
         return s.labels
     if isinstance(s, Group):
         # a single LGroup used for all ticks of an Axis
         return _to_ticks(s.eval())
-    elif isinstance(s, pd.Index):
-        return s.values
     elif isinstance(s, np.ndarray):
         # we assume it has already been translated
         # XXX: Is it a safe assumption?
         return s
+
+    if isinstance(s, pd.Index):
+        ticks = s.values
     elif isinstance(s, (list, tuple)):
-        return [_to_tick(e) for e in s]
+        ticks = [_to_tick(e) for e in s]
     elif sys.version >= '3' and isinstance(s, range):
-        return list(s)
+        ticks = s
     elif isinstance(s, basestring):
         seq = _seq_str_to_seq(s, parse_single_int=parse_single_int)
         if isinstance(seq, slice):
             raise ValueError("using : to define axes is deprecated, please use .. instead")
-        elif isinstance(seq, (basestring, int)):
-            return [seq]
-        else:
-            return seq
+        ticks = [seq] if isinstance(seq, (basestring, int)) else seq
     elif hasattr(s, '__array__'):
-        return s.__array__()
+        ticks = s.__array__()
     else:
         try:
-            return list(s)
+            ticks = list(s)
         except TypeError:
             raise TypeError("ticks must be iterable (%s is not)" % type(s))
+    return np.asarray(ticks)
 
 
 _axis_name_pattern = re.compile('\s*(([A-Za-z]\w*)(\.i)?\s*\[)?(.*)')
 
@@ -24,15 +24,15 @@
 
 class TestValueStrings(TestCase):
     def test_split(self):
-        self.assertEqual(_to_ticks('M,F'), ['M', 'F'])
-        self.assertEqual(_to_ticks('M, F'), ['M', 'F'])
+        assert_array_equal(_to_ticks('M,F'), np.asarray(['M', 'F']))
+        assert_array_equal(_to_ticks('M, F'), np.asarray(['M', 'F']))
 
     def test_union(self):
         self.assertEqual(union('A11,A22', 'A12,A22'), ['A11', 'A22', 'A12'])
 
     def test_range(self):
-        self.assertEqual(_to_ticks('0..115'), range(116))
-        self.assertEqual(_to_ticks('..115'), range(116))
+        assert_array_equal(_to_ticks('0..115'), np.asarray(range(116)))
+        assert_array_equal(_to_ticks('..115'), np.asarray(range(116)))
         with self.assertRaises(ValueError):
             _to_ticks('10..')
         with self.assertRaises(ValueError):
@@ -1654,6 +1654,11 @@ def test_group_agg_anonymous_axis(self):
         raw = np.asarray(la)
         assert_array_equal(la.sum(a2[0, 2]), raw[:, [0, 2]].sum(1))
 
+    def test_group_agg_zero_padded_label(self):
+        arr = ndtest("a=01,02,03,10,11; b=b0..b2")
+        expected = LArray([36, 30, 39], "a=01_03,10,11")
+        assert_array_equal(arr.sum("01,02,03 >> 01_03; 10; 11", "b"), expected)
+
     def test_group_agg_on_int_array(self):
         # issue 193
         arr = ndtest('year=2014..2018')
 
@@ -38,6 +38,10 @@ def test_init(self):
         # range-string
         axis = Axis('0..115', 'age')
         assert_array_equal(axis.labels, np.arange(116))
+        # int-like labels with 0 padding
+        assert_array_equal(Axis('01..12', 'zero_padding').labels, [str(i).zfill(2) for i in range(1, 13)])
+        assert_array_equal(Axis('01,02,03,10,11,12', 'zero_padding').labels, ['01', '02', '03', '10', '11', '12'])
+
         # another axis group
         group = axis[:10]
         group_axis = Axis(group)
 
@@ -516,7 +516,30 @@ def error_handler(error, flag):
 
 
 def _isintstring(s):
-    return s.isdigit() or (len(s) > 1 and s[0] == '-' and s[1:].isdigit())
+    """
+    Return True if the passed string represents an integer.
+    Zero padded integers are considered as strings and not integers.
+
+    Parameters
+    ----------
+    s : str
+        string to test if representing an integer.
+
+    Examples
+    --------
+    >>> _isintstring('12')
+    True
+    >>> _isintstring('-12')
+    True
+    >>> _isintstring('a1')
+    False
+    >>> _isintstring('01')
+    False
+    """
+    def isposint(s):
+        # exclude zero padded strings
+        return s.isdigit() and not (len(s) > 1 and s[0] == '0')
+    return isposint(s) or (len(s) > 1 and s[0] == '-' and isposint(s[1:]))
 
 
 def _parse_bound(s, stack_depth=1, parse_int=True):
@@ -545,6 +568,8 @@ def _parse_bound(s, stack_depth=1, parse_int=True):
     2
     >>> _parse_bound('42')
     42
+    >>> _parse_bound('01')
+    '01'
     """
     s = s.strip()
     if s == '':