Diferencias entre apply, map y applymap

logo python

Les invito a conocer en este post, las diferencias entre apply, map y applymap, y en consecuencia cuando aplicar cada una.

El uso de estas funciones, para multiples labores en Python, nos permiten obtener resultados de un modo que nos arreglan bastante la vida.

Muchas de estas veces nos apoyamos para ello en funciones lambda, por su simplicidad, veamos un poco, de que hablo.

Funciones lambda

Otro modo de aplicar redondeo es utilizar una función  lambda en un array de una dimensión, o sea para una columna o fila.

Las funciones lambdas, son una poderosa herramienta de Python, que nos permite escribir un tipo de función, que se ejecuta en un línea.

Hablo un poco sobre la funciones lambda en este articulo que escribi hace un tiempo.

Apoyándonos en ellas,  podemos redondear, utilizando diferentes funciones que trabajan a partir de elementos.

Recordemos que en Python todo son objetos, las funciones map  y applymap, se  basan ambas en este concepto.

La diferencia entre ellos es que applymap es un función basada en elementos que trabaja en el dataframe, mientras map lo hace en las series, o sea una columna o una fila.

En el ejemplo verán la aplicación de map() en una columna y applymap() en todo el dataframe, en ambos casos se combina su uso con la función format, y  una función lambda para determinar los términos del redondeo.

Existe una buena explicación de la diferencia entre estas funciones en este link


Map

Applymap

Como hemos ya modificado una columna volvemos a importar nuestro dataset y aplicamos applymap()

Diferencias entre Map, applymap, y apply

map() es una función basada en elementos que solo se aplica a series, acepta dict, series o callables.

Está diseñada para mapear valores de un dominio a otro, por lo que está optimizada para el rendimiento.

Su construcción, como vimos antes es del tipo :

df['A'].map({1:'a', 2:'b', 3:'c'}))

applymap(), es una función también basada en elementos, que  solo se aplica a Dataframes, y únicamente acepta callables.

applymap() es perfecto, para transformar de elementos en varias filas / columnas, sin que sea necesario utilizar apply()

df[['A', 'B', 'C']].applymap(str.strip))

apply(), se basa también, en elementos, pero puede tener otras complejidades y su compartamiento y resultado, depende de la función.

Se aplica, tanto a series como dataframes , y solo acepta callables

Es importante saber que se usa cuando en cualquier función que no puede ser vectorizada

Otros elementos a tener en cuenta son:

map() cuando se le pasa un diccionario o serie mapeará elementos basados ​​en sus claves Los valores faltantes se registrarán como NaN en la salida.

applymap() puede funcionar un poco más rápido que apply en algunos casos.  

map() está optimizado para mapeos y transformaciones por elementos. Las operaciones que involucran diccionarios o series permitirán a  Pandas usar rutas de código más rápidas para un mejor rendimiento.

apply() devuelve un escalar para agregar operaciones, también tiene rutas rápidas cuando se llama con ciertas funciones NumPy como mean, sum, etc.

… también en el infierno llueve sobre mojado, lo se porque he pasado, más de una noche allí…

J.Sabina

Expresiones regulares. RegEx

Aprender sobre manejar expresiones regulares fue de las primeras cosas a las que tuve que enfrentarme, casi desde cero.

Les dejo una explicación de la esencia de este tema, que espero que a más de uno le sirva de ayuda.

Una expresión regular (RegEx) es una secuencia de caracteres que define un patrón de búsqueda.

En su modo mas simple digamos que una expresión regular del tipo :

^t…o$

Corresponde a cualquier palabra de cinco letras que comience con t y termine en o, como «tanto», «tonto», «tengo», «trillo», o «talio» por ejemplo, entre muchas otras .

En cambio, palabras como «tampoco», «tantísimo», o «tranco», por ejemplo no cumplirían los requisitos para coincidir , con esa búsqueda.

Las expresiones regulares, conocidas como RegEx, es una herramienta medianamente compleja, que nos permite identificar caracteres específicos de texto dentro de cadenas, para operar con ellos.

Conocer todas las expresiones regulares, es algo que lleva tiempo y practica, pero intentaré explicarlo sucintamente.

Metacaracteres

La lista de abajo muestra los metacaractéres, estos tienen un significado especial dentro de las RegEx

[] . ^ $ * + ? {} () \ |

Veamos cada uno

Los corchetes []

