{"id":13468078,"url":"https://github.com/SethMMorton/natsort","last_synced_at":"2025-03-26T03:31:31.879Z","repository":{"id":3178316,"uuid":"4209988","full_name":"SethMMorton/natsort","owner":"SethMMorton","description":"Simple yet flexible natural sorting in Python.","archived":false,"fork":false,"pushed_at":"2024-10-14T05:16:48.000Z","size":1461,"stargazers_count":906,"open_issues_count":3,"forks_count":51,"subscribers_count":15,"default_branch":"main","last_synced_at":"2024-10-29T21:59:23.817Z","etag":null,"topics":["natsort","natural-sort","python","sorting","sorting-interface"],"latest_commit_sha":null,"homepage":"https://pypi.org/project/natsort/","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/SethMMorton.png","metadata":{"files":{"readme":"README.rst","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2012-05-03T02:58:47.000Z","updated_at":"2024-10-21T02:27:19.000Z","dependencies_parsed_at":"2024-03-04T18:12:01.945Z","dependency_job_id":"1ff8e83f-ceca-40d1-b104-cdefadec5519","html_url":"https://github.com/SethMMorton/natsort","commit_stats":{"total_commits":891,"total_committers":21,"mean_commits":42.42857142857143,"dds":0.0785634118967452,"last_synced_commit":"51b2fd3b581b35b5f07b0ad58631ced7e20d0276"},"previous_names":[],"tags_count":62,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SethMMorton%2Fnatsort","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SethMMorton%2Fnatsort/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SethMMorton%2Fnatsort/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SethMMorton%2Fnatsort/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/SethMMorton","download_url":"https://codeload.github.com/SethMMorton/natsort/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":245584928,"owners_count":20639646,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["natsort","natural-sort","python","sorting","sorting-interface"],"created_at":"2024-07-31T15:01:05.174Z","updated_at":"2025-03-26T03:31:31.860Z","avatar_url":"https://github.com/SethMMorton.png","language":"Python","readme":"natsort\n=======\n\n.. image:: https://img.shields.io/pypi/v/natsort.svg\n    :target: https://pypi.org/project/natsort/\n\n.. image:: https://img.shields.io/pypi/pyversions/natsort.svg\n    :target: https://pypi.org/project/natsort/\n\n.. image:: https://img.shields.io/pypi/l/natsort.svg\n    :target: https://github.com/SethMMorton/natsort/blob/main/LICENSE\n\n.. image:: https://github.com/SethMMorton/natsort/workflows/Tests/badge.svg\n    :target: https://github.com/SethMMorton/natsort/actions\n\n.. image:: https://codecov.io/gh/SethMMorton/natsort/branch/main/graph/badge.svg\n    :target: https://codecov.io/gh/SethMMorton/natsort\n\n.. image:: https://img.shields.io/pypi/dw/natsort.svg\n    :target: https://pypi.org/project/natsort/\n\nSimple yet flexible natural sorting in Python.\n\n    - Source Code: https://github.com/SethMMorton/natsort\n    - Downloads: https://pypi.org/project/natsort/\n    - Documentation: https://natsort.readthedocs.io/\n\n      - `Examples and Recipes`_\n      - `How Does Natsort Work?`_\n      - `API`_\n\n    - `Quick Description`_\n    - `Quick Examples`_\n    - `FAQ`_\n    - `Requirements`_\n    - `Optional Dependencies`_\n    - `Installation`_\n    - `How to Run Tests`_\n    - `How to Build Documentation`_\n    - `Dropped Deprecated APIs`_\n    - `History`_\n\n**NOTE**: Please see the `Dropped Deprecated APIs`_ section for changes.\n\nQuick Description\n-----------------\n\nWhen you try to sort a list of strings that contain numbers, the normal python\nsort algorithm sorts lexicographically, so you might not get the results that\nyou expect:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['2 ft 7 in', '1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '7 ft 6 in']\n    \u003e\u003e\u003e sorted(a)\n    ['1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '2 ft 7 in', '7 ft 6 in']\n\nNotice that it has the order ('1', '10', '2') - this is because the list is\nbeing sorted in lexicographical order, which sorts numbers like you would\nletters (i.e. 'b', 'ba', 'c').\n\n`natsort`_ provides a function `natsorted()`_ that helps sort lists\n\"naturally\" (\"naturally\" is rather ill-defined, but in general it means\nsorting based on meaning and not computer code point).\nUsing `natsorted()`_ is simple:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e from natsort import natsorted\n    \u003e\u003e\u003e a = ['2 ft 7 in', '1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '7 ft 6 in']\n    \u003e\u003e\u003e natsorted(a)\n    ['1 ft 5 in', '2 ft 7 in', '2 ft 11 in', '7 ft 6 in', '10 ft 2 in']\n\n`natsorted()`_ identifies numbers anywhere in a string and sorts them\nnaturally. Below are some other things you can do with `natsort`_\n(also see the `Examples and Recipes`_ for a quick start guide, or the\n`API`_ for complete details).\n\n**Note**: `natsorted()`_ is designed to be a drop-in replacement for the\nbuilt-in `sorted()`_ function. Like `sorted()`_, `natsorted()`_\n`does not sort in-place`. To sort a list and assign the output to the same\nvariable, you must explicitly assign the output to a variable:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['2 ft 7 in', '1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '7 ft 6 in']\n    \u003e\u003e\u003e natsorted(a)\n    ['1 ft 5 in', '2 ft 7 in', '2 ft 11 in', '7 ft 6 in', '10 ft 2 in']\n    \u003e\u003e\u003e print(a)  # 'a' was not sorted; \"natsorted\" simply returned a sorted list\n    ['2 ft 7 in', '1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '7 ft 6 in']\n    \u003e\u003e\u003e a = natsorted(a)  # Now 'a' will be sorted because the sorted list was assigned to 'a'\n    \u003e\u003e\u003e print(a)\n    ['1 ft 5 in', '2 ft 7 in', '2 ft 11 in', '7 ft 6 in', '10 ft 2 in']\n\nPlease see `Generating a Reusable Sorting Key and Sorting In-Place`_ for\nan alternate way to sort in-place naturally.\n\nQuick Examples\n--------------\n\n- `Sorting Versions`_\n- `Sort Paths Like My File Browser (e.g. Windows Explorer on Windows)`_\n- `Sorting by Real Numbers (i.e. Signed Floats)`_\n- `Locale-Aware Sorting (or \"Human Sorting\")`_\n- `Further Customizing Natsort`_\n- `Sorting Mixed Types`_\n- `Handling Bytes`_\n- `Generating a Reusable Sorting Key and Sorting In-Place`_\n- `Other Useful Things`_\n\nSorting Versions\n++++++++++++++++\n\n`natsort`_ does not actually *comprehend* version numbers.\nIt just so happens that the most common versioning schemes are designed to\nwork with standard natural sorting techniques; these schemes include\n``MAJOR.MINOR``, ``MAJOR.MINOR.PATCH``, ``YEAR.MONTH.DAY``. If your data\nconforms to a scheme like this, then it will work out-of-the-box with\n`natsorted()`_ (as of `natsort`_ version \u003e= 4.0.0):\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['version-1.9', 'version-2.0', 'version-1.11', 'version-1.10']\n    \u003e\u003e\u003e natsorted(a)\n    ['version-1.9', 'version-1.10', 'version-1.11', 'version-2.0']\n\nIf you need to versions that use a more complicated scheme, please see\n`these version sorting examples`_.\n\nSort Paths Like My File Browser (e.g. Windows Explorer on Windows)\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\nPrior to `natsort`_ version 7.1.0, it was a common request to be able to\nsort paths like Windows Explorer. As of `natsort`_ 7.1.0, the function\n`os_sorted()`_ has been added to provide users the ability to sort\nin the order that their file browser might sort (e.g Windows Explorer on\nWindows, Finder on MacOS, Dolphin/Nautilus/Thunar/etc. on Linux).\n\n.. code-block:: python\n\n    import os\n    from natsort import os_sorted\n    print(os_sorted(os.listdir()))\n    # The directory sorted like your file browser might show\n\nOutput will be different depending on the operating system you are on.\n\nFor users **not** on Windows (e.g. MacOS/Linux) it is **strongly** recommended\nto also install `PyICU`_, which will help\n`natsort`_ give results that match most file browsers. If this is not installed,\nit will fall back on Python's built-in `locale`_ module and will give good\nresults for most input, but will give poor results for special characters.\n\nSorting by Real Numbers (i.e. Signed Floats)\n++++++++++++++++++++++++++++++++++++++++++++\n\nThis is useful in scientific data analysis (and was the default behavior\nof `natsorted()`_ for `natsort`_ version \u003c 4.0.0). Use the `realsorted()`_\nfunction:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e from natsort import realsorted, ns\n    \u003e\u003e\u003e # Note that when interpreting as signed floats, the below numbers are\n    \u003e\u003e\u003e #            +5.10,                -3.00,            +5.30,              +2.00\n    \u003e\u003e\u003e a = ['position5.10.data', 'position-3.data', 'position5.3.data', 'position2.data']\n    \u003e\u003e\u003e natsorted(a)\n    ['position2.data', 'position5.3.data', 'position5.10.data', 'position-3.data']\n    \u003e\u003e\u003e natsorted(a, alg=ns.REAL)\n    ['position-3.data', 'position2.data', 'position5.10.data', 'position5.3.data']\n    \u003e\u003e\u003e realsorted(a)  # shortcut for natsorted with alg=ns.REAL\n    ['position-3.data', 'position2.data', 'position5.10.data', 'position5.3.data']\n\nLocale-Aware Sorting (or \"Human Sorting\")\n+++++++++++++++++++++++++++++++++++++++++\n\nThis is where the non-numeric characters are also ordered based on their\nmeaning, not on their ordinal value, and a locale-dependent thousands\nseparator and decimal separator is accounted for in the number.\nThis can be achieved with the `humansorted()`_ function:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['Apple', 'apple15', 'Banana', 'apple14,689', 'banana']\n    \u003e\u003e\u003e natsorted(a)\n    ['Apple', 'Banana', 'apple14,689', 'apple15', 'banana']\n    \u003e\u003e\u003e import locale\n    \u003e\u003e\u003e locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')\n    'en_US.UTF-8'\n    \u003e\u003e\u003e natsorted(a, alg=ns.LOCALE)\n    ['apple15', 'apple14,689', 'Apple', 'banana', 'Banana']\n    \u003e\u003e\u003e from natsort import humansorted\n    \u003e\u003e\u003e humansorted(a)  # shortcut for natsorted with alg=ns.LOCALE\n    ['apple15', 'apple14,689', 'Apple', 'banana', 'Banana']\n\nYou may find you need to explicitly set the locale to get this to work\n(as shown in the example). Please see `locale issues`_ and the\n`Optional Dependencies`_ section below before using the `humansorted()`_ function.\n\nFurther Customizing Natsort\n+++++++++++++++++++++++++++\n\nIf you need to combine multiple algorithm modifiers (such as ``ns.REAL``,\n``ns.LOCALE``, and ``ns.IGNORECASE``), you can combine the options using the\nbitwise OR operator (``|``). For example,\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['Apple', 'apple15', 'Banana', 'apple14,689', 'banana']\n    \u003e\u003e\u003e natsorted(a, alg=ns.REAL | ns.LOCALE | ns.IGNORECASE)\n    ['Apple', 'apple15', 'apple14,689', 'Banana', 'banana']\n    \u003e\u003e\u003e # The ns enum provides long and short forms for each option.\n    \u003e\u003e\u003e ns.LOCALE == ns.L\n    True\n    \u003e\u003e\u003e # You can also customize the convenience functions, too.\n    \u003e\u003e\u003e natsorted(a, alg=ns.REAL | ns.LOCALE | ns.IGNORECASE) == realsorted(a, alg=ns.L | ns.IC)\n    True\n    \u003e\u003e\u003e natsorted(a, alg=ns.REAL | ns.LOCALE | ns.IGNORECASE) == humansorted(a, alg=ns.R | ns.IC)\n    True\n\nAll of the available customizations can be found in the documentation for\n`the ns enum`_.\n\nYou can also add your own custom transformation functions with the ``key``\nargument. These can be used with ``alg`` if you wish.\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['apple2.50', '2.3apple']\n    \u003e\u003e\u003e natsorted(a, key=lambda x: x.replace('apple', ''), alg=ns.REAL)\n    ['2.3apple', 'apple2.50']\n\nSorting Mixed Types\n+++++++++++++++++++\n\nYou can mix and match `int`_, `float`_, and `str`_ types when you sort:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e a = ['4.5', 6, 2.0, '5', 'a']\n    \u003e\u003e\u003e natsorted(a)\n    [2.0, '4.5', '5', 6, 'a']\n    \u003e\u003e\u003e # sorted(a) would raise an \"unorderable types\" TypeError\n\nHandling Bytes\n++++++++++++++\n\n`natsort`_ does not officially support the `bytes`_ type, but\nconvenience functions are provided that help you decode to `str`_ first:\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e from natsort import as_utf8\n    \u003e\u003e\u003e a = [b'a', 14.0, 'b']\n    \u003e\u003e\u003e # natsorted(a) would raise a TypeError (bytes() \u003c str())\n    \u003e\u003e\u003e natsorted(a, key=as_utf8) == [14.0, b'a', 'b']\n    True\n    \u003e\u003e\u003e a = [b'a56', b'a5', b'a6', b'a40']\n    \u003e\u003e\u003e # natsorted(a) would return the same results as sorted(a)\n    \u003e\u003e\u003e natsorted(a, key=as_utf8) == [b'a5', b'a6', b'a40', b'a56']\n    True\n\nGenerating a Reusable Sorting Key and Sorting In-Place\n++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\nUnder the hood, `natsorted()`_ works by generating a custom sorting\nkey using `natsort_keygen()`_ and then passes that to the built-in\n`sorted()`_. You can use the `natsort_keygen()`_ function yourself to\ngenerate a custom sorting key to sort in-place using the `list.sort()`_\nmethod.\n\n.. code-block:: pycon\n\n    \u003e\u003e\u003e from natsort import natsort_keygen\n    \u003e\u003e\u003e natsort_key = natsort_keygen()\n    \u003e\u003e\u003e a = ['2 ft 7 in', '1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '7 ft 6 in']\n    \u003e\u003e\u003e natsorted(a) == sorted(a, key=natsort_key)\n    True\n    \u003e\u003e\u003e a.sort(key=natsort_key)\n    \u003e\u003e\u003e a\n    ['1 ft 5 in', '2 ft 7 in', '2 ft 11 in', '7 ft 6 in', '10 ft 2 in']\n\nAll of the algorithm customizations mentioned in the\n`Further Customizing Natsort`_ section can also be applied to\n`natsort_keygen()`_ through the *alg* keyword option.\n\nOther Useful Things\n+++++++++++++++++++\n\n - recursively descend into lists of lists\n - automatic unicode normalization of input data\n - `controlling the case-sensitivity`_\n - `sorting file paths correctly`_\n - `allow custom sorting keys`_\n - `accounting for units`_\n\nFAQ\n---\n\nHow do I debug `natsorted()`_?\n    The best way to debug `natsorted()`_ is to generate a key using `natsort_keygen()`_\n    with the same options being passed to `natsorted()`_. One can take a look at\n    exactly what is being done with their input using this key - it is highly\n    recommended to `look at this issue describing how to debug`_ for *how* to debug,\n    and also to review the `How Does Natsort Work?`_ page for *why* `natsort`_ is\n    doing that to your data.\n\n    If you are trying to sort custom classes and running into trouble, please\n    take a look at https://github.com/SethMMorton/natsort/issues/60. In short,\n    custom classes are not likely to be sorted correctly if one relies\n    on the behavior of ``__lt__`` and the other rich comparison operators in\n    their custom class - it is better to use a ``key`` function with\n    `natsort`_, or use the `natsort`_ key as part of your rich comparison\n    operator definition.\n\n`natsort`_ gave me results I didn't expect, and it's a terrible library!\n    Did you try to debug using the above advice? If so, and you still cannot figure out\n    the error, then please `file an issue`_.\n\nHow *does* `natsort`_ work?\n    If you don't want to read `How Does Natsort Work?`_,\n    here is a quick primer.\n\n    `natsort`_ provides a `key function`_ that can be passed to `list.sort()`_\n    or `sorted()`_ in order to modify the default sorting behavior. This key\n    is generated on-demand with the key generator `natsort_keygen()`_.\n    `natsorted()`_ is essentially a wrapper for the following code:\n\n    .. code-block:: pycon\n\n        \u003e\u003e\u003e from natsort import natsort_keygen\n        \u003e\u003e\u003e natsort_key = natsort_keygen()\n        \u003e\u003e\u003e sorted(['1', '10', '2'], key=natsort_key)\n        ['1', '2', '10']\n\n    Users can further customize `natsort`_ sorting behavior with the ``key``\n    and/or ``alg`` options (see details in the `Further Customizing Natsort`_\n    section).\n\n    The key generated by `natsort_keygen()`_ *always* returns a `tuple`_. It\n    does so in the following way (*some details omitted for clarity*):\n\n      1. Assume the input is a string, and attempt to split it into numbers and\n         non-numbers using regular expressions. Numbers are then converted into\n         either `int`_ or `float`_.\n      2. If the above fails because the input is not a string, assume the input\n         is some other sequence (e.g. `list`_ or `tuple`_), and recursively\n         apply the key to each element of the sequence.\n      3. If the above fails because the input is not iterable, assume the input\n         is an `int`_ or `float`_, and just return the input in a `tuple`_.\n\n    Because a `tuple`_ is always returned, a `TypeError`_ should not be common\n    unless one tries to do something odd like sort an `int`_ against a `list`_.\n\nShell script\n------------\n\n`natsort`_ comes with a shell script called `natsort`_, or can also be called\nfrom the command line with ``python -m natsort``.  Check out the\n`shell script wiki documentation`_ for more details.\n\nRequirements\n------------\n\n`natsort`_ requires Python 3.8 or greater.\n\nOptional Dependencies\n---------------------\n\nfastnumbers\n+++++++++++\n\nThe most efficient sorting can occur if you install the\n`fastnumbers`_ package\n(version \u003e=2.0.0); it helps with the string to number conversions.\n`natsort`_ will still run (efficiently) without the package, but if you need\nto squeeze out that extra juice it is recommended you include this as a\ndependency. `natsort`_ will not require (or check) that\n`fastnumbers`_ is installed at installation.\n\nPyICU\n+++++\n\nIt is recommended that you install `PyICU`_ if you wish to sort in a\nlocale-dependent manner, see this page on `locale issues`_ for an explanation why.\n\nInstallation\n------------\n\nUse ``pip``!\n\n.. code-block:: console\n\n    $ pip install natsort\n\nIf you want to install the `Optional Dependencies`_, you can use the\n`\"extras\" notation`_ at installation time to install those dependencies as\nwell - use ``fast`` for `fastnumbers`_ and ``icu`` for `PyICU`_.\n\n.. code-block:: console\n\n    # Install both optional dependencies.\n    $ pip install natsort[fast,icu]\n    # Install just fastnumbers\n    $ pip install natsort[fast]\n\nHow to Run Tests\n----------------\n\nPlease note that `natsort`_ is NOT set-up to support ``python setup.py test``.\n\nThe recommended way to run tests is with `tox`_. After installing ``tox``,\nrunning tests is as simple as executing the following in the `natsort`_ directory:\n\n.. code-block:: console\n\n    $ tox\n\n``tox`` will create virtual a virtual environment for your tests and install\nall the needed testing requirements for you.  You can specify a particular\npython version with the ``-e`` flag, e.g. ``tox -e py36``. Static analysis\nis done with ``tox -e flake8``. You can see all available testing environments\nwith ``tox --listenvs``.\n\nHow to Build Documentation\n--------------------------\n\nIf you want to build the documentation for `natsort`_, it is recommended to\nuse ``tox``:\n\n.. code-block:: console\n\n    $ tox -e docs\n\nThis will place the documentation in ``build/sphinx/html``.\n\nDropped Deprecated APIs\n-----------------------\n\nIn `natsort`_ version 6.0.0, the following APIs and functions were removed\n\n - ``number_type`` keyword argument (deprecated since 3.4.0)\n - ``signed`` keyword argument (deprecated since 3.4.0)\n - ``exp`` keyword argument (deprecated since 3.4.0)\n - ``as_path`` keyword argument (deprecated since 3.4.0)\n - ``py3_safe`` keyword argument (deprecated since 3.4.0)\n - ``ns.TYPESAFE`` (deprecated since version 5.0.0)\n - ``ns.DIGIT`` (deprecated since version 5.0.0)\n - ``ns.VERSION`` (deprecated since version 5.0.0)\n - ``versorted()`` (discouraged since version 4.0.0,\n   officially deprecated since version 5.5.0)\n - ``index_versorted()`` (discouraged since version 4.0.0,\n   officially deprecated since version 5.5.0)\n\nIn general, if you want to determine if you are using deprecated APIs you\ncan run your code with the following flag\n\n.. code-block:: console\n\n    $ python -Wdefault::DeprecationWarning my-code.py\n\nBy default `DeprecationWarnings`_ are not shown, but this will cause them\nto be shown. Alternatively, you can just set the environment variable\n``PYTHONWARNINGS`` to \"default::DeprecationWarning\" and then run your code.\n\nAuthor\n------\n\nSeth M. Morton\n\nHistory\n-------\n\nPlease visit the changelog `on GitHub`_.\n\n.. _natsort: https://natsort.readthedocs.io/en/stable/index.html\n.. _natsorted(): https://natsort.readthedocs.io/en/stable/api.html#natsort.natsorted\n.. _natsort_keygen(): https://natsort.readthedocs.io/en/stable/api.html#natsort.natsort_keygen\n.. _realsorted(): https://natsort.readthedocs.io/en/stable/api.html#natsort.realsorted\n.. _humansorted(): https://natsort.readthedocs.io/en/stable/api.html#natsort.humansorted\n.. _os_sorted(): https://natsort.readthedocs.io/en/stable/api.html#natsort.os_sorted\n.. _the ns enum: https://natsort.readthedocs.io/en/stable/api.html#natsort.ns\n.. _fastnumbers: https://github.com/SethMMorton/fastnumbers\n.. _sorted(): https://docs.python.org/3/library/functions.html#sorted\n.. _list.sort(): https://docs.python.org/3/library/stdtypes.html#list.sort\n.. _key function: https://docs.python.org/3/howto/sorting.html#key-functions\n.. _locale: https://docs.python.org/3/library/locale.html\n.. _int: https://docs.python.org/3/library/functions.html#int\n.. _float: https://docs.python.org/3/library/functions.html#float\n.. _str: https://docs.python.org/3/library/stdtypes.html#str\n.. _bytes: https://docs.python.org/3/library/stdtypes.html#bytes\n.. _list: https://docs.python.org/3/library/stdtypes.html#list\n.. _tuple: https://docs.python.org/3/library/stdtypes.html#tuple\n.. _TypeError: https://docs.python.org/3/library/exceptions.html#TypeError\n.. _DeprecationWarnings: https://docs.python.org/3/library/exceptions.html#DeprecationWarning\n.. _\"extras\" notation: https://packaging.python.org/tutorials/installing-packages/#installing-setuptools-extras\n.. _PyICU: https://pypi.org/project/PyICU\n.. _tox: https://tox.readthedocs.io/en/latest/\n.. _Examples and Recipes: https://github.com/SethMMorton/natsort/wiki/Examples-and-Recipes\n.. _How Does Natsort Work?: https://github.com/SethMMorton/natsort/wiki/How-Does-Natsort-Work%3F\n.. _API: https://natsort.readthedocs.io/en/stable/api.html\n.. _on GitHub: https://github.com/SethMMorton/natsort/blob/main/CHANGELOG.md\n.. _file an issue: https://github.com/SethMMorton/natsort/issues/new\n.. _look at this issue describing how to debug: https://github.com/SethMMorton/natsort/issues/13#issuecomment-50422375\n.. _controlling the case-sensitivity: https://github.com/SethMMorton/natsort/wiki/Examples-and-Recipes#controlling-case-when-sorting\n.. _sorting file paths correctly: https://github.com/SethMMorton/natsort/wiki/Examples-and-Recipes#sort-os-generated-paths\n.. _allow custom sorting keys: https://github.com/SethMMorton/natsort/wiki/Examples-and-Recipes#using-a-custom-sorting-key\n.. _accounting for units: https://github.com/SethMMorton/natsort/wiki/Examples-and-Recipes#accounting-for-units-when-sorting\n.. _these version sorting examples: https://github.com/SethMMorton/natsort/wiki/Examples-and-Recipes#sorting-more-expressive-versioning-schemes\n.. _locale issues: https://github.com/SethMMorton/natsort/wiki/Possible-Issues-with-natsort.humansorted-or-ns.LOCALE\n.. _shell script wiki documentation: https://github.com/SethMMorton/natsort/wiki/Shell-Script","funding_links":[],"categories":["Python","General Utilities"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FSethMMorton%2Fnatsort","html_url":"https://awesome.ecosyste.ms/projects/github.com%2FSethMMorton%2Fnatsort","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FSethMMorton%2Fnatsort/lists"}