Saltar al contenido

Taller de Ejercicios: 11 características y funciones muy utilizadas en la programación con python

Existe muchísima información sobre lo que es Python como lenguaje de programación, sobre su constante crecimiento en la industria del software, sobre su alta demanda laboral, sobre su importancia y presencia en grandes proyectos tecnológicos de las principales compañías TOP de Internet, sobre su amplia comunidad de programadores y su notable incremento de librerías para proyectos de Data Science e Inteligencia Artificial.

El objetivo de esta publicación, es resaltar algunas de las muchas funcionalidades y características que nos ofrece la sintaxis de Python. Probablemente ya conozcas algunas o quizás aún no lo aplicas sobre un caso real. Por esa razón, se está agregando una propuesta de ejercicios para comprender en que situación deberías emplear estas funcionalidades.

Asignaciones Múltiples

Una de las características más importantes de todo lenguaje de programación es su forma como nos permite declarar y asignar valores a nuestras variables, la cual debemos conocer muy bien, respetando sus reglas de sintaxis y comprendiendo el correcto uso de los tipos de datos de nuestras variables.

Es común ver en muchos scripts, que la declaración y asignación de una variable se realice en una sola línea e incluso en dos líneas. Python nos permite declarar y asignar múltiples variables en una misma linea, como por ejemplo:

a,b = 1, 2
x,y,z = 1,2,3
a,b = b, a

El siguiente ejercicio aplicaremos conceptos de la programación orientada a objetos y asignación múltiple de variables.

Desarrollar un programa en python, que devuelva el perímetro de un triángulo formado por las distancias que existen entre los puntos A, B, C. Considerar que estos puntos están basados sobre un plano cartesiano. Las coordenadas x, y de cada punto se detalla a continuación:
Punto A: (x1, y1), Punto B: (x2, y2), Punto C: (x3, y3)
Donde:
x1 = 2
x2 = x1 ^ 2
x3 = 5 * x1
y1 = 2 * x1
y2 = x2 ^ 2
y3 = (x1 * x2) + 1

Una vez obtenido los valores de las coordenadas x, y de cada punto, los puntos A, B y C se ubicarían de la siguiente manera en un plano cartesiano.

A = (2,4)
B = (4,16)
C = (10,9)
Puntos A, B y C

Una vez calculado la distancia entre los puntos A, B, C; se podría obtener el perímetro del triangulo formado.

Triángulo formado por los puntos A,B y C

Creamos un directorio «BuildTrianglePoints«, con los siguientes ficheros *.py

Point.py

# !/usr/bin/env python
# -*- coding: utf-8 -*-

__file__ = "Point.py"

class Point(object):
    def __init__(self,name, x,y):
        self.name = name
        self.x, self.y = x, y

Triangle.py

# !/usr/bin/env python
# -*- coding: utf-8 -*-

__file__ = "Triangle.py"

from math import sqrt,pow

class Triangle(object):

    def __init__(self, obj_point_a, obj_point_b, obj_point_c):
        self.point_a = obj_point_a
        self.point_b = obj_point_b
        self.point_c = obj_point_c
    
    def calculateDistance(self, point_start, point_end):
        return sqrt(pow(point_end.x - point_start.x, 2) + pow(point_end.y - point_start.y, 2))
    
    def build(self):
        self.side_AB = self.calculateDistance(self.point_a, self.point_b)
        self.side_AC = self.calculateDistance(self.point_a, self.point_c)
        self.side_BC = self.calculateDistance(self.point_b, self.point_c)
    
    def getPerimeter(self):
        return self.side_AB + self.side_BC + self.side_AC

__main__.py

# !/usr/bin/env python
# -*- coding: utf-8 -*-

__file__ = "__main__.py"
__author__ = "Gonzalo Chacaltana"

from Triangle import Triangle
from Point import Point

class App(object):
    def __init__(self):
        self.console_line_length = 40

    def display(self, triangle):
        self.triangle = triangle
        self.displayLegendPoints()
        self.displayPointsDistance()
        self.displayTrianglePerimeter()

    def displayLegendPoints(self):
        print("\nPuntos: A (x1,y1), B (x2,y2), C (x3,y3)\n")
        self.displayConsoleLine()
        print("Asignacion Multiple de variables\n")
        self.displayConsoleLine()
        print("x1 = 2")
        print("x2, x3 = x1 ^ 2, 5 * x1")
        print("y1, y2, y3 = 2 * x1, x2 ^ 2, (x1 * x2) + 1")
        self.displayConsoleLine()
        print("Punto {} (x,y): ({},{})".format(self.triangle.point_a.name,self.triangle.point_a.x,self.triangle.point_a.y))
        print("Punto {} (x,y): ({},{})".format(self.triangle.point_b.name,self.triangle.point_b.x,self.triangle.point_b.y))
        print("Punto {} (x,y): ({},{})".format(self.triangle.point_c.name,self.triangle.point_c.x,self.triangle.point_c.y))
    
    def displayConsoleLine(self):
        print("\n".ljust(self.console_line_length,'*'),'\n')

    def displayPointsDistance(self):
        self.displayConsoleLine()
        print("Distancia de Puntos")
        self.displayConsoleLine()
        print("{} -> {}: {}".format(self.triangle.point_a.name,self.triangle.point_b.name,self.triangle.side_AB))
        print("{} -> {}: {}".format(self.triangle.point_a.name,self.triangle.point_c.name,self.triangle.side_AC))
        print("{} -> {}: {}".format(self.triangle.point_b.name,self.triangle.point_c.name,self.triangle.side_BC))
        
    
    def displayTrianglePerimeter(self):
        print("\nEl perimetro del triangulo es {}".format(self.triangle.getPerimeter()))

if __name__=='__main__':
    
    # Asignación múltiple de variables.
    x1 = 2
    x2,x3 = pow(x1,2), 5*x1
    y1,y2,y3 = 2*x1, pow(x2,2), x2*x1+1

    point_a = Point('A',x1,y1)
    point_b = Point('B',x2,y2)
    point_c = Point('C',x3,y3)
    
    triangle = Triangle(point_a, point_b, point_c)
    triangle.build()

    console = App()
    console.display(triangle)
    

Compresiones de Listas

Las compresiones de listas es una de las características más notables de la sintaxis de python. Permite recorrer los elementos de una colección mediante una sola línea de código legible y funcionalmente eficiente.

Observe cómo podemos crear una lista a partir de otra, en el siguiente ejercicio.

Dada la sucesión:
Desarrollar un script en python para mostrar en pantalla las siguientes sucesiones:
Donde:

Los elementos de la sucesión S1, está conformado por los elementos de la sucesión S que son múltiples de 3.

Los elementos de la sucesión S2, está conformado por los elementos de la sucesión S1 elevado al cuadrado.

Finalmente, el programa deberá mostrar la suma de los elementos de la sucesión S2, que sean mayores a 2000
# !/usr/bin/env python
# -*- coding: utf-8 -*-

from math import pow

if __name__=='__main__':

    # Asignación múltiple
    serie_start, serie_end, step, multiplo = 10, 100, 2, 3

    # Creamos la serie S, mediante comprensión de lista.
    s = [n for n in range(serie_start,serie_end+1,step)]

    print(f"\Sucesión:\nS = ",s)
    print(f"\nInicio: {serie_start}\tFin: {serie_end}\tSalto: {step}")

    print(f"\Sucesión S1 conformado por los numeros multiplos de {multiplo} de la sucesión S")
    s1 = [n for n in range(serie_start,serie_end+1,step) if n%3==0]
    print("\nS1 = ", s1)

    print(f"\Sucesión S2 conformado por numeros elevados al cuadrado de la sucesión S1")
    s2 = [pow(n,2) for n in s1]
    print("\nS2 = ",s2)

    print(f"\nSuma de los numeros mayores a 2000 de la sucesión S2 = {sum(n for n in s2 if n>2000)}")

Funciones ZIP para unir colecciones

Con la función ZIP, podrás unir distintas colecciones, generando una nueva colección iterable de tuplas, denominada ZIP Object.

En el siguiente ejemplo, tenemos 3 colecciones de listas que almacenan la información de los participantes de un juego en línea.

