La ciencia de datos está cambiando el mercado actual de maneras inimaginables. Desde que comenzó a crecer, se ha perfeccionado continuamente y se ha convertido en la herramienta más indispensable para las organizaciones de todas las industrias. Desde el análisis de los comportamientos de los clientes hasta la predicción de las tendencias del mercado, la ciencia de datos ofrece a las empresas información valiosa que puede ayudarlas a tomar mejores decisiones y obtener una ventaja competitiva en sus respectivas industrias.

Python para ciencia de datos

Python es un lenguaje de programación versátil y fácil de usar que ofrece una variedad de bibliotecas y herramientas para inteligencia artificial, aprendizaje automático y análisis de datos. Su extenso ecosistema de biblioteca incluye módulos conocidos como NumPy, Pandas, Matplotlib, Scikit-learn y TensorFlow, que los científicos de datos suelen utilizar para crear visualizaciones y modelos de datos complejos. Además de sus capacidades técnicas, también cuenta con una gran comunidad de apoyo que contribuye continuamente a su crecimiento y desarrollo. Debido a todo lo que tiene para ofrecer, los científicos de datos pueden obtener una ventaja competitiva al dominar Python antes de ingresar a la industria.

Conceptos esenciales al aprender sobre los fundamentos de Python

A. Tipos de datos

Aunque Python es un lenguaje tipado dinámicamente donde los tipos de datos se determinan durante el tiempo de ejecución, aún es esencial conocer las diferencias entre los tipos de datos, ya que determina las operaciones que se pueden realizar en una variable determinada.

Tipos de datos básicos en Python

1. numérico

Enteros vs Flotantes

Un entero es simplemente un número entero, mientras que un número de coma flotante , o float , es un número que consta de lugares decimales. Esto hace que el valor 11 sea un número entero y el valor decimal 2,5 sea un flotante.

Usar la función type() lo ayudaría a confirmarlo.

num = 11
print(f"num is a \"{type(num)}\"")

decimal = 1.1
print(f"decimal is a \"{type(decimal)}\"")

Las cadenas son valores de texto compuestos por una secuencia de caracteres (letras, dígitos y otros caracteres válidos).

name = "S@r4!1l"
print(f"name is a \"{type(name)}\"")

Los booleanos se utilizan para almacenar los valores lógicos "Verdadero" y "Falso" . Estos valores se ven a menudo en declaraciones condicionales, ya que se utilizan para controlar el flujo de la programación.

found = True
print(f"found is a \"{type(found)}\"")

1. Lista

Las listas son colecciones ordenadas de elementos que son mutables , lo que significa que el objeto se puede modificar después de crearlo. Se crea usando corchetes [] donde todos sus elementos están dentro separados por una coma.

Por ejemplo,

colors = ["Red", "Yellow", "Blue"]

empty_list = []
print(f"empty_list is a \"{type(empty_list)}\"")

Las tuplas son colecciones ordenadas de elementos que son inmutables , lo que significa que el objeto no se puede modificar después de haberlo creado. Se crea usando paréntesis () donde todos sus elementos están dentro separados por una coma.

Por ejemplo,

fruits = ("Mango", "Pineapple", "Strawberry")

empty_tuple = ()
print(f"empty_tuple is a \"{type(empty_tuple)}\"")

Diccionarios colección ordenada mutable de elementos que no permite duplicados. Consiste en pares clave-valor dentro de llaves {} donde se usan dos puntos ( :) para separar las claves de su valor correspondiente.

Por ejemplo,

my_dict = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e', 6:'f', 7:'g', 8:'h', 9:'i', 10:'j', 11:'k', 12:'l', 13:'m', 14:'n', 15:'o', 16:'p', 17:'q', 18:'r', 19:'s', 20:'t', 21:'u', 22:'v', 23:'w', 24:'x', 25:'y', 26:'z'}

empty_dict = {}
print(f"empty_dict is a \"{type(empty_dict)}\"")

Los conjuntos son colecciones desordenadas mutables de datos únicos que no permiten duplicados. Se crea usando llaves {} donde todos sus elementos están separados por una coma.

Por ejemplo,

even = {2, 4, 6, 8, 10}

empty_set = set()
print(f"empty_set is a \"{type(empty_set)}\"")

El flujo de control de un programa es la secuencia en la que se evalúan y ejecutan las instrucciones. La secuencia se puede cambiar según las declaraciones de flujo de control utilizadas. Ser competente con este concepto permite a los programadores realizar operaciones complejas y escribir código legible y mantenible.

Declaraciones de selección

1. Si declaración

Las declaraciones If se utilizan para ejecutar un cuerpo de código cuando se cumplen ciertas condiciones. La sintaxis de una sentencia if es:

if condition:
    # code to be executed if True

if grade > 75 and grade <= 100:
    print("Passed")

