Programación en python – Se un programador con fundamentos

Fundamentos de programación en Python¿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.

 

 

Importante!
Este post es tan largo como un PDF. Por eso su lectura conlleva un tiempo considerable!. Pero te aseguro que si te gusta la programación no tiene desperdicio!! Aquí trato de explicar y exponer conceptos que más allá del lenguaje en que programes te serán extremadamente útiles!
También te dejo algunos consejos!
Si eres autodidacta y recién comienzas a programar en Python, por más que no entiendas algo o te aburra te aconsejo seguir leyendo. Busca en google e infórmate más!. Todo esto que esta aquí expresado tiene una utilidad enorme para cualquier lenguaje que programes o vallas a programar en un futuro.

 

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!

 

Indice del contenido

Introducción: Ampliar la visión

Fundamentos de programación en PythonSucede 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; cada mes; 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.

Programación en Python

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?

Importante!
Sabe un buen programador que no hay «problema» que no pueda resolver valiéndose de «la tecnología disponible». Y por eso me rehúso a encapsular un programador en un lenguaje o en una mierda de categoría: junior; senior y ni una mierda!.

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!.

Programación en la vida real

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.

bla bla Algoritmos-¿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..Dibujo algoritmo?

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 mas 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»

Diagrama de flujo
Diagrama de flujo de un programa sencillo.

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):

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. Diagrama de flujo de algoritmo calcular promedioIndicamos 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:

Figuras del diagrama de flujo

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 ademas 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.

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.

 

 

 


SEPARADOR CUTRE – Hablamos de elementos y estructuras de los principales lenguajes.


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.

Importante!
Pero OJO!. Existen diferentes tipos de lenguajes de programación de ALTO NIVEL y también están clasificados según diversas características (Como generación e historia; paradigmas; etc) . Como lo pueden ser:

  • Imperativo
  • Declarativo
  • Orientado a Objetos (Python)
  • u Orientado al problema etc.

Recuerda que Python es un lenguaje MULTIPARADIGMA. Ya lo explicamos en la primera lección por lo que nos permite programar utilizando diferentes estilos de programación. Así es mi idea enseñar las estructuras básicas de cualquier lenguaje ya sea orientado a objetos o estructurados.

Fíjate más aquí:

Lenguajes de programaciónAsí 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:

PalabraP. TraducciónPalabra P. Traducción
in«En»global«Define global»
del«Delete, borrar»is«ES»
and«Y» (Operador L)from«DESDE»
or«O» (Operador L)try«Intentar» (M. Errores)
not«NO» (Operador L)exec«Ejecutar»
if«SI» (condicional)except«Excepción» (M. Errores)
else«SINO» (condicional)print«Imprimir; mostrar»
elif«O SI» (condicional)raise«Levantar»  (M. Errores)
def«Definir»lambda«Función»
while«MIENTRAS» (Bucle)class«Clase»
 for«PARA» (Bucle)import«Importar»
break«Romper» (Bucle)asser«Acierto» (M. Errores)
continue«Continuar» (Bucle)return«Retornar; devolver» (Funciónes)
finally«Terminar» (Bucle)yieldasd

También los operadores son reservados!

OperadorFunción
+«Suma»
«Resta»
*«Multiplicación»
**«Exponente»
%«Mod»
/«División»
//«División entero»

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:


REVISAR REVISAR REVISAR REVISAR REVISAR REVISAR REVISAR REVISAR REVISAR REVISAR


Manten 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.

Tipos de estructura de datos
En la mayoría de lenguajes de programacion podemos distinguir los siguientes tipos de estructuras de datos clasificados según:

Diagrama Datos Estructurados

 

Y Python tiene las siguientes variables de datos estructurados

VARIABLES DE DATOS ESTRUCTURADOS, REPITO; VARIABLES DE DATOS ESTRUCTURADOS EN PYTHON.

Recordemos que en Python; al tratarse de un lenguaje orientado a objetos y de tipado dinámico una variable puede tomar diferentes valores de diferentes tipos sin necesidad de que tengamos que expecificarlo. Por lo que una variable puede ser utilizada con diferentes tipos de datos.

En python las variables «se amoldan automáticamente al dato almacenado». Algo como «Be Water my Friend«.

Tipos de variables de datos estructurados en Python
  • complex (Números parte real; parte imaginaria.)

Variables de cadena de caracteres:

  • str (Texto, palabras, símbolos entre comillas simples, dobles o triples)

