Revert spelling changes

Author: FabioRosado

doc/source/10min.rst

@@ -663,7 +663,7 @@ Convert the raw grades to a categorical data type.
     df["grade"]
 
 Rename the categories to more meaningful names (assigning to 
-``Series.cat.categories`` is in place!).
+``Series.cat.categories`` is inplace!).
 
 .. ipython:: python
 

doc/source/advanced.rst

@@ -182,7 +182,7 @@ For example:
    df[['foo','qux']].columns  # sliced
 
 This is done to avoid a recomputation of the levels in order to make slicing
-highly efficient. If you want to see only the used levels, you can use the
+highly performant. If you want to see only the used levels, you can use the
 :func:`MultiIndex.get_level_values` method.
 
 .. ipython:: python
@@ -342,7 +342,7 @@ As usual, **both sides** of the slicers are included as this is label indexing.
                        columns=micolumns).sort_index().sort_index(axis=1)
    dfmi
 
-Basic multi-index slicing using slices, lists, and labels.
+Basic MultiIndex slicing using slices, lists, and labels.
 
 .. ipython:: python
 
@@ -559,7 +559,7 @@ return a copy of the data rather than a view:
 
 .. _advanced.unsorted:
 
-Furthermore if you try to index something that is not fully lex-sorted, this can raise:
+Furthermore if you try to index something that is not fully lexsorted, this can raise:
 
 .. code-block:: ipython
 
@@ -593,7 +593,7 @@ Take Methods
 
 Similar to NumPy ndarrays, pandas Index, Series, and DataFrame also provides
 the ``take`` method that retrieves elements along a given axis at the given
-indexes. The given indices must be either a list or an ndarray of integer
+indices. The given indices must be either a list or an ndarray of integer
 index positions. ``take`` will also accept negative integers as relative positions to the end of the object.
 
 .. ipython:: python

doc/source/categorical.rst

@@ -847,7 +847,7 @@ the categories being combined.
 
 By default, the resulting categories will be ordered as
 they appear in the data. If you want the categories to
-be lex-sorted, use ``sort_categories=True`` argument.
+be lexsorted, use ``sort_categories=True`` argument.
 
 .. ipython:: python
 

doc/source/cookbook.rst

@@ -307,7 +307,7 @@ MultiIndexing
 
 The :ref:`multindexing <advanced.hierarchical>` docs.
 
-`Creating a multi-index from a labeled frame
+`Creating a MultiIndex from a labeled frame
 <http://stackoverflow.com/questions/14916358/reshaping-dataframes-in-pandas-based-on-column-labels>`__
 
 .. ipython:: python
@@ -330,7 +330,7 @@ The :ref:`multindexing <advanced.hierarchical>` docs.
 Arithmetic
 **********
 
-`Performing arithmetic with a multi-index that needs broadcasting
+`Performing arithmetic with a MultiIndex that needs broadcasting
 <http://stackoverflow.com/questions/19501510/divide-entire-pandas-multiindex-dataframe-by-dataframe-variable/19502176#19502176>`__
 
 .. ipython:: python
@@ -342,7 +342,7 @@ Arithmetic
 Slicing
 *******
 
-`Slicing a multi-index with xs
+`Slicing a MultiIndex with xs
 <http://stackoverflow.com/questions/12590131/how-to-slice-multindex-columns-in-pandas-dataframes>`__
 
 .. ipython:: python
@@ -363,7 +363,7 @@ To take the cross section of the 1st level and 1st axis the index:
 
    df.xs('six',level=1,axis=0)
 
-`Slicing a multi-index with xs, method #2
+`Slicing a MultiIndex with xs, method #2
 <http://stackoverflow.com/questions/14964493/multiindex-based-indexing-in-pandas>`__
 
 .. ipython:: python
@@ -386,13 +386,13 @@ To take the cross section of the 1st level and 1st axis the index:
    df.loc[(All,'Math'),('Exams')]
    df.loc[(All,'Math'),(All,'II')]
 
-`Setting portions of a multi-index with xs
+`Setting portions of a MultiIndex with xs
 <http://stackoverflow.com/questions/19319432/pandas-selecting-a-lower-level-in-a-dataframe-to-do-a-ffill>`__
 
 Sorting
 *******
 
-`Sort by specific column or an ordered list of columns, with a multi-index
+`Sort by specific column or an ordered list of columns, with a MultiIndex
 <http://stackoverflow.com/questions/14733871/mutli-index-sorting-in-pandas>`__
 
 .. ipython:: python