Desarrollar un  script en python para mostrar en pantalla el nombre, país y puntaje de cada jugador, cuya información se encuentra almacenada en 3 diferentes listas.
# !/usr/bin/env python
# -*- coding: utf-8 -*-

if __name__=='__main__':

    # Lista 1: Nombre de los jugadores.
    players = ['Alvaro Revoredo', 'Mike Frist', 'Paula Jimenez','Gonzalo Chacaltana','Felipe Ayala']
    
    # Lista 2: País de procedencia.
    countries = ['Uruguay','Brasil','México','Perú','Chile']

    # Lista 3: Puntaje
    scores = [89.2,81.8,83.4,82.6,80.9]

    # Utilizamos la función zip() para unir las 3 listas.
    for player,country,score in zip(players,countries,scores):
        print('Jugador: {} Pais: {} Puntaje: {}'.format(player.ljust(30),country.ljust(15),score))

    # Devuelve
    # Jugador: Alvaro Revoredo               Pais: Uruguay         Puntaje: 89.2
    # Jugador: Mike Frist                    Pais: Brasil          Puntaje: 81.8
    # Jugador: Paula Jimenez                 Pais: México          Puntaje: 83.4
    # Jugador: Gonzalo Chacaltana            Pais: Perú            Puntaje: 82.6
    # Jugador: Felipe Ayala                  Pais: Chile           Puntaje: 80.9

Funciones LAMBDA para ordenar colecciones

Las funciones lambda o funciones anónimas son funciones que no tienen un nombre específico, cuyo contenido consiste en una única expresión lógica.

Desarrollar un programa en python que muestre en pantalla el nombre, país de origen y puntaje obtenido de cada jugador, ordenados según su puntaje de mayor a menor y viceversa.
# !/usr/bin/env python
# -*- coding: utf-8 -*-

if __name__=='__main__':

    # Lista 1: Nombre de los jugadores.
    players = ['Alvaro Revoredo', 'Mike Frist', 'Paula Jimenez','Gonzalo Chacaltana','Felipe Ayala']
    
    # Lista 2: País de procedencia.
    countries = ['Uruguay','Brasil','México','Perú','Chile']

    # Lista 3: Puntaje
    scores = [89.2,81.8,83.4,82.6,80.9]

    print("\nResultado ordenado por puntaje de menor a mayor")
    # Creamos una lista de diccionarios a partir de las 3 listas, mediante una sintaxis de compresión.
    competition = [{'score':scores[i], 'player':players[i],'country':countries[i]} for i in range(len(players))]

    for data in sorted(competition, key=lambda x: x['score'], reverse=False):
        print(f"Jugador: {data['player'].ljust(30)}Pais: {data['country'].ljust(15)}Puntaje: {data['score']}")

    # Devuelve
    # Jugador: Felipe Ayala                  Pais: Chile          Puntaje: 80.9
    # Jugador: Mike Frist                    Pais: Brasil         Puntaje: 81.8
    # Jugador: Gonzalo Chacaltana            Pais: Perú           Puntaje: 82.6
    # Jugador: Paula Jimenez                 Pais: México         Puntaje: 83.4
    # Jugador: Alvaro Revoredo               Pais: Uruguay        Puntaje: 89.2

    print("\nResultado ordenado por puntaje de mayor a menor")

    for data in sorted(competition, key=lambda x: x['score'], reverse=True):
        print(f"Jugador: {data['player'].ljust(30)}Pais: {data['country'].ljust(15)}Puntaje: {data['score']}")

    # Devuelve
    # Jugador: Alvaro Revoredo               Pais: Uruguay        Puntaje: 89.2
    # Jugador: Paula Jimenez                 Pais: México         Puntaje: 83.4
    # Jugador: Gonzalo Chacaltana            Pais: Perú           Puntaje: 82.6
    # Jugador: Mike Frist                    Pais: Brasil         Puntaje: 81.8
    # Jugador: Felipe Ayala                  Pais: Chile          Puntaje: 80.9

Iterar colecciones con la función ENUMERATE

