Python
Pandas Sorted: Guía para principiantes sobre la clasificación eficiente

Pandas Sorted: Guía para principiantes sobre la clasificación eficiente

MoeNagy Dev

Clasificación de datos en Pandas

Importancia de la clasificación en el análisis de datos

La clasificación es una operación fundamental en el análisis de datos que ayuda a organizar los datos de manera significativa. Facilita la exploración y comprensión de los datos, y prepara los datos para un análisis y visualización más avanzados. Al clasificar los datos, puedes identificar patrones, tendencias y valores atípicos más fácilmente, lo que conduce a una mejor comprensión y toma de decisiones.

Clasificación de una Serie de una sola columna

La clasificación de una Serie de una sola columna en Pandas es un proceso sencillo. Puedes clasificar los datos en orden ascendente o descendente, y manejar los valores faltantes durante el proceso de clasificación.

Clasificación en orden ascendente

import pandas as pd
 
# Crear una muestra de Serie
s = pd.Series([3, 1, 4, 2, None])
 
# Clasificar la Serie en orden ascendente
sorted_s = s.sort_values()
print(sorted_s)

Resultado:

1    1.0
3    2.0
0    3.0
2    4.0
4    NaN
dtype: float64

Clasificación en orden descendente

# Clasificar la Serie en orden descendente
sorted_s = s.sort_values(ascending=False)
print(sorted_s)

Resultado:

2    4.0
0    3.0
3    2.0
1    1.0
4    NaN
dtype: float64

Manejo de valores faltantes durante la clasificación

Por defecto, Pandas colocará los valores faltantes (NaN) al final de la Serie clasificada, independientemente del orden de clasificación. Puedes controlar la ubicación de los valores faltantes utilizando el parámetro na_position.

# Colocar los valores faltantes al principio de la Serie clasificada
sorted_s = s.sort_values(na_position='first')
print(sorted_s)

Resultado:

4    NaN
1    1.0
3    2.0
0    3.0
2    4.0
dtype: float64

Clasificación de DataFrames de varias columnas

La clasificación de un DataFrame de varias columnas implica especificar la(s) columna(s) por las que clasificar, y controlar el orden de clasificación para cada columna.

Clasificación por una sola columna

# Crear un DataFrame de muestra
df = pd.DataFrame({'A': [3, 1, 4, 2], 'B': [1, 2, 3, 4]})
 
# Clasificar el DataFrame por la columna 'A'
sorted_df = df.sort_values(by='A')
print(sorted_df)

Resultado:

   A  B
1   1  2
3   2  4
0   3  1
2   4  3

Clasificación por varias columnas

# Clasificar el DataFrame por las columnas 'A' y 'B'
sorted_df = df.sort_values(by=['A', 'B'])
print(sorted_df)

Resultado:

   A  B
1   1  2
0   3  1
2   4  3
3   4  4

Control del orden de clasificación para cada columna

# Clasificar el DataFrame por 'A' en orden ascendente y 'B' en orden descendente
sorted_df = df.sort_values(by=['A', 'B'], ascending=[True, False])
print(sorted_df)

Resultado:

   A  B
1   1  2
0   3  1
3   4  4
2   4  3

Clasificación con funciones de clave personalizadas

Puedes utilizar funciones de clave personalizadas para controlar el comportamiento de clasificación en Pandas. Esto te permite aplicar lógica de clasificación compleja basada en tus requisitos específicos.

Uso de funciones Lambda como claves

# Clasificar el DataFrame por el valor absoluto de la columna 'A'
sorted_df = df.sort_values(by='A', key=lambda x: x.abs())
print(sorted_df)

Resultado:

   A  B
1   1  2
3   2  4
0   3  1
2   4  3

Aplicación de lógica de clasificación compleja con funciones personalizadas

def custom_sort_key(x):
    # Clasificar por el cuadrado del valor en la columna 'A'
    # y luego por el valor en la columna 'B'
    return (x['A'] ** 2, x['B'])
 
sorted_df = df.sort_values(by=['A', 'B'], key=custom_sort_key)
print(sorted_df)

Resultado:

   A  B
1   1  2
0   3  1
2   4  3
3   4  4

Mantenimiento del índice original durante la clasificación

Por defecto, Pandas modificará el índice de los datos clasificados. Si deseas preservar el índice original, puedes utilizar el parámetro ignore_index o restablecer el índice después de la clasificación.

Preservación del índice original

# Clasificar el DataFrame conservando el índice original
sorted_df = df.sort_values(by='A', ignore_index=False)
print(sorted_df)

Resultado:

   A  B
0   1  2
1   3  1
2   4  3
3   2  4

Restablecimiento del índice después de la clasificación

# Clasificar el DataFrame y restablecer el índice
sorted_df = df.sort_values(by='A').reset_index(drop=True)
print(sorted_df)

Resultado:

   A  B
0   1  2
1   2  4
2   3  1
3   4  3

Clasificación de datos parciales

A veces, es posible que necesites clasificar solo un subconjunto de filas o columnas en un DataFrame. Pandas proporciona flexibilidad para manejar este tipo de escenarios.