Se puede agregar una condición else después de una declaración if . La sintaxis de una sentencia if-else es:

if condition:
    # code to be executed if True 
else:
    # code to be executed if False

if grade > 75 and grade <= 100:
    print("Passed")
else:
    print("Failed")

Agregar una palabra clave elif permite múltiples alternativas. La sintaxis de una instrucción if-elif-else es:

if condition1:
    # code to be executed if condition1 is True 
elif condition2:
    # code to be executed if condition2 is True
else:
    # code to be executed when both condition1 and condition2 are False

if grade > 75 and grade <= 100:
    print("Passed")
elif grade == 0:
    print("Incomplete")
else:
    print("Failed")

1. Para bucle

Los bucles for se utilizan para iterar a través de un objeto iterable, como una cadena, una lista o una tupla. A continuación, crearemos un ciclo que itera a través de una lista de nombres e imprimirá cada elemento en la lista.

for name in name_list:
    print(name)

Los bucles while se utilizan para ejecutar un bloque de código hasta que se cumplan ciertas condiciones. A continuación, crearemos un bucle que imprima el valor de i hasta que llegue a 5.

while i <= 5:
    print(i)
    i += 1

Las funciones son bloques de código reutilizable que realizan una tarea específica. Esto permite a los programadores descomponer sus soluciones en tareas específicas, evitar la repetición de códigos y mantener programas legibles.

La sintaxis para declarar una función en Python puede ser la siguiente:

# without parameters
def function_name1():
    # function body 

# with parameters
def function_name2(parameter):
    # function body

def greeting(name):
    print(f"Hello {name}!")

Así es como se hace:

greeting("Mary")

La programación orientada a objetos (POO) es un enfoque para escribir programas de computadora en el que las clases de objetos están estrechamente vinculadas con los atributos (variables) y los comportamientos (métodos) con los que están asociados. Comprender OOP proporciona una mejor comprensión detrás de las bibliotecas de python y nos permite crear programas fáciles de mantener y legibles.

Cuatro pilares de la programación orientada a objetos

1. Herencia

La herencia es la derivación de una nueva clase a partir de una clase existente. Esta nueva clase (también conocida como clase secundaria) hereda los métodos y propiedades de una clase existente (llamada clase principal).

Pongamos un ejemplo,

# Parent class
class Fruit:
    def __init__(self, name, price):
        self.name = name
        self.price = price

# Child class 
class Mango:
    def __init__(self, name, price, state):
        # Access methods and properties of the parent class using super()
        super().__init__(name, price)
        self.state = state

2. Encapsulación

La encapsulación es la agrupación de atributos y métodos relacionados en una sola clase. A través de la encapsulación , las clases externas no pueden cambiar los atributos y métodos disponibles para una clase. Esto se debe a que las variables generalmente se hacen "privadas" para ocultar datos.

En Python, los atributos privados se indican mediante guiones bajos dobles ( __ ).

Un ejemplo sería,

class Fruit:
    def __init__(self, name):
        self.name = name
        self.__price = 10

    def sell(self, payment):
        print(f"Selling price: {self.__price}")
        print(f"Change: {payment - self.__price}")

    def set_price(self, price):
        self.__price = price

orange = Fruit("orange")
orange.sell(12)

# Changing the price
orange.__price = 5
orange.sell(12)

# Using the setter method
orange.set_price(3)
orange.sell(12)

3. Polimorfismo

El polimorfismo es el uso de una sola entidad para realizar diferentes tipos de comportamientos. Digamos que tenemos el siguiente ejemplo:

class Cat:
    def make_sound(self):
        print("Meow")

class Frog:
    def make_sound(self):
        print("Ribbit")

class Cow:
    def make_sound(self):
        print("Moo")

4. Abstracción

La abstracción es ocultar al usuario detalles sin importancia para reducir la complejidad del programa y asegurarse de que los programadores solo se concentren en los que son importantes.

Aquí hay un ejemplo de su implementación,

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def drive(self):
        pass

class Car(Vehicle):
    def drive(self):
        print("Driving a car")

class Motorcycle(Vehicle):
    def drive(self):
        print("Driving a motorcycle")

#vehicle = Vehicle()
car = Car()
motorcycle = Motorcycle()

#vehicle.drive()
car.drive()
motorcycle.drive()

Conclusión

En resumen, adquirir una base sólida de los fundamentos de Python es vital para las personas que aspiran ingresar al campo de la ciencia de datos. Python es un lenguaje de programación muy adecuado para la ciencia de datos debido a su naturaleza fácil de usar, amplias bibliotecas, versatilidad y comunidad de apoyo. Además, el uso generalizado de Python en el campo crea numerosas oportunidades profesionales para quienes lo dominan. Por lo tanto, aprender los fundamentos de Python puede convertirse en un paso crucial hacia una carrera exitosa en la ciencia de datos para los aspirantes a profesionales de la ciencia de datos.