Summary  
This chapter covers how to sort arrays using NumPy’s `sort()` function versus the `ndarray.sort()` method—highlighting the difference between returning a new sorted copy and modifying in place—and shows how to obtain ascending and descending order (via slicing).  

General domain of usage  
Analyzing employee salary data

**Ordenar** significa organizar los elementos de un array en un cierto orden.

Definición

Esta operación es sumamente útil ya que la búsqueda en un **array ordenado** es mucho más rápida porque algoritmos eficientes como la **búsqueda binaria** solo funcionan con arrays ordenados.

Watch this video for a step-by-step explanation of sorting arrays in NumPy. You'll learn how to use both the `numpy.sort()` function and the `.sort()` method, see how to sort arrays in ascending and descending order, and understand the difference between sorting functions and methods. Real-world examples, such as sorting employee salaries, will help you master these essential array manipulation techniques.

## Función numpy.sort()

**NumPy** tiene una función incorporada `sort()` para ordenar elementos por valores en orden ascendente. El valor de retorno de esta función es un array de **NumPy** ordenado. Su sintaxis general es: `numpy.sort(a, axis=-1, kind=None, order=None)`, donde:
* `a` es un array;
* `axis` es el eje a lo largo del cual ordenar (último eje (`-1`) por defecto);
* `kind` es el algoritmo de ordenamiento a utilizar (`quicksort` por defecto).

import numpy as np
array_1d = np.array([10, 2, 5, 1, 6, 5])
print(np.sort(array_1d))

## Método ndarray.sort()

Como ya se mencionó, la función `numpy.sort()` devuelve un array ordenado pero no modifica el array **original**. Si se desea modificar el array, se debe escribir `array = np.sort(array)`.

Sin embargo, **NumPy** proporciona un método `.sort()` como alternativa, que ordena el array **en el lugar** y no devuelve un nuevo array (devuelve `None`, es decir, no retorna nada). Su sintaxis es similar a la función `sort()`.

Una **función** es un bloque de código independiente que realiza una tarea específica y puede ser llamada directamente. Un **método** es una función que está asociada a un objeto y se llama sobre ese objeto, utilizando el operador `.`.

Nota

import numpy as np
array_1d = np.array([10, 2, 5, 1, 6, 5])
# Calling the .sort() method 
array_1d.sort()
print(array_1d)

Después de llamar al método `.sort()`, `array_1d` fue ordenado **en el lugar** y ahora contiene los elementos ordenados en **orden ascendente**.


## Ordenar arreglos 1D en orden descendente

A veces se puede necesitar ordenar un arreglo en **orden descendente**. Ni el método `.sort()` ni la función `sort()` admiten esta funcionalidad directamente. Sin embargo, se puede utilizar **slicing** con `step` igual a `-1` sobre un arreglo ordenado:

import numpy as np
array_1d = np.array([10, 2, 5, 1, 6, 5])
# Sorting array_1d in descending order
array_1d = np.sort(array_1d)[::-1]
print(array_1d)

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style formatted output"""
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        # Очікувані результати
        cls.salaries = np.array([45000, 38000, 52000, 47000, 43000, 39000])
        cls.expected_sorted = np.sort(cls.salaries)[::-1]  # спадний порядок
        cls.expected_top3 = cls.expected_sorted[:3]

    def test_sorted_salaries(self):
        """1. salaries sorted in descending order"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "sorted_salaries")
        arr = getattr(module, "sorted_salaries", None)
        type_ok = isinstance(arr, np.ndarray)
        val_ok = type_ok and np.array_equal(arr, self.expected_sorted)
        order_ok = type_ok and np.all(np.diff(arr) <= 0)

        _dynamic_test(
            self,
            ok and type_ok and val_ok and order_ok,
            "salaries sorted in descending order correctly",
            "salaries not sorted correctly in descending order",
        )

    def test_print_top3(self):
        """2. top 3 salaries printed using positive end slice"""
        # Перехоплюємо stdout
        f = io.StringIO()
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        with redirect_stdout(f):
            spec.loader.exec_module(module)
        output = f.getvalue().strip()

        # Перевірка, що всі 3 найбільші зарплати є у виводі
        expected_values = [str(x) for x in self.expected_top3]
        contains_all = all(val in output for val in expected_values)

        # Перевірка, що не виведено більше трьох
        contains_extra = any(str(x) in output for x in self.expected_sorted[3:])

        _dynamic_test(
            self,
            contains_all and not contains_extra,
            "top 3 salaries printed correctly",
            "top 3 salaries print incorrect or extra values included",
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Desbloquea todo el potencial de la biblioteca más esencial de Python para el cálculo numérico, NumPy. Este curso integral está diseñado para llevarte desde un nivel principiante hasta un nivel avanzado de competencia en NumPy. Ya seas científico de datos, ingeniero, investigador o desarrollador, dominar NumPy es fundamental para la manipulación eficiente de datos, el cálculo científico y el aprendizaje automático.

Explora las aplicaciones de NumPy y comprende por qué es una de las bibliotecas más populares para el cálculo numérico. Aprende las diferentes formas de crear e inicializar arreglos para manejar diversas necesidades de datos de manera eficiente.

Descubre cómo acceder a elementos específicos y subconjuntos en arreglos de NumPy utilizando la notación de índices. Aprende a aplicar indexación condicional para filtrar datos y gestionar valores faltantes de manera eficiente.

NumPy ofrece muchas funciones integradas para realizar operaciones comunes con arreglos. Aprenda cómo aplicar estas herramientas para transformar, agregar y analizar datos de manera eficiente sin escribir código repetitivo.

Aprende a realizar operaciones matemáticas de manera eficiente en arreglos de NumPy. Aplica estas operaciones para resolver problemas del mundo real y adquiere una comprensión más profunda de cómo los cálculos vectorizados aceleran el análisis numérico.

Ordenar Arreglos

Función numpy.sort()

Método ndarray.sort()

Ordenar arreglos 1D en orden descendente

Solución