Comandos de Artisan

logo laravel

La potencia  de los comandos de Artisan, para aquellos que ya entienden algo de Laravel, es indiscutible.

Artisan posee un conjunto de comandos, que permiten que pueda aprovecharse muy bien su capacidad. Para listar estos comandos basta con escribir en la consola

  php artisan list 

e inmediatamente obtendremos:

Las opciones que disponibles con cada comando, pueden obtenerse mediante  help:

php artisan help nombre-comando 

o acortando simplemente con -h:

php artisan nombre-comando -h

Así obtendremos: la forma de usar el comando, sus argumentos , una descripción y las opciones que podemos agregar. Por ejemplo, para php artisan migrate -h  nos muestra:

Aquí nos está diciendo dice que “mígrate” es el comando para correr las migraciones y entre las opciones con que cuenta está poder indicar cuál es la base de datos por ejemplo php artisan migrate –database=tests .

Una de las grandes ventajas de esta herramienta es que tiene un conjunto de comandos dedicado a generadores, es decir, que nos permiten crear elementos como controladores, middleware, seeders, modelos, entre otros, los cuales son los que están bajo la categoría make:


Cada uno de esos generadores tiene sus propias opciones, así que puedes revisarlo con el comando help.

Artisan nos permite crear controladores sin métodos, mediante el uso de la opción plain:

php artisan make:controller PostController --plain

Abajo muestro una lista de algunos de los comandos de uso  más común.

Serve:

php artisan serve

Se utiliza para lanzar el servidor de una aplicación,  corriéndolo desde el root de nuestra app.

Este servidor viene incluido en laravel y se levanta de modo individual para cada  caso. Después de cargarlo, nos indicará donde está corriendo.   

laravel development server started on http://localhost:8000/

Si vamos al navegador, y visitamos  http://localhost:8000/,  veremos nuestra aplicación corriendo.

Para detener el servidor, utilizaremos la combinación de  las teclas Ctrl+C.  

Cambiar el namespace de la aplicación:

php artisan app:name nombre-namespace

Ver el listado completo de rutas: 

php artisan route:list


Como resultado nos mostrará un listado de todas las rutas de la aplicación, con la información sobre el método HTTP, la URI, la acción, el nombre y sus  middlewares.

Poner en modo mantenimiento nuestra aplicación:

php artisan down

Sacar la aplicacion del modo mantenimiento

php artisan up

Artisan además asimila crear comandos, lo cual es muy útil para ejecutar tareas manuales o testear comportamientos.

Crear una tabla

php artisan make:migration
create_posts_table --create posts 

Correr la migracion

php artisan migrate

Modificar una tabla existente

De este modo estariamos agregando el campo «resumen» a la tabla «articulos»

php artisan make:migration add_resumen_to_articulos_table --table="articulos"

Agregar varios campos nuevos a la tabla «users»

php artisan make:migration add_fields_to_users_table
--table="users"

Generar una llave para hashing

php artisan key:generate

Crear un middleware

Por ejemplo escribir esto para crear un middleware que verifique si el usuario tiene una sesión

php artisan make:middleware HasUserASession

Crear un modelo

El siguiente comando creara el modelo Tarea

php artisan make:model Tarea

Crear un controlador

Crear un controlador de recursos tipo REST (resource), que incluye todos los métodos del CRUD(create, read, update, delete)

php artisan make:controller TareaController --resource

Generar el código boilerplate para autenticación de usuarios

Este comando debería ejecutarse lo más pronto al iniciar tu proyecto ya que re-escribirá tus layouts y controladores de Autenticación y Usuarios

 php artisan make:auth

Y listo, esto es todo.

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

Gracias.

Subir montañas hermana hombres……

Pickle. serializar datos con Python

logo python

Al manejar datos, de gran volumen, que necesitamos por ejemplo guardar en archivos, para manejarlos con mayor facilidad, lo màs adecuado es emplear un modulo como Pickle, para serializarlos. 

El modulo pickle de Python, de que hablaré en ese post,  lo que hace es, serializar objetos para que puedan guardarse en un archivo y tener la opción de volver a cargarlos más adelante.

