Programación en python – Se un programador con fundamentos

¿Qué tal Pythoner’s?!. He vuelto para ver fundamentos de programación. Y a modo de repaso me propuse crear este llamémosle «folleto» para reforzar y ampliar conocimientos respecto a fundamentos de programación en general y los módulos 1 y 2 de mi sitio de Python.

Entonces aquí primero te voy a dar un poco de lata y luego vamos a repasar todo el módulo 1 de Python Básico para «verlo todo desde arriba». Comprender el mapa completo de lo que venimos aprendiendo.

Nota: Me gusta ser cabrón y hacerla larga, explicativa y con onda. Si ya tienes estos conceptos incorporados; te puede resultar tedioso. Pero para quien no; habrá descubierto la rueda!. Y sobre todo entenderá lo que hace cuando programa!

¿Qué no es largo?. Nada mas fíjate el indice!. Y por cierto suscribete a mi blog, que habrá mucho más salseo!

Introducción

Sucede que tengo ganas de hablar de porque la programación sea en el lenguaje que sea; me llena la mente y el corazón!. Y es que cada día está mas adentrada en nuestra vida cotidiana. Y la tecnología avanza muy rápido y con ella si tenemos conocimientos logramos quitarnos una venda de los ojos que nos permite ver el mundo de otra manera!. Así que de esto va esta entrada; de sacarte la venda de los ojos; no solo estás aprendiendo programación en Python!. Hazte un café; o unos mates; en mi país. Este viaje no será corto!

¿Qué aprendemos cuando aprendemos a programar?

Me sucedió al comenzar a programar que pensé; «joder; todo lo que me falta aprender y eso que es un solo lenguaje».

Error! No solo estamos aprendiendo un lenguaje; estamos aprendiendo a pensar maneras de automatizar; puesto que uno de los principales objetivos de la programación es justamente eso; automatizar procesos. La programación no solo está en las computadoras y en la tecnología. Es más que eso; la programación (en general) es un proceso que se utiliza para idear y ordenar acciones en un marco determinado.

Así cuando tu comes; tu sistema está programado para obtener los nutrientes que necesita y desechar el resto. Eso; es un sistema y está programado para lograr determinados resultados! (no quiero saber cuales son).

Olvídate por un momento del lenguaje que sabes y que no sabes. Debemos ver más allá de los lenguajes; de las computadoras; de las variables.

Alguien que aprende programación más allá de saber hacer una estúpida aplicación debe poder planificar; optimizar; automatizar casi cualquier cosa. Debe ser capaz de crear procesos que permitan agilizar trabajos; ideas; conocimientos.

Fíjate que antes de las computadoras las personas organizaban procesos sin tener noción de fundamentos de programación o matemáticas.

Cuando te sumerges en la historia un poquito realmente te vuela la cabeza!. Fíjate los aztecas o los mayas; no tenían una mierda de PC siquiera. Y optimizaban sus jardines para mejorar sus cultivos aplicando cálculos matemáticos; geográficos; astronómicos que no te das una pálida idea!

¿Y a dónde voy con todo esto?

Conociendo las piezas; se aprende a jugar ajedrez. Y se puede volver a empezar volviéndolas a su lugar. Entonces; si estudias las piezas; elaboras una estrategia. Podrás perder varias veces, pero en una tendrás éxito; puesto que a más juegas más dominas el juego y conoces a tu oponente; lo estudias. Y en esto me quiero basar; en estudiar, analizar, comprender y ampliar, dividir para reinar. Todo se relaciona con todo; entonces descubrí que si puedo programar en un lenguaje; puedo en todos. Porque ya tengo..

Los fundamentos de programación en Python

Los fundamentos de programación son las armas del programador. Son la base consolidada que todo programador debe tener independientemente el lenguaje en que programe. Puesto que el Lenguaje es una Herramienta de comunicación con el ordenador.

Si el lenguaje es una herramienta; entonces los fundamentos son el conocimiento necesario para aplicarlas de manera correcta; eficaz y lógicamente viable. Por lo que sí tenemos la base de los fundamentos podemos aplicar casi cualquier lenguaje.

Nosotros llegado a este punto tenemos los fundamentos de programación en Python. Pero quizás no somos conscientes aún de ello. De su utilidad y aplicación en otros lenguajes!

¿Qué son los fundamentos de programación?

Yo los definí de la siguiente manera:

Como sabes todos los lenguajes tienen su propia sintaxis; características; utilidad; etc. Podemos ver a los fundamentos como el conjunto de características y conceptos que todos los lenguajes tienen en común.

De esa forma los agrupamos para comprender el funcionamiento en diversos lenguajes y facilitar su aplicación, traducción y optimización..

Beneficios de comprender los fundamentos de programación

En criollo; y basado en mi experiencia voy a explicarte los beneficios que nos brinda aprenderlos; recordarlos y aplicarlos:

• Nos permite desarrollar habilidades para resolver problemas lógicos.
• Agudiza nuestro poder de observación para conformar o desarrollar sistemas más óptimos u optimizar los ya existentes.
• Son aplicables fuera del lenguaje. Aprender a programar es aprender a automatizar; y numerosas áreas y aplicaciones resulta de mucha utilidad la agilidad para optimizar procesos.
• Nos permite comunicarnos y desarrollar programas conjunto a otros programadores facilitando el entendimiento mas allá del lenguaje en cual se programe.
• Facilita la transcripción de código de un lenguaje a otro. Entre otros muchos beneficios.

¿Cómo se aplican los fundamentos para resolver un problema?

1. Analizar el problema y sus requerimientos (y analizarlos bien; no solo superficialmente)
2. Elaborar un algoritmo (serie de pasos que lo resuelvan).
3. Luego, basándote en los fundamentos de programación y creatividad. Crear una maqueta; ya sea en pseudocódigo; diagrama de flujos o dibujos en la pared como un niño. Da igual!
4. Finalmente eliges el lenguaje que más se ajuste a los requerimientos. Y lo programas!
5. Obtienes el resultado esperado y a otra cosa mariposa!

Conociendo medianamente los fundamentos; todo problema y lenguaje parece una tontería!.

Y no solo hablamos de computadoras y tecnologías. Si tu problema es que necesitas una hamaca en el patio; pues es aplicable. Elegirás luego si de madera; metal; cuerdas o cadenas; etc.

Si piensas con detenimiento; si has cultivado la astucia; si tienes la capacidad y creatividad necesaria. Tu puedes elaborar un plan; un algoritmo; una solución que no falle. Y aplicarla y modificarla hasta lograr resultados.

Es por esto; que complican tanto la programación con matemáticas; fórmulas y algoritmos. Porque es una forma de «razonamiento lógico«. Y yo para enseñar en el primer módulo trate de quitar un poco la matemática complicada, y la profundidad de los conceptos; permaneciendo en lo sencillo. Pero es importante que la aprendas; porque son conocimientos realmente valiosos.

Así que vamos a complementar y organizar en bloques los conocimientos que ya tienes no solo más allá del lenguaje, los vamos a ejemplificar en Python. Y lo vamos a hacer en Python porque pues; de eso va este blog. ¿No?. De programación en python!

Eso sí; antes estudiemos un poco los conceptos:

Programación

Dijimos entonces que la programación era el proceso de ordenar acciones en un marco determinado. Pero nos referíamos a la palabra en general. Más orientado al caso de la informática la programación se refiere a la implementación de un Algoritmo para dar lugar a un programa que cumpla un objetivo de manera eficiente.

Algoritmo

Un algoritmo es un conjunto de operaciones sistemáticas que permiten hacer un cálculo o hallar la solución a un problema.

«Una serie de pasos para alcanzar un resultado»

Puede ser un ejemplo de algoritmo fácilmente comprensible una receta de cocina. La misma especifica pasos; cantidades; procesos; a fin de lograr un objetivo.

Imagina a un algoritmo por ejemplo una sucesión de pasos que te permiten obtener un resultado si se los lleva a cabo correctamente. Estos pasos pueden ser cálculos; instrucciones; etc.

Tipos de algoritmos

Existen así diferentes tipos de algoritmos:

• Cualitativos: Verbalmente precisos; como la receta de cocina.
• Cuantitativos: Numéricos; matemáticos; precisos.
• Computacionales: Algoritmos complejos; Numéricos; Cuantitativos combinados; optimizados.
• Y así encontraremos muchos mas tipos.

¿Qué es un programa o aplicación?

Similar que un algoritmo es un «programa«: puesto que se basa en algoritmos. Es un programa una secuencia de instrucciones para realizar una tarea determinada.

-¿Qué es un programa informático entonces?

-Una sucesión de instrucciones para realizar una tarea determinada…

-¿Y qué es un algoritmo?..

-Un conjunto de operaciones ordenadas a fin de alcanzar un resultado determinado. Fin.

¿Son muy similares verdad?. Pero no son lo mismo puesto que el algoritmo es independiente del lenguaje de programación. No así el programa que debe estar programado en un determinado lenguaje para que el ordenador lo pueda ejecutar.

Los programas se basan en algoritmos. Pero los algoritmos NO SON PROGRAMAS.

Se le pueden dar miles de vueltas; pero permanecemos ahí!. Por ahora..

Y así los algoritmos están presentes en nuestra vida diaria para resolver problemas siguiendo los pasos. Existen algoritmos hasta para dibujar! Se ve que alguien tenía problemas con el arte! –>

Un programa informático además de a los algoritmos; está también ligado a los datos y variables. DATOS y VARIABLES!

Como hemos visto antes existen datos simples y estructurados. 

Los programas informáticos trabajan con datos de entrada y salida. Creo que no hay mucha necesidad de explicarlo. Los mismos pueden ser simples o estructurados. Estos datos son almacenados en variables puesto que los mismos pueden variar sus valores. Entonces aquí deviene en los programas la aplicación de los algoritmos matemáticos. Por ejemplo la aplicación de las ecuaciones; funciones; etc. Estas son variables; porque así dependiendo el valor de la misma puede cambiar valor del resultado. Pero ojo; dije «el valor» no el resultado; que es siempre el mismo!

Así podemos ejemplificar un programa informático como:

Inicio

Leer (N1; N2; N3)

promedio = (N1 + N2 + N3) / 3    #Función mat x=x1,x2,x3 / 3

Mostrar (promedio)

Fin

#(pseudocódigo)

Esto es un boceto de un programa(pseudocódigo) basado en un algoritmo que consta de una función matemática para calcular por ejemplo el promedio de n1; n2; n3 que equivaldrá a X en este caso es la variable (promedio). Si cambia el valor de alguno de los elementos variables (n); cambiaría el valor del resultado. Por ejemplo sustituimos los valores n1; n2; n3 con las notas de un alumno:

x(promedio) = (10 + 7 + 4) / 3

x(promedio) = 21/3

x(promedio) = 7

El valor de la variable promedio es el «promedio» de nuestro alumno: 7. Pero; el resultado por más que modifiquemos los valores de las variables será un promedio. Porque así lo establece el algoritmo que aplicamos. ¿Comprendes Mendez?

En el ejemplo; todas son variables excepto el 3 que es el entero referente a la cantidad de elementos por los cuales dividimos el resultado de la suma.

Este ejemplo anterior está expresado en pseudocódigo; no recurrimos todavía a programación en Python. Y decidí ponerlo así para llamar la atención del lenguaje..

El lenguaje del ordenador; el de representación y el de programación

Como sabes las computadoras son aparatos eléctricos y como tales trabajan con impulsos eléctricos. Así se ve que en el código binario significan:

El 1 : Hay impulso. Es verdadero

El 0: No hay impulso. Es falso

Y llevarle la corriente a la computadora en binario; sería además de difícil; una mierda porque es un lenguaje de bajo nivel!!. Muy difícil y tedioso de comprender; programar y entender para el ser humano.