Enumerate es una de las muchas funciones incorporadas de python, conocidas como «Built-in Functions«. Puedes utilizar enumerate para iterar una lista con un contador automático. Veamos el siguiente ejemplo:

# !/usr/bin/env python
# -*- coding: utf-8 -*-

if __name__ == "__main__":

    # Lista de cuentas de Twitter
    twitter_accounts = ('@AndrewYNg','@ylecun','@solodatascience','@solocodigoweb','@DataScienceCtrl','@gchacaltanab')

    # Iteramos la lista "twitter_accounts"
    for key,value in enumerate(twitter_accounts):
        print(f'Key: {key} - Account Name: {value}')

    # Devuelve:
    # Key: 0 - Account Name: @AndrewYNg
    # Key: 1 - Account Name: @ylecun
    # Key: 2 - Account Name: @solodatascience
    # Key: 3 - Account Name: @solocodigoweb
    # Key: 4 - Account Name: @DataScienceCtrl
    # Key: 5 - Account Name: @gchacaltanab

    print(f"\n")
    # Inicializamos el contador en 298090
    for key,value in enumerate(twitter_accounts,298090):
        print(f'Account ID: {key} - Account Name: {value}')

    # Devuelve:
    # Account ID: 298090 - Account Name: @AndrewYNg
    # Account ID: 298091 - Account Name: @ylecun
    # Account ID: 298092 - Account Name: @solodatascience
    # Account ID: 298093 - Account Name: @solocodigoweb
    # Account ID: 298094 - Account Name: @DataScienceCtrl
    # Account ID: 298095 - Account Name: @gchacaltanab

Función MAP: Pasar elementos de una colección por una función

Seguramente te haz topado con la necesidad de pasar los elementos de una lista por una función para calcular algún dato o ejecutar alguna acción. Generalmente, utilizarías una sentencia «for» para recorrer la lista. Ejem:

def calculateIGV(amount:float):
    return amount*0.18

amounts, igv_list = [98,46.50,88,70.40], []

for i in amounts:
    igv_list.append(calculateIGV(i))

Con la función map() podrás hacerlo de la siguiente forma:

def calculateIGV(amount:float):
    return amount*0.18

amounts, igv_list = [98,46.50,88,70.40], []

igv_list = list(map(calculateIGV,amounts))
print(igv_list)

Veamos el siguiente ejemplo:

Desarrollar un programa en python que muestre en pantalla el récord académico de las notas de un alumno: Nombre del curso,  Notas obtenidas (Nota 1 y Nota 2), Nota Final y Estado ("Aprobado" o "Desaprobado"). Para aprobar el curso, la "Nota Final" debe ser mayor o igual a 13. Además calcular y mostrar el "Promedio Final Anual" y estado final de aprobación de todos los cursos del año en curso.
Considerar los siguientes valores:

Cursos = ['Programación de Sistemas','Estadística Básica', 'Algebra Lineal', 'Matrices Distribuidas', 'Redes Neuronales']

Nota 1 = [15,18,12,19,13]

Nota 2 = [18,16,13,16,18]

Nota Final = (Nota 1 + Nota 2) / 2

Promedio Final Anual = (Nota Final Curso 1 + ... + Nota Final Curso 5) / 5
# !/usr/bin/env python
# -*- coding: utf-8 -*-
from statistics import mean

def average(a,b):
    return mean([a,b])

courses = ['Programación de Sistemas','Estadística Básica', 'Algebra Lineal', 'Matrices Distribuidas', 'Redes Neuronales']
score_01, score_02, score_min = [15,18,12,19,13], [18,16,13,16,18], 13

# Usamos "map" para invocar función "average" a cada elemento de las listas.
score_course_final = list(map(average,score_01,score_02))
score_final = mean(score_course_final)

if __name__ == "__main__":
    for x in range(0,len(courses)):
        print("\nCurso: {}".format(courses[x]))
        print("\n{} {}".format('Nota 1 :'.ljust(14),score_01[x]))
        print("{} {}".format('Nota 2 :'.ljust(14),score_02[x]))
        print("{} {}".format('Nota Final :'.ljust(14),score_course_final[x]))
        print("Estado: {}".format('Aprobado' if score_course_final[x]>=score_min else 'Desaprobado'))
        print("\n{}".format(''.ljust(30,'*')))
    print("\nPromedio Final: {}".format(score_final))
    print("Estado Final: {}".format('Aprobado' if score_final>=score_min else 'Desaprobado'))