Los caracteres individuales que queremos encontrar se encierran entre [] .
por ejemplo [abc], devolverá coincidencias, con cualquier cadena que contenga esas tres letras como “a”, “a veces”,“obcecado”

A esta búsqueda se puede añadir otros elementos para hacerla mas especifica por ejemplo :

[a-d] es lo mismo que  [abcd].

[1-4] es lo mismo [1234].

[0-39] es lo mismo [01239]

Aunque en los dos primeros casos muestra intervalo, en el último indica intervalo igualmente, pero no así para el ultimo dígito que se indica específicamente.

 Contrario a esto, el símbolo ^ , cuando se inserta entre los corchetes al inicio de la expresión, indica excepción por ejemplo [^abc], nos dice que cualquier carácter excepto 'a' o 'b‘ o 'c

Por tanto  si escribimos por ejemplo [^a-z], estamos hablando de cualquier carácter  que no se encuentre en el rango de la ‘a’ a la ‘z’ .

[^0-9] indica cualquier carácter menos los dígitos, …

y [^123], cualquier carácter excepto 1 ó 2 ó 3.

El punto .  

El punto equivale a cualquier carácter individual, menos un salto de línea '\n'.

Por ejemplo la expresión, encontrará coincidencias con cualquier cadena que contenga como mínimo tres caracteres. Una cadena de tres caracteres devolverá un coincidencia, al igual que una de 5, pero una de seis encontrará dos y una de 9, tres

Intercalado o caret (inglés) ^

Cuando se coloca solo, se utiliza para conocer si una cadena comienza con determinado carácter.

Por ejemplo ^b, hallara coincidencias en ‘brillo’ y ‘bandera’, pero no en ‘abanderado’  

Símbolo  dollar $

Se emplea para saber si una cadena termina en un determinado carácter.

$r, buscara coincidencias para cadenas que terminen en ‘r’

Símbolo asterisco *, símbolo suma + y símbolo de interrogación ?

Estos tres signos buscan coincidencias en cadenas, siguiendo una lógica de unión entre los caracteres.

La diferencia de su comportamiento esta en que * busca 0 o mas coincidencias, mientras + busca una o más y   '?' busca 0 o una

Si tomamos como  expresión búsqueda , «te*n»,  esta nos dice que buscamos cualquier cadena donde no este completa, o este esta condición  que exista una»t» ,  y una «n», y si existe una «e», este obligatoriamente seguida de la «n”.

Hallaremos  coincidencias en «tn», «ten», «teen», y «manten», pero no en «tean», porque la «e» no va seguida inmediatamente de la «n»,

La expresión te+n, sigue la misma lógica pero espera encontrar una o más coincidencias, por tanto tn, no devolverá coincidencias, porque no hay una «e», ni tampoco «tean», porque la «e» no va seguida de la «n».

Si utilizamos con esta mismo texto de búsqueda, pero sustituyendo la RegEx por un signo de interrogación te?n, este busca 0 o una coincidencia, en tn hallará una, al igual que en «ten» y «manten».

No sucederá lo mismo  en «teen» o «tean», primero porque en «teen» no existe más de un carácter e y en «tean», la e no va seguida de la n.

Llaves {}

Las llaves {}, se emplean para indicar un rango, de ocurrencia, donde el primer elemento es el mínimos esperado y el segundo, el máximo.

O se n{x,y}, espera que exista como mínimo una ocurrencia x y cómo máximo una y del patrón n.

Si tomamos como patrón de búsqueda a {1,9}, estamos esperando hallar como mínimo una a y como máximo 9.

Un ejemplo común, es que un patrón como [0-9]{3, 6}, buscara al menos tres dígitos seguidos y como máximo 6.

Por tanto hallara coincidencias en las siguientes cadenas 1234, 234567, 333; sin embargo no hallará en 22, 3456878,  o 1

Barra vertical |

Esta es más conocida de otros lenguajes de progrmacion y se usa para alternar entre valores.

De este modo a|b, busca a o b y en una cadena como «babilonia», hallará cuatro coincidencias

Parentesis ()

Se emplean para agrupar varios patrones.

Un agrupamiento de (a|e|i)r, buscará coincidencias de cualquier subcadena , a, e i que vayan seguidas inmediatamente del carácter r.

De este modo hallara ocurrencias en ‘balar’, ‘correr’, ‘reir’, ‘harto’, verde, ‘irina’, ‘subir’ o ‘bajar’, pero no en ‘a’, ‘ r’, ‘eleonor’, u ‘orina’.

Backslah \