¿Quién quiere programar en eso?. Es por eso que recurrimos a los lenguajes de Alto nivel (parecidos al nuestro) como pueden ser Python, Java, C, etc.

Estos nos permiten entendernos mejor con ella!.

Pero ¿Estas prestando atención?.. No te pierdas!

Hablamos de comunicarnos con la computadora mediante lenguaje de alto nivel (Python) para evitar hacerlo en binario.  Pero también existen lenguajes que nos permiten elaborar «Bocetos de programas» rápidamente y compartirlos con otros programadores.

Así definimos:

• El lenguaje del ordenador (bajo nivel)
• El lenguaje de representación de un programa o algoritmo para que nosotros mismos o otra persona lo entienda. (Pseudocódigo; diagramas; etc)
• Y el lenguaje de alto nivel que es el que traduce a bajo nivel para que el ordenador pueda comprenderlo. Ejemplos: Python, C, Java, etc. Puede ser orientado a objetos; estructurado, etc.

Para diseñar o elaborar un boceto o descripción de programa entendible podemos usar Pseudocódigo; Diagramas de flujo. Da igual cual de los dos. Es un boceto; luego se perfecciona. Y esto es para darle salida rápida a nuestras ideas y elaborar rápidamente una estructura de lo que será nuestro programa.

¿Por qué respetar la estructura de un programa?

Si tuvieras que aplicar esa «solución» en forma de algoritmo para que le funcione a alguien más; entonces debes seguir una descripción formal de alto nivel. (El lenguaje de alto nivel para expresar los algoritmos computacionales o programas). Y ni hablemos si se lo quieres hacer tragar a la computadora. Debes ser muy específico..

De lo contrario otro programador o el computador no habrá de entenderte. O puede que el programador no sepa programar en Python y si en JAVA. Entonces debemos entregarle el algoritmo siguiendo una estructura formal basada en un lenguaje de alto nivel para presentar algoritmos: Pseudocódigo o Diagrama de Flujo. (las más conocidas y utilizadas como universales).

Y dentro de esta representación formal se cuenta con estructuras (bloques de instrucciones) que van desde prefabricados a creados por el diseñador del mismo. Y son muy importantes comprender; puesto que evitan que quien los lee o interpreta cometa errores. Incluso nosotros mismos; cuántas veces escribes un código y a la semana solo el diablo lo entiende!!

Tú a algunas de estas estructuras (bloques de instrucciones) ya las conoces (condicionales; bucles while; etc.); pero en Python. Son las que hemos estudiado en el módulo 1.

Pseudocódigo y Diagramas de flujo

Tanto el pseudocódigo como los diagramas de flujo utilizan las convenciones estructurales de un lenguaje de programación real. Pero en vez de facilitar la lectura del computador facilitan la del ser humano; utilizando su lenguaje.

Así en pseudocódigo decimos «Mostrar()» cómo en Python decimos «Print()». Un bucle «for in» de Python; en pseudocódigo se escribe «para / hacer»

Y básicamente los Diagramas de Flujo expresan los algoritmos en formas de diagramas mediante una representación gráfica basada en figuras geométricas que varían según la estructura de código.

Ambos son útiles para elaborar algoritmos o bocetos de programas. Incluso existen herramientas para facilitarnos desarrollarlos en pseudocódigo como PSeINT o Draw.io para diagramas.

¿Cómo desarrollarías un programa?

1. Creas un boceto rápido; puede ser lápiz y papel. En el no olvides especificar el objetivo del mismo; para nunca desviarte. (INFORMAL)

2. Lo perfeccionas en pseudocódigo o diagrama de flujo. (Presentación FORMAL)

3. Lo traduces al lenguaje que mejor se adapte; quieras o sepas. (Por ejemplo Python)

Estructuras de los programas y ejemplos

¿Qué te parece si vemos algunos bocetos de programas basados en algoritmos sencillos y comenzamos a entender esta estructura de bloques de código de la que te hablo?. Tanto en Pseudocódigo como en Diagrama de Flujo y en Python; por supuesto!

Comencemos por algo fácil. El boceto anterior que vimos de un programa que basado en un algoritmo básico era capaz de calcular el promedio de tres notas de un alumno. ¿Recuerdas?. Fíjate:

Programa basado en algoritmo que calcula los promedios de un alumno (Pseudocódigo):

{Calcular_promedio_Alumnos}
var                                                             #Define variables:
real: n1, n2, n3, promedio                                      #Tipo; variables
Inicio                                                          #Inicia
    Escribir ("Ingrese la primer nota del alumno"); Leer (n1)   #Obtener notas:
    Escribir ("Ingrese la segunda nota del alumno"); Leer (n2)
    Escribir ("Ingrese la tercera nota del alumno"); Leer (n3)
    promedio <- (n1 + n2 + n3) / 3                   #Algoritmo calculo
Escribir ("El promedio del alumno es", promedio)                #Mostrar resultado
Fin                                                             #Finaliza

Esta es la estructura básica que debemos seguir en Pseudocódigo. Primeramente se indica el nombre del programa o algoritmo. Luego debemos declarar las variables debajo de la palabra reservada «VAR». Para declarar las variables primero indicamos el «tipo de variable» (Entero, real, character, etc.). Y seguido de dos puntos «:» los nombres de las mismas. A diferentes tipos; se declaran en una línea aparte.

Siempre declaramos cuando inicia y termina un programa o subprograma (sub-algoritmo). Entonces colocamos Inicio.

Luego solicitamos al usuario que ingrese las notas y lo hacemos mediante la instrucción «Escribir o Mostrar»; que sería como un «print» en Python. La instrucción «Leer()» indica que se va a leer una entrada de datos y se aclara en que variable será almacenada; en este caso n1, n2 y n3. [Cuidado con confundir estas instrucciones; Leer (Es Entrada). Mostrar o Escribir (Es salida)]

Finalmente realizamos el cálculo matemático indicando que almacenamos el resultado en la variable «promedio». Para indicar que un dato se almacena en una variable yo utilizo flechas (<-)

Finalmente y como es debido; mostramos el mensaje y el valor de la variable promedio. Seguido damos por finalizado nuestro programa colocando «Fin»

Programa basado en algoritmo que calcula los promedios de un alumno (Diagrama de Flujo):

Vamos a representar el mismo programa pero en Diagramas de flujos. Presta atención a las figuras geométricas y las flechas que indican el orden de ejecución. Al finalizar el mismo explicaremos esto y te colocare las descripciones de cada figura.

1. 1. Indicamos el inicio.

   2. Luego solicitamos los datos al usuario y los almacenamos en las variables.

   3. Finalmente enviamos estos datos al «proceso de calcular el promedio».

   4. Expresamos el resultado al usuario.

   5. Finalizamos nuestro programa.

El diagrama de flujo facilita mucho expresar por primera vez un programa. Más sencillo e informal que el pseudocódigo es ideal para dibujar rápidamente una idea.

Fíjate aquí tienes en una sola imagen las figuras geométricas y a que estructura corresponden:

Pero el pseudocódigo es más fácil de traducir a cualquier lenguaje sin desviarnos demasiado del proyecto original. Te recomiendo que pruebes representar una aplicación sencilla primero en Diagramas de flujo; luego traducirla a pseudocódigo y finalmente a Python. Veras que hay muchísima similitud entre ambos últimos y además notaras cierto perfeccionamiento en el traspaso de uno a otro!

Programa basado en algoritmo que calcula los promedios de un alumno (Python):

Vamos a traducir nuestro «boceto de programa» a un lenguaje de alto nivel que pueda comprender e interpretar nuestro ordenador.

Puesto que los anteriores son lenguaje y representación gráfica orientada al entendimiento meramente humano.

Lograras ver así la similitud de Python con el Pseudocódigo y gracias al Diagrama de Flujo comprenderás desde diversas representaciones el mismo programa. Las ventajas son muchas puesto que teniendo estas representaciones cualquier programa puede ser traducido fácilmente a otro lenguaje por un programador que quizás no comprenda Python.

Y también nos permite diseñar un programa; en colaboración con otras personas.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#  Calcular_promedio_Alumnos.py                                         #Nombre
                                                                        #Declaramos variables
n1 = 0
n2 = 0
n3 = 0
promedio = 0
                                                                        #Inicio
n1 = int(input("Ingrese las notas del alumno: n"))                      #Solicitamos
n2 = int(input("Ingrese las notas del alumno: n"))
n3 = int(input("Ingrese las notas del alumno: n"))
                                                                        #Calc de promedio
promedio = ((n1 + n2 + n3)/3)
                                                                        #Mostramos el resultado
print ("El promedio del alumno es:", promedio)
                                                                        #Fin

Como sabrás no era necesario declarar las variables al inicio en Python; pero intento demostrar la similitud con el pseudocódigo. También hay que recordar que en Python no necesitamos especificar el tipo de variable.

Elementos y estructuras de programación

Como sabrás si has completado el módulo básico de Python que propongo en mi sitio. Entenderás que has aprendido por pasos y nivel de dificultad ciertos elementos que se encuentran en la mayoría de lenguajes de alto nivel de programación. Como lo son Variables; Funciones; condicionales; bucles; etc.

Ahora; esos elementos se denominan estructuras y son comunes a casi todo lenguaje y representación de programa.

Así que vamos a verlos detenida, pero rápidamente. Para que tu tengas todo el conocimiento general necesario; para Python o para cualquier otro lenguaje.

Palabras reservadas

Recuerdas que hay ciertas palabras en Python que ejecutan una función específica. Y son reservadas propias del lenguaje, es decir, que no se pueden reutilizar si no es para la función designada. Por ejemplo: No podemos crear una función «print» porque ya existe y es palabra reservada. Palabra santa!!

Las palabras reservadas en Python son las siguientes:

También los operadores son reservados!

Expresiones

Son combinaciones de constantes; variables; y operadores para ejecutar una operación y son interpretadas según las normas de asociación del lenguaje. Ejemplo: c = (a+b)

Instrucciones

Son el conjunto de datos insertados en una secuencia estructurada especifica que el procesador interpreta y ejecuta. Es lo que habitualmente llamamos sentencia y varían su sintaxis según el lenguaje de programación. Ejemplo: print(a).

Identificadores

Los identificadores son los nombres o etiquetas que le damos a los elementos. Por ejemplo el nombre de una variable es un identificador!. Ejemplo: Nombre_Alumno. En los mismos tampoco se pueden utilizar palabras reservadas..

Caracteres especiales

Son caracteres como por ejemplo la coma; punto y coma; etc. Que son parte del lenguaje o algoritmo y estas varían según el lenguaje en que trabajamos. Por ejemplo compara C con Python. Hay elementos en C como el punto y coma que toman otra relevancia luego de una instrucción.

Constantes

Así se les llama a los datos que no van a modificarse en la ejecución del programa. Puede ser una variable de referencia que no cambia su valor.

Variables

Ya debes saberlo mejor que yo!. Son aquellos elementos que permiten almacenar datos simples y estructurados. Y pueden ser modificados durante la ejecución del programa.

El tipo de variable está definido por el tipo de dato (simple o estructurado) y el tipo de valor que almacenan:

Mantén tus datos fuera de los nombres de variable(Ingles)

Tus nombres de variables son horribles. (Ingles)

Estructuras de datos

Universalmente en la programación se reconocen tipos de datos simples y estructurados.

Datos simples

Podemos definir un dato simple como aquel que permite que una variable pueda almacenarlo como un único valor de ese único tipo.  No podría ser un dato simple un conjunto de valores (porque es más de uno), ni por sobre todas las cosas de «diferentes tipos».

Tipos de datos simples:

• Datos Lógicos (True o False) [Booleanos]
• Tipos de datos Enteros (Números enteros: -3, -2, -1, 0, 1, 2 ,3..)
• Datos de Coma flotante (Números decimales: -1.0001, 1.9991, 3.14966, 1.0003..)

Estos datos simples son almacenados en variables de tipo simple como pueden ser:

Tipos de variables cuantitativas simples:

• Int (Enteros, Reales); En python
• Float (Flotantes o decimales); En python
• Real (Números reales)
• etc.

Tipos de variables lógicas:

• Bool: (True o False)

Datos estructurados

Así como existen los datos simples; también los datos estructurados que exigen el uso de otro tipo de variables con la finalidad de permitirnos almacenar estructuras de un conjunto de datos simples y estructurados. Cada lenguaje tiene diferentes tipos de estructuras y diferencias en cuanto al almacenamiento y sintaxis.

Ojo no te confundas; recuerda que una cosa es el tipo de dato y otra la variable.

CUIDADO: ERRORES DE CONCEPTOS, DEFINICIONES, NOMENCLATURAS

SEPARADOR- Veamos entonces los principales tipos de datos estructurados de la mayoría de los lenguajes de programación. Comenzando por Arrays; Cadenas; Registros. Luego seguiremos con listas; tuplas y conjuntos

Arreglos (Arrays) 

Los arreglos son un conjunto o estructura de datos simples homogéneos (es decir del mismo tipo) que se encuentran almacenados de forma consecutiva en la memoria. Definido formalmente como: «grupo o colección finita, homogénea y ordenada de elementos». Estos también constan de diferentes tipos según su dimensión (Unidimensionales, Bidimensionales y Multi-dimensionales)

Un arreglo tiene en común en cualquier lenguaje las siguientes características:

1. Todos sus elementos tienen el mismo tipo.
2. En general su tamaño debe ser fijo; es decir, que no debe cambiar durante la ejecución.
3. Se ocupan generalmente para almacenar datos numéricos.

Así también a los arreglos se los conoce como Vectores o Matrices en matemáticas.

Entonces, venga a explicar esto facilito y rapidito:

Asocia para no olvidar arreglo con regla. Puesto que podemos «reglar» los elementos consecutivos del mismo tipo a partir de un índice. Y eso sería algo así:

Como puedes ver en la imagen este es un arreglo unidimensional (de una sola dimensión) que consta de números enteros (mismo tipo). A los cuales podemos referenciar a partir de un indice (el que se encuentra en corchetes debajo).

Al ser Unidimensional como te expreso más arriba este arreglo está formado por una sola fila. Y nos podemos referir a sus elementos mediante la utilización de índices los cuales son correlativos– (tienen una correspondencia o relación con los elementos). Además existen diferentes tipos de indices dependiendo su base. En Python generalmente son en base cero. Es decir que comienzan a contar a partir del cero hasta «n» siendo «n» variable. También los podemos encontrar que empiecen a contar a partir de uno (base 1) [Como el ejemplo]. O base n; desde cualquier número.

• Haaa entonces una Lista en Python es un arreglo!
• No0, cabrón! (Gracias @Al). Revisa las características de los arreglos que especificamos más arriba.

Una lista en Python no es un arreglo; puesto que puede modificarse en tiempo de ejecución y además una Lista nos permite almacenar diferentes tipos de datos.

Para utilizar «estrictamente» un arreglo en Python. Debemos hacerlos mediante el módulo Array o NumPy.

¿Pero para que crear un Array (Arreglo) usando este módulo si en Python lo podemos hacer mediante una Lista o una Tupla?

Es obvio que es infinitamente mejor si solo programamos en Python sin ningún requisito, pero.. Si alguien te pidiera hazme un Array en Python y tu le hicieras una Lista, te la vas a pasar mal!

Estoy enseñando fundamentos!!. Y puede que quieras aprender otro lenguaje; luego te hablaran de arrays y tu creerás que es una Lista.

Y esto sucede porque Python es un lenguaje orientado a objetos!

Y hay una variación también de la nomenclatura de las estructuras de datos.

Así que veamos un poco mas de los Arrays y su utilidad en programación. Vamos a verlo en Pseudocódigo, pero rapidito que esto va para largo:

En pseudocódigo un arreglo unidimensional y bidimensional se declara así:

//Arreglo o vector Unidimensional ##########################

entero: Numeros[7]

// Arreglo de 7 elementos de tipo entero

//La sintaxis utilizada a menudo es la siguiente:

//<Tipo><Nombre del array><datos>

//Arreglo o vector Bidimensional ##########################

entero: Tateti [3][3]

//La sintaxis es igual pero se añade filas y columnas deseadas
//creando así una Matriz de 3 x 3

Aquí te dejo mas sobre Arreglos y Vectores en pseudocódigo para complementar tu aprendizaje. Ademas fíjate que puedes recorrerlos mediante bucles de iteración. Fíjate:

Arreglos y recorrido en Pseudocódigo

No voy a reinventar la rueda: Puedes ver aquí cómo crear Arrays en Python y trabajar con ellos en los siguientes tutoriales:

Crear Arrays con NumPy (módulo) en Python

Arrays en Python con el módulo Array

Cadenas (Caracteres o char)

Con lo que mas solemos trabajar en Python en el módulo primero es con cadenas de caracteres. Y no es muy difícil de comprender este tipo de dato estructurado puesto que hablamos de una secuencia ordenada y finita de caracteres (pueden ser símbolos y también números [expresados entre comillas])de un lenguaje en particular. Así sin más.

En Python como habrás visto se indica mediante las comillas simples, dobles o triples. Utilizamos preferentemente las simples cuando se trataba de una cadena corta y sin saltos o espacios. Las dobles para cadenas mas largas y con espacios pero sin saltos de línea u conformación de un párrafo. (Por preferencia de un orden para el programador)

Y finalmente las comillas triples yo las suelo utilizar únicamente para párrafos largos. De esa manera también mantengo un orden personal y coloración diferente en el IDE. Pero es mi caso..

Algunos programadores suelen utilizar las comillas triples para los Comentarios. Pero no se recomienda en Python puesto que el intérprete nos lanza un error de sintaxis. Aun así aquí varía mucho también de gustos y colores; y el lenguaje obviamente.

Recordemos que las cadenas de caracteres almacenadas en una variable en el caso de Python pueden ser STR o UNICODE. En este caso nos referimos al tipo de variable; automáticamente asignada en Python en caso de no especificar. Pero en otros lenguajes es requisito especificarle antes el tipo de variable donde se aloja la cadena como «Char, Str, string, etc».

Las cadenas también pueden ser Estáticas o Dinámicas. Es decir, que pueden o no ser modificables en tiempo de ejecución dependiendo el lenguaje y cómo se las trabaje.

Podemos realizar operaciones también con cadenas (importante recordar):

• Concatenación: Unir dos o más cadenas.
• Asignación: Asignar una cadena a otra.
• Búsqueda: Consiste en localizar dentro de una cadena un carácter o cadena mas pequeña.
• Extracción: Extraer o sacar una porción de la cadena.
• Comparación: Comparar la coincidencia exacta de una cadena con otra.

Escapes de cadena en Python:

En Python como en otros lenguajes; podemos escapar de una cadena.

¿Qué es escapar de una cadena?.

Es cuando deseas imprimir una palabra fuera del contexto que podría darle el lenguaje; un símbolo u otro elemento que podría pertenecer a la semántica del lenguaje en el cual estas programando. Supongamos la siguiente cadena en Python:

print ("Hola estas son comillas dobles: \" ")

Fíjate este es el resultado en el intérprete de Python:

Si quisiéramos imprimir algo como el ejemplo debemos escapar de la cadena antes de las comillas para especificarle al interprete que no se trata de un carácter reservado del lenguaje. Para esto recurrimos a una Secuencia de escape:

Siguiendo la tabla lo hacemos mediante un:

print ("Hola estas son comillas dobles: \" ")

Así en cada lenguaje encontrarás distintas secuencias de escapes para diferentes motivos. Aunque por cierto son bastantes similares. Como también encontraras formatos de salidas como vimos en format en Python.

Registros (record)

Al ser Python un lenguaje orientado a objetos como hemos dicho antes tiene Clases pero no Registros. Igualmente vamos a aprender qué son los registros y cómo los creamos en Python (haciendo trampa). También veremos rápidamente clases y su utilidad.

Veamos primero qué es un registro:

Los registros son estructuras de datos cuyos elementos pueden ser de diferentes tipos. En los mismos podemos almacenar diferentes datos pertenecientes a un mismo objeto.

Cada elemento se almacena en un campo de registro independiente y puede ser referenciado por su nombre.

También, se puede decir que un registro (record) es un tipo de dato estructurado que consta de un conjunto de elementos que pueden ser del mismo tipo o no. Los componentes de un registro se denominan campos, cada campo tiene un nombre llamado identificador del campo.

Para imaginarme y recordar los registros como tales me gusta imaginarlos como una hoja de una persona dentro de un archivador. Dicha hoja tiene campos: (Nombre; Apellido; Edad; Estado Civil; etc.) Y son los mismos en todas las hojas; solo cambian los datos que colocamos en ellos. Luego para acceder debemos referenciar dicho campo; por ejemplo el de Nombre de la persona. (Podríamos referenciar así [si el registro se llamará archivo]: Archivo.Nombre) Así encontramos el campo que buscamos!

Veamos un ejemplo de registro en Pseudocódigo:

Registro: empleado    //#Comienza registro, datos:
    Entero: edad, asistencia, inasistencia
    Real: salario
    Cadena: Nombre, Apellido
fin_registro         //#Termina registro
Var
    Obrero: empleado
    
###Algoritmo ingresar datos al registro######
Inicio
Mostrar ("Ingrese los datos del empleado")
Leer (Obrero.Nombre, Obrero.Apellido, Obrero.edad, Obrero.asistencia
Obrero.inasistencia)    //##Lee los datos ingresados

Mostrar ("Los datos del obrero son")
Mostrar ("Nombre", Obrero.Nombre)
Mostrar ("Apellido", Obrero.Apellido)
Mostrar ("edad", Obrero.edad)
Mostrar ("Asistencia, Obrero.asistencia")
Mostrar ("Inasistencia, Obrero.inasistencia")
Fin

En este ejemplo trato de mostrar la creación de un Registro básico. Por supuesto que se puede perfeccionar más añadiendo al mismo un Array y almacenando mediante iteración una ficha de empleado distinta en cada Índice del mismo. Ahí es donde recurro al ARCHIVADOR (Array) que mencione arriba; donde ordeno por N° de folio (Índice del Array) y luego itero como un desgraciado robot mediante un bucle desde/para (tipo For en Python). Supongamos..

Puesto que en este ejemplo solo podríamos almacenar «los datos de un solo empleado»

También, fijarse como referenciamos cada campo por su nombre para acceder al registro y no por un índice como lo haríamos con un vector o Array.

La diferencia entre Registro y vectores o Arrays. Es que en los registros los datos pueden ser de diferentes tipos mientras que en el vector o Array deben ser del mismo tipo. Además a los registros accedemos preferentemente mediante el nombre de campo seguido del carácter reservado «.».

Entonces no es lo mismo Array que Registro, ni que Lista! Ni registro lo mismo que clase (aunque a veces se parecen) OJO al PIOJO!. Que luego te acabaras rascando la cabeza!

SEPARADOR CUTRE- Aprendemos a trabajar con arrays y registros en Pseudocódigo

Aprendiendo a trabajar con Arrays y Registros en Pseudocódigo:

Entonces si quisiera almacenar los datos de diversos empleados en un registro que sea recorrible mediante un bucle de iteración. ¿Como lo haría?