pickle() se utiliza para serializar y deserializar estructuras de objetos de Python,  esta acción es también conocida cómo clasificación o aplanamiento de los datos.

La serialización, en su explicación más simple no es otra cosa que  convertir un objeto que tenemos en la memoria, en un flujo de bytes que se puede almacenar en el disco o enviar a través de una red,  y que puede ser posteriormente recuperado, transformándolo nuevamente en un objeto Python deserializado.

Las ventajas de serializar nuestros datos, no es solamente que se puedan guardar en el disco para continuar trabajando con ellos, y que podamos también enviar nuestros datos a otros por TCP, o una conexión de socket.

Pickle es igualmente poderosa porque a través de ella podemos almacenar objetos de Python en una base de datos.

Sobre todo cuando trabajamos con algoritmos de aprendizaje automático, conocer su uso nos evitará tener que reescribir todo o entrenar el modelo nuevamente, ya que podemos guardarlos y recuperarlos cuando queramos.   

Datos

Pickle(), nos permite  serializar los siguientes datos:

Cadenas,

Listas,

Tuplas

Enteros

Flotadores

Booleanos,

Números complejos,

Diccionarios que contienen objetos serializables.

Dataframes

 Pickle(), también puede serializar las clases y funciones, incluso las lambdas.  En el caso de estas últimas se usa dill(), un paquete adicional diseñado para ello, a partir de un fork de multiprocessing(), el paquete de multiprocesamiento de Python

A pesar de su capacidad, elementos como los dict predeterminados, las clases internas, o los generadores pueden tener problemas para ser serializados.

Los dicts predeterminados, necesitan ser creados con una función a nivel de módulo.

Serializando archivos

Importamos pickle()  

import pickle

Creamos un diccionario  y luego estructuramos un archivo de salida llamado alumnos_dic.

#escribimos un diccionario sencillo
alumnos_dict = {'Jose': 7,'Arnoldo': 8,'Mario': 5, 'Maria': 78,'Amara': 50,'Rolando': 67,'Hemeregildo': 78,'Prudencio': 79,'Zoraida': 0}

Abrimos un archivo utilizando la función open(), para poder escribirlo en formato binario. En este articulo, puede leerse un poco mas sobre las opciones para usar open().

#abrimos nuestro archivo para escribir en formarto binario
alumnos_pick= open('alumnos', 'wb')

Serializamos el archivo inicial y obtenemos un nuevo objeto file, luego cerramos la conexión

#usamos dump para serializar
pickle.dump(alumnos_dict, alumnos_pick)
alumnos_pick.close()

Deserializar nuestro archivo

El proceso de volver a cargar un archivo serializado en Python, no es complejo.

Usaremos la función open () nuevamente, pero esta vez con 'rb' como segundo argumento.

alumnos_pick.close()

Lo que haremos será leer el formato binario con que serializamos anteriormente.

#usamos dump para serializar
pickle.dump(alumnos_dict, alumnos_pick)
alumnos_pick.close()

Asignamos su valor  a infile.

infile = open('alumnos','rb')

Para cargar el archivo utilizamos pickle.load (), con infile como argumento, al que asignaremos  a nuevo_alumnos.

nuevo_alumnos = pickle.load(infile)

El contenido del archivo ahora está asignado a esta nueva variable.

Nuevamente,  cerramos  el archivo al final.

infile.close()
nuevo_alumnos
output:{'Jose': 7, 'Arnoldo': 8, 'Mario': 5, 'Maria': 78, 'Amara': 50, 'Rolando': 67, 'Hemeregildo': 78, 'Prudencio': 79, 'Zoraida': 0}

Comparamos los archivos.

#comparamos ambos archivos
print(nuevo_alumnos==alumnos_dict)
print(type(nuevo_alumnos))
output: True 
<class 'dict'>

Comprimir archivos

Si el tamaño del archivo es grande, por ejemplo datasets, voluminosos, podemos ahorrar espacio comprimiendo, el archivo deserializado.

Hay diferentes vías, dos de ellas son bzip2 y gzip.  Puede ver otras en este articulo.

Su diferencia en esencia, radica en que  gzip  es más rápido, pero los archivos que crea bzip2, ocupan  la mitad de espacio que los que crea gzip.

Una cuestión importante y que puede tender a confundir es que deserializar, no es lo mismo que comprimir.  

La deserialización es la conversión de un objeto de una representación (datos en la memoria de acceso aleatorio (RAM)) a otra (texto en el disco); mientras que la compresión es el proceso de codificación de datos con menos bits, para ahorrar espacio en el disco.

Lo primero es importar bz2

import bz2

Luego como primer parámetro del método BZ2File, pasaremos el nuevo nombre del nuevo archivo compactado que se creará al ejecutarse el script

sfile = bz2.BZ2File('compress_alumnos', 'w')
pickle.dump(alumnos_dict, sfile)

Multiproceso

Pickle es especialmente sensible al multiprocesamiento, pues hay elementos como las funciones lambda que no pueden ser fácilmente serializadas.

Cuando necesitamos realizar tareas complejas que ocupan mucho espacio de memoria, es común distribuir esta tarea en varios procesos.

El multiprocesamiento, es la subdivisión de un proceso en varios que se ejecutan simultáneamente, generalmente en varias Unidades Centrales de Procesamiento (CPU) o núcleos de CPU, ahorrando tiempo, como es el caso de operaciones de entrenamiento de modelos de aprendizaje automático, la creación de redes neuronales, todos ellos procesos intensivos.

En Python, esto se hace usando el paquete de multiprocesamiento multiprocessing().

La ventaja de trabajar de esta forma, es que los procesos en que se divide una tarea no comparten espacio de memoria, y comparten datos entre ellos serializados 

En el ejemplo lo que haremos será crear una especie de abstracción llamada pool, para que trabaje en segundo plano procesando una tarea, y al que indicaremos cuantos procesadores empleará para ello.

#trabajando con multiprocesamiento
#importamos el modulo y creamos con la la funcion cos una tarea
import multiprocessing as mp
from math import cos
p = mp.Pool(2)
p.map(cos, range(10))
output:[1.0, 0.5403023058681398, -0.4161468365471424, -0.9899924966004454, -0.6536436208636119, 0.2836621854632263, 0.9601702866503661, 0.7539022543433046, -0.14550003380861354, -0.9111302618846769]

Si quisiéramos ejecutar en vez de cos() un lambda, nos lanzara un error, indicando que Pickle no puede serializar un lambda.

p.map(lambda x: 2**x, range(10))
output: .......
PicklingError: Can't pickle <function <lambda> at 0x7fe84683a830>: attribute lookup <lambda> on __main__ failed

Afortunadamente existe un modulo para resolver esto dill(), que pertenece a un fork, llamado pathos.multiprocessing

Pathos esta en desarrollo aun, y debe ser instalado desde github, según recomendaciones de su creador. Puedes ver este articulo en stackoverflow

El amor siempre empieza soñando y termina en insomnio

R.Arjona

Como ponerle un alias a una tabla

laravel

Suele suceder que tengamos la necesidad de ponerle un alias a una tabla, si nos vemos obligado a ello, podemos hacer esto.

Otros posts sobre Laravel

$cars = Car::from('cars as c')
    ->join('marcas as m',function($join){
        $join->on('c.roles_id','=','m.id')->where('m.estado','=',1);
    })    
    ->select("c.*","m.name")
    ->where('c.estado','=',1)
    ->get();

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

Manejar excepciones en Python

python error

Si lo que necesitas es manejar excepciones en Python, para adecuar tu código a determinada exigencias, el lenguaje nos da suficientes herramientas para ello.

En este ejemplo que hemos tomado de aquí , se le pide al usuario una entrada hasta que ingrese un entero válido; sin embargo también se le permite un modo de interrumpir el programa la ejecución del programa, usando Control-C.

Esta interrupción se recoge generando la excepción KeyboardInterrupt.

>>> while True:
...     try:
...         x = int(input("Please enter a number: "))
...         break
...     except ValueError:
...         print("Oops!  That was no valid number.  Try again...")
...

Las excepciones se manejan con las sentencias try y except

Manejar las excepciones

La sentencia try funciona de la siguiente manera.

  • Primero, se ejecuta la cláusula try  que ejecuta el código que exista entre entre las palabras reservadas try y  except).
  • Si no ocurre ninguna excepción, la cláusula except() se omite y la ejecución de la cláusula try finaliza.
  • Si una excepción ocurre durante la ejecución de try, el resto de la clausula se salta.
  • En ese caso si su tipo coincide con la excepción nombrada después de la palabra clave except, se ejecuta la cláusula except, y luego la ejecución continúa después del bloque try / except.

Si la excepción que ocurre no coincide con la excepción nombrada en la cláusula except,  se pasa a ejecutar las sentencias try externas; y si no se encontraran, entonces el interprete considerará excepción como una excepcion no controlada y  detendrá la ejecución, lanzando un mensaje como el que aparece en el ejemplo.  

Una declaración try() puede tener más de una cláusula except, para especificar manejadores para diferentes excepciones que corresponden a un mismo try().

No obstante, como máximo, se ejecutará un controlador.

Los manejadores solo manejan las excepciones que ocurren en la cláusula try correspondiente.

Una cláusula except puede nombrar múltiples excepciones, empleando  una tupla entre paréntesis, por ejemplo:

... except (RuntimeError, TypeError, NameError):
...     pass

Si declaramos una clase en una cláusula except esta será  compatible con una excepción, si es la misma clase o una clase base de la misma.

Esto no funciona al revés, o sea  una cláusula except que enumera una clase derivada no es compatible con una clase base.

Por ejemplo, el siguiente código imprimirá B, C, D en ese orden:

class B(Exception):
    pass

class C(B):
    pass

class D(C):
    pass

for cls in [B, C, D]:
    try:
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

Si invirtiéramos las cláusulas, colocando except B primero, obtendríamos como resultado B,B,B, ya que una vez que el bucle alcanza el primera coincidencia se lanza la excepción.

Todas las excepciones heredan de BaseException,  de modo que puede emplearse como comodín.

No obstante dado que las excepciones pueden enmascar un error de programación real , es recomendable emplearlo con cuidado.

La instrucción try ... except tiene una cláusula else opcional, que, cuando está presente, seguir a las cláusulas except.

Es útil para el código que debe ejecutarse si la cláusula try no genera una excepción. Por ejemplo:

De este modo else() evita capturar accidentalmente una excepción que no fue generada por el código que está protegido por la declaración try … except.

Cuando ocurre una excepción, puede tener un valor asociado, también conocido como el argumento de la excepción. La presencia y el tipo de argumento depende del tipo de excepción.

La cláusula except puede especificar una variable después del nombre de la excepción.

Dicha variable está vinculada a una instancia de excepción con los argumentos almacenados en instance.args.

Por conveniencia, la instancia de excepción define __str __ () para que los argumentos se puedan imprimir directamente sin tener que hacer referencia a .args.

También se puede crear una instancia de una excepción antes de generarla y agregarle los atributos que desee.

>>> try:
...     raise Exception('spam', 'eggs')
... except Exception as inst:
...     print(type(inst))    # instancia de la excepcion
...     print(inst.args)     # argumentos guardados en .args
...     print(inst)          # __str__ permite args para que          
                             #sean imprimidos directamente
...                          # pero pueden ser sobrescritos 
                             #en las subclases de la            
                             #excepcion
...     x, y = inst.args     # desempaquetando  args
...     print('x =', x)
...     print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

Cuando una excepción tiene argumentos, estos se imprimen en la parte final del mensaje para las excepciones no gestionadas (“Unhandled exception”).

Los controladores de excepciones no solo manejan las excepciones si ocurren inmediatamente en la cláusula try, sino también si ocurren dentro de funciones que se llaman (incluso indirectamente) en la cláusula try.

Por ejemplo:

>>> def this_fails():
...     x = 1/0
...
>>> try:
...     this_fails()
... except ZeroDivisionError as err:
...     print('Handling run-time error:', err)
...
Handling run-time error: division by zero

…. siempre habrá poesía

J. A. Becquer

Trabajar con el modulo re() de Python

logo python

Python tiene un módulo llamado re() para trabajar con las RegEx. Trabajar con el modulo re(), no es complejo.

Pueden ver un articulo que escribí hace un tiempo, sobre ello.

En Python, existen herramientas especificas, que funcionan como auxiliares y modificadores para el trabajo con las RegEx.

Me refiero tanto al uso del modulo re() , como al empleo de r o R antes de una RegEx como prefijo.

Cuando se escribe una expresión regular y se coloca el \ delante de ella, este equivale a un escape del carácter que le sigue, de este modo \n o \r provocará que el lenguaje escape estos caracteres; sin embargo cuando colocamos r delante, estos serán considerados y tratados como un carácter normal.

La sintaxis para esto, es por ejemplo r’[\n\r]’

Veamos como usar re()

re.findall()

Nos devuelve una lista de todas las cadenas que contienen la coincidencias

import re

cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\D+'
buscamos todos aquellos caracteres que no sean digitos con re.findall()
coincid = re.findall(pattern, cadena)
coincid
ouput:['Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.']

pattern = '\d+'
output:[]

re.split()

Separa las cadenas donde existen las coincidencias y retorna una lista de  cadenas donde hay coincidencias.

pattern = '\D+'
cadena = 'amigos 12345 45:67'
#separamos las palabras de la cadena con re.split()
coincid = re.split(pattern, cadena)
coincid
output: ['', '12345', '45', '67']
pattern = '\d+'
output:cadena = 'amigos 12345 45:67'

#separamos las palabras de la cadena con re.split()
coincid = re.split(pattern, cadena)
coincid
output:['amigos ', ' ', ':', '']

Como se ve en el ejemplo se puede usar maxsplit para determinar el numero máximo de separaciones que deseamos que ocurran.

#utilizamos maxsplit 1
pattern = '\D+'
cadena = 'amigos 12345 45:67'
coincid = re.split(pattern, cadena, 1)
coincid
output:['', '12345 45:67']

#utilizamos maxsplit 3
pattern = '\D+'
cadena = 'amigos 12345 45:67'
coincid = re.split(pattern, cadena, 3)
coincid
output:['', '12345', '45', '67']

Re.sub()

Devuelve la cadena donde existe coincidencia y reemplaza el contenido con el valor de la variable replace.

#sustituimos en la cadena los valores con re.sub()
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.sub(pattern, replace, cadena)
nueva_cadena
out:'Cuanto,hice,hasta,hoy,,y,haré,,es,para,eso.,En,silencio,ha,tenido,que,ser,y,como,indirectamente,,porque,hay,cosas,que,para,lograrlas,han,de,andar,ocultas,,y,de,proclamarse,en,lo,que,son,levantarían,dificultades,demasiado,recias,para,alcanzar,sobre,ellas,el,fin.'

Podemos contar  utilizando count() como cuarto parámetro, para determinar cuántos reemplazosharenmos.

Si omitiéramos el valor sub(), reemplazará todas las coincidencias.

#añadiendo count() como parametro
string = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.sub(pattern, replace, string, 5)
nueva_cadena
output:'Cuanto,hice,hasta,hoy,,y,haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'

re.subn()

Es similar a sub(), pero devuelve una tupla con contiene la nueva cadena y la cantidad de sustitucones realizadas.

#empleamos re.subn(), para obgener una tupla que contiene la nueva cadena y la cantidad de substituciones realizadas
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.subn(pattern, replace, cadena)
nueva_cadena
output: ('Cuanto,hice,hasta,hoy,,y,haré,,es,para,eso.,En,silencio,ha,tenido,que,ser,y,como,indirectamente,,porque,hay,cosas,que,para,lograrlas,han,de,andar,ocultas,,y,de,proclamarse,en,lo,que,son,levantarían,dificultades,demasiado,recias,para,alcanzar,sobre,ellas,el,fin.', 44)

re.search()

Se emplea para la búsqueda de coincidencias directamente, utilizando dos argumentos, el patrón a buscar y la cadena donde buscarlo.

Su resultado es un objeto match, si no hubiera coincidencia retornaría None.

#empleamos re.search(), para hallar la subcadena silencio
sustituimos en la cadena los valores con re.sub()
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
busqueda = re.search('silencio',cadena)
busqueda
output:<re.Match object; span=(47, 55), match='silencio'>

El objeto que nos devuelve la variable búsqueda es del tipo match, con el cual podemos hacer también varias operaciones.

#operando con el resultado, ahora buscamos silencio al final de una cadena y hacemos algo
adena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
busqueda = re.search('\Zsilencio',cadena)
if busqueda:
pass
else:
print('no se halló nada')
output:no se halló nada

Con re(), podemos buscar utilizando re.match(), que  recibe dos parámetros: los patrones que buscamos y el texto donde los buscamos.

match.group()

Nos permite agrupar los resultados en subcadenas.

#buscamos con match.group() el grupo de letras seguidas por una r
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '(a|e|i)r'
match = re.search(pattern, cadena)
if match:
print(match.group())
else:
print('no se halló nada')
output:ar

#buscamos un grupo que tiene dos digitos separados por un espacio de una cadena no digital de seis caracteres
cadena = '234 567896 10 acceso dni color de los ojos'
pattern = '(\d{2}) (\D{6})'
match = re.search(pattern, cadena)
if match:
print(match.group())
else:
print('no se halló nada')
output: 10 acceso

Podemos condicionar cuantas subcadenas queremos y sus posiciones

#imprimiendo solo el primer subgrupo
match = re.search(pattern, cadena)
if match:
print(match.group(1))
else:
print('no se halló nada')
output:10

#obteniendo la posicion donde comienza el grupo, donde termina y una tupla con ambos valores
match = re.search(pattern, cadena)
if match:
print(match.start(), match.end(), match.span())
else:
print('no se halló nada')
output:11 20 (11, 20)

Match.string

Nos devuelve la cadena.

match.string
output:'234 567896 10 acceso dni color de los ojos'

«En total oscuridad cualquier cosa, puede ser luz»

Ordenar las relaciones, en Laravel

laravel

En Laravel podemos ordenar las relaciones de acuerdo a diferentes parámetros, por ejemplo size()

class Category extends Model
{
	public function shoes()
	{
		return $this->hasMany('App\Shoe')->orderBy('size');
	}
}

Otro orden que podemos conseguir es al usar las tablas pivotes, para las relaciones belongsToMany.

Post sobre Laravel

En el siguiente ejemplo tenemos el modelo Role y el modelo User,  y estamos mostrando en una vista, la relación entre ambos de forma descendente, según la fecha en que fue creado, en grupos  de 15, por página.

class Role extends Model
{
	public function users()
	{
		return $this->belongsToMany('Role\User')->withTimestamps();
	}
}

@if ($roles->users->count() > 0)
	Asignación
	@foreach ($roles->users()->orderBy('rol_user.created_at', 'desc')->take(15)->get() as $user)
		...
	@endforeach
@endif

Y listo, esto es todo.

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

Gracias.

Subir montañas hermana a los hombres……

TypeError: ‘Index’ object is not callable

python error

TypeError: ‘Index’ object is not callable, es un error que puedes recibir, al escribir esto en Pandas:

data_df.columns()

Esto se debe a que están intentado llamar el método de modo incorrecto.

Desarrollar funciones en Python

Es un error común de principiante, porque intentas obligar a Pandas a que use cómo índice el propio índice que el establece.

El objeto index no puede llamarse , porque no es un atributo del dataframe, entonces no puede llamarlas de ese modo, según el concepto de la librería.

Por la misma causa podrías recibir el error SyntaxError: invalid syntax

Solución

data_df.columns

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

Gracias

«Sin   herramientas para imaginar tu secreto…..»

Y
Translate »