Se emplea como señal de escape de varios caracteres y esto incluye también a los meta caracteres.
Por ejemplo si lo usamos antes de un metacaracter alterará o anulará su significado.

Si escribimos \$n,  se encontraran coincidencias, en aquellos casos  donde después del símbolo de dólar aparezca una ‘n‘,  y dejará de verlo como una expresión regular que indica final de la cadena.

Backslah también se utiliza para indicar otras cuestiones, usándolo con otros caracteres. Veamos

\A encuentra coincidencias con caracteres específicos que se encuentran al comienzo de una cadena.\Aes, hallará ocurrencias en cadenas que comiencen con es.

\b encuentra coincidencias con caracteres específicos al comienzo o terminación de una palabra. \bfía, coincidirá con «ecografía» y «con fiabilidad», y no con «confiabilidad»

\B encuentra coincidencias donde no se cumple la condición o sea, que no aparezcan al inicio o comienzo de la palabra los caracteres dados. Es la oposición al \b anterior asi que ahora si coincidirá con confiabilidad

\d halla coincidencias con cualquier dígito decimal. Esta expresión es lo mismo que escribir [0-9].

\D, se opone al anterior y por tanto buscará concurrencias de cualquier elemento que no sea un dígito

\s coincide con cualquier cadena, que posea un espacio en blanco.

\S coincide con cualquier cadena, donde no exista un espacio en blanco.

\w hallará coincidencias con cualquier cadena, donde existan caractéres alfanuméricos (o sea números y letras, incluidos _). Sería lo mismo que escribir [a-zA-Z0-9_].

\W busca cualquier carácter que no sea alfanumérico. Tendriamos el mismo resultado que si escribimos [^a-zA-Z0-9_]

\Z, coincidirá con caracteres específicos al final de una cadena. \Zión hallará una ocurrencia en ‘sanción’.

De forma bastante resumida,  estas son las expresiones regulares. Existen múltiples herramientas en internet, para agilizar el trabajo con ellas de forma online, y que pueden ayudarte a construirlas de manera efectiva.

«En total oscuridad cualquier cosa, puede ser luz»

Otros comandos de git

Este articulo da continuación a otro que publique, e intentaré hablar de otros comandos de Git.

Continuaremos pues con otros comandos también muy importantes en Git

git log

Permite ver los operaciones que hemos realizado:

git log --oneline

Como resultado nos traerá los commit realizados:

El primer conjunto de letras y números que veremos, a la izquierda es el id del commit, que nos servirá para identificar el commit y si es necesario volcer a un estado anterior a el. Entre paréntesis nos mostrará la rama a la que pertenece el commit y a continuación el mensaje que le agregamos

git commit –amend

Nos permite rectitficar un commit, ya sea que nos hemos equivocado en un detalle importante, en el mensaje, u otra cosa; con este comando rectificaremos, mediante el uso del parametro --amend

git commit --amend -m "Estoy corrigiendo cosas entre ellas mensaje"

git checkout id_commit

Es el comando  que usa git para volver a un commit anterior, o estado anterior a ese commit:

Este potente comando, es el que necesitamos todos, cuando algo falla sin que podamos saber que es, y necesitamos volver a ese momento en que todo funcionaba.

Al regresar se revertirán todos los cambios; si hemos eliminado archivos del  proyecto en el que trabajamos estos se recuperaran o viceversa si se han añadido, desaparecerán al retornar a una posición anterior en el tiempo. 

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

….un sueño es casi todo  y más que  nada, más que todo al soñarlo, casi nada después……

Uso de issubclass()

logo python

En Python, issubclass(), es utilizado para conocer la herencia y relación que existe entre dos o más clases.

En el ejemplo creamos una clase llamada Planeta y una subclase que lleva el nombre de Continente.

Lo que haremos luego,  es verificar la relación que existe entre ellas

«…he olvidado ya el lugar de donde vengo y puede que no exista el sitio adonde voy…..»

J.Sabina

Entendiendo Vue(componentes)

Intentemos comprender Vue(componentes). La estructura de un componente se compone en esencia de tres partes

Template

Es la plantilla del componente que posee formato html y donde inyectaremos las variables por una de las  vías que Vue nos ofrece.

Clase

La clase es la zona javascript del componente, en ella creamos la variables y las propiedades que insertaremos en la zona html del componente

Estilos

Son los estilos css del componente, necesarios o no en dependencia de la estructura que demos al proyecto, ya que estos estilos también podrían ser asumidos por un archivo css externo.