Clasificación de un subconjunto de filas o columnas

# Crear un DataFrame de muestra
df = pd.DataFrame({'A': [3, 1, 4, 2], 'B': [1, 2, 3, 4], 'C': [10, 20, 30, 40]})
 
# Clasificar solo las filas donde la columna 'A' es mayor que 2
sorted_df = df[df['A'] > 2].sort_values(by='A')
print(sorted_df)

Resultado:

   A  B   C
0   3  1  10
2   4  3  30

Manejo de valores faltantes en datos parciales

# Crear un DataFrame con valores faltantes
df = pd.DataFrame({'A': [3, 1, None, 2], 'B': [1, 2, 3, 4]})
 
# Clasificar solo las filas con valores no faltantes en la columna 'A'
sorted_df = df.loc[df['A'].notna()].sort_values(by='A')
print(sorted_df)

Resultado:

     A  B
1    1  2
3    2  4
0    3  1

Clasificación de datos categóricos

Pandas proporciona un manejo especial para clasificar datos categóricos, lo que te permite controlar el orden de las categorías durante el proceso de clasificación.

Clasificación de categorías basada en su orden

import pandas as pd
 
# Crear una Serie categórica
s = pd.Series([1, 2, 3, 1], dtype='category')
s = s.cat.reorder_categories([3, 1, 2])
 
# Clasificar la Serie categórica
sorted_s = s.sort_values()
print(sorted_s)

Resultado:

0    1
3    1
1    2
2    3
dtype: category
Categories (3, int64): [3, 1, 2]

Personalización del orden de las categorías para clasificar

# Crear un DataFrame con columnas categóricas
df = pd.DataFrame({'A': [1, 2, 3, 1], 'B': ['a', 'b', 'c', 'a']})
# Addition
result = 10 + 5
print(result)  # Output: 15
 
# Subtraction
result = 10 - 5
print(result)  # Output: 5
 
# Multiplication
result = 10 * 5
print(result)  # Output: 50
 
# Division
result = 10 / 5
print(result)  # Output: 2.0
 
# Modulo
result = 10 % 3
print(result)  # Output: 1
 
# Exponentiation
result = 10 ** 3
print(result)  # Output: 1000

Comparison Operators

x = 5
y = 10
 
# Equal to
print(x == y)  # Output: False
 
# Not equal to
print(x != y)  # Output: True
 
# Greater than
print(x > y)  # Output: False
 
# Less than
print(x < y)  # Output: True
 
# Greater than or equal to
print(x >= y)  # Output: False
 
# Less than or equal to
print(x <= y)  # Output: True

Logical Operators

x = True
y = False
 
# Logical AND
print(x and y)  # Output: False
 
# Logical OR
print(x or y)  # Output: True
 
# Logical NOT
print(not x)  # Output: False

Assignment Operators

x = 5
 
# Addition assignment
x += 3  # Equivalent to x = x + 3
print(x)  # Output: 8
 
# Subtraction assignment
x -= 2  # Equivalent to x = x - 2
print(x)  # Output: 6
 
# Multiplication assignment
x *= 4  # Equivalent to x = x * 4
print(x)  # Output: 24
 
# Division assignment
x /= 6  # Equivalent to x = x / 6
print(x)  # Output: 4.0
 
# Modulo assignment
x %= 3  # Equivalent to x = x % 3
print(x)  # Output: 1.0

String Concatenation

first_name = "John"
last_name = "Doe"
 
# Using the + operator
full_name = first_name + " " + last_name
print(full_name)  # Output: John Doe
 
# Using f-string
full_name = f"{first_name} {last_name}"
print(full_name)  # Output: John Doe
 
# Using the join() method
full_name = " ".join([first_name, last_name])
print(full_name)  # Output: John Doe

Control Flow

If Statement

x = 10
 
if x > 5:
    print("x is greater than 5")
elif x == 5:
    print("x equals 5")
else:
    print("x is less than 5")

For Loop

fruits = ["apple", "banana", "cherry"]
 
for fruit in fruits:
    print(fruit)

While Loop

x = 0
 
while x < 5:
    print(x)
    x += 1

Break Statement

fruits = ["apple", "banana", "cherry"]
 
for fruit in fruits:
    if fruit == "banana":
        break
    print(fruit)

Continue Statement

fruits = ["apple", "banana", "cherry"]
 
for fruit in fruits:
    if fruit == "banana":
        continue
    print(fruit)

Try-Except Statement

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Division by zero is not allowed")

Functions

Defining a Function

def greet(name):
    print(f"Hello, {name}!")
 
greet("Alice")  # Output: Hello, Alice!

Returning a Value

def add(x, y):
    return x + y
 
result = add(3, 5)
print(result)  # Output: 8

Default Parameters

def exponentiate(x, power=2):
    return x ** power
 
print(exponentiate(2))  # Output: 4
print(exponentiate(2, 3))  # Output: 8

Variable Number of Arguments

def concatenate(*args):
    return "".join(args)
 
print(concatenate("Hello", ", ", "World"))  # Output: Hello, World

Lambdas

double = lambda x: x * 2
 
