def tz_localize(self, tz, axis=<NUM_LIT:0>, level=None, copy=True,<EOL>ambiguous='<STR_LIT>', nonexistent='<STR_LIT>'):
nonexistent_options = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>')<EOL>if nonexistent not in nonexistent_options and not isinstance(<EOL>nonexistent, timedelta):<EOL><INDENT>raise ValueError("<STR_LIT>"<EOL>"<STR_LIT>"<EOL>"<STR_LIT>")<EOL><DEDENT>axis = self._get_axis_number(axis)<EOL>ax = self._get_axis(axis)<EOL>def _tz_localize(ax, tz, ambiguous, nonexistent):<EOL><INDENT>if not hasattr(ax, '<STR_LIT>'):<EOL><INDENT>if len(ax) > <NUM_LIT:0>:<EOL><INDENT>ax_name = self._get_axis_name(axis)<EOL>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % ax_name)<EOL><DEDENT>else:<EOL><INDENT>ax = DatetimeIndex([], tz=tz)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ax = ax.tz_localize(<EOL>tz, ambiguous=ambiguous, nonexistent=nonexistent<EOL>)<EOL><DEDENT>return ax<EOL><DEDENT>if isinstance(ax, MultiIndex):<EOL><INDENT>level = ax._get_level_number(level)<EOL>new_level = _tz_localize(<EOL>ax.levels[level], tz, ambiguous, nonexistent<EOL>)<EOL>ax = ax.set_levels(new_level, level=level)<EOL><DEDENT>else:<EOL><INDENT>if level not in (None, <NUM_LIT:0>, ax.name):<EOL><INDENT>raise ValueError("<STR_LIT>".format(level))<EOL><DEDENT>ax = _tz_localize(ax, tz, ambiguous, nonexistent)<EOL><DEDENT>result = self._constructor(self._data, copy=copy)<EOL>result = result.set_axis(ax, axis=axis, inplace=False)<EOL>return result.__finalize__(self)<EOL>
Localize tz-naive index of a Series or DataFrame to target time zone.

This operation localizes the Index. To localize the values in a
timezone-naive Series, use :meth:`Series.dt.tz_localize`.

Parameters
----------
tz : string or pytz.timezone object
axis : the axis to localize
level : int, str, default None
    If axis ia a MultiIndex, localize a specific level. Otherwise
    must be None
copy : boolean, default True
    Also make a copy of the underlying data
ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
    When clocks moved backward due to DST, ambiguous times may arise.
    For example in Central European Time (UTC+01), when going from
    03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at
    00:30:00 UTC and at 01:30:00 UTC. In such a situation, the
    `ambiguous` parameter dictates how ambiguous times should be
    handled.

    - 'infer' will attempt to infer fall dst-transition hours based on
      order
    - bool-ndarray where True signifies a DST time, False designates
      a non-DST time (note that this flag is only applicable for
      ambiguous times)
    - 'NaT' will return NaT where there are ambiguous times
    - 'raise' will raise an AmbiguousTimeError if there are ambiguous
      times
nonexistent : str, default 'raise'
    A nonexistent time does not exist in a particular timezone
    where clocks moved forward due to DST. Valid values are:

    - 'shift_forward' will shift the nonexistent time forward to the
      closest existing time
    - 'shift_backward' will shift the nonexistent time backward to the
      closest existing time
    - 'NaT' will return NaT where there are nonexistent times
    - timedelta objects will shift nonexistent times by the timedelta
    - 'raise' will raise an NonExistentTimeError if there are
      nonexistent times

    .. versionadded:: 0.24.0

Returns
-------
Series or DataFrame
    Same type as the input.

Raises
------
TypeError
    If the TimeSeries is tz-aware and tz is not None.

Examples
--------

Localize local times:

>>> s = pd.Series([1],
... index=pd.DatetimeIndex(['2018-09-15 01:30:00']))
>>> s.tz_localize('CET')
2018-09-15 01:30:00+02:00    1
dtype: int64

Be careful with DST changes. When there is sequential data, pandas
can infer the DST time:

>>> s = pd.Series(range(7), index=pd.DatetimeIndex([
... '2018-10-28 01:30:00',
... '2018-10-28 02:00:00',
... '2018-10-28 02:30:00',
... '2018-10-28 02:00:00',
... '2018-10-28 02:30:00',
... '2018-10-28 03:00:00',
... '2018-10-28 03:30:00']))
>>> s.tz_localize('CET', ambiguous='infer')
2018-10-28 01:30:00+02:00    0
2018-10-28 02:00:00+02:00    1
2018-10-28 02:30:00+02:00    2
2018-10-28 02:00:00+01:00    3
2018-10-28 02:30:00+01:00    4
2018-10-28 03:00:00+01:00    5
2018-10-28 03:30:00+01:00    6
dtype: int64

In some cases, inferring the DST is impossible. In such cases, you can
pass an ndarray to the ambiguous parameter to set the DST explicitly

>>> s = pd.Series(range(3), index=pd.DatetimeIndex([
... '2018-10-28 01:20:00',
... '2018-10-28 02:36:00',
... '2018-10-28 03:46:00']))
>>> s.tz_localize('CET', ambiguous=np.array([True, True, False]))
2018-10-28 01:20:00+02:00    0
2018-10-28 02:36:00+02:00    1
2018-10-28 03:46:00+01:00    2
dtype: int64

If the DST transition causes nonexistent times, you can shift these
dates forward or backwards with a timedelta object or `'shift_forward'`
or `'shift_backwards'`.
>>> s = pd.Series(range(2), index=pd.DatetimeIndex([
... '2015-03-29 02:30:00',
... '2015-03-29 03:30:00']))
>>> s.tz_localize('Europe/Warsaw', nonexistent='shift_forward')
2015-03-29 03:00:00+02:00    0
2015-03-29 03:30:00+02:00    1
dtype: int64
>>> s.tz_localize('Europe/Warsaw', nonexistent='shift_backward')
2015-03-29 01:59:59.999999999+01:00    0
2015-03-29 03:30:00+02:00              1
dtype: int64
>>> s.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1H'))
2015-03-29 03:30:00+02:00    0
2015-03-29 03:30:00+02:00    1
dtype: int64