El  funcionamiento de un componente no es demasiado complejo, y relativamente fácil de comprender.

Tomemos el  ejemplo que nos ofrece Vue por defecto: el componente HelloWorld.vue  allí veremos definidas las tres partes con sus etiquetas de apertura   y cierre, para template, script y style.

Si eliminemos ahora todo lo que está dentro de template,  y solo dejemos la clase hello, para luego revisar en el navegador, veremos que ahora no hay nada ahí.

Vayamos a la clase encerrada dentro de script, ahí veremos que nombre de esa clase coincide con el nombre el componente, y que posee una propiedad, llamada msg, del tipo string, la misma que aparece en  el template, entonces modifiquemosla, añadiendo una  funcion data que nos devuelve una variable llamada bienvenida,  con un texto adentro;

<script>
export default { 
name: 'HelloWorld',
   props: {
      msg: String
   },
  data()
     {
       return     {
         bienvenida:"Estoy aqui"
       }
     }
 }
 </script> 

Luego vamos a incluir esa nueva variable, dentro del template, siguiendo la estructura de las dos llaves que vimos antes.

<h3>{{ bienvenida }}</h3>

Revisemos ahora el navegador y veremos  que nuestra nueva variable aparece allí con su mensaje.

Un elemento a tener en cuenta es, que un componente, se asigna siguiendo la estructura de nodos del  DOM, y  solo puede imprimirse  en un nodo, por tanto no podríamos imprimir dos msg aunque los declaráramos en el script, a no ser que lo incluyéramos dentro de un div, o lo que es lo mismo no podemos escribirlo en  dos etiquetas html

Construyendo un componente

Un componente es un archivo con extensión vue

Lo crearemos dentro de la carpeta components, lo llamaremos ComponenteNuevo.vue, y le daremos luego esta estructura:

<template>
        <div id=”comp-nuevo”>
             <h1> Nuevo componente de calculo </h1>
             <h3> {{ subtitulo }} </h3>
       </div>
  </template>

 <script>
 export default{
       name: "ComponenteNuevo",
       data(){
             return{
                   subtitulo: "Extraer duplicados"
             }
       }
 }
 </script> 

Como puede verse, no definimos los estilos, solo el template y el código js:

Creamos un div con dos etiquetas dentro, donde el segundo de ellos contendrá el valor de la variable subtitulo creada dentro del script.

Dentro de la etiqueta script, además le asignamos  el nombre, que en nuestro caso será el mismo que el componente.

Y ya hecho esto, nos quedará solo inscribir el componente recién creado dentro del archivo App.vue, dándole la url con la ruta.

Y luego insertándolo dentro del listado de componentes con que trabajamos.

Nuestro código queda así:

<script>
 import HelloWorld from './components/HelloWorld.vue'
 import ComponenteNuevo from './components/ComponenteNuevo.vue'
  
 export default {
   name: 'App',
   components: {
     HelloWorld
     ComponenteNuevo
   }
 }
 </script>

Hecho esto, para que se vea en la página, solo falta añadirlo dentro del div app en la zona del template :

<template>
   <div id="app">
     <img alt="Vue logo" src="./assets/logo.png">
     <HelloWorld msg="Welcome to Your Vue.js App"/>
     <ComponenteNuevo> </ComponenteNuevo>
   </div>
 </template> 

</template>

Ahora ya el componente, que en este caso es solo texto será visible.

La condición para reutilizar este componente en otro lugar o dentro de otro componente, es traerlo mediante el import.

Supongamos que quisiéramos mosrarlo dentro del componente que trae Vue, por defecto: HelloWorld, podemos hacer esto:

 <template>
   <div class="hello">
     <h1>{{ msg }}</h1>
     <h3>{{ bienvenida }}</h3>
 //insertamos el componente con un estilo css
     <div style="background-color:#000;color:#fff">
 <ComponenteNuevo></ComponenteNuevo>
 </div>
   </div>
 </template>
  
 <script>
 //Importamos el componente para que pueda ser usado 
 import ComponenteNuevo from './ComponenteNuevo.vue'
 export default {
   name: 'HelloWorld',
 //utilizamos la misma propiedad components que usa app.vue
     components: {
        ComponenteNuevo
   },
   props: {
      msg: String
   },
  data()
     {
       return     {
         bienvenida:"Estoy aqui"
       }
     }
 }
 </script> 

Finalmente entonces, sabemos que:

  • Un componente consta de tres partes: template(html), script(js) y estilos(css)
  • Que un componente es un trozo de código con funcionalidades, y  que se alojará,  en el DOM o la pantalla, en un nodo.
  • Tiene un nombre, terminado con la extensión vue, y que este nombre será utilizado tanto para importarlo como para declararlo dentro del archivo central app.vue, y en aquel que se vaya  a utilizar.
  • Es reutilizable, y eso quiere decir que donde queramos usarlo debemos importarlo.

Espero que este pequeño articulo, le sirva de ayuda a alguien.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

…. hay que levantarse cada mañana con una esperanza y dormirse cada noche con una meta….

Comandos para crear un proyecto en Laravel

laravel

He aquí dos sencillos comandos para crear un proyecto en Laravel, que siempre nos serán útiles y necesarios.

Crear proyecto

composer create-project --prefer-dist laravel/laravel nombre del proyecto

Crear modelos y toda la estructura al mismo tiempo

php artisan make:model Company-mcr
•	-m  crea el archivo de la migración o sea la tabla
•	-c   crea  el controlador
•	-r   indica que el controlador es un controlador de recurso preparado para un CRUD(create, read, update, delete), compatible con REST

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

subir montañas hermana hombres…..

Diferencia entre número de coma flotante y decimal

logo python

5 y 5.0 no son iguales desde el punto de vista de la programación. A diferencia de otros lenguajes,  en Python es importante conocer la diferencia entre número de coma flotante y decimal.

Cuando pasamos un dato a Python, este  intenta determinar a que tipo de dato corresponde

 La lógica que aplica Python, es considerar que si haces una división entre enteros, estas esperando un entero como resultado, y eso es lo que ofrece.

Pero si lo que esperamos es un resultado en fracción, hay que decirle a Python que al menos uno de elloslo es, haciendo una declaración del tipo  foo  = x.0

Entonces si , el  lenguaje retornará un valor del tipo flotante, al dividir. 

En Python 3, esto ya funciona de modo automático, e incluso sin colocar el punto devolverá un flotante, por una cuestión de optimización del funcionamiento del lenguaje.

 Una forma de ayudar a Python, es indicando que uno de los elementos de la división es del tipo float, haciendo una conversión sencilla del tipo z = float (x) / y  de modo que transformamos el valor  de x en un número de coma flotante, antes de operar con el.  

Este comporamientos heredado de C, tiene su base en la diferencia que existe al operar a bajo nivel con números enteros, de coma flotante o decimales.

Conocer esta diferencia sobre todo  nos hará entender mejor lo que hacemos.

Los números de coma flotante, no representan todas las  fracciones decimales, sino que algunas son redondeadas; sin embargo el  Decimal, es capaz de representar estas, obedeciendo al limite de precisión qué le indiquemos. 

La diferencia entre coma flotante y decimal

Coma flotante

Como decía antes, los números de coma flotante obvian ciertas representaciones.

Estos se componen de un signo, ya sea negativo o positivo, la mantisa, que es el número binario de un solo dígito seguido por una parte fraccional y el exponente que indica en qué lugar se ubica la coma decimal.

Por ejemplo, el número 1,25 tiene signo positivo, una mantisa de 1,01 (en binario) y un exponente de 0.

 El número 5 también es positivo, y posee la misma mantisa,  y su exponente es 2, pero cómo hay que multiplicar su mantisa por 4 (2 a la 2); 1,25 x 4 vale 5.

Hay que decir que la norma IEEE 754, que define el tratamiento de los números con coma flotantes, esta presente en casi todos los sistemas. 

Debido a esto es lógico, que el tipo de datos de coma flotante basados en  C doublé, es común que aparezca implementado en un número de 64 bits del IEEE 754, que al mismo tiempo emplea un espacio de  52 bits para la mantisa.

Esto equivale a  que las cifras de coma flotante, sólo se pueden definir  hasta 54 bits de precisión.

Todo lo que exceda de ese espacio, será recortado,.

El problema surge cuando se requiere o se posee una salida en base 10, que como sucede a menudo con fracciones en base 10, estas son del tipo periódico en base 2.

Entonces como expresar estas fracciones periódicas, sin exceder los 52 bits pues creando una ligera imprecisión, que puede acarrear inexactitudes importantes a la larga.

Muchas veces esto es imperceptible y puede dejarse pasar. Si consideramos la magnificencia de C al devolver los datos, y la poca falta que puede hacernos una exactitud rigurosa, puede no ser necesario incluso considerarlo.

No obstante en cálculos aritméticos exigentes, esta omisión puede requerir soluciones complejas.  

 Decimal

Decimal, es un modulo creado para resolver esta situación.

Posee en su estructura las clases Decimal y Context, que le aportan una estructura útil, para los que extrañaban algo así en Python 2.

Las instancias de estas clases, se reparten la responsabilidad de ofrecer una solución robusta para construir el redondeo.

Mientras la clase Decimal representa a los números; Context se usa para agrupa aquellas propiedades, que definirán el resultado esperado, como son el modo de redondeo y la precisión

Una vez creado el numero es inmutable, por lo que no puede cambiarse su valor, y  es muy ductil ya que las instancias de Decimal se pueden crear a partir de enteros, cadenas y tuplas:

import decimal 
decimal.Decimal(567)
Decimal("1972")
>>>decimal.Decimal("9.8")
Decimal("1.1")

En el caso de las tuplas, se puede complejizar un poco mas y ofrecerle a Python en una tupla el signo, la mantisa como tupla de dígitos decimales, y el exponente:

>>> decimal.Decimal((1, (2, 3, 2, 3), -1))
Decimal('-232.3')

En estos casos hay que respetar que el  bit de signo es Booleano, por lo que 0 significa positivo y 1 significa negativo.

¿Y los flotantes?

Otro punto importante es que los creadores de Python dejaron fuera la conversión directa de números de coma flotante. La solución es convertir el número de coma flotante en una cadena con la precisión esperada y luego pasar esta al constructor de Decimal:

>>> f = 2.2
decimal.Decimal(str(f))
Decimal('2.2')
>>> decimal.Decimal('%.8f' % f)
Decimal('2.20000000')
La única limitación que nos da decimal ahora es que el exponente sea un numero entero.  Una operación en la que no se cumpla ese principio arrojara errores de estos tipos 
decimal.InvalidOperation: x ** (non-integer)
unsupported operand type(s) for ** or pow(): 'str' and 'str'

Otra muestra de la fortaleza de decimal es que permite combinar instancias de Decimal con enteros,  sin embargo esto no es posible con números de coma flotante:

Por otro lado, no todo podía ser color rosa, cuando utilizamos los modulos de Python math y cmath, estos se convierten a números de coma flotante antes de operar, y por supuesto el resultado del calculo será también un numero de coma flotante 

Usando Context

Las instancias de Context encapsulan las propiedades que deseamos asignar a nuestra operación de redondeo

  • prec es la precisión, el número de decimales.
  • rounding especifica el modo de redondeo. Existen varias constantes para las diferentes opciones: ROUND_DOWN (hacia cero), ROUND_CEILING (hacia arriba),   ROUND_HALF_EVEN (al más cercano), ROUND_UP, ROUND_05UP    ROUND_HALF_DOWN  ROUND_HALF_UP ROUND_FLOOR
  • • traps es un diccionario, que indica como tratar los errores.

Dentro de esto tenemos la opción de utilizar getcontext(), que como su nombre indica no es mas que un  contexto predeterminado local, que establece el hilo de ejecución  y que permite cambiar las propiedades en búsqueda de cambios en la precisión, el redondeo o captura de errores.

 Ahora cuando trabajes con un numero de coma flotante o con decimal, ya sabes un poco mas de que va el tema.

«Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino»

Instalar una versión anterior en Laravel

laravel

Una de las cuestiones que podemos necesitar hacer es instalar una versión anterior en Laravel.

Las razones pueden ser varias : estudiar las modificaciones entre versión y versión, mantener la compatibilidad de un proyecto, o de un desarrollo previo, testear una app, o como sucede en algunos servidores cloud, adecuarse a la versión de que estos disponen.

La solucion es sencilla y composer nos permite incorporarla al iniciar nuestro proyecto

Basta con añadir a la consola la versión que necesitamos:

 composer create-project laravel/laravel [nombreproyecto] [version.*]

seria algo como esto:

composer create-project laravel/laravel ProyectoTest 6.*

Aquí estamos instalando la versión 6 en su última variante, podríamos escribirlo también asi:

composer create–project laravel/laravel=6.* ProyectoTest

Donde 6 será la versión que necesitamos, acepta  incluso 6.2  o 5.1, y el asterisco indica dentro de ella la que incorpora la última actualización, lo  que significa que se han  reparado los bugs, o sea es una versión Bugfixed.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

….un sueño es casi todo  y más que  nada, más que todo al soñarlo, casi nada después……