@@ -677,7 +677,7 @@ To create year and month cross tabulation:
 Apply
 *****
 
-`Rolling Apply to Organize - Turning embedded lists into a multi-index frame
+`Rolling Apply to Organize - Turning embedded lists into a MultiIndex frame
 <http://stackoverflow.com/questions/17349981/converting-pandas-dataframe-with-categorical-values-into-binary-values>`__
 
 .. ipython:: python
@@ -1030,7 +1030,7 @@ Skip row between header and data
     """
 
 Option 1: pass rows explicitly to skip rows
-""""""""""""""""""""""""""""""""""""""""""
+"""""""""""""""""""""""""""""""""""""""""""
 
 .. ipython:: python
 

doc/source/groupby.rst

@@ -1332,7 +1332,7 @@ In order to resample to work on indexes that are non-datetimelike, the following
 
 In the following examples, **df.index // 5** returns a binary array which is used to determine what gets selected for the groupby operation.
 
-.. note:: The below example shows how we can down-sample by consolidation of samples into fewer samples. Here by using **df.index // 5**, we are aggregating the samples in bins. By applying **std()** function, we aggregate the information contained in many samples into a small subset of values which is their standard deviation thereby reducing the number of samples.
+.. note:: The below example shows how we can downsample by consolidation of samples into fewer samples. Here by using **df.index // 5**, we are aggregating the samples in bins. By applying **std()** function, we aggregate the information contained in many samples into a small subset of values which is their standard deviation thereby reducing the number of samples.
 
 .. ipython:: python
 

doc/source/io.rst

@@ -116,7 +116,7 @@ header : int or list of ints, default ``'infer'``
   existing names.
 
   The header can be a list of ints that specify row locations
-  for a multi-index on the columns e.g. ``[0,1,3]``. Intervening rows
+  for a MultiIndex on the columns e.g. ``[0,1,3]``. Intervening rows
   that are not specified will be skipped (e.g. 2 in this example is
   skipped). Note that this parameter ignores commented lines and empty
   lines if ``skip_blank_lines=True``, so header=0 denotes the first
@@ -953,7 +953,7 @@ datetime strings are all formatted the same way, you may get a large speed
 up by setting ``infer_datetime_format=True``.  If set, pandas will attempt
 to guess the format of your datetime strings, and then use a faster means
 of parsing the strings.  5-10x parsing speeds have been observed.  pandas
-will fall-back to the usual parsing if either the format cannot be guessed
+will fallback to the usual parsing if either the format cannot be guessed
 or the format that was guessed cannot properly parse the entire column
 of strings.  So in general, ``infer_datetime_format`` should not have any
 negative consequences if enabled.
@@ -1644,7 +1644,7 @@ over the string representation of the object. All arguments are optional:
     argument and returns a formatted string; to be applied to floats in the
     ``DataFrame``.
   - ``sparsify`` default True, set to False for a ``DataFrame`` with a hierarchical
-    index to print every multi-index key at each row.
+    index to print every MultiIndex key at each row.
   - ``index_names`` default True, will print the names of the indices
   - ``index`` default True, will print the index (ie, row labels)
   - ``header`` default True, will print the column labels
@@ -1812,7 +1812,7 @@ Writing to a file, with a date index and a date column:
    dfj2.to_json('test.json')
    open('test.json').read()
 
-Fall-back Behavior
+Fallback Behavior
 +++++++++++++++++
 
 If the JSON serializer cannot handle the container contents directly it will
@@ -2237,7 +2237,7 @@ A few notes on the generated table schema:
     name is ``values``
   + For ``DataFrames``, the stringified version of the column name is used
   + For ``Index`` (not ``MultiIndex``), ``index.name`` is used, with a
-    fall-back to ``index`` if that is None.
+    fallback to ``index`` if that is None.
   + For ``MultiIndex``, ``mi.names`` is used. If any level has no name,
     then ``level_<i>`` is used.
 
@@ -2246,7 +2246,7 @@ A few notes on the generated table schema:
 
 ``read_json`` also accepts ``orient='table'`` as an argument. This allows for
 the preservation of metadata such as dtypes and index names in a
-round-trip manner.
+round-trippable manner.
 
   .. ipython:: python
 
@@ -3467,7 +3467,7 @@ Fixed Format
 ''''''''''''
 
 The examples above show storing using ``put``, which write the HDF5 to ``PyTables`` in a fixed array format, called
-the ``fixed`` format. These types of stores are **not** able to be appended once written (though you can simply
+the ``fixed`` format. These types of stores are **not** appendable once written (though you can simply
 remove them and rewrite). Nor are they **queryable**; they must be
 retrieved in their entirety. They also do not support dataframes with non-unique column names.
 The ``fixed`` format stores offer very fast writing and slightly faster reading than ``table`` stores.
@@ -3820,7 +3820,7 @@ indexed dimension as the ``where``.
 
 .. note::
 
-   Indexes are auto-magically created on the indexables
+   Indexes are automagically created on the indexables
    and any data columns you specify. This behavior can be turned off by passing
    ``index=False`` to ``append``.
 
@@ -4629,7 +4629,7 @@ included in Python's standard library by default.
 You can find an overview of supported drivers for each SQL dialect in the
 `SQLAlchemy docs <http://docs.sqlalchemy.org/en/latest/dialects/index.html>`__.
 
-If SQLAlchemy is not installed, a fall-back is only provided for sqlite (and
+If SQLAlchemy is not installed, a fallback is only provided for sqlite (and
 for mysql for backwards compatibility, but this is deprecated and will be
 removed in a future version).
 This mode requires a Python database adapter which respect the `Python
@@ -4735,7 +4735,7 @@ SQL data type based on the dtype of the data. When you have columns of dtype
 You can always override the default type by specifying the desired SQL type of
 any of the columns by using the ``dtype`` argument. This argument needs a
 dictionary mapping column names to SQLAlchemy types (or strings for the sqlite3
-fall-back mode).
+fallback mode).
 For example, specifying to use the sqlalchemy ``String`` type instead of the
 default ``Text`` type for string columns:
 
@@ -4922,7 +4922,7 @@ You can combine SQLAlchemy expressions with parameters passed to :func:`read_sql
     pd.read_sql(expr, engine, params={'date': dt.datetime(2010, 10, 18)})
 
 
-Sqlite fall-back
+Sqlite fallback
 '''''''''''''''
 
 The use of sqlite is supported without using SQLAlchemy.

doc/source/merging.rst

@@ -895,7 +895,7 @@ The merged result:
 
 .. note::
 
-   Merging on ``category`` dtypes that are the same can be quite efficient compared to ``object`` dtype merging.
+   Merging on ``category`` dtypes that are the same can be quite performant compared to ``object`` dtype merging.
 
 .. _merging.join.index:
 

doc/source/missing_data.rst

@@ -25,7 +25,7 @@ pandas.
     for simplicity and performance reasons. It differs from the MaskedArray
     approach of, for example, :mod:`scikits.timeseries`. We are hopeful that
     NumPy will soon be able to provide a native NA type solution (similar to R)
-    efficient enough to be used in pandas.
+    performant enough to be used in pandas.
 
 See the :ref:`cookbook<cookbook.missing_data>` for some advanced strategies.
 

doc/source/spelling_wordlist.txt

@@ -2377,12 +2377,17 @@ serialisable
 lzo
 usepackage
 booktabs
+coereced
 rcl
 multicolumns
+gfc
+automagically
 fastparquet
 brotli
 sql
 nullable
+performant
+lexsorted
 tw
 latin
 StrL

doc/source/whatsnew/v0.17.0.txt

@@ -73,7 +73,7 @@ We are adding an implementation that natively supports datetime with timezones.
 *could* be assigned a datetime with timezones, and would work as an ``object`` dtype. This had performance issues with a large
 number rows. See the :ref:`docs <timeseries.timezone_series>` for more details. (:issue:`8260`, :issue:`10763`, :issue:`11034`).
 
-The new implementation allows for having a single-timezone across all rows, with operations in a efficient manner.
+The new implementation allows for having a single-timezone across all rows, with operations in a performant manner.
 
 .. ipython:: python
 

doc/source/whatsnew/v0.19.0.txt

@@ -1512,7 +1512,7 @@ Bug Fixes
 - Bug in ``.set_index`` raises ``AmbiguousTimeError`` if new index contains DST boundary and multi levels (:issue:`12920`)
 - Bug in ``.shift`` raises ``AmbiguousTimeError`` if data contains datetime near DST boundary (:issue:`13926`)
 - Bug in ``pd.read_hdf()`` returns incorrect result when a ``DataFrame`` with a ``categorical`` column and a query which doesn't match any values (:issue:`13792`)
-- Bug in ``.iloc`` when indexing with a non lex-sorted MultiIndex (:issue:`13797`)
+- Bug in ``.iloc`` when indexing with a non lexsorted MultiIndex (:issue:`13797`)
 - Bug in ``.loc`` when indexing with date strings in a reverse sorted ``DatetimeIndex`` (:issue:`14316`)
 - Bug in ``Series`` comparison operators when dealing with zero dim NumPy arrays (:issue:`13006`)
 - Bug in ``.combine_first`` may return incorrect ``dtype`` (:issue:`7630`, :issue:`10567`)

pandas/_libs/tslibs/ccalendar.pyx

@@ -18,7 +18,7 @@ from strptime import LocaleTime
 # ----------------------------------------------------------------------
 # Constants
 
-# Slightly more efficient cython lookups than a 2D table
+# Slightly more performant cython lookups than a 2D table
 # The first 12 entries correspond to month lengths for non-leap years.
 # The remaining 12 entries give month lengths for leap years
 cdef int32_t* days_per_month_array = [

pandas/_libs/tslibs/np_datetime.pyx

@@ -80,7 +80,7 @@ reverse_ops[Py_GE] = Py_LE
 
 cdef inline bint cmp_scalar(int64_t lhs, int64_t rhs, int op) except -1:
     """
-    cmp_scalar is a more efficient version of PyObject_RichCompare
+    cmp_scalar is a more performant version of PyObject_RichCompare
     typed for int64_t arguments.
     """
     if op == Py_EQ:

pandas/_libs/tslibs/resolution.pyx

@@ -346,7 +346,7 @@ class Resolution(object):
 # Frequency Inference
 
 
-# TODO: this is non efficient logic here (and duplicative) and this
+# TODO: this is non performant logic here (and duplicative) and this
 # simply should call unique_1d directly
 # plus no reason to depend on khash directly
 cdef unique_deltas(ndarray[int64_t] arr):

pandas/core/dtypes/cast.py

@@ -59,7 +59,7 @@ def is_nested_object(obj):
     return a boolean if we have a nested object, e.g. a Series with 1 or
     more Series elements
 
-    This may not be necessarily be efficient.
+    This may not be necessarily be performant.
 
     """
 

pandas/core/frame.py

@@ -4540,7 +4540,7 @@ def nlargest(self, n, columns, keep='first'):
 
         This method is equivalent to
         ``df.sort_values(columns, ascending=False).head(n)``, but more
-        efficient.
+        performant.
 
         Parameters
         ----------

pandas/core/indexes/frozen.py

@@ -129,7 +129,7 @@ def searchsorted(self, v, side='left', sorter=None):
         numpy.searchsorted : equivalent function
         """
 
-        # we are much more efficient if the searched
+        # we are much more performant if the searched
         # indexer is the same type as the array
         # this doesn't matter for int64, but DOES
         # matter for smaller int dtypes

pandas/core/indexes/multi.py

@@ -2141,7 +2141,7 @@ def slice_locs(self, start=None, end=None, step=None, kind=None):
 
         Notes
         -----
-        This method only works if the MultiIndex is properly lex-sorted. So,
+        This method only works if the MultiIndex is properly lexsorted. So,
         if only the first 2 levels of a 3-level MultiIndex are lexsorted,
         you can only pass two levels to ``.slice_locs``.
 

pandas/core/indexing.py

@@ -1801,7 +1801,7 @@ def _is_scalar_access(self, key):
         # this is a shortcut accessor to both .loc and .iloc
         # that provide the equivalent access of .at and .iat
         # a) avoid getting things via sections and (to minimize dtype changes)
-        # b) provide an efficient path
+        # b) provide a performant path
         if not hasattr(key, '__len__'):
             return False
 
@@ -1977,7 +1977,7 @@ def _is_scalar_access(self, key):
         # this is a shortcut accessor to both .loc and .iloc
         # that provide the equivalent access of .at and .iat
         # a) avoid getting things via sections and (to minimize dtype changes)
-        # b) provide an efficient path
+        # b) provide a performant path
         if not hasattr(key, '__len__'):
             return False
 

pandas/tests/groupby/test_categorical.py

@@ -379,7 +379,7 @@ def test_observed_codes_remap(observed):
 
 def test_observed_perf():
     # we create a cartesian product, so this is
-    # non-efficient if we don't use observed values
+    # non-performant if we don't use observed values
     # gh-14942
     df = DataFrame({
         'cat': np.random.randint(0, 255, size=30000),

pandas/tseries/offsets.py

@@ -1691,7 +1691,7 @@ class YearOffset(DateOffset):
 
     def _get_offset_day(self, other):
         # override BaseOffset method to use self.month instead of other.month
-        # TODO: there may be a more efficient way to do this
+        # TODO: there may be a more performant way to do this
         return liboffsets.get_day_of_month(other.replace(month=self.month),
                                            self._day_opt)