print(double(5))  # Output: 10

Classes and Objects

Defining a Class

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def greet(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old")
 
person = Person("Alice", 25)
person.greet()  # Output: Hello, my name is Alice and I'm 25 years old

Inheritance

class Student(Person):
    def __init__(self, name, age, major):
        super().__init__(name, age)
        self.major = major
 
    def study(self):
        print(f"I'm studying {self.major}")
 
student = Student("Bob", 20, "Math")
student.greet()  # Output: Hello, my name is Bob and I'm 20 years old
student.study()  # Output: I'm studying Math

Python admite los siguientes operadores aritméticos: + (suma), - (resta), * (multiplicación), / (división), // (división entera), % (módulo) y ** (exponenciación).

x = 10
y = 3
print(x + y)  # Salida: 13
print(x - y)  # Salida: 7
print(x * y)  # Salida: 30
print(x / y)  # Salida: 3.3333333333333335
print(x // y)  # Salida: 3
print(x % y)  # Salida: 1
print(x ** y)  # Salida: 1000

Operadores de comparación

Python admite los siguientes operadores de comparación: < (menor que), > (mayor que), <= (menor o igual que), >= (mayor o igual que), == (igual a) y != (no igual a).

x = 10
y = 20
print(x < y)  # Salida: True
print(x > y)  # Salida: False
print(x <= 10)  # Salida: True
print(x >= y)  # Salida: False
print(x == 10)  # Salida: True
print(x != y)  # Salida: True

Operadores lógicos

Python admite los siguientes operadores lógicos: and (y), or (o) y not (no).

x = 10
y = 20
print(x < 15 and y > 15)  # Salida: True
print(x < 5 or y > 15)  # Salida: True
print(not(x < 5))  # Salida: True

Operadores bitwise

Python también admite operadores bitwise, que realizan operaciones en los bits individuales de los números. Estos incluyen & (y), | (o), ^ (xor), ~ (no), << (desplazamiento a la izquierda) y >> (desplazamiento a la derecha).

x = 0b1010  # 10 en binario
y = 0b1100  # 12 en binario
print(x & y)  # Salida: 8 (0b1000)
print(x | y)  # Salida: 14 (0b1110)
print(x ^ y)  # Salida: 6 (0b0110)
print(~x)  # Salida: -11 (0b11111111111111111111111111110101)
print(x << 1)  # Salida: 20 (0b10100)
print(y >> 1)  # Salida: 6 (0b110)

Flujo de control

Declaraciones condicionales

La declaración if-elif-else se utiliza para ejecutar diferentes bloques de código en función de ciertas condiciones.

x = 10
if x > 0:
    print("x es positivo")
elif x < 0:
    print("x es negativo")
else:
    print("x es cero")

Bucles

Python tiene dos tipos principales de bucles: bucles for y bucles while.

# Bucle for
fruits = ["manzana", "plátano", "cereza"]
for fruit in fruits:
    print(fruit)
 
# Bucle while
count = 0
while count < 5:
    print(count)
    count += 1

Interrumpir y continuar

La instrucción break se utiliza para terminar prematuramente un bucle, mientras que la instrucción continue se utiliza para saltar la iteración actual y pasar a la siguiente.

# Ejemplo de break
for i in range(10):
    if i == 5:
        break
    print(i)
 
# Ejemplo de continue
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

Funciones

Las funciones en Python se definen utilizando la palabra clave def. Pueden tomar parámetros y devolver valores.

def saludar(nombre):
    print(f"Hola, {nombre}!")
 
saludar("Alice")  # Salida: Hola, Alice!
 
def sumar_numeros(a, b):
    return a + b
 
resultado = sumar_numeros(5, 3)
print(resultado)  # Salida: 8

Las funciones también pueden tener valores de parámetros predeterminados y argumentos de longitud variable.

def imprimir_info(nombre, edad=30):
    print(f"{nombre} tiene {edad} años.")
 
imprimir_info("John")  # Salida: John tiene 30 años.
imprimir_info("Jane", 25)  # Salida: Jane tiene 25 años.
 
def sumar_numeros(*args):
    total = 0
    for num in args:
        total += num
    return total
 
print(sumar_numeros(1, 2, 3))  # Salida: 6
print(sumar_numeros(4, 5, 6, 7, 8))  # Salida: 30

Módulos y paquetes

La biblioteca estándar de Python proporciona una amplia gama de módulos incorporados que se pueden utilizar en programas. También puedes crear tus propios módulos y paquetes para organizar tu código.

import math
print(math.pi)  # Salida: 3.141592653589793
 
from math import sqrt
print(sqrt(16))  # Salida: 4.0
 
import my_module
my_module.my_function()

Conclusión

En este tutorial, has aprendido sobre los conceptos fundamentales de Python, incluyendo variables, tipos de datos, operadores, flujo de control, funciones y módulos. Con este conocimiento, puedes comenzar a construir tus propias aplicaciones en Python y explorar temas más avanzados en el futuro. Recuerda, la mejor manera de mejorar tus habilidades en Python es practicar regularmente y seguir aprendiendo.

MoeNagy Dev