{"id":377,"date":"2024-11-23T19:11:01","date_gmt":"2024-11-23T19:11:01","guid":{"rendered":"https:\/\/equipomedios.com\/blog\/?p=377"},"modified":"2024-10-18T19:12:32","modified_gmt":"2024-10-18T19:12:32","slug":"funciones-de-orden-superior-python","status":"publish","type":"post","link":"https:\/\/equipomedios.com\/blog\/funciones-de-orden-superior-python\/","title":{"rendered":"Funciones de orden superior | Python"},"content":{"rendered":"

Funciones de orden superior<\/h1>\n

Las funciones de Python pueden tomar funciones como par\u00e1metros y devolver funciones como resultado. Una funci\u00f3n que hace ambas cosas o alguna de ellas se llama funci\u00f3n de orden superior.<\/p>\n

<\/span><\/p>\n

filter()<\/h2>\n

La funci\u00f3n\u00a0filter()<\/span><\/code>\u00a0es una funci\u00f3n la cual toma un\u00a0predicado<\/span>\u00a0y una lista y devuelve una lista con los elementos que satisfacen el predicado. Tal como su nombre indica\u00a0filter()<\/span><\/code>\u00a0significa filtrar, ya que a partir de una lista o iterador y una funci\u00f3n condicional, es capaz de devolver una nueva colecci\u00f3n con los elementos filtrados que cumplan la condici\u00f3n.<\/p>\n

Todo esto podr\u00eda haberse logrado tambi\u00e9n usando\u00a0listas por comprensi\u00f3n<\/span>\u00a0que usaran\u00a0predicados<\/em>. No hay ninguna regla que diga cuando usar la funci\u00f3n\u00a0map()<\/span>\u00a0o la funci\u00f3n\u00a0filter()<\/span><\/code>\u00a0en lugar de las\u00a0listas por comprensi\u00f3n<\/span>, simplemente debe decidir que es m\u00e1s legible dependiendo del contexto.<\/p>\n

Por ejemplo, suponga que tiene una lista varios n\u00fameros y requiere filtrarla, quedando \u00fanicamente con los n\u00fameros m\u00faltiples de 5, eso seria as\u00ed:<\/p>\n

\n
\n
>>> <\/span># Primero declaramos una funci\u00f3n condicional<\/span>\r\ndef multiple(numero):<\/span>\r\n# Comprobamos si un numero es m\u00faltiple de cinco<\/span>\r\nif numero % 5 == 0:<\/span>\r\n    # S\u00f3lo devolvemos True si lo es<\/span>\r\n    return True<\/span>\r\n\r\n>>> <\/span>numeros<\/span> =<\/span> [<\/span>2<\/span>,<\/span> 5<\/span>,<\/span> 10<\/span>,<\/span> 23<\/span>,<\/span> 50<\/span>,<\/span> 33<\/span>]<\/span>\r\n>>> <\/span>filter<\/span>(<\/span>multiple<\/span>,<\/span> numeros<\/span>)<\/span>\r\n[5, 10, 50]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Si ejecuta el filtro obtiene una lista los n\u00fameros m\u00faltiples de 5. Por tanto cuando utiliza la funci\u00f3n\u00a0filter()<\/span><\/code>\u00a0tiene que enviar una funci\u00f3n condicional, para esto, puede utilizar una funci\u00f3n an\u00f3nima\u00a0lambda<\/span><\/code>, como se muestra a continuaci\u00f3n:<\/p>\n
\n
\n
>>> <\/span>numeros<\/span> =<\/span> [<\/span>2<\/span>,<\/span> 5<\/span>,<\/span> 10<\/span>,<\/span> 23<\/span>,<\/span> 50<\/span>,<\/span> 33<\/span>]<\/span>\r\n>>> <\/span>filter<\/span>(<\/span>lambda<\/span> numero<\/span>:<\/span> numero<\/span>%<\/span>5<\/span> ==<\/span> 0<\/span>,<\/span> numeros<\/span>)<\/span>\r\n[5, 10, 50]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
As\u00ed, en una sola l\u00ednea ha definido y ejecutado el filtro utilizando una funci\u00f3n condicional an\u00f3nima y devolviendo una lista de n\u00fameros.<\/p>\n
\n
Filtrando objetos<\/h3>\n
Sin embargo, m\u00e1s all\u00e1 de filtrar listas con valores simples, el verdadero potencial de la funci\u00f3n\u00a0filter()<\/span><\/code>\u00a0sale a relucir cuando usted necesita filtrar varios objetos de una lista.<\/p>\n
Por ejemplo, dada una lista con varias personas, a usted le gustar\u00eda filtrar \u00fanicamente las cuales son menores de edad:<\/p>\n
\n
\n
>>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n...<\/span>\r\n... <\/span>    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> nombre<\/span>,<\/span> edad<\/span>):<\/span>\r\n... <\/span>        self<\/span>.<\/span>nombre<\/span> =<\/span> nombre<\/span>\r\n... <\/span>        self<\/span>.<\/span>edad<\/span> =<\/span> edad<\/span>\r\n...<\/span>\r\n... <\/span>    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n... <\/span>        return<\/span> \"<\/span>{}<\/span> de <\/span>{}<\/span> a\u00f1os\"<\/span>.<\/span>format<\/span>(<\/span>self<\/span>.<\/span>nombre<\/span>,<\/span> self<\/span>.<\/span>edad<\/span>)<\/span>\r\n...<\/span>\r\n>>> <\/span>personas<\/span> =<\/span> [<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Leonardo\"<\/span>,<\/span> 38<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Ana\"<\/span>,<\/span> 33<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Sabrina\"<\/span>,<\/span> 12<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Enrique\"<\/span>,<\/span> 3<\/span>)<\/span>\r\n... <\/span>]<\/span>\r\n>>> <\/span>menores<\/span> =<\/span> filter<\/span>(<\/span>lambda<\/span> persona<\/span>:<\/span> persona<\/span>.<\/span>edad<\/span> <<\/span> 18<\/span>,<\/span> personas<\/span>)<\/span>\r\n>>> <\/span>for<\/span> menor<\/span> in<\/span> menores<\/span>:<\/span>\r\nprint menor<\/span>\r\nSabrina de 12 a\u00f1os<\/span>\r\nEnrique de 3 a\u00f1os<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Este es un ejemplo sencillo, con el cual usted puede realizar filtrados con objetos, de forma amigable.<\/p>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
map()<\/h2>\n
La funci\u00f3n\u00a0map()<\/span><\/code>\u00a0toma una funci\u00f3n y una lista y aplica esa funci\u00f3n a cada elemento de esa lista, produciendo una nueva lista. Va a ver su definici\u00f3n de tipo y como se define.<\/p>\n
Esta funci\u00f3n trabaja de una forma muy similar a\u00a0filter()<\/span>, con la diferencia que en lugar de aplicar una condici\u00f3n a un elemento de una lista o secuencia, aplica una funci\u00f3n sobre todos los elementos y como resultado se devuelve un lista de n\u00fameros doblado su valor:<\/p>\n
\n
\n
>>> <\/span>def<\/span> doblar<\/span>(<\/span>numero<\/span>):<\/span>\r\nreturn numero*2<\/span>\r\n\r\n>>> <\/span>numeros<\/span> =<\/span> [<\/span>2<\/span>,<\/span> 5<\/span>,<\/span> 10<\/span>,<\/span> 23<\/span>,<\/span> 50<\/span>,<\/span> 33<\/span>]<\/span>\r\n>>> <\/span>map<\/span>(<\/span>doblar<\/span>,<\/span> numeros<\/span>)<\/span>\r\n[4, 10, 20, 46, 100, 66]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Usted puede simplificar el c\u00f3digo anterior usando una funci\u00f3n\u00a0lambda<\/span><\/code>\u00a0para substituir la llamada de una funci\u00f3n definida, como se muestra a continuaci\u00f3n:<\/p>\n
\n
\n
>>> <\/span>map<\/span>(<\/span>lambda<\/span> x<\/span>:<\/span> x<\/span>*<\/span>2<\/span>,<\/span> numeros<\/span>)<\/span>\r\n[4, 10, 20, 46, 100, 66]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
La funci\u00f3n\u00a0map()<\/span><\/code>\u00a0se utiliza mucho junto a expresiones\u00a0lambda<\/span><\/code>\u00a0ya que permite evitar escribir\u00a0bucles for<\/span>.<\/p>\n
Adem\u00e1s se puede utilizar sobre m\u00e1s de un objeto iterable con la condici\u00f3n que tengan la misma longitud. Por ejemplo, si requiere multiplicar los n\u00fameros de dos listas:<\/p>\n
\n
\n
>>> <\/span>a<\/span> =<\/span> [<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>]<\/span>\r\n>>> <\/span>b<\/span> =<\/span> [<\/span>6<\/span>,<\/span> 7<\/span>,<\/span> 8<\/span>,<\/span> 9<\/span>,<\/span> 10<\/span>]<\/span>\r\n>>> <\/span>map<\/span>(<\/span>lambda<\/span> x<\/span>,<\/span>y<\/span> :<\/span> x<\/span>*<\/span>y<\/span>,<\/span> a<\/span>,<\/span>b<\/span>)<\/span>\r\n[6, 14, 24, 36, 50]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
E incluso usted puede extender la funcionalidad a tres listas o m\u00e1s:<\/p>\n
\n
\n
>>> <\/span>a<\/span> =<\/span> [<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>]<\/span>\r\n>>> <\/span>b<\/span> =<\/span> [<\/span>6<\/span>,<\/span> 7<\/span>,<\/span> 8<\/span>,<\/span> 9<\/span>,<\/span> 10<\/span>]<\/span>\r\n>>> <\/span>c<\/span> =<\/span> [<\/span>11<\/span>,<\/span> 12<\/span>,<\/span> 13<\/span>,<\/span> 14<\/span>,<\/span> 15<\/span>]<\/span>\r\n>>> <\/span>map<\/span>(<\/span>lambda<\/span> x<\/span>,<\/span>y<\/span>,<\/span>z<\/span> :<\/span> x<\/span>*<\/span>y<\/span>*<\/span>z<\/span>,<\/span> a<\/span>,<\/span>b<\/span>,<\/span>c<\/span>)<\/span>\r\n[66, 168, 312, 504, 750]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
Mapeando objetos<\/h3>\n
Evidentemente, siempre que la funci\u00f3n\u00a0map()<\/span><\/code>\u00a0la utilice correctamente podr\u00e1 mapear una serie de objetos sin ning\u00fan problema:<\/p>\n
\n
\n
>>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n...<\/span>\r\n... <\/span>    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> nombre<\/span>,<\/span> edad<\/span>):<\/span>\r\n... <\/span>        self<\/span>.<\/span>nombre<\/span> =<\/span> nombre<\/span>\r\n... <\/span>        self<\/span>.<\/span>edad<\/span> =<\/span> edad<\/span>\r\n...<\/span>\r\n... <\/span>    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n... <\/span>        return<\/span> \"<\/span>{}<\/span> de <\/span>{}<\/span> a\u00f1os\"<\/span>.<\/span>format<\/span>(<\/span>self<\/span>.<\/span>nombre<\/span>,<\/span> self<\/span>.<\/span>edad<\/span>)<\/span>\r\n...<\/span>\r\n>>> <\/span>personas<\/span> =<\/span> [<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Leonardo\"<\/span>,<\/span> 38<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Ana\"<\/span>,<\/span> 33<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Sabrina\"<\/span>,<\/span> 12<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Enrique\"<\/span>,<\/span> 3<\/span>)<\/span>\r\n... <\/span>]<\/span>\r\n>>> <\/span>def<\/span> incrementar<\/span>(<\/span>p<\/span>):<\/span>\r\n... <\/span>    p<\/span>.<\/span>edad<\/span> +=<\/span> 1<\/span>\r\n... <\/span>    return<\/span> p<\/span>\r\n...<\/span>\r\n>>> <\/span>personas<\/span> =<\/span> map<\/span>(<\/span>incrementar<\/span>,<\/span> personas<\/span>)<\/span>\r\n>>> <\/span>for<\/span> persona<\/span> in<\/span> personas<\/span>:<\/span>\r\n... <\/span>    print<\/span> persona<\/span>\r\n...<\/span>\r\nLeonardo de 39 a\u00f1os<\/span>\r\nAna de 34 a\u00f1os<\/span>\r\nSabrina de 13 a\u00f1os<\/span>\r\nEnrique de 4 a\u00f1os<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Claro que en este caso tiene que utilizar una funci\u00f3n definida porque no necesitamos actuar sobre la instancia, a no ser que usted se tome la molestia de rehacer todo el objeto:<\/p>\n
\n
\n
>>> <\/span>class<\/span> Persona<\/span>:<\/span>\r\n...<\/span>\r\n... <\/span>    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> nombre<\/span>,<\/span> edad<\/span>):<\/span>\r\n... <\/span>        self<\/span>.<\/span>nombre<\/span> =<\/span> nombre<\/span>\r\n... <\/span>        self<\/span>.<\/span>edad<\/span> =<\/span> edad<\/span>\r\n...<\/span>\r\n... <\/span>    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n... <\/span>        return<\/span> \"<\/span>{}<\/span> de <\/span>{}<\/span> a\u00f1os\"<\/span>.<\/span>format<\/span>(<\/span>self<\/span>.<\/span>nombre<\/span>,<\/span> self<\/span>.<\/span>edad<\/span>)<\/span>\r\n...<\/span>\r\n>>> <\/span>personas<\/span> =<\/span> [<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Leonardo\"<\/span>,<\/span> 38<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Ana\"<\/span>,<\/span> 33<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Sabrina\"<\/span>,<\/span> 12<\/span>),<\/span>\r\n... <\/span>    Persona<\/span>(<\/span>\"Enrique\"<\/span>,<\/span> 3<\/span>)<\/span>\r\n... <\/span>]<\/span>\r\n>>> <\/span>def<\/span> incrementar<\/span>(<\/span>p<\/span>):<\/span>\r\n... <\/span>    p<\/span>.<\/span>edad<\/span> +=<\/span> 1<\/span>\r\n... <\/span>    return<\/span> p<\/span>\r\n...<\/span>\r\n>>> <\/span>personas<\/span> =<\/span> map<\/span>(<\/span>lambda<\/span> p<\/span>:<\/span> Persona<\/span>(<\/span>p<\/span>.<\/span>nombre<\/span>,<\/span> p<\/span>.<\/span>edad<\/span>+<\/span>1<\/span>),<\/span> personas<\/span>)<\/span>\r\n>>> <\/span>for<\/span> persona<\/span> in<\/span> personas<\/span>:<\/span>\r\n... <\/span>    print<\/span> persona<\/span>\r\n...<\/span>\r\nLeonardo de 39 a\u00f1os<\/span>\r\nAna de 34 a\u00f1os<\/span>\r\nSabrina de 13 a\u00f1os<\/span>\r\nEnrique de 4 a\u00f1os<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
lambda<\/h2>\n
La expresi\u00f3n\u00a0lambda<\/span><\/code>, es una funci\u00f3n an\u00f3nima que suelen ser usadas cuando necesita una funci\u00f3n una sola vez. Normalmente usted crea funciones\u00a0lambda<\/span><\/code>\u00a0con el \u00fanico prop\u00f3sito de pasarlas a funciones de orden superior.<\/p>\n
En muchos lenguajes, el uso de\u00a0lambdas<\/span><\/code>\u00a0sobre funciones definidas causa problemas de rendimiento. No es el caso en Python.<\/p>\n
\n
\n
>>> <\/span>import<\/span> os<\/span>\r\n>>> <\/span>archivos<\/span> =<\/span> os<\/span>.<\/span>listdir<\/span>(<\/span>os<\/span>.<\/span>__file__<\/span>.<\/span>replace<\/span>(<\/span>\"\/os.pyc\"<\/span>,<\/span> \"\/\"<\/span>))<\/span>\r\n>>> <\/span>print<\/span> filter<\/span>(<\/span>lambda<\/span> x<\/span>:<\/span> x<\/span>.<\/span>startswith<\/span>(<\/span>'os.'<\/span>),<\/span> archivos<\/span>)<\/span>\r\n['os.pyc', 'os.py']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el ejemplo anterior se usa el m\u00e9todo\u00a0os.__file__<\/span><\/code>\u00a0para obtener la ruta donde esta instalada el m\u00f3dulo\u00a0os<\/span><\/code>\u00a0en su sistema, ejecutando la siguiente sentencia:<\/p>\n
\n
\n
>>> <\/span>os<\/span>.<\/span>__file__<\/span>\r\n'\/usr\/lib\/python2.7\/os.pyc'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Si con el m\u00e9todo\u00a0os.__file__<\/span><\/code>\u00a0obtiene la ruta del m\u00f3dulo\u00a0os<\/span><\/code>\u00a0con el m\u00e9todo\u00a0replace(\"\/os.pyc\",<\/span>\u00a0\"\/\")<\/span><\/code>\u00a0busca la cadena de car\u00e1cter \u00ab\/os.pyc\u00bb y la remplaza por la cadena de car\u00e1cter \u00ab\/\u00bb<\/p>\n
\n
\n
>>> <\/span>os<\/span>.<\/span>__file__<\/span>.<\/span>replace<\/span>(<\/span>\"\/os.pyc\"<\/span>,<\/span> \"\/\"<\/span>)<\/span>\r\n'\/usr\/lib\/python2.7\/'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Luego se define la variable\u00a0archivos<\/span><\/code>\u00a0generando una lista de archivos usando la funci\u00f3n\u00a0os.listdir()<\/span><\/code>, pasando el par\u00e1metro obtenido de la ruta donde se instalo el m\u00f3dulo\u00a0os<\/span><\/code>\u00a0ejecutando en el comando previo, con la siguiente sentencia:<\/p>\n
\n
\n
>>> <\/span>archivos<\/span> =<\/span> os<\/span>.<\/span>listdir<\/span>(<\/span>\"\/usr\/lib\/python2.7\/\"<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
De esta forma se define en la variable\u00a0archivos<\/span><\/code>\u00a0un\u00a0tipo lista<\/span>\u00a0con un tama\u00f1o de\u00a0433<\/em>, como se puede comprobar a continuaci\u00f3n:<\/p>\n
\n
\n
>>> <\/span>type<\/span>(<\/span>archivos<\/span>)<\/span>\r\n<type 'list'><\/span>\r\n>>> <\/span>len<\/span>(<\/span>archivos<\/span>)<\/span>\r\n443<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Opcionalmente puede comprobar si la cadena de caracteres\u00a0os.pyc<\/strong>\u00a0se encuentras una de las posiciones de la lista\u00a0archivos<\/span><\/code>, ejecutando la siguiente sentencia:<\/p>\n
\n
\n
>>> <\/span>\"os.pyc\"<\/span> in<\/span> archivos<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Ya al comprobar que existe la cadena de caracteres \u00abos.pyc<\/strong>\u00bb se usa una funci\u00f3n\u00a0lambda<\/span><\/code>\u00a0como par\u00e1metro de la funci\u00f3n\u00a0filter()<\/span>\u00a0para filtrar todos los archivos del directorio \u00ab\/usr\/lib\/python2.7\/<\/em>\u00bb por medio del funci\u00f3n\u00a0os.listdir()<\/span><\/code>\u00a0que inicien con la cadena de caracteres \u00abos.<\/strong>\u00bb usando la funci\u00f3n\u00a0startswith()<\/span>.<\/p>\n
\n
\n
>>> <\/span>print<\/span> filter<\/span>(<\/span>lambda<\/span> x<\/span>:<\/span> x<\/span>.<\/span>startswith<\/span>(<\/span>'os.'<\/span>),<\/span> os<\/span>.<\/span>listdir<\/span>(<\/span>'\/usr\/lib\/python2.7\/'<\/span>))<\/span>\r\n['os.pyc', 'os.py']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
As\u00ed de esta forma se comprueba que existe el archivo compilado \u00abos.pyc<\/strong>\u00bb de Python junto con el mismo m\u00f3dulo Python \u00abos.py<\/strong>\u00bb.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Funciones de orden superior Las funciones de Python pueden tomar funciones como par\u00e1metros y devolver funciones como resultado. Una funci\u00f3n que hace ambas cosas o alguna de ellas se llama funci\u00f3n de orden superior. filter() La funci\u00f3n\u00a0filter()\u00a0es una funci\u00f3n la cual toma un\u00a0predicado\u00a0y una lista y devuelve una lista con los elementos que satisfacen el […]<\/p>\n","protected":false},"author":1,"featured_media":331,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[39,40],"tags":[],"class_list":["post-377","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programacion","category-python"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/equipomedios.com\/blog\/wp-content\/uploads\/2024\/08\/python-logo-master-v3-TM.png?fit=601%2C203&ssl=1","jetpack_sharing_enabled":true,"jetpack-related-posts":[],"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/377","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/comments?post=377"}],"version-history":[{"count":1,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/377\/revisions"}],"predecessor-version":[{"id":378,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/377\/revisions\/378"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media\/331"}],"wp:attachment":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media?parent=377"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/categories?post=377"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/tags?post=377"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}