….centrado en crear soluciones que importen
Puedes rotar los tick labels en Matplotlib, empleando el método tick_params() sobre los ejes (Axes objects), con que trabaja la librería, indicándole exactamente que quieres hacer.
ax.tick_params(axis='x', rotation=60) #Esto rotará 60 grados las etiquetas, sobre el eje de las x.
Conoce mas como trabajar con los ticks en este árticulo
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias
…..lo que realmente importa no es lo que te da la vida, sino lo que haces con ello….
En este post realizaré un análisis de regresión, en el que tomaremos una set de datos preparado previamente.
El problema real al que nos enfrentamos, es determinar la relación que pueda existir entre la cantidad de ventas de la empresa “El Dorado”, y el numero de vendedores que la han integrado durante el periodo que se estudia, que son 36 meses o sea los últimos 3 años.
El departamento ha cambiado de responsable en varias ocasiones, y cada uno ha aplicado políticas diferentes de ventas, algunas intensivas, buscando mayor productividad en las ventas, a bases de estímulos como bonos, primas, ascensos, etc; y en otras ocasiones, en cambio, se han aplicado medidas extensivas incrementando el numero de vendedores, en una afán por ampliar la cobertura de ventas.
Lo que vamos a hacer es implementar un análisis de regresión lineal.
La regresion lineal es una técnica estadística, que el machine learning adoptó y que incluye como uno de los algoritmos supervisados.
He escrito hace unos meses algún articulo sobre regresion lineal y resumiendo lo que hara este análisis es obtener una recta que se acerque lo mas posible a todos los puntos de datos representados en un plano.
En nuestro caso es una regresion simple (participan dos variables ) y la recta que buscamos obtener es, la mejor posible.
Esto quiere decir que de todas las rectas esta sea la que mejor se adapte al conjunto de puntos, lo que le permitirá tendencialmente estimar o predecir valores, dentro del contexto de datos estudiados.
La recta tiene forma esta forma Y = mX + b; donde Y es el resultado obtenido, X es la variable, m la pendiente (o coeficiente) de la recta y b el valor constante, que gráficamente expresa el “punto donde cuando X tiene valor cero, se produce la intercepción o corte con el eje Y.
Su optimización o ajuste se logra aplicándole una función llamada de mínimos cuadráticos, o también conocida de error cuadrático.
Su nombre obedece a que esa funcion intenta minimizar el error existente entre los puntos o dados y los obtenidos, elevendo al cuadrado sus valores para evitar que se anulen.
De este modo el algoritmo, se centra en minimizar el coste de dicha función
Recordemos que los algoritmos de Machine Learning Supervisados, aprenden por sí mismos.
Utilizaremos un archivo de datos que ya tenemos, y que muestra el número de ventas y vendedores por meses; o sea tendremos dos columnas: vendedores y ventas.
Y nuestro en nuestro análisis de regresión, lo que vamos a intentar es determinar a partir de los vendedores que tenemos, que valor podemos esperar en la ventas de acuerdo, a la relación dada entre ambas variables.
Trabajaremos con Jupiter Notebook,utilizaremos las librerías Pandas, SkLearn, Seaborn, Numpy, de modo que comenzaremos por ahí.
Importamos las librerías
Cargamos nuestro archivo en un dataset de pandas después de leerlo, definiendo el separador de columnas.
Adquirimos la información de nuestro dataset, con el método info(). Observamos que tenemos dos tipos de datos : enteros en columna vendedores y decimales en la columna ventas.
Comprobamos la estructura del dataset, con el método shape, que nos dice que tenemos efectivamente dos columnas y 36 registros en cada una.
Con head(), visualizamos las 6 primeras filas de nuestro dataset
Convertimos por comodidad la columna venta a tipo entero, empleando el método astype() y guardamos esa transformación en un nuevo dataset, que es con el que continuaremos trabajando.
Definimos con columns(), los encabezados de las columnas
Obtenemos los valores estadísticos de nuestro dataset con el método describe()
Observamos entre otros valores, que la media de vendedores es 23, con una desviación de 4,63; mientras que la de ventas es 42 millones y su desviación es de 7.12.
Visualizamos los datos, en gráficos, mostrando las columnas por separados
Empleando scatter mostramos los puntos coloreados, separando los colores a partir de la media de vendedores (23)
En este punto creamos nuestra recta de regresion y visualizamos los coeficientes que la componen nuestra recta.
Nuestro error cuadrático no es elevado pero es alto y nuestra varianza esta más cerca de 0 que de 1, por lo que este modelo tal vez podría mejorarse.
La intersección (b), tiene un valor de 9,67…. donde se corta la recta cuando el valor en X es 0
En función de observar el comportamiento del modelo, asignamos valores diferentes para ver su comportamiento
Ahora visualicemos la recta dentro de nuestro gráfico
Podemos observar nuestros datos de diferentes formas, en este caso con la librería seaborn, vemos el comportamiento de los datos en los diferentes periodos y su relación.
Para mejorarla tenemos varios caminos, podemos aplicar métodos como el gradiente, podemos hurgar en los datos y añadir más variables predictivas, referidas por ejemplo a la competencia, la innovación o la aceptación de los productos, pasando de una regresión simple a una regresión múltiple, podríamos también ampliar la cantidad de registros buscando mas años, desechar los valores extremos, etc.
En otros artículos iré aplicando algunos de estos métodos, haciendo referencia a estos mismos datos.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias
«El amor es la guerra perdida, entre el sexo y la risa»
R.Arjona
Para crear conexiones dinámicas en Laravel, que varíen en función de nuestras necesidades, tendremos que modificar los valores de los archivos de configuración, que están dentro de la carpeta config.
Los pasos son :
Es el encargado de establecer la estructura básica del comportamiento de Laravel para conexiones entre otras cosas.
Aquí añadiremos el marco de las conexiones a la base de datos y al servidor.
DB_CONNECTION_VAR=server_variable DB_HOST_VAR= DB_HOST_VAR= DB_PORT_VAR= DB_DATABASE_VAR= DB_USERNAME_VAR= DB_PASSWORD_VAR= FTP_HOST= FTP_PASSWORD= FTP_USERNAME= FTP_PORT=
Como sabemos este archivo establece los términos de conexión a la base de datos, e inicialmente toma valores del archivo .env.
Podemos crear en él, tantas conexiones, como necesitemos, así que lo que haremos será crear una nueva conexión, dentro de database, que será nuestro conexión dinámica:
'connections' => […….
'server_variable' => [
'driver' => 'mysql',
'url' => env('DB_DATABASE_URL_VAR',''),
'host' => env('DB_HOST_VAR', ''),
'port' => env('DB_PORT_VAR', ''),
'database' => env('DB_DATABASE_VAR','' ),
'username' => env('DB_USERNAME_VAR','' ),
'password' => env('DB_PASSWORD_VAR','' ),
'unix_socket' => env('DB_SOCKET_VAR', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'strict' => false,
'engine' => null,
],
…………..]
Lo que haremos ahora es crear una clase que modifica los valores del archivo config, para poder acceder a ellos de modo dinámico y variarlos en función del tipo de conexión que queremos establecer.
?php
namespace App\Personalizado;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Config;
class Conexion
{
public function conectar()
{
$hora = date("H.i.s");
$sitio = DB::table('sitios')->where('hora_deseada','=',$hora)->get();
if ($sitio);
{
$sitio = DB::table('sitios')->where('id')->first();
$driv='msql';
$puerto_conex=$sitio->port_conex;
$database_name=$sitio->nombre_bd;
$user_name=$sitio->usuario_bd;
$contra_=$sitio->pass_bd;
$host_con=$sitio->host_conex;
$user_FTP=$sitio->user_FTP;
$pass_FTP=$sitio->pass_FTP;
$port_conex=$sitio->port_conex;
Establecemos la ruta de los archivos database y filesystem, dentro del archivo config, utilizando la convención del punto de Laravel, y seteamos los datos dinámicos tomados de la bd.
Config::set([ 'database.connections.server_variable.driver'=>$driv, 'database.connections.server_variable.database'=>$database_name, 'database.connections.server_variable.username'=>$user_name, 'database.connections.server_variable.password'=>$contra, 'filesystem.disk.ftp.driver'=> 'ftp', 'filesystem.disk.ftp.host' => $host_con, 'filesystem.disk.ftp.username' => $user_FTP, 'filesystem.disk.ftp.password' => $pass_FTP, 'filesystem.disk.ftp.port' => $puerto_conex, ]);
Solo conectaremos por ahora via ftp_connect
$driver = ( Config::get('filesystem.disk.ftp.driver'));
$host = ( Config::get('filesystem.disk.ftp.host'));
$username = ( Config::get('filesystem.disk.ftp.username'));
$password = ( Config::get('filesystem.disk.ftp.password'));
$port = ( Config::get('filesystem.disk.ftp.port'));
$conex = [$driver, $host, $username, $password, $port];
$ftp_conn = ftp_connect($host) or die("no conecta ftp");
if ($ftp_conn){
echo "<br>Conectado";
$login =ftp_login($ftp_conn,$username,$password);
ftp_pasv($ftp_conn, TRUE);
if($login)
{echo "<br>logeado";
$remote='httpdocs/tienda/import/importacion.csv';
$local='./storage/app/csv/convertidos.csv';
if (ftp_put($ftp_conn,$remote,$local, FTP_BINARY))
{ echo "<br>Upload";}
else
{echo "<br>not upload";}
}
else
{echo "fallo login";}
if(ftp_close($ftp_conn))
{echo "conexion cerrada";};
}
return $conex;
}
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……
Si estamos trabajando con LARAVEL, empleando un cliente conectado a proveedores, y necesitamos desarrollar alguna api que pueda importar un archivo remoto, y guardarlo en nuestro servidor de modo automático para después trabajar con él, una forma sencilla de hacerlo, seria esta:
$dia = date("m.d.y");
$hora = date("H.i.s");
$filepath = 'http://dirección_remota';
//fijamos la hora a la que queremos iniciar el proceso de importacion para que el scheduler la vea
if ($hora === "13:16") // hora que deseamos hacer la importacion
{ $guardar = Storage::disk('importados')->put($dia.'_'.$hora.'_nuevoarchivo', file_get_contents($filepath)); }
Si ahora queremos retornar ese último archivo guardado, podemos dirigirnos a su posición en la carpeta storage, y escoger el último asi:
$archivo = \Storage::disk('importados')->files()->end();
A partir de aquí podríamos, trabajar con la variable archivo.
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
…..lo que realmente importa no es lo que te da la vida, sino lo que haces con ello….
Laravel trabaja con clases que generalmente se guardan en repositorios desde el cual son llamadas. Esta estructura requiere que ademas de conocer la organización del framework, comprendamos su enfoque para crear y almacenar las clases.
Puede parecer para muchos complicado, pero es una estructura que desde mi punto de vista esta enfocada a componentes como parte de un todo, de ahi la necesidad de entenderla adecuadamente
Las clases en Laravel se crean dentro de la carpeta App, usando psr-4. Basta con crear un archivo en una dirección dentro de App y comenzaremos a tener una clase reconocida, por la aplicación:
Creamos el archivo Conexión dentro de una carpeta nueva llamada Personalizado
App/Personalizado/Conexión.php
Y luego colocamos la clase con sus métodos y/o atributos. En nuestro caso estamos creando una clase que sustituirá los valores de conexión a la bd en el archivo env.
class Conexion
{
public function conectar()
{
return 'conecto';
}
}
Una vez creado, la clase principal que se encuentra ubicada en “App\Personalizado\Conexion\conexion.php”, tendrá como namespace y que es el que podrá ser usado desde cualquier lugar de la aplicación, o sea hacer bind, este:
App\Personalizado\conexion
Para que el bind funcione, son necesarios unos pasos más. Lo siguiente que haremos será crear el Service Provider de la clase.
Lo haremos con Artisan desde la consola:
php artisan make:provider ConexionServiceProvider
Lo que sigue es registrar la clase en el método register() del ConexionServiceProvider, haciendo el adecuado bind.
public function register()
{
//registramos la clase
\App::bind('Conexion');
}
Y finalmente registramos ConexionServiceProvider en el fichero de configuración, que se encuentra en la ruta config/app.php, agregando la clase, dentro del array de providers:
/* * Application Service Providers... */ App\Providers\AppServiceProvider::class, App\Providers\AuthServiceProvider::class, ………… /* * Clases Propias añadidas... */ App\Providers\ConexionServiceProvider::class,
Nos faltaría comprobar que nuestra clase es accesible, podemos hacer diferentes pruebas, como llamar la clase desde una ruta o correr una prueba con Tinker.
Comencemos con Tinker, llamándolo desde la consola:
>>>php artisan tinker
Una vez abierto, llamamos la clase, y la corremos :
Psy Shell v0.9.12 (PHP 7.2.3 — cli) by Justin Hileman >>> use App\Personalizado\Conexion;
La instanciamos :
>>> $h =new Conexion();
=> App\Personalizado\Conexion {#3106}
Y llamamos la funcion:
>>> $h->conectar(); => "conecto" >>>
Salimos de Tinker, con control +C.
Tambien podemos probarlo en el sistema de rutas de Laravel.
Route::get('conectando', function(){
if(class_exists('App\Personalizado\Conexion'))
dd('hallada');
else dd(' no hallada');
}
);
Si accedemos ahora a la ruta conectando deberíamos ver escrita la palabra hallada.
Ahora, nuestra clase esta lista y disponible para ser usada.
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
…., si avanzo sígueme, si me detengo empújame, si retrocedo mátame…….
Crear comandos que nos permiten ejecutar acciones manuales desde la consola, es una herramienta que necesitamos más comúnmente de lo que parece, por eso crear un comando en Laravel, es una buena opción que agiliza el desarrollo.
Hablo por supuesto desde mi humilde experiencia.
El desarrollo me he exigido que además de las herramientas de testeo, en muchos casos correr directamente comandos de Artisan, para comprobar el funcionamiento en vivo de funciones o métodos construidos, como parte del proceso de creación de una aplicación.
En este ejemplo muestro como crear un comando Artisan, que va a conectarse a un base de datos y hacer una inserción según un momento determinado en ella.
Llamaremos a nuestro comando importar.
En la consola dentro del root de nuestro proyecto creamos el comando:
php artisan make:command Importar
Como crear un componente en Laravel
Esto creará nuestro comando, si vamos ahora a la ruta
app/Console/Commands/importar.php, el archivo Commands, que se crea al correr
make:command
tendrá dentro los datos del comando creado.Dentro del comando hay varias zonas importantes:
La primera es la variable $signature, que es donde daremos el nombre con que llamaremos al comando en la consola
protected $signature = 'importar';
La segunda es la variable descripción, allí escribiremos la descripción de la razon de ser del comando que aparecerá cuando listemos los comandos de Artisan
protected $description = 'Insertar productos en la Base de datos';
La tercera zona importante es la función handle en la cual desarrollaremos la lógica.
public function handle()
{//
$archivos = \Storage::disk('listos')->files();
$ultimo = end($archivos);
$contenido_Exp = \Storage::disk('listos')->get($ultimo);
$contenido_Exp = json_decode($contenido_Exp);
//dd($contenido_Exp[2]->codigo);
/*
->get(); */
//dd($archivo);
function hora_exportar($sitio, $hora)
{
$hora = date("H.i.s");
$hora_deseada = DB::table('sitios')->hora_deseada;
if ($hora === $hora_deseada){
$sitio = DB::table('sitios')->nombre;
$host = DB::table('sitios')->host_conex;
$username = DB::table('sitios')->usuario_bd;
$passwd = DB::table('sitios')->pass_bd;
$dbname = DB::table('sitios')->nombre_bd;
}
}
/*
$host ="154.53….";
$username = "admin_bd ";
$passwd= "Hlnv68?";
$dbname= "bd_pt";*/
// $consulta = ;
$enlace = mysqli_connect($host,$username,$passwd,$dbname);
/* if ($mysqli_ping($enlace)){
printf("conexion bien");
}
else{ printf("error de conexion");}
mysqli_close($enlace);*/
if(!$enlace){
echo "Error no se pudo conectar".PHP_EOL;
echo "Errno de depuracion:".msqli_connect_errno().PHP_EOL;
echo "Errno de depuracion:".msqli_connect_error().PHP_EOL;
exit;
}
echo "realizada conexion exitosa".PHP_EOL;
echo "info del host:".msqli_get_host($enlace).PHP_EOL;
mysqli_close($enlace);
//insertamos en nuestra bd los datos de la ultima exportacion
$insertar_exportacion = DB::table('importaciones')->insert([
'users_id' => 1,
'estados_id' => '3',
'proveedores_id' =>'1',
'sitios_id' => $ultimo,
'url_archivo' => $url,
'nombre_archivo' => $url,
'tipo_archivo' =>$tipo,
'tamaño' =>'1',
]);
}
En nuestro ejemplo tenemos una columna en la bd llamada hora deseada, que compareremos con la hora actual del servidor, si el valor es igual ejecutaremos la consulta.
El ultimo paso para que el comando funcione es declararlo en el archivo kernel.php dentro de la ruta App/Console, dentro de los comandos protegidos
protected $commands = [
// Commands\Importar::class, ];
Y en la función Schedule, tenemos la opción de configurar la ejecución su ejecución periódicamente, podríamos también colocar una tarea en el servidor de llamar esta función, a una hora especifica, en nuestro caso la colocaremos aquí diaria.
protected function schedule(Schedule $schedule)
{
$schedule->command('Importar')
->daily();
}
Esto es todo, no obstante debemos decir que la recomendación de Laravel es que los comandos sean ligeros para no cargar demasiado la ejecución del sistema en si y como una buena práctica de programación.
La mejor opción es aprovechar la reusabilidad, y utilizar ese mismo código dentro de un controlador, ejecutándolo de modo periódico, y así dejar la ejecución del comando solo para tareas manuales.
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
…todo lo que se contiene, termina desbordándose……
Laravel es un framework basado en componentes y esta es una de sus características y quizás la mas importante de todas, que lo hace tan útil, sencillo y potente a la vez.
Los componentes dicho de forma rápida son un conjunto de funciones, scripts y/u otros elementos que pueden que crean una funcionalidad y que son reusables.
Piensa en una pieza de ropa o un accesorio femenino que puedes combinar(usar), con varias otras prendas, sin que pierda funcionalidad, y para diferentes ocasiones y tantas veces como quieras.
Hay diferentes tipos de componentes, voy a centrarme hoy en construir uno en Blade el gestor de plantillas Blade
Un componente en Blade, cumple la misma función que la combinación entre las directrices section y layouts, por tanto es una alternativa a esta, digamos más moderna.
Consta de dos variables, el component y el slot. Mientras que el component es la estructura general, slot es la parte dinámica que inyectaremos en el.
El primer paso para crear un componente Blade, considerando que va a estar relacionado con las vistas, es colocarlo dentro del área que tiene que ver con las capas(layouts) de las vistas, así que en la ruta resources/views/layouts, creamos una carpeta llamada componentes.
Luego crearemos un archivo, que contendrá la lógica del componente.
El compenente, que vamos a construir, va a llamarse curric_autor, y se encargará de mostrar una pequeña nota al final de cada articulo que publiquemos en nuestro blog.
Estará colocado a la izquierda de la página, e incluirá la foto del autor y un pequeño texto con su descripción.
A este archivo lo nombraremos curric_autor.php y lo guardaremos en la carpeta componentes que hemos creado.
El próximo paso es escribir nuestro código, el cual podría ser este:
<divclass = flex-row comd-6> <div class=d- flexjustify-content-end col-md-9> <spanclass= text-justify> Amante del codigo, y de las mascotas con garras.</span> <divclass="text-center col-md-3"> <imgsrc="..."class="rounded"alt="..."> </div> </div> </div>
Una vez creado el componente podemos usarlo de diferente modo:
Podemos llamarlos desde nuestra vista e inyectarlo en la vista siguiendo las directivas @ de Blade.
@component('layouts.components.curric_autor')
@endcomponent
Con esto será suficiente, pero ¿que sucede si en el blog publica más de un autor y por tanto los datos que usamos necesitan ser extraidos dinámicamente de la base de datos?
Tendríamos entonces que añadir en el código del componente variables necesarias para que recojan esta dinámica, y lo haríamos con $autor que representará al modelo autor que posee varios atributos, lema, avatar_alt y avatar, y para añadirlos seria asi:
<div class = flex-row col-md-6 >
<div class=d- flexjustify-content-end col-md-9>
<spanclass= text-justify> {{$autor->lema}}.</span>
<divclass="text-center col-md-3">
<imgsrc="{{$autor->avatar}}..."class="rounded"alt=" {{$autor->avatar_alt}}">
</div>
</div>
</div>
Una alternativa es que no extraigamos valores de la base de datos y solo necesitemos introducir variables que llevan valores estaticos.
<div class = flex-row col-md-6 >
<div class=d- flexjustify-content-end col-md-9>
<spanclass= text-justify> {{$autor}}.</span>
<divclass="text-center col-md-3">
<imgsrc="{{$avatar}}..."class="rounded"alt=" {{$avatar_alt}}">
</div>
</div>
</div>
Ahora al llamar el componente desde la vista añadiríamos la directiva slot que es la encargada de traernos el valor de esas variables.
@component('layouts.components.navbar')
@slot('autor')
colocamos aquí el valor
@endslot
@slot('avatar')
colocamos aquí el valor
@endslot
@endcomponent
@slot('avatar_alt')
colocamos aquí el valor
@endslot
Esto pudiéramos hacerlo también de otro modo, gracias a la ductilidad de Laravel. Esta via por cierto es un poco más robusta.
Para ello declararemos, nuestro componente en el proveedor de servicios de Laravel, en su función boot()
Antes de hacer esto debemos decirle al proveedor de servicios que vamos a usar una instancia de la fachada Blade, asi que tendremos que incluir al inicio la sentencia.
use Illuminate\Support\Facades\Blade;
//Luego podemos ya incluir en la función boot, lo siguiente:
Blade::component('layouts.components.curric_autor,'autor');
Con esto le estamos diciendo a Laravel primero donde se encuentra el componente, y segundo nombre que utulizaremos para llamarlo, entendemos entonces que la estructura es:
(ruta o namespace del componente, alias del componente)
Entonces, ahora podremos llamar al componente, desde cualquier lugar con la directriz @y su alias, en nuestro caso será:
@autor
Quedando el modo de llamar a nuestro componente como:
@autor(['autor'=>'valor', 'avatar'=>'valor', 'avatar_alt'=>'valor',]) @endautor
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……
Las ticks en Matplotlib, son los marcadores que indican los puntos de datos en los ejes.
Normalmente en Matplotlib, los localizadores y formateadores predeterminados de los ticks, están diseñados para ser suficientes en la mayor parte de los casos comunes, sin embargo la posición y las etiquetas de las ticks , se pueden manejar explícitamente para adaptarlos a nuestros requisitos.
Las funciónes xticks() y yticks(), toma un objeto de lista como argumento y los elementos de la lista indican las posiciones de la acción correspondiente donde se mostrarán los ticks.
ax.set_xticks ([3,6,9,12,15])
En este caso, el método marcará los puntos de datos, en aquellas posiciones dadas con ticks.
Si lo que deseas en manejar los grados, y sus etiquetas, se pueden hacer mediante las funciones set_xlabels() y set_ylabels() respectivamente.
ax.set_xlabels ([«tres», «seis», «nueve», «doce», «quince»])
Esto mostrará las etiquetas de texto debajo de los marcadores en el eje x.
Veamos un ejemplo completo
import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*3, 0.05)
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # eje principal
y = np.sin(x)
ax.plot(x, y)
ax.set_xlabel(‘angle’)
ax.set_title('sine')
ax.set_xticks([0,3,9,12])
ax.set_xticklabels(['cero','tres','nueve','doce'])
ax.set_yticks([-1,0,1])
plt.show()
Quién va en busca de montañas no puede detenerse a recoger las piedras del camino.
J. Martí
El método save(), acepta parámetros, ello da la capacidad para decirle que ignore el la asignación que hace update_at por defecto, tomando la fecha y momento actual, haciendo esto, lo cual nos permite hacer override del update_at con save(), sin mayores problemas:
$product = Product::find($id); $product->updated_at = '2019-01-01 10:00:00'; $product->save(['timestamps' => false]);
Y listo, esto es todo.
Espero modestamente que este artículo, sirva de ayuda a alguien.
Gracias.
Subir montañas hermana hombres……
Puede ser que necesitemos a menudo acceder a archivos o directorios con espacios en el nombre en Mac; acá les explico como hacerlo.
Al intentar acceder a un archivo en Mac de la manera habitual, que tiene espacios en el nombre solemos recibir este error:
cd mi archivo
no such file or directory
Existen al menos tres soluciones para ello.
La primera es empleando el símbolo de escape
Esta vía es más compleja. Lo que debemos hacer para acceder a un directorio con espacio entre el nombre, es utilizar el símbolo \ seguido de un espacio.
Si tuviéramos, por ejemplo un directorio llamado mi directorio
Seria algo así como:
cd mi\ directorio/
La segunda opción es muy sencilla, basta con encerrar entre comillas dobles, el nombre del archivo tal y como está, o sea así:
cd "mi directorio"Y la tercera es acudir al autocompletado, para lo cual emplearemos Tab y autocompletar el nombre del archivo o el directorio.
Como siempre, espero que sirva de ayuda a alguien.
Muchas gracias.
Porque la vida es eso sembrar, sembrar, sembrar
J. A. Buesa