# Devuelve
# Curso: Programación de Sistemas

# Nota 1 :       15
# Nota 2 :       18
# Nota Final :   16.5
# Estado: Aprobado

# ******************************

# Curso: Estadística Básica

# Nota 1 :       18
# Nota 2 :       16
# Nota Final :   17
# Estado: Aprobado

# ******************************

# Curso: Algebra Lineal

# Nota 1 :       12
# Nota 2 :       13
# Nota Final :   12.5
# Estado: Desaprobado

# ******************************

# Curso: Matrices Distribuidas

# Nota 1 :       19
# Nota 2 :       16
# Nota Final :   17.5
# Estado: Aprobado

# ******************************

# Curso: Redes Neuronales

# Nota 1 :       13
# Nota 2 :       18
# Nota Final :   15.5
# Estado: Aprobado

# ******************************

# Promedio Final: 15.8
# Estado Final: Aprobado

Expresiones condicionales abreviadas

Sintaxis del lenguaje de programación que permite probar una condición en una sola línea haciendo que el código sea compacto. Por ejemplo:

# !/usr/bin/env python
# -*- coding: utf-8 -*-
from statistics import mean

score_exams = [16,14,17,11,13]
min_score = 13

score_course = mean(score_exams)
# utilizando una expresión condicional abreviada ó shorthand conditional
state_course = 'Aprobado' if score_course>=min_score else 'Desaprobado'

print(f'\nNotas de Evaluaciones: ', str(score_exams))
print(f'Promedio mínimo para aprobar: {min_score}')
print(f'Estado: {state_course.ljust(12)} Promedio Final: {score_course}')

Cortar secuencias

Una secuencia es una lista, una tupla o una cadena de texto. Vea los siguientes ejemplos.

# !/usr/bin/env python
# -*- coding: utf-8 -*-

computerResearchers = ["Andrew NG", "Yann LeCun", "Yoshua Bengio", "Carol Reiley", "Sebastian Thrun", "Jeff Dean", "Pieter Abbeel"]
# Indices de la Lista computerResearchers
# 0 => Andrew NG 
# 1 => Yann LeCun
# 2 => Yoshua Bengio
# 3 => Carol Reiley
# 4 => Sebastian Thrun
# 5 => Jeff Dean
# 6 => Pieter Abbeel

# <Nombre Lista>[posición inicial : posición final]
# Si la posición final ("n") es 2, python lo interpreta como 1. Siempre es "n" - 1
print(computerResearchers[0:1])
# Devuelve: ['Andrew NG']

print(computerResearchers[1:2])
# Devuelve: ['Yann LeCun']

print(computerResearchers[1:3])
# Devuelve: ['Yann LeCun', 'Yoshua Bengio']

print(computerResearchers[2:6:2])
# <Nombre Lista>[posición inicial : posición final : saltos]
# Devuelve: ['Yoshua Bengio', 'Sebastian Thrun']

print(computerResearchers[:3])
# <Nombre Lista>[ : posición final]
# Si la posición inicial es vacío es igual a 0.
# Devuelve: ['Andrew NG', 'Yann LeCun', 'Yoshua Bengio']

print(computerResearchers[4:])
# <Nombre Lista>[posición inicial : ]
# Si la posición final es vacío significa que python cogerá hasta el último elemento de la lista.
# Devuelve: ['Sebastian Thrun', 'Jeff Dean', 'Pieter Abbeel']

print(computerResearchers[:])
# <Nombre Lista>[ : ]
# Si la posición inicial y final están vacíos, python cogerá todos los elementos de la lista.
# Devuelve: ['Andrew NG', 'Yann LeCun', 'Yoshua Bengio', 'Carol Reiley', 'Sebastian Thrun', 'Jeff Dean', 'Pieter Abbeel']

print(computerResearchers[::-1])
# <Nombre Lista> [ : : -1]
# Se está tomando todos los elementos, pero al tener un salto -1, la lista de muestra en sentido inverso.
# Devuelve: ['Pieter Abbeel', 'Jeff Dean', 'Sebastian Thrun', 'Carol Reiley', 'Yoshua Bengio', 'Yann LeCun', 'Andrew NG']

Reversión de secuencias

Puede revertir una secuencia utilizando la sentencia «for» y recorriendo la secuencia en sentido inverso. Sin embargo, con python, la reversión de secuencia se más simple y práctico.

# !/usr/bin/env python
# -*- coding: utf-8 -*-

books_to_read = ["Python Data Science Handbook", "Understanding Machine Learning", "Linear Algebra Problem Book", "Naked Statistics", "Python for Data Analysis"]
print(f"Libros ordenados por su indice")
print([n for n in books_to_read])
# Devuelve:
# ['Python Data Science Handbook', 'Understanding Machine Learning', 'Linear Algebra Problem Book', 'Naked Statistics', 'Python for Data Analysis']

print(f"\nLibros en orden inverso")
print([n for n in reversed(books_to_read)])
# Devuelve:
# ['Python for Data Analysis', 'Naked Statistics', 'Linear Algebra Problem Book', 'Understanding Machine Learning', 'Python Data Science Handbook']

print(f"\nLibros en ordenados por su nombre")
print([n for n in sorted(books_to_read)])
# Devuelve
# ['Linear Algebra Problem Book', 'Naked Statistics', 'Python Data Science Handbook', 'Python for Data Analysis', 'Understanding Machine Learning']

Cortar secuencia de texto

En python, puedes trabajar una cadena de texto, como si fuera una secuencia (una lista).

# !/usr/bin/env python
# -*- coding: utf-8 -*-

researcher = "Andrew NG"
# El contenido de una cadena de texto se comporta como una lista.
# 0 => A
# 1 => n
# 2 => d
# 3 => r
# 4 => e
# 5 => w
# 6 =>  
# 7 => N
# 8 => G

print(researcher[0:6])
# Devuelve: Andrew

print(researcher[7:9])
# Devuelve: NG

print(researcher[::-1])
# Devuelve: GN werdnA

# Secuencia Inversa
# Podemos interpretar las posiciones inversas de la siguiente forma:
# -9 => A
# -8 => n
# -7 => d
# -6 => r
# -5 => e
# -4 => w
# -3 =>  
# -2 => N
# -1 => G
print(researcher[-1])
# Devuelve: G

print(researcher[-2:])
# Devuelve: NG

print(researcher[-9:-3])
# Devuelve: Andrew

Filtrar secuencias

El uso de la función «filter()» es muy similar a la función «map()» que vimos anteriormente. Veamos el siguiente ejemplo:

Desarrollar un script en python que almacene en una lista, las contraseñas que cumplan con las reglas de validación.

Reglas de validación de contraseña:
1. Debe tener más de 8 caracteres.
2. Debe tener al menos uno de los siguientes símbolos "@&$_".
3. Debe tener al menos un número.
4. Debe tener al menos una vocal en minúscula.
Utilizar como set de pruebas, la siguiente lista de contraseñas.

['123456','sistemas','[email protected]_','segura','[email protected]_','secreto','v8$nbep1bf_','cumple1304']
# !/usr/bin/env python
# -*- coding: utf-8 -*-

def isGoodPassword(password:str):
    len_password = len(password)>8
    has_symbols = not set('@&amp;$_').isdisjoint(password.lower())
    has_numbers = not set('1234567890').isdisjoint(password.lower())
    has_vowels = not set('aeiou').isdisjoint(password.lower())
    return has_symbols &amp; len_password &amp; has_numbers &amp; has_vowels

if __name__ == '__main__':

    passwords = ['123456','sistemas','[email protected]_','segura','[email protected]_','secreto','v8$nbep1bf_','cumple1304']

    print(list(filter(isGoodPassword,passwords)))

# Devuelve:
# ['[email protected]_', 'v8$nbep1bf_']
Publicado enProgramación