• Pues ordenando el registro mediante un array y luego iterando!! Venga vamos a cacharrear un poquillo:

 
Tipo 
    Registro: empleado //#Comienza registro, datos:
    Array [1..20] de empleado : vector
    Entero: edad, asistencia, inasistencia 
    Real: salario 
    Cadena: Nombre, Apellido 
    fin_registro //#Termina registro 
    
    Var 

    vector : id
    
###Algoritmo ingresar datos al registro###### 
Inicio
entero: i
    Para i<-1 hasta 20 hacer:
        Mostrar ("Ingrese los datos del empleado") 
            //##Lee los datos ingresados 
        
        Leer (id[i].Nombre, id[i].Apellido, id[i].edad, id[i].asistencia id[i].inasistencia) 

            //#Muestra los datos ingresados
    
        Mostrar ("Los datos del obrero", id[i], "son:") 
        Mostrar ("Nombre", id[i].Nombre) 
        Mostrar ("Apellido", id[i].Apellido) 
        Mostrar ("edad", id[i].edad) 
        Mostrar ("Asistencia, id[i].asistencia") 
        Mostrar ("Inasistencia, id[i].inasistencia") 
    
Fin_procedimiento

Si te fijas bien el código es muy similar al anterior solo que ahora estamos utilizando un bucle Desde / para que nos permite iterar desde 1 hasta 20 correspondiendo con el índice de nuestro vector y así referenciamos los datos de cada empleado. Por supuesto esto es un simple boceto, a la ligera, una tirada mía.

Pero si quisiéramos luego buscar el empleado «Marcelo contrera» supongamos; podemos iterar mediante bucle Desde / Para (desde 1 hasta 20 que es la longitud de nuestro vector) especificando el campo .Nombre == «Marcelo» como un condicional.

Intento hacerte pensar como un programador, fuera de tu lenguaje, fuera de Python!!. Pero como ves es similar; recurrimos a estructuras similares que funcionan de manera muy similar.

Si nos saliéramos de Arrays y registros esto en Python lo podemos hacer recurriendo a clases fíjate aquí:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  juan.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro> https://pythones.net
#  

x = list(range(2)) #Creamos una lista usando RANGE (desde el 0 al 2)
i = 0 #Indicamos el valor de i que sera de donde comience a iterar el bucle
indice = 0


class empleado(): #Definimos la clase empleado
		
	def __init__(self, nombre, apellido, edad, asistencia, inasistencia, salario):
		self.nombre = nombre #indicamos los atributos (no es necesario)
		self.apellido = apellido
		self.edad = edad
		self.asistencia = asistencia
		self.inasistencia = inasistencia
		self.salario = salario
	pass

#ATENCIÓN AQUÍ

Empleados = [empleado("","",0,0,0,0) for i in x]
#Creamos una lista llamada Empleados donde cada iteración del bucle for
#  (desde i hasta x) creara un objeto con la clase como elemento de lista.

	

print ("Bienvenido a registro de empleados")
#ATENCIÓN AQUÍ
#Creamos otro bucle for! Entonces iteramos para cada empleado en EMPLEADOS
for empleado in Empleados:
	print ("---------Ingresar nuevo empleado------------")
	print ("\n El empleado sera guardado con el indice:", indice, "\n")
#Indicamos el indice donde sera guardado al principio de cada vuelta
	empleado.nombre = input(str("Ingrese el nombre del empleado: "))
	empleado.apellido = input(str("Ingrese el apellido del empleado: "))
	empleado.edad = input(("Ingrese la edad del empleado: "))
	empleado.asistencia = input(("Ingrese la asistencia del empleado: "))
	empleado.inasistencia = input(("Ingrese la inasistencia del empleado: "))
	empleado.asistencia = input(("Ingrese el salario en USD del empleado: "))
	print ("###############Exito###################")
	print("El empleado fue guardado en el registro de empleados \n \n")
#Sumamos 1 al indice para el siguiente empleado
	indice = indice + 1

#Entonces finalmente tenemos una lista llamada EMPLEADOS donde cada item es un objeto
# de la clase empleado()
#Para acceder solo indicamos el indice de la lista y el atributo
# que nos interesa, por ejemplo:

print (Empleados[1].nombre)

OTRO SEPARADOR CUTRE – Veamos ahora un poco de Listas, Tuplas y Diccionarios; luego tratemos de traducir el programa anterior que usamos como ejemplo de registros a Python; pero usando CLASES.

Listas; tuplas; range y diccionarios – Python

Como ya hablamos antes y cualquier aprendiz de Python comprende tanto las listas; como las tuplas y diccionarios pertenecen al tipo de variables que nos permiten almacenar datos estructurados. Ya vimos listas; tuplas y diccionarios en los siguientes post:

• Listas, tuplas y range en Python
• Diccionarios en Python

Pero veamos rápidamente una Lista:

1. Son similares a los arrays (aunque no son lo mismo como ya explique). Pero con la diferencia de que son MUTABLES (es decir como las clasificamos más arriba; dinámicas).
2. Las listas nos permiten ordenar datos simples o estructurados dentro de ellas para referenciarlos posteriormente a través de un indice.  (Las listas no solo pueden almacenar números y cadenas. Pueden almacenar también otros tipos de datos; como por ejemplo objetos)
3. Las listas pueden ser creadas a través de bucles; o mediante funciones por ejemplo random().
4. Una lista al poder contener diferentes tipos de datos también puede contener otra lista. (Listas anidadas)

Ejemplos de creación de una lista rápidamente:

lista = list(range(2,14)) print (lista)

Resultado:

Explicación del código:

Recurrimos al tipo de dato estructurado Range que crea un rango de números y lo almacenamos en una lista usando la función List. De lo contrario los datos brindados por range quedarían almacenados implícitamente en memoria pero no dentro de una variable.

También como dijimos podemos crear una lista mediante el uso de bucles for:

ListaCuadrados = [x**2 for x in range(10)]
print (ListaCuadrados)


#ListaCuadrados = [<expresión> para x en rango (1..10)] <- Explicación for
# o
# seria lo mismo que (Pseudocódigo):

# Para x en rango(1..10) hacer:
#     ListaCuadrados <- x**2

Resultado:

Puedes encontrar más en Iterables por comprensión en mi blog. En este post también encontraras como crear diccionarios utilizando Dict o a travez de bucles, etc.

¿ Y las tuplas (h,i,j,o, d,e, p,u,t,a,s)?

Como ya sabes las tuplas son diferentes de las listas por no ser modificables en tiempo de ejecución. Aunque parecen una mierda, puesto que uno se debe plantear ¿Quién carajos va a usar una tupla cuando puede usar una lista?. ¿Así como para que quiero un jodido array si puedo usar una lista?.

Y también así haciéndote esas preguntas es como todo cobra sentido. Si no estuvieras programando en Python estarías muy jodido.

Las tuplas entonces son secuencias inmutables de objetos arbitrarios y pudiendo ser de diferentes tipos.

Utilizar una tupla en vez de una lista nos brinda los siguientes beneficios:

• Reducido espacio de almacenamiento.
• Menor consumo de procesamiento al accederlas.
• Podemos utilizarlas como claves de diccionarios; no así las listas porque son mutables.
• El famoso empaquetado y desempaquetado de tuplas.

Existe una manera de pensar a las tuplas como algo similar a un registro. Como una base de datos donde alojamos aquellos datos que son de referencia y sabemos no requieren ser modificados.

Entonces es buena practica de programación almacenar datos en tuplas que no requieres almacenar en una lista puesto que sabes NO VAS A MODIFICAR EN EJECUCIÓN. Supongamosle como ejemplo: los días de la semana. (Cambian en el calendario pero siempre van a denominarse igual, por lo que seria innecesario almacenarlos en una lista.)

Puedes buscar más sobre tuplas en Python en google, te aseguro que hay mucho que a mi se me ha pasado por alto explicar en mi blog. No lo hice a propósito (obviamente)

Como bien también exprese anteriormente existen amplias diferencias entre Listas y tuplas. Así como también explicamos que Range a partir de ahora en Python se considera un dato estructurado y NO UNA FUNCIÓN.

Lo que me interesa destacar en este post; es que amplíes el abanico de tus ideas. Piensa como en el ejemplo anterior como logramos crear fácilmente una lista mediante Range; similar a un Array. Y como logramos también almacenar objetos dentro de otra lista para su posterior iteración.

Normalmente si pensamos en la utilidad de una lista nos mantenemos llanamente en almacenar números, letras o palabras. Cuando combinando este tipo de datos con bucles lograremos darle una utilidad increíble a la vez que nos permite ahorrar mucho esfuerzo y lineas de código!

Pero se nos exige conocer y comprender bien los fundamentos de programación; sintaxis del lenguaje que trabajamos (en este caso Python). Y una cierta practica que se consigue «picando código»; es decir, escribiendo mucho código diario!

Si tu revisas códigos de cuando comenzabas a aprender Python vas a darte cuenta que quizás una Lista que creabas especificando ítem por ítem, ahora la puedes crear con una sola linea de código mediante un range!. O podrías cargar archivos de textos y mediante iteración convertirlos en lista para trabajar con esos datos que almacenaba.

Y muchas veces no hay una sola manera de estructurar un código o programa. Pero si hay una manera más optima que es a la que debes aspirar. Con obvia intención de optimizar pero continuar comprendiendo lo que escribes!

Y los diccionarios..

Joder no se termina nunca este post! Llevo como tres semanas en esto me quiero morir!

Ya definimos diccionarios como:

Estructuras de datos utilizadas para mapear claves arbitrarias a valores.

Un diccionario nos permite almacenar datos al igual que una lista. Pero con la diferencia de que podemos acceder a ellos a través de una Key (clave); a diferencia de un indice. Recordemos que una Key para un diccionario puede ser cualquier elemento INMUTABLE!. ¿Quieres usar como Key una tupla?, pues se puede.

Y los Value (valores) pueden ser cualquier elemento MUTABLE, como una lista si se quiere.

Así cada clave referencia a un valor!. No voy a hablar de la sintaxis y demás puesto que para eso esta la entrada en mi blog: Diccionarios en Python

Algo mas a aclarar de los diccionarios en Python. Los mismos se crean como instancia de la clase primitiva dict. Lo que quiere decir, en mal modo que los diccionarios están basados en una clase preestablecida por el lenguaje.

Fíjate en el interprete de Python:

Pero no debemos confundir clases con diccionarios. ojo!

Los diccionarios son útiles:

• Para almacenar y estructurar datos referenciandolos por Keys en vez de utilizar indices; para cuando una lista se pone muy grande y difícil de recordar el indice. Si trabajáramos con muchos datos por ejemplo de una persona; convendría utilizar diccionarios y no listas. Puesto que así evitamos memorizar los indices.
• Intenta mantener una estructura visualmente ordenada cuando programes para declara diccionarios; es mejor así (ejemplo):

test = { 
'Nombre' : 'Marcos',
 'Apellido' : 'Logan',
 'Edad' : 0,
 'Respuesta1' : 0,
 'Respuesta2' : 0,
 'Respuesta3' : 0
}

• Que así:

test = {'Nombre' : 'Marcos', 'Apellido' : 'Logan', 'Edad' : 0, 'Respuesta1' : 0, 'Respuesta2' : 0, 'Respuesta3' : 0}

Tus ojos te lo agradecerán algún día!

1. Mantén los datos ordenados; el código limpio y comentado.
2. Hazlo simple y respetuoso. Los diccionarios desordenados son causantes de muchos errores de sintaxis.
3. Recuerda siempre el zen de python!

Separador cutre – Veamos ahora un poco de clases!

Clases ( OOP)

Los lenguajes de programación modernos orientados a objetos (OOP) cuentan con estructuras de clases.

Las clases no son un tipo de dato estructurado; sino más bien una agrupación de las variables de diferentes tipos, métodos y eventos. 

La wikipedia define una clase en programación como:

Plantilla para la creación de objetos de datos según un modelo predefinido. Las clases se utilizan para representar entidades o conceptos como los sustantivos en el lenguaje.

Cada clase es un modelo que define un conjunto de variables; el estado;  y métodos apropiados para trabajar con dichos datos (su comportamiento).

Ya vemos clases en el módulo de 2 de Pythones. Aunque un poco cutre y rápido lo admito: debo completarlo aún más. Pero si aun no entiendes el concepto de clases es muy sencillo; se trata de una Plantilla o Modelo (un molde) para crear objetos (crear un objeto a partir de clase: instanciar) con características similares y trabajar con ellas. Así las clases cuentan con herencia. Y también nos permiten la encapsulación de datos para evitar que sean accesibles desde el exterior de la clase.

Pero solemos ver a las clases como algo ajeno a la programación diaria en Python, como si se tratara de «estilos». Pues no, las clases son más que eso!!

Imagínate una clase como un conjunto de lineas de código que determinan las características que tendrán todos los objetos que tu crees a partir de ellos.

Un programador que comprenda los beneficios de la clases estoy seguro que va a utilizarlas!

No voy a explicar aquí todo sobre clases.. Para eso esta el módulo 2 en mi blog..

Ahora si quisiéramos traducir nuestro programa anterior creado en Pseudocódigo utilizando Array y registros.

¿Como lo haríamos en Python utilizando clases y listas?

Yo lo hice así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  juan.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro> https://pythones.net
#  

x = list(range(2)) #Creamos una lista usando RANGE (desde el 0 al 2)
i = 0 #Indicamos el valor de i que sera de donde comienze a iterar el bucle
indice = 0


class empleado(): #Definimos la clase empleado
        
    def __init__(self, nombre, apellido, edad, asistencia, inasistencia, salario):
        self.nombre = nombre #indicamos los atributos (no es necesario)
        self.apellido = apellido
        self.edad = edad
        self.asistencia = asistencia
        self.inasistencia = inasistencia
        self.salario = salario
    pass

#ATENCION AQUI

Empleados = [empleado("","",0,0,0,0) for i in x]
#Creamos una lista llamada Empleados donde cada iteración del bucle for
#  (desde i hasta x) creara un objeto con la clase como elemento de lista.

    

print ("Bienvenido a registro de empleados")
#ATENCION AQUI
#Creamos otro bucle for! Entonces iteramos para cada empleado en EMPLEADOS
for empleado in Empleados:
    print ("---------Ingresar nuevo empleado------------")
    print ("\n El empleado sera guardado con el indice:", indice, "\n")
#Indicamos el indice donde sera guardado al principio de cada vuelta
    empleado.nombre = input(str("Ingrese el nombre del empleado: "))
    empleado.apellido = input(str("Ingrese el apellido del empleado: "))
    empleado.edad = input(("Ingrese la edad del empleado: "))
    empleado.asistencia = input(("Ingrese la asistencia del empleado: "))
    empleado.inasistencia = input(("Ingrese la inasistencia del empleado: "))
    empleado.asistencia = input(("Ingrese el salario en USD del empleado: "))
    print ("###############Exito###################")
    print("El empleado fue guardado en el registro de empleados \n \n")
#Sumamos 1 al indice para el siguiente empleado
    indice = indice + 1

#Entonces finalmente tenemos una lista llamada EMPLEADOS donde cada item es un objeto
# de la clase empleado()
#Para acceder solo indicamos el indice de la lista y el atributo
# que nos interesa, por ejemplo:

print (Empleados[1].nombre)

Resultado:

Te invito a que pruebes el código.

Como podrás analizar:

1. Primero creamos la clase de la forma típica como ya explique en el módulo 2 sobre clases.
2. Creamos la variables X e I. Las cuales almacenan el valor para controlar el bucle for que determina cuantos empleados tiene nuestra lista.
3. Mediante un bucle for creamos la lista Empleados que instancia (crea objetos basados en nuestra clase con los argumentos por defecto) hasta el valor de X. Entonces nos queda una lista con los objetos cuyos argumentos son los por defecto. Pero ahora tienen un indice proporcionado por la lista!!!
4. Luego debemos entonces iterar esa lista (Empleados) e ir agregando los argumentos para cada atributo. Mientras especificamos el indice en que se van a guardar al comienzo del bucle. Y al final le sumamos 1 a ese indice para que en la vuelta siguiente «Muestre» que indice lleva el empleado siguiente. De esa forma quien añade los empleados sabe en que indice de la lista Empleados son añadidos para facilitar su búsqueda.
5. El resto se comprende facilito.

El uso de la variable «indice» es nada mas que para una guía del usuario del programa.. Lo que determina el verdadero orden esta en que estamos trabajando dentro de una lista de objetos (la cual nos permite referenciar por indices)..

Ahora si comparamos el pseudocódigo con el código en Python notaras las siguientes diferencias:

1. Obviamente en el primero utilizamos Arrays y Registros. Mientras que en Python recurrimos a Listas y Clases.
2. En el primer código simplemente referenciabamos el indice del vector y allí almacenábamos los datos en cada vuelta de bucle. Mientras que en Python primero creamos la lista con los objetos y luego les pasamos los argumentos para sus atributos en cada vuelta de bucle. (La intención es la misma; ordenar los datos dentro de un indice, por pseudocódigo mediante vector y en Python mediante una Lista)
3. En python me explaye un poquito mas en la terminación del programa; dando lugar a una mejor experiencia de usuario, pero pura tontera nada más..

Si quisiéramos llevar este programa a un mejor nivel podríamos crear luego un bucle for que le pregunte al usuario de que empleado quiere visualizar los datos y mediante el indice de la lista se los mostramos. O podrías incluir un algoritmo de búsqueda que recorra la lista buscando por el atributo «.nombre», «.edad», etc de cada empleado. Y por supuesto si cierras el programa se borraran los datos; no te creas aquí que esto se almacena en una base de datos externa. Tu solo estas guardando los datos en tiempo de ejecución!

Subrutina o Sub-Algoritmo (Funciones y procedimientos)

Como ya habrás visto anteriormente conocemos las funciones como Subrutinas o Subprogramas. Como idea principal representa un Subalgoritmo que forma parte del algoritmo principal. Y ya dijimos en la entrada referente a funciones estas nos sirven entre otras cosas para reutilizar bloques de código.

Al ser posible declarar un bloque de código con un identificador nos brinda la ventaja de poder llamarlo posteriormente las veces que se lo requiera. Así podemos reconocer una función en diversos lenguajes como subrutinas o subalgoritmos.

De no incluir los subagoritmos resultaría muy tedioso elaborar un programa complejo. Puesto que se incrementaría mucho la cantidad de lineas de código.

El uso de subalgoritmos (subrutinas) nos permite dividir un problema complejo en sub-problemas más pequeños y sencillos.

Recordemos también que las funciones o subalgoritmos pueden recibir datos y retornarnos un resultado al algoritmo principal o a otro subalgoritmo según se especifique (y según el lenguaje).

Así las funciones tienen tres componentes muy importantes:

• • 1. Parámetros: Identificador para los valores que recibe la función como entrada.
    2. Bloque de código: las instrucciones que conforman un bloque de código perteneciente a la función y encargados de procesar los datos.
    3. El retorno o resultado: Datos que provee la función a otra función o algoritmo principal.

Pero ademas de funciones nos podemos encontrar con Procedimientos.

Diferencia entre procedimiento y funciones:

Existen los llamados procedimientos que burdamente podría describirlos como funciones sin devolución de resultado. Entonces es un subprograma o subalgoritmo que realiza una tarea determinada dentro de un programa o algoritmo principal pero no devuelve o retorna un resultado. Son también conocidos como procedimientos o funciones sin retorno.

Ejemplo de función en pseudocódigo; Diagramas y en Python

Vamos a ver ahora algunos ejemplos sencillos de funciones  y procedimientos para que comprendas mejor su funcionamiento. Además aprenderemos los diferentes tipos de paso por parámetros.

Como veníamos ejemplificaremos en Pseudocódigo; Diagramas y Python.

Vamos a suponer como ejemplo el anterior «boceto de programa» y «programa en python» de calcular los promedios. Ese mismo; lo vamos a convertir en función!.

No voy a volver a citar tooodo el código ni el diagrama así que aquí te dejo en enlace para revisarlo: Puff hacia arriba!

Vamos a convertir en función el calculo del promedio; en Pseudocódigo lo hacemos así:

#############################Función####################################
Real funcion calcular_Promedio (Real: n1, n2 ,n3)
VAR #LOCAL HEEE!
    Real: promedio
    Inicio
    promedio<- ((n1 + n2 + n3) / 3)
    retornar (promedio)
        Fin-funcion
#########################Algoritmo principal############################
{Calcular_promedio_Alumnos}
VAR #GLOBAL HEEE!
    Real: n1, n2, n3, resultado
Inicio
    Mostrar "Bienvenido profesor"
    Escribir ("Ingrese la primer nota del alumno); Leer (n1)
    Escribir ("Ingrese la segunda nota del alumno); Leer (n2) 
    Escribir ("Ingrese la tercer del alumno); Leer (n3)
    resultado<-calcular_Promedio(n1, n2, n3)
    Mostrar "El promedio del alumno es", resultado
    Mostrar "Hasta luego profesor"
Fin
########################################################################

Fíjate en este ejemplo como declaramos una función en pseudocode y luego la invocamos en el algoritmo principal.
Ahora pasemos nuestro boceto en pseudocódigo a Python!

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  promedio.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
############################Función#####################################

def calcular_Promedio (n1, n2, n3):       #<- Definimos la función DEF
    promedio = 0.0                    #<- Variable local promedio
    promedio = ((n1 + n2 + n3)/3)     #<- Aplicamos nuestro algoritmo mat
    return (promedio)               #<- Retornamos el valor de variable
###########################Algoritmo Principal##########################
                                          #INICIO
print ("Bienvenido Profesor")
resultado = 0                             #Variable Global
n1 = float(input("Ingrese la primer nota del alumno: "))
n2 = float(input("Ingrese la segunda nota del alumno: "))
n3 = float(input("Ingrese la tercera nota del alumno: "))
resultado = calcular_Promedio(n1, n2, n3) #<-Almacenamos el retorno
                                          # de la función en la 
                                          #variable global resultado
print ("El promedio del alumno es", resultado)
print ("Hasta luego")
                                    
##################################FIN###################################

Como puedes ver existe en este ejemplo la variable promedio que esta declarada de manera local dentro de la función calcular_Promedio. Y la variable «resultado» que esta declarada de manera global la cual posteriormente recibe su valor de la variable promedio que es el retorno de la función. Por lo que podemos ejemplificarlo así:

resultado (Global) <- promedio(local de la función)

Algoritmo principal <- Función o sub-algoritmo

Variables Globales y Locales

Fíjate también en las variables que declaramos dentro de la función funcionan de manera LOCAL, es decir, que una variable declarada en una función; no es accesible fuera de ella. Como si lo es una variable GLOBAL (declarada en el algoritmo principal.)

Pero las variables dentro de las funciones también se pueden declarar como globales si así se requiere.

¿Porque es útil comprender la diferencia y aplicar estos conceptos?

Es útil diferenciar y aplicar variables como LOCALES cuando es necesaria una variable LOCAL.

Y GLOBAL; solo cuando es necesario que la misma sea GLOBAL.

Si recurrimos a declarar todas las variables como GLOBALES haciendo caso omiso a este fundamento corres los siguientes riesgos:

• Dificultas la legibilidad de tu código.
• Tu programa solo servirá para determinados casos.
• Puedes producir errores muy difíciles de resolver posteriormente.
• Puede ocasionar alteraciones no deseadas de variables globales dentro de las funciones.
• Atenta contra el principio de programación de la modularidad. Este supone no compartir memoria con otras funciones y optimizar el paso de información entre ellas para que la misma trate la información localmente.

Para declarar una variable como global dentro de una función. Permitiendo así que sea accesible fuera de ella utilizamos la palabra reservada «global» seguida de la variable.

«Técnicamente»

Pero suele producir algunos errores por lo que te recomiendo que declares las locales dentro de la función y las globales directamente en el algoritmo principal.  De esa manera no necesitas recurrir a la palabra reservada «global» y mantienes un orden de código limpio.

Funciones y variables dentro de clases (OOP)

Como ya sabes Python es un lenguaje también orientado a objetos y por ende solemos recurrir a la utilización de clases. Una función declarada dentro de una clase se suele denominar «MÉTODO« (o también «Funciones miembro»). Y las variables dentro de clases (de instancia) se suelen denominar «ATRIBUTOS« (o también «variables miembro»).

Pero no necesariamente debemos recurrir a clases; por esto es que Python como así también algunos otros lenguajes se denominan un lenguaje híbrido; permitiendo diferentes técnicas de programación (programación estructurada y orientada a objetos).

Recordando lecciones anteriores del módulo 2 de clases en Python podemos ejemplificar rápidamente a que nos referimos:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>

class Humano(object): #Creamos la clase Humano
    def __init__(self, edad, nombre): #Definimos el atributo edad
        self.edad = edad # Definimos que el atributo (variable local de instancia)
        self.nombre = nombre # Definimos que el atributo nombre(variable local de instancia)
 
    def hablar (self, mensaje):
        print (('-'), (mensaje))
        
    def correr (self, kilometros): #Definimos el método correr y usamos el parámetro kilometros
        self.kilometros = kilometros #El parámetro kilometros sera igual al arg que le asignemos
        print (("""Ha corrido"""), (kilometros), ("""km""")) #Imprimimos el resultado

Alberto = Humano(10, "Alberto")     #Instanciamos creando el objeto Alberto
Alberto.hablar("Hola soy alberto")      #Llamamos al método (función) hablar e 
                        #indicamos como argumento el mensaje
Alberto.correr(20)          #Llamamos método (función) correr e
                    #indicamos como argumento los kilometros

Resultado:

• Hola soy alberto
  Ha corrido 20 km

1. Definimos la clase Humano y heredamos de object
2. Construimos y dentro especificamos variables locales como «Atributos». Edad y Nombre
3. Definimos dentro de la clase la función (Método) «Hablar» con el parámetro «mensaje»
4. Definimos dentro de la clase la función (Método) «Correr» con el parámetro «kilometros»
5. Instanciamos (Creamos el objeto «Alberto, le damos los argumentos para las variables (atributos))
6. Llamamos a las funciones (métodos) del objeto instanciado brindando los argumentos para las mismas.

Por supuesto podemos crear funciones fuera de la clase también y llamarlas de la manera tradicional antes mencionada. Sabemos así que nos permite manejar ambos estilos de programación

Variables de clase (De clase y de instancia)

Como sabemos ya las variables de instancia dentro de una clase se denominan «ATRIBUTOS» pero recordemos que existen variables locales a la clase; por mal llamarlas. Son las variables de clase; que son accesibles únicamente dentro de la clase y que no requieren INSTANCIAR para ser utilizadas.

Y también existen las variables de instancia; que son aquellas que se relacionan con una única instancia de la clase. Es decir que por ende son accesibles luego de instanciar y mediante el objeto instanciado. ¿Nose si me explico bien?. Hagamos un ejemplo sencillo con el mismo código anterior:

En el código anterior estas son variables de instancia:

class Humano(object): #Creamos la clase Humano
    def __init__(self, edad, nombre): #Definimos el atributo edad
        self.edad = edad # Definimos que el atributo (variable local de instancia)
        self.nombre = nombre # Definimos que el atributo nombre(variable local)

Y como en el ejemplo no hay variable de clase local; vamos a crear una así:

class Humano(object): #Creamos la clase Humano
    Camina = True # Variable local de la clase estática
    def __init__(self, edad, nombre): #Definimos el atributo edad
        self.edad = edad # Definimos que el atributo (variable local de instancia)
        self.nombre = nombre # Definimos que el atributo nombre(variable local de instancia)

La diferencia es que para llamar a la variable LOCAL DE LA CLASE;  «camina». No necesitamos INSTANCIAR. Podemos mostrar su valor simplemente especificando la clase así:

print(Humano.Camina)

Resultado:

True

Funciones de clases (Métodos)

Como ya vimos existe una diferencia entre funciones y procedimientos. Y también existe una diferencia con los Métodos; puesto que estos pueden ser Funciones o procedimientos pero se corresponden a una clase, es decir, que se encuentran dentro de ella y son llamados a través de la instancia de la misma. Hemos visto numerosas veces como se crea un método en un clase en los ejemplos anteriores.

Tipos de parámetros en las funciones

• Debemos recordar que los argumentos se deben pasar según el orden de los parámetros! Y si deseamos modificar ese orden debemos especificar el valor del parámetro al pasar el argumento:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>

class Humano(object): #Creamos la clase Humano
    def __init__(self, edad, nombre): #Definimos el atributo edad
        self.edad = edad # Definimos que el atributo (variable local)
        self.nombre = nombre # Definimos que el atributo nombre(variable local)
 
    def hablar (self, mensaje, saludo):
        print (('-'), (mensaje))
        print (saludo)
        
    def correr (self, kilometros): #Definimos el método correr y usamos el parámetro kilometros
        self.kilometros = kilometros #El parámetro kilometros sera igual al arg que le asignemos
        print (("""Ha corrido"""), (kilometros), ("""km""")) #Imprimimos el resultado

Alberto = Humano(10, "Alberto")     #Instanciamos creando el objeto Alberto
Alberto.hablar(saludo = "Hola soy alberto", mensaje = "Me gustan las chicas")

Resultado:

• Me gustan las chicas
  Hola soy alberto

• Podemos declarar valores por defecto para los parámetros:

Si tratáramos de llamar basándonos en el ejemplo anterior la función (Método) correr de el objeto sin indicar como parámetro los kilómetros. (Ver el ejemplo) obtendríamos un error!. Mas específicamente al llamarlo así:

Alberto.correr()

Resultado:

El error nos esta especificando que no se brindo argumento para el parámetro correspondiente al método!! Y dicho error ocurre porque no hemos definido un valor por defecto para este parámetro. Si deseáramos añadir un valor por defecto podemos hacerlo así al momento de crear la función (Método):

    def correr (self, kilometros = 0): #Definimos el método. Especificamos el parametro y valor por defecto
        self.kilometros = kilometros #El parámetro kilometros sera igual al arg que le asignemos
        print (("""Ha corrido"""), (kilometros), ("""km""")) #Imprimimos el resultado

Entonces el valor «0» sera el parámetro por defecto para cuando no se especifique!

Podemos clasificar en la Mayoría de lenguajes de programación dos formas de paso por parámetros:

Paso de parámetros por valor o por referencia:

Hay diferentes formas de pasarle los argumentos a los parámetros; como lo hicimos en el ejemplo anterior.

A esta manera se la llama Paso de parámetros por valor:

Cuando le brindamos a la función como parámetro un valor, sea numérico; string; etc.

Alberto.correr(20)

O cuando Pasamos un parámetro por referencia:

Pasar un parámetro por referencia es brindarle a la función como argumento a su parámetro una variable; de esta manera se tomara como argumento el «valor» de dicha «variable» en ese momento!

km = a + b     # Siendo km, a y b variables GLOBALES

Alberto.correr(km)

Por supuesto debe tratarse de una variable global; de lo contrario obtendrías un error. Puesto que esa variable debe ser accesible para la función a la cual se las has pasado!. Ejemplo:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
a = 12 # VARIABLES GLOBALES
b = 21
km = a + b
class Humano(object): #Creamos la clase Humano

    def __init__(self, edad, nombre): #Definimos el atributo edad
        self.edad = edad # Definimos que el atributo (variable local)
        self.nombre = nombre # Definimos que el atributo nombre(variable local)
 
    def hablar (self, mensaje, saludo):
        print (('-'), (mensaje))
        print (saludo)
        
    def correr (self, kilometros = 0): #Definimos el método correr y usamos el parámetro kilometros
        self.kilometros = kilometros #El parámetro kilometros sera igual al arg que le asignemos
        print (("""Ha corrido"""), (kilometros), ("""km""")) #Imprimimos el resultado

Alberto = Humano(10, "Alberto")     #Instanciamos creando el objeto Alberto
Alberto.correr(km)    #PASO DE PARAMETROS POR REFERENCIA

Resultado:

Ha corrido 33 km

Parámetros y argumentos (Posicionales y palabras claves) en Python

Seguramente habrás visto palabras clave como parámetro o argumento de función en algún ejemplo o código de programa en Python.

Como ya explicamos se suelen brindar los argumentos en base al orden de parámetros especificados en la función. Pero vimos también que especificando el parámetro al cual corresponde el argumento mediante el operador » = » también se nos permite así pasar argumentos en diferentes ordenes.

Ejemplo:

Si enviamos los argumentos al llamar la función sin especificar a que parámetro corresponde cada uno. Se asigna según la posición; es decir que hablamos de Argumentos posicionales

Resultado:

Matias tiene: 15
Manuel tiene: 25
Diego tiene 35

Pero si especificamos estaríamos hablando de argumentos por Keywords o palabras clave:

Resultado:

Matias tiene: 15
Manuel tiene: 35
Diego tiene 25

Pero ojo!. Hay ciertas reglas a respetar a la hora de pasar parámetros por palabra clave de esta manera.

• Esta prohibido colocar argumentos de palabras clave; antes de los posicionales. Por ejemplo!. Por ende debes colocarlos a lo ultimo respetando ese orden.
• Y  también si ya colocaste argumentos por palabras claves, no puedes especificar otro argumento luego de la coma que no sea del mismo tipo: por palabra clave.

Y..

¿Para qué sirve *args y **kargs en Python?

Fácilmente podemos identificar estas palabras así:

Veamos esto con ejemplos prácticos y tratemos de explicarlo profunda y filosofalmente! ;P

Recuerdas nuestra función de promedio al principio del post; bueno era así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  promedio.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
############################Función#####################################

def calcular_Promedio (n1, n2, n3):       #<- Definimos la función DEF
    promedio = 0.0                    #<- Variable local promedio
    promedio = ((n1 + n2 + n3)/3)     #<- Aplicamos nuestro algoritmo mat
    return (promedio)               #<- Retornamos el valor de variable
###########################Algoritmo Principal##########################
                                          #INICIO
print ("Bienvenido Profesor")
resultado = 0                             #Variable Global
n1 = float(input("Ingrese la primer nota del alumno: "))
n2 = float(input("Ingrese la segunda nota del alumno: "))
n3 = float(input("Ingrese la tercera nota del alumno: "))
resultado = calcular_Promedio(n1, n2, n3) #<-Almacenamos el retorno
                                          # de la función en la 
                                          #variable global resultado
print ("El promedio del alumno es", resultado)
print ("Hasta luego")
                                    
##################################FIN###################################

Supongamos que nuestro profesor luego nos dice; eres un capullo!!. Debía ingresar 6 notas este año y tu programa solo me permite tres; es una mierda!

Y aquí es donde nos inclinamos un poquito y sacamos *args de la galera!. Fíjate:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  promedio.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
#  
def promedio(*args):
    notas = 0
    s = len(args)
    for n in args:
        notas += n
    resultado = (notas / s)
    print ("""El promedio de los argumentos
que brindo para la función son:""", resultado)


promedio(2, 10, 8, 9, 6, 4)

Resultado:

Ahora el profesor puede pasar tantas notas como se le de la regalada gana!

Pero ¿Por qué?

Fíjate que cuando creamos la función únicamente pasamos *args como parámetro. Lo que le indica al interprete que se trata de una tupla de parámetros posicionales. La cual tendrá tantos elementos como argumentos le demos al llamar la función.

Entonces finalmente queda llamar la función con todas las notas que deseamos se nos promedie. Expliquemos ahora el código de la función:

1. Primeramente declara que notas es una variable entero y que vale 0.
2. Luego obtenemos mediante la función predefinida len() la longitud de esta tupla de argumentos (args). Puesto que sino no podríamos saber a la hora de calcular el promedio por cuanto debemos dividir; así se le asigna el valor a la variable s.
3. Luego iteramos la dichosa tupla (args) mediante un bucle for para ir sumando los números y almacenando el resultado en «notas«.
4. Finalmente a esa suma la dividimos por s; y el resto ya lo sabes. Expresamos el resultado!

Un clásico ejemplo del uso de args; si utilizas un poco el marote le encontraras muchísimas utilidades!

**kargs en Python

Así al utilizarla se crea un diccionario como ya vimos con Keys asociadas a valores. Cuya cantidad puede ser infinita y cuyo orden no importa; puesto que cada palabra se asocia a un valor o dato!. Para ejemplificar su uso vamos a recurrir a una función sencilla que expresa los premios de usuarios (una tontería básica):

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  promedio.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
#  

def premios_usuarios(**kargs):
    for k, v in kargs.items():
        print ("El {} es para {}".format (k, v))

premios_usuarios (
Puesto_1 = "Juaquin", 
Puesto_2 = "Leonard",
Puesto_3 = "Patricio",
Puesto_4 = "Richard")

Resultado:

Así podremos pasar tantos puestos y usuarios como queramos. Sin un limite especifico brindando un diccionario de argumento a nuestra función!

De esta manera podemos pasar tantos argumentos en forma de palabra clave como nos sean necesarios a una función.

Utilizando *args y **kargs en la misma función

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  promedio.py
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
#  
def premios_usuarios(*args, **kargs):
    print("Se sortean ${}:".format (args))
    for k, v in kargs.items():
        print ("El {} es para {}".format (k, v))

premios_usuarios (40000, 20000, 3000, 500, 
Puesto_1 = "Juaquin", 
Puesto_2 = "Leonard",
Puesto_3 = "Patricio",
Puesto_4 = "Richard")

Resultado:

La verdad el ejemplo es una cutrada pero se explica lo suficientemente fácil el uso de ambas en la misma función. Recordemos siempre ubicar los posicionales primero (*) y las palabras clave después!

Primero aquellos argumentos posicionales simples, luego especificamos *args para utilizar argumentos posicionales variables. Luego aquellos parámetros por keywords y finalmente **kargs para argumentos por keywords variables.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#  
#  Copyright 2019 Pyr0 Maniac <Pyro@Pyro>
#  
def funcion_ejemplo (arg1, arg2, *args, **kargs):
    print(arg1, arg2, args, kargs)
    
funcion_ejemplo(1, 2, 33, 44, esto = "es Python")

Salida:

Aquí puedes leer más:

Pyciencia: Argumentos de funciones *args y **kargs

Codea.com.mx: Uso de args y kargs

Expresión lambda en Python : Funciones anónimas

Puede resultar muy confuso entender las expresiones lambda puesto que se suelen confundir con funciones. Y de hecho no lo son; lambda pertenece a una palabra reservada del lenguaje para expresar una expresión; expresión lambda.

Pero son realmente muy útiles y a mi entender podemos «asimilarlas» como funciones anónimas (porque no están enlazadas a un identificador); y tienen la particularidad de ser una única expresión en lugar de un bloque de código. Así una expresión lambda a diferencia de una función normal se expresa en una sola linea.

Podemos decir que las expresiones lambda se utilizan para realizar tareas sencillas sin recurrir a mayor cantidad de lineas de código como lo haríamos con una función normal (def) para realizar tareas mas extensas y complejas. Así que seria buena practica recurrir a lambda cuando la expresión es sencilla y expresable en una sola linea para lograr un resultado determinado. Y declarar una función normal cuando no; cuando se requiere más lineas de código.

Así podemos traducir una función sencilla como por ejemplo:

En una sola expresión como esta:

Pero aquí ha dejado de ser una función para convertirse en una Expresión Lambda. Que quede claro.

El mismo ejemplo con entrada de datos:

Las expresiones lambda tienen la siguiente sintaxis a respetar:

<lambda> <parámetros>: <expresión>

Así también la podemos encontrar como:

lambda <parámetros>: <expresión>

lambda: <expresión>

<referencia> = <lambda> <parámetros>: <expresión>

Pero no siempre las encontraremos de esta manera tan sencilla de comprender; una expresión lambda puede incluso encontrarse dentro de una función normal definida por el programador o una función predefinida (o predeterminada) del lenguaje.

Pero debemos comprender también que cuando hablamos de expresión no es lo mismo que una instrucción o asignación.

Te invito a leer mas aquí:

https://es.wikipedia.org/wiki/Expresi%C3%B3n_lambda

Estructuras de control

Como vimos los programas siguen un flujo de ejecución de las instrucciones. Por ejemplo en Python tenemos un orden de ejecución de las mismas que va desde el inicio al final.

Tú por supuesto cuando programas en Python no escribes primero la ultima linea de código puesto que se debe respetar un orden de acuerdo a como el procesador lee y traduce cada linea de código. O así no puedes llamar una función en la segunda linea y luego declararla en la tercera. Porque obtendrás un ERROR. Esto se debe al flujo de ejecución y para todos los lenguajes es igual; debe respetarse.

Es claramente visible y esta representado con una flecha en los Diagramas de Flujo: ->

(Tú allí no puedes solicitar el valor de N1; N2; N3. Luego de haber calculado el promedio. Puesto que el calculo necesita primero de esos datos)

Pero existen estructuras que permiten controlar ese flujo. Permitiéndonos por ejemplo ejecutar una instrucción que esta declarada en una linea anterior. Dependiendo de una determinada condición. Estas estructuras se denominan de control.

Y existen diferentes formas y estructuras de control de flujo. A continuación te voy a explicar cada una y a ejemplificarlas de diversas maneras.

De selección / decisión

En una estructura de selección o decisión el algoritmo al ser ejecutado determina si se debe ejecutar un bloque de código u otro si se cumplen o no ciertas condiciones. De ahí que se les suele llamar «condicionales».

Existen tres tipos de estructuras de selección:

• Estructura de selección simple: Que podríamos expresar como una estructura que evalúa una determinada condición; y si esta se cumple (suponiendo que sea verdadera) toma la decisión de ejecutar determinado bloque de código especificado; modificando el flujo normal del programa a través de una bifurcación. En caso de ser determinada como falsa, continua el flujo normalmente haciendo caso omiso de ella. Ejemplo:

si a = b entonces:

Mostrar (‘Si’)

Lo que en python podría traducirse a:

a = 1
b = 1

if a == b:                             #Compara ambas variables; si es verdadero
    print ("(a) es igual a (b)")   #ejecuta el print
                                       #Tanto si es verdadero o no; continua el flujo
    
print ("Continua el flujo normal del programa")

• Estructura de selección doble: Al igual que la estructura de selección simple evalúa una condición pero con la diferencia de que permite tomar dos opciones o bifurcaciones diferentes según se cumpla o no dicha condición. Son fácilmente reconocidas o mencionadas como estructuras «si/sino» o «if/else». Y fácilmente diferenciables de las simples por permitir ingresar otro bloque de código adicional en caso de no cumplirse una condición (else) obteniendo así otro ramal de flujo alternativo. Fíjate en el diagrama y presta atención que también se representa de manera distinta para que sea más comprensible!. Estas estructuras de selección doble también se pueden encontrar en «cascada» o «anidadas»; las cuales no deben confundirse con las de selección múltiple!

Si a = b entonces:

Mostrar (‘(a) es igual a (b)’)

Sino:

Mostrar (‘(a) NO es igual a (b)’)

En python podría traducirse:

a = 1
b = 2

if a == b:                             #Si es verdadero continuara al print
    print ("(a) es igual a (b)")
else:                                  #Si es falso ira al siguiente
    print ("(a) NO es igual a (b)")
    
print ("Continua el flujo normal del programa")  #Luego continuara normalmente

• Estructura de selección múltiple: Al igual que la anterior nos permite realizar bifurcaciones en ramales pero con la diferencia de que no solo nos permite dos; sino muchas más; eligiendo una así entre varias posibles (ademas de permitir agregar una por defecto «else» al final). Y con la diferencia también que lo hace en base a un valor de una variable; siendo este el determinante del ramal a seguir en el flujo.

Si a = b:

Mostrar (‘ (a) es igual a (b) ‘)

Sino:

Si a = c:

Mostrar (‘ (a) es igual a (c) ‘)

Sino:

Si a = d:

Mostrar (‘(a) es igual a (d) ‘)

Sino:

Si a = n:

Mostrar (‘(a) es igual a (n) ‘)

Lo que en Python podríamos traducir:

a = 1
b = 2
c = 3
d = 4
n = 1
if a == b:
    print ("(a) es igual a (b)")
elif a == c:
    print ("(a) es igual a (c)")
elif a == d:
    print ("(a) es igual a (d)")
elif a == n:
    print ("(a) es igual a (n)")    

    
print ("Continua el flujo normal del programa")

También podríamos incluir un else al final por si no se cumpliera ninguna condición de las anteriores!

Más:

• Algoritmos de selección múltiple pseudocódigo y diagramas de flujos.
• Alegsa: Estructuras de selección
• Wikiversidad: Fundamentos de programación: Control de flujo

Tu estas estructuras ya las habrás utilizado en Python o en el lenguaje que suelas programar. Pues son comunes a la mayoría de ellos; la existencia de diversas formas de controlar el flujo resulta para mi como un universo por descubrir lleno de la magia que nos brindan las infinitas posibilidades! It is magic!

De iteración, iterativas o de repetición

Seguramente conocerás la palabra «bucle». Conocida en la vida cotidiana para referirse a una repetición de una acción un numero indeterminado de veces. Los bucles en programación son muy útiles para diversas tareas y pertenecen a las estructuras de control de flujo de ejecución. Puesto que permiten modificar el mismo e incluso hacerlo repetir la misma instrucción múltiples veces.

Resultan de amplio beneficio para el programador porque permiten crear contadores, tareas en segundo plano de ejecución continua, reutilizar código y demás.

Así existen diversos tipos de bucles; pero entre los más comunes a los diversos tipos de lenguajes de alto nivel se encuentran Do-While, Do-Until y For-Next.

Si tu programas en Python quizás te suenen raros pero vas a ver que son muy similares!. En python encontramos While y For con ciertas diferencias a otros lenguajes:

Bucles While:

Anteriormente vimos bucles while en python e incluso ejemplificamos mucho sobre ellos; me gustaría expresar algunas diferencias con la estructura Do-While en otros lenguajes y luego veremos rápidamente y por arriba While y For. Ademas estudiaremos los bucles anidados y ejemplificaremos con algunos programillas sencillos como ya te tengo acostumbrado!

No debemos confundir los bucles While en Python con los bucles Do-While en C por ejemplo. Puesto que existe una diferencia en el numero de veces que se ejecuta el cuerpo del mismo; en el caso de While en Python se ejecuta un mínimo de cero veces; mientras que Do-While en C una vez.

Estudiemos un poco el bucle Do, Do-While; su propósito es ejecutar un bloque de código (se le suele llamar Cuerpo del bucle) mientras determinada condición se cumpla. El mismo se suele expresar en pseudocódigo como Hacer / Mientras. Así para facilitar la comprensión comencemos expresándolo en Pseudocódigo y diagrama de flujos.

Do-While:

Hacer:

Instrucciones

Mientras (Condición)

Como puedes interpretar en el diagrama de flujo el bucle Do-While comienza ejecutando primero el bloque de código del cuerpo y luego si determinada condición se cumple procede a realizar determinadas repeticiones hasta que la condición deje de cumplirse.

While

Puedes ver mas sobre While en Python en mi blog; allí ejemplificamos con una calculadora y la creación de menús sencillos mediante el uso de bucles while infinitos. Por supuesto no quiero aquí volver a escribir y explicar todo sobre While.

Bucles For

Los clásicos bucles for que en pseudocódigo se expresan («para / hacer») son de mucha utilidad para iterar estructuras de datos.

Iterar: significa realizar cierta acción repetidas veces y en el caso de for hace referencia a recorrer elementos iterables, como lo son diccionarios, listas, cadenas, etc. Comprobando una determinada condición y ejecutando un bloque según se cumpla o no la misma. Así cada vuelta de un bucle For se denomina iteración.

En pseudocódigo:

PARA VariableControl := ValorInicial A ValorFinal, PASO = Incremento

Instrucciones

FIN PARA

Para <elemento> hasta <elemento> a incremento de <elemento> hacer:

Cuerpo del bucle

fin-para

 

#o bien:

Para <elemento> en <elemento> hacer:

Cuerpo del bucle

fin-para

Así en este tipo de bucles podemos encontrar: Variable de control, El valor inicial de la variable de control, la condición, el incremento y el cuerpo del bucle. Veamos algunos ejemplos en pseudocódigo y en Python.

Comencemos con un bucle for para iterar una lista en Python:

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

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9
,10, 11, 12, 13, 14] #Creamos la lista con números
for num in numeros: #En la variable "num" almacenamos los ítem de la lista
    if num % 2 == 0: #Condición: Si el resto de la división por dos es cero entonces:
        print (num) # Imprimimos la variable num

Resultado: 2, 4, 6, 8, 10, 12, 14

Como ves primeramente resalte la declaración del bucle For donde expresa Para <elemento> en <lista> hacer. Y finalmente añade la condición seguido del cuerpo del bucle. En pseudocódigo se nos obliga especificar el valor inicial de la variable de control; que en el caso del ejemplo sería «num«.

En python por defecto la variable de control toma valor «0» pero no es así en todos los lenguajes!. Aunque al revisar código te vas a dar cuenta de que puedes reconocer bucles fácilmente.

Veamos otro ejemplo expresado gráficamente:

Como puedes ver el bucle for recorre uno a uno los indices de la lista «l» almacenando el valor de cada elemento correspondiente en la variable de control «char» en este caso, para así mediante los condicionales pertenecientes al cuerpo del bucle compararla con el carácter solicitado. Si se corresponden devolverá un True!. Así tenemos ante nosotros un algoritmo de búsqueda mediante iteración y posterior selección.

Te recuerdo que la profundidad en la que debemos intentar mantener el bucle for es de hasta 3 bucles anidados. Con esto nos referimos a un bucle dentro de otro.

Estructuras anidadas (bucles y condicionales): «rizando el riso»

Como ya sabrás podemos estructurar programas anidando estructuras de control como lo son bucles y condicionales para realizar acciones concretas.

Anidar significa colocar una estructura dentro de otra; como así también podemos anidar listas; tuplas; etc. En el  caso de los condicionales o estructuras de control selectivas se puede observar de la siguiente manera:

Si  <condición> entonces

Si < condición2> entonces

Si <condición3> entonces

<acciones>

Fin_si

Fin_si

Fin_si

Si te fijas bien la estructura en caso de ser falsa alguna condición escapa directamente a terminar el programa; en cambio cumpliéndose las tres condiciones llegara hasta el proceso y luego escapara hacia el Fin.

Pero recordemos que debemos anidar condicionales solo cuando es estrictamente necesario anidar; puesto que por contrario podemos comparar tres variables dentro del mismo condicional haciendo uso de Operadores Lógicos tipo And, Or, Not.

Y.. ¿cuando crees que estrictamente necesario anidar?:

Por lo general cuando el siguiente condicional depende de alguna modificación de variable del anterior. Es decir cuando nos encontramos ante una variable dependiente.

Veamos un ejemplo de estructuras de control selectiva anidada en Python:

En este caso pongo de ejemplo un código sencillo: Supongamos que Manuel debe comprar alfajores y el empleado del negocio a veces le regala uno. Queremos poder ingresar datos variables de cuantos tiene; cuantos quiere y cuantos le van a regalar; para que Manuel si o si se valla con la cantidad necesaria para el y su hermana. Para esto recurrimos a estructuras de condicionales anidados:

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


Debe_comprar = int(input("¿Cuantos alfajores debe comprar Manuel?: "))
Tiene_alfajores = int(input("¿Cuantos alfajores tiene Manuel?: "))
Regalo = 0

if Tiene_alfajores < Debe_comprar:                                   #Nivel de anidado 0
    print ("Manuel: Señor me regala un alfajor para mi hermana?")
    Regalo = int(input("Cuantos le regalas?: "))
    if Regalo > 0:                                                   #Nivel de anidado 1
        Tiene_alfajores += Regalo
        print ("Manuel: Gracias")
        if Tiene_alfajores < Debe_comprar:                                                     #Nivel de anidado 2
            print ("Manuel: Entonces voy a comprar", (Debe_comprar - Tiene_alfajores))
            
    elif Regalo <= 0:                                                #Nivel de anidado 1
        print ("Tacaño!")
        print ("Manuel: Entonces voy a comprar", (Debe_comprar - Tiene_alfajores))
if Tiene_alfajores >= Debe_comprar:                                  #Nivel de anidado 0
    print ("Manuel: No necesito comprar mas")

Veamos ahora una representación en diagramas de flujos de este código!

Como podrás ver es necesario anidar; puesto que en caso de ser falso el condicional que compara si es menor (por segunda vez) la variable Tiene_alfajores con Debe_comprar sale del condicional anidado y se encuentra con el segundo condicional de primer nivel o nivel 0 que compara nuevamente dando por resultado True y saliendo a «No necesito comprar más»

Si este segundo condicional de primer nivel fuera un else o elif; no se ejecutaría!

Fíjate también que luego de ingresar datos en las variables que se solicita te encuentras con condicionales y es el valor de cada una de ellas el determinante del resultado final de la variable Debe_comprar.

Anidando bucles

En el caso de los bucles también podemos anidar un While dentro de otro; un For dentro de otro; o While y For repetidamente uno dentro de otro. Pero es recomendable no abusar del anidado de bucles mas allá de 3 niveles salvo casos muy específicos en que fuese necesario!

Anidar bucles resulta de mucha utilidad por ejemplo:

Tenemos una lista anidada con alumnos pertenecientes a 1er grado; con 4 cursos a, b, c y d. Así:

Lista_Anidada = [[‘Marcos’, ‘Juan’, ‘Miguel’],[‘Luisa’,’Maria’,’Antonia’],
[‘Julia’,’Violeta’,’Emilia’],[‘Roberto’,’Gastón’,’Emiliano’]]

Debemos programar un algoritmo que conociendo estos datos sea capaz de llamar por altavoz al alumno o alumnos que se desee basándonos en el indice de la sub-lista. Y debemos presentarle opciones al usuario.

Lo primero que se nos ocurrirá sera un bucle while y dentro de el bucles for para iterar la lista según sea la opción.

A mi se me ocurrió crear un bucle while y dentro colocarle las opciones; y dentro de ella volver a brindar opciones para llamar al alumno; sin iterar múltiples veces la lista. Puesto que utilizamos la opción que ingrese como indice de sub lista y solo nos resta mostrar mediante un slice la misma y así ofrecerle a que alumno llamar (segunda opción) la cual determina el segundo subindice. Fíjate:

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

orden = -1  #Variable utilizada para segundo Menu

Lista_Anidada = [['Marcos', 'Juan', 'Miguel'],['Luisa','Maria','Antonia'],
['Julia','Violeta','Emilia'],['Roberto','Gastón','Emiliano']]
#Lista anidada que dentro tiene 4 listas.

while True:     #Presentamos opciones mediante WHILE
    print ("Bienvenido a la lista de alumnos de 1ero")
    print ("¿Que curso le interesa conocer?")
    print ("0 - Para conocer 1ero A")
    print ("1 - Para conocer 1ero B")
    print ("2 - Para conocer 1ero C")
    print ("3 - Para conocer 1ero D")

    while True:     #Segundo bucle WHILE anidado
        opt = int(input("Ingresa la opción que deseas..: ")) #Permitimos ingrese opción
                                                #Según esa opción indicamos la sublista
        for i in (Lista_Anidada[opt][0:3]):     #ITERAMOS mediante un FOR espec opt + SLICE
            orden += 1                          #Sumamos en cada vuelta 1 a orden
            print ((orden),(i))                 #Imprimimos orden; seguido elemento (i)

        while True:                             #Tercer bucle anidado
            opt2 = int(input("Qué alumno desea llamar?"))   #Solicitamos segunda opción
            print ("################################")
            print ("#", "ATENCIÓN: LLAMANDO A ", (Lista_Anidada[opt][opt2])) #Añadimos primera y segunda
                                                                            #Opcion (opt y opt2)
            print ("#", (Lista_Anidada[opt][opt2]), ("Acudira de inmediato a direccióon!!"))
            print ("################################")
            print ("\n")
            break #Salimos del tercer bucle
        orden = -1 #Restauramos orden al valor original para volver a comenzar
        break       #Salimos del segundo bucle anidado
        
#Volvemos al bucle inicial; sin salida

Resultado:

Como puedes ver recurrimos simplemente a especificar los indices de la sublista y elemento de la sublista mediante la opción ingresada por el usuario. Pero si utilizamos el bucle for para mostrar las opciones en orden real. Y ademas usamos while para ofrecer un menú.

Por supuesto si no ingresa un número entero habrá un error y se petara todo. Pero ya veremos eso luego.

Veamos ejemplo del uso de bucles for anidados:

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

for i in range(10):
    for j in range(10):
        print(i, j)

El código anterior devolverá como resultado números desde el 00 hasta el 99. Puesto que comprendiendo como funciona el bucle for en Python para cada vuelta del primero hará todas las del segundo.

Como puedes observar el numero de la izquierda corresponde al primer bucle cuya variable de control es «i«. Y el de la derecha al segundo bucle; que estaría dentro del primero. Así puedes notar que For anidado en Python hará (en este caso) las 10 vueltas del segundo cada 1 vuelta del primero.

Y existe una diferencia a como trabajan los bucles for en otros lenguajes!.

Recordemos que mediante bucles for también podemos solicitar entradas de datos. Como en el programa anterior solicitamos datos para diversas variables. También podemos automatizar esto mediante un for para iterar un tipo de dato estructurado e ir añadiendo elementos.

Fíjate el siguiente ejemplo para añadir elementos a una lista:

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

lista = [1, 2, 3, 4, 5, 6] # Declaramos una lista
for x in lista:             #Creamos for para iterarla
    if len(lista) < 10:      #Condicional longitud de lista hasta 10
        i = int(input("Agregar numeros a la lista: ")) #Ingresamos elementos en i
        lista.append(i)             #Ordenamos almacenar el elemento i
print (lista)                   #Imprimimos la lista

Salida:

Así los bucles for nos permiten automatizar muchos procesos a la hora de trabajar con datos estructurados, entre otros muchos usos y ventajas que nos permiten acortar muchas lineas de código y facilitarnos procesos.

Si aun no has visitado esta entrada te recomiendo la revises: iterables por comprensión