Variables de conjunto; listas, tuplas y diccionarios en python:

  • tuple (Colección o conjuntos de datos del mismo tipo o no) (Cualquier conjunto de datos sin paréntesis es almacenado por Python como una tupla.)
  • list (Lista de elementos de diferentes tipos que pueden ser referenciados por un indice. )
  • dict (En Python llamado Diccionario. Son estructuras de datos utilizadas para mapear claves arbitrarias a valores. )
  • range (Actualmente considerado en Python un tipo de dato estructurado al igual que las listas, tuplas y diccionarios. Range hace referencia a una sucesión aritmética de números almacenadas implícitamente en memoria como una lista inmutable )

Estos son los tipos de datos estructurados más utilizados en Python.

 

CUIDADO: ERRORES DE CONCEPTOS, DEFINICIONES, NOMENCLATURAS
Importante!

Como dije anteriormente una cosa es el tipo de dato estructurado y otro la variable que lo almacena. Que a su vez depende como trabaje también el lenguaje de programación. Por eso en Python al ser orientado a objetos y MULTIPARADIGMA no se suele crear un Array ni un Registro. Puesto que se recurre directamente a Listas o Tuplas y a Clases.

Entonces debemos tener en cuenta no confundir; ni hacer MALAS ASOCIACIONES.

Ni un ARRAY es una LISTA o TUPLA. Ni un REGISTRO es un DICCIONARIO O CLASE.

NO CONFUNDIR POR FAVOR PORQUE TE VAN A PATEAR LA CABEZA!! Todo difiere según el paradigma del lenguaje y la definición o características de estos tipos de datos estructurados o variables.

Encontraras muchas veces estos errores que se dicen que un Array es una Lista o Tupla. Cuando no es así. Porque:

Array es un tipo de dato estructurado diferente a una Lista.

Por supuesto que los mismos datos de un array se pueden almacenar en una lista!. Pero eso no los hace el mismo tipo de estructura de datos.

Te recomiendo leer el siguiente artículo titulado: Programación Orientada a objetos vs Programación estructurada

 


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)Dejarme en paz

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í:

Arreglo

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!No es lo mismo

– 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í:

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

[Aquí termina ARRAYS]

 

 

 

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:

 

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

 

Comillas dobles

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:

SecuenciaFunción de la misma
\newlineIgnora backslash(\) y nueva línea
\\Nos permite colocar un backslash(\)
\’Nos permite mostrar una comilla simple sin errores
Nos permite mostrar comillas dobles o triples sin errores
\bElimina un espacio hacia atrás (?)
\nSalto de línea
\rEs como un salto de linea con sangría o espacio al comienzo de la segunda línea.
\tTabulación horizontal
\vTabulación vertical
\oooNos permite ingresar caracteres del sistema octal
\xhhNos permite ingresar valores hexadecimales.

Siguiendo la tabla lo hacemos mediante un:

 

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.

 

 

[Fin cadenas]

 

 

 

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 + ArrayEn 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 «.».

No es lo mismo; es distinto
Me estoy suicidando mentalmente!!

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:

 

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í:

Utilizando clases para crear un registro de empleados en Python

Yo lo hice así:

Resultado:

clases en Python

Te invito a que pruebes el código.

En la parte referente a Clases, mas abajo encontraras la explicación del código..

 


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:

Pero veamos rápidamente una Lista:

Listas en Python

  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:

Resultado:

[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

 

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:

Resultado:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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)?

Tuplas en python

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.

meme jengaUtilizar 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 mas 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!

Diccionarios en Python

 

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:

Class dict

 

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):
 

  • Que así:
 

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

Mantén los datos ordenados; el código limpio y comentado.

Hazlo simple y respetuoso. Los diccionarios desordenados son causantes de muchos errores de sintaxis.

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).

Clases en PythonYa 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.

Clases en Python

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?

{NOTA AL MARGEN: ME DUELE LA CABEZA Y SE HACE MUUUY LARGO!!}

Yo lo hice así:

Resultado:

clases en Python

Te invito a que pruebes el código.

Analizar códigoComo 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!

Importante!

Te recomiendo analizar bien el código y descubrir por ti mismo como logramos trabajar indexando objetos de determinada clase en Python.

Si comprendes ingles te invito a revisar estos post; muy importantes a tener en cuenta cuando queremos trabajar de esta manera:

Como crear múltiples objetos mediante un bucle en Python

No olvides revisar la documentación oficial de Python (en español)

 


 

 

Subrutina o Sub-Algoritmo (Funciones y procedimientos)

Funciones; subalgoritmosComo 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

Funciones - SubalgoritmosVamos 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í:

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!

 

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)

Funciones y variables dentro de clasesComo 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:

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:

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

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)

 

Métodos en python

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

Funciones dentro de clases en python

  • 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:

 

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:

Error paso por parametros

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):

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

 

Lenguajes de programaciónPodemos 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:

Resultado:

Ha corrido 33 km

 


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

args y kwargs 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:

Argumentos posicionales python

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:

Argumentos por Keywords

 

 

 

 

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í:

*args

Se refiere a parámetros posicionales. Y el uso de «cualquier palabra» (sea args o asd) seguido del asterisco(*) pasado en forma de parámetro hace referencia a una Tupla de argumentos variables.

Se utiliza la palabra args como guía del programador o palabra reservada en el léxico del mismo para especificar y reconocer fácilmente que se trata de UNA TUPLA DE ARGUMENTOS. Pero podemos utilizar cualquier palabra en realidad siempre y cuando especifiquemos que se trata de argumentos posicionales mediante un «*» !

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í:

Profesor jirafales enojadoSupongamos 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:

Resultado:

Función calcular promedios en Python usando *args

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

 

Pero ¿Por qué?args python galera

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 posicionalesLa 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
**kargs

Al igual que con *args. Si utilizamos ** estamos indicando que se trata de un diccionario variable en cantidad de palabras clave como argumentos.

Luego la palabra «kargs» se utiliza por conveniencia para el programador; así conservamos un código legible y otro quien lea podrá entender fácilmente de que se trata!.

Entonces en conclusión si pasamos «**kargs» como parámetro; estaremos luego pasando UN DICCIONARIO DE PALABRAS CLAVE COMO ARGUMENTOS DE LA FUNCIÓN!

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):

Resultado:

kargs en python

 

 

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

 

Resultado:

sorteo

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.

Salida:

args y kargs

 

 

Aquí puedes leer más:

Pyciencia: Argumentos de funciones *args y **kargs

Codea.com.mx: Uso de args y kargs

oks

 

 

 

 

 

 

 

 

 

 

Expresión lambda en Python : Funciones anónimas

Lambda Python

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:

función suma

 

 

 

 

 

En una sola expresión como esta:

lambda python suma

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:

lambda 2

resultado-lambda-entrada

 

 

 

 

 

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

 


Falta completar.


 

Estructuras de control

 

 

Control de flujoComo 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.

Diagrama de flujo de algoritmo calcular promedio
Fíjate las flechas van 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:

  • Condicional simpleEstructura 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:

 

 

  • Condicional dobleEstructura 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:

 

  • Condicional múltipleEstructura 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:

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

Más:

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:Bucle Do-While

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

En cambio...
El bucle WHILE de Python no ejecutara el cuerpo del bucle ni una sola vez, primero evaluará la condición; y por eso podríamos representarlo así

Bucle While en Python

¿Puedes notar y comprender la diferencia?. En Python tenemos While a diferencia de en otros lenguajes el clásico Do-While. Entonces si quisiéramos emular en Python el clásico Do-While bastaría con duplicar el cuerpo del bucle y ejecutarlo primero para que luego siga con el condicional y entonces lo vuelva a ejecutar.

Pero estoy seguro que tu lo sabrás hacer en ese momento si comprendiste la diferencia entre While (Python) y Do-While (en otros lenguajes).

Viendo un bucle Do-while en C al apar de un While en Python se comprende la diferencia fíjate:

Do-while y while

El primero es en C y el segundo en Python.

En pseudocódigo se expresan

hacer / mientras o mientras / hacer!!

Más sobre Do-while y While: ¿Donde quedo el do-while en Python?

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:

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:

Bucle for

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.

 

 

For en Javascript

Te animo a echar un vistazo a un bucle for en Javascript!  para que salgas un poco de Python; y veras que comprendiendo los fundamentos básicos; no te hallaras tan perdido pudiendo ubicar, reconocer y estudiar diferentes estructuras de código!. Así comprendiendo medianamente estos fundamentos estas abierto a aprender cualquier lenguaje con más facilidad, ademas de permitirte ordenar tu cabeza a la hora de pensar en una aplicación y estructurar bien tu código. A pesar de que el mismo no funciona igual que el de Python!

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:Estructuras de control selectivas anidadas

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:

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:

Resultado:

Bucles anidados - Lista anidada

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.

 

llamando a...

 

 

 

 

 

Consejo

Te recomiendo siempre que escribas un código; buscar la manera de hacerlo mas corto; más sencillo pero tratando de preservar la legibilidad y comprensión. Puesto que a medida vallas desarrollando más aplicaciones esa capacidad de comprensión se ira ampliando permitiéndote escribir en menos lineas un código mas compreso; pero igual o más eficiente en base a consumo de memoria y procesamiento.

También intenta evitar el uso excesivo de bucles cuando no son necesarios!

Veamos ejemplo del uso de bucles for anidados:

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.

Bucle for anidado 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:

Salida:

agregar elementos a lista mediante for
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

 

Atención
La entrada se encuentra aún en edición!
Ayúdame a llegar a mas personas!
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •