Búsqueda y reemplazo

¿Han notado que las expresiones regulares pueden ser “malas palabras” en algunos comics?

Nah, lo del reemplazo a JSON me volo la mente. Siento que se me abrio el tercer ojo.

(Como dato perturbador) :: Esta es la ultima clase que se hizo el mismo día a juzgar por la ropa que lleva Beco, entonces beco sabe, TANTO, que logró hacer 20 temas! en un solo día, mis respetos Beco

Expresión sencilla

^\d+::(.*)\s\((\d{4})\)::.*$

Cuando por fin dominas las expresiones regulares

Es un verdadero placer cognitivo entender esta clase, de verdad sientes como si adquirieras un nuevo súper poder.

¡Que potencia señores! ¡pero que potencia! me eeeencanta

Esto sí me voló la cabeza… Increíble tu clase Beto, muchas gracias…
Aquí dejo la expresión lógica que use para buscar en todas las líneas sin excepción…

Buenas compañeros, al que le este agarrando dos lineas al momento de establecer los parentesis, deben hacer la expresion lazzy en el primer grupo, como se establece a continuación:

<^\d+::([\w\s,:'\.&\!\-\(\)\/\?\*\$\;\#]+?)>

Buscar y reformatear movies.csv a json, manteniendo los géneros:

Find: ^\d+::(.*) \((\d{4})\)::([\w\-]*)\|?([\w\-]*)\|?([\w\-]*)\|?([\w\-]*)\|?([\w\-]*)
Replace: {title: '$1', year: $2, genres: {$3, $4, $5, $6, $7}}

Find: (, ){2,}

Replace:

Find: , }}

Replace: }}

Wow!, esta es la aplicación más potente que he visto. Con esto ya no tendré que utilizar CONCAT de excel. Lo usaba para crear querys con estructura WHERE IN (id1,id2,…idn) donde los ids provenian de un archivo csv.

Si siguen este curso desde VS Code, ¡encontré una extensión buenísima! Se llama: Regexp Explain
Escriban su expresión regular, selecciónenla con el mouse, click derecho, explicar regex y verán cómo es que está funcionando. Me sirvió mucho para entender esta clase.
Respecto a $1,$2, puedo entender que hicimos un: “Conserva solamente la información del grupo 1 y del grupo 2”

Wooooooooooooowwwwwwwwwww!!! 🤯🤯🤯

Archivo no apto para procesadores core i3 😦

Tremenda clase, cuanto poder en las expresiones regulares… y yo que las odiaba 😛

Les dejo la RegEx que usé para encontrar todas las líneas sin excepción:

^\d+::(.+[^\s])\s?\(([\d]{4})\)::.*$

Y la fórmula para crear un JSON ordenado:

{\n  movie: '$1', \n  year: $2, \n},

Quedaría así:

Esta expresión toma todas las líneas y sirve para hacer las sustitución correctamente :

^\d+::(.*)\s\((\d{4,4})\)::.*

ahora, hay problemas con el hecho de que sea tan general?

La magia existe…se llama expresiones regulares

Si uno hubiera hecho antes el curso de fundamentos de base de datos antes de este curso, esta explicacion no me hubiera volado la cabeza.
Excelente clase

La regex que selecciona todas las líneas:

<code> 
^\d+::([\w :,\(\)'\.\-&¿?¡!\/áéíóúâäöüøàèìòùåâêîôûçÁÉÍÓÚÀÈÌÒÙ½+³æ*$]+)\s\((\d\d\d\d)\)::.*$
</code>

Coincido con todos mis compañeros en esta clase: BRUTAL!. Ahora es casi tangible la utilidad de las Expresiones Regulares.

lo estoy usanfo en atom, y escribo la misma epresion y no me funciona correctamente , coge 2 lineas en algunos casos,
lo q me funciono fue esto .

^\d+::(.*)\s\((\d\d\d\d)\)::.*$

Mi aporte hecho por mi cuenta:

Code:

^(.*)::(.*)\((\d+)\)::.*$

Para el de 10,000 lineas!

^\d+::([\w :,\(\)\.'á-ý\-&\/ä-ÿÄ-ŸçÇà-ù!\?#·\*À-Ù\[\][³²¡\+@"½\$¿°]+) (\(\d{4,4}\))::.*$

Jajaja php ya se puede considerar una tecnología obsoleta???

Demasiado brutal!! 😮

Este programa es muy útil para saber, por ejemplo, cuáles películas son de 1994, solo es pasar la regex correcta por parámetro.

 public static void lineMatches(String sPath, Pattern pattern){
        Path filePath = Paths.get(sPath);
        AtomicInteger total = new AtomicInteger();
        AtomicInteger matchs = new AtomicInteger();
        try (Stream<String> stream = Files.lines(filePath)) {
            stream.forEach(line -> {
                if (pattern.matcher(line).find()){
                    System.out.println(String.format("%d. %s", matchs.get()+1, line));
                    matchs.getAndIncrement();
                }
                total.getAndIncrement();
            });
            System.out.println(String.format("Total: %d, Matchs: %d, AllMatch: %b", total.get(), matchs.get(), total.get()==matchs.get()));
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

Flipando estoy!!!

Para un json
search: ^\d+:😦.+)\s?((\d{4,4})):😦.)$
replace: {“title”: “$1”, “year”: $2, “category”: ["$3"]},
search: ["(.)(|)(.*)?"]
replace(x5): ["$1","$3"]
solo faltaria poner
{“pelis”: [ al inicio
]} al final del archivo
y eliminar la ultima coma

^\d+::([\w\s:,\(\)\.'éè\-Àûîêôóí&!ã\*\?]+)\s\((\d{4})\)::(([\w\-']+[\|]?)+)$ - Permitiendo con $3 obtener las categorías

Increíble la clase

Ejercicio con el archivo de movies.dat para convertirlo en un json:
1 Primero busque los ( | ) para sustituirlos por ( , )
2 Despúes meti esta regex para abarcar la linea completa y separar tres grupos:

^\d+::(.*)\s\((\d{4,4})\)::(.*)$

3 Por ultimo reemplace por esto:

{title:"$1", year:$2, categories:[$3]}

4 Obteniendo como resultado un json con estas lineas:

{title:"Ace Ventura", year:1994, categories:[Comedy, Children]}

Maravillosa clase.

Wow… 🤯

Hay alguna diferencia entre estas dos expresiones:
([\w])+
([\w]+)
pensé que era lo mismo pero noté que la primera se comporta diferente. ¿Alguien sabe la diferencia?.
😃

^[A-Za-záéíóú]{3,}\s?([A-Z]?[a-záéíóú]{3,})?(\s?[A-Z]?[a-záéíóú]{3,})?(\s?[A-Z]?[a-záéíóú]{3,})?

Esa es mi solución para poder encontrar con dos nombres y dos apellidos; apuesto a que hay forma de optimizar, pero pues estoy aprendiendo, jeje

PFFF! impresionante esta clase

Excelente clase

Apuntes: Al igual que una navaja suiza, las expresiones regulares son una herramienta increíblemente útil pero tienes que darle la importancia y las responsabilidades adecuadas a cada una, ya que no son la panacea, no solucionan todos los problemas.

El uso más conveniente de las expresiones regulares es buscar coincidencias o matches de cadenas en un texto, y si es necesario, reemplazarlas con un texto diferente.

Con esta expresión se consiguen todos los resultados

^\d+::([\w\s:,\(\)\.'\-&!\/\?;#\*$]+)\s?(\(\d\d\d\d\))::.*$

Esta es la que toma todos los caracteres especiales de la lista de 10680 pelis

^\d+::([\w\s:,\d'\[\] $*"\(\)\.°½æ ÅÄÁÀãáïàâå@äüÊëèéôîÔòöøóýìí¡!¿ÇßêÉûúùÜàñç/#³&\+?·-]+)\s\((\d{4,4})\)::.*

Alucinante! Esto esta genial!! Gracias profe!

¡Que pasada!

Así quedé al terminar esta clase 👉🤯

Excelente, cuanto sufri en el pasado con cosas asi
jajajajaja

Cuando hiciste lo de insert en sql me exploto la cabeza es absolutamente genial.

Llegue a estas dos expresiones, regulares, pero no logre incluir las tíldes.

^\d{0,}::(.*)\s\((\d\d\d\d)\)::.*```

^\d{0,}:😦[\w\s:,.()’&/"-(),?!]{0,})\s((\d\d\d\d))::.*

Solo para que no se pierda

^(\d{1,6})::([\w ,\(\)\-ÁÄÂÀÅáåäâàãÉÊéèêëíîìïÔôóöòüÜûúùÇçñæøßý½°#¿"\$\*\.'³:&!\/\?\+\[\]¡@·]+)(\(\d\d\d\d\))::(([A-Z\(]*[a-záéíóúüñ \-\)]*\|?){1,9})$

Super super potente las regex!!

//hace march
1::Toy Story (1995)::Adventure|Animation|Children|Comedy|Fantasy
2::Jumanji (1995)::Adventure|Children|Fantasy
3::Grumpier Old Men (1995)::Comedy|Romance
4::Waiting to Exhale (1995)::Comedy|Drama|Romance
5::Father of the Bride Part II (1995)::Comedy
6::Heat (1995)::Action|Crime|Thriller
7::Sabrina (1995)::Comedy|Romance
8::Tom and Huck (1995)::Adventure|Children

(^\d+)::([\w\s\déèíáÀó$Áúùìã\?\+,½'\*üåçäê³âôîöû\/"&\(\)¡!\.:æø\-]+)\s\((\d{4}\))::.*$

Agrupar

• ()
• Sirve para agrupar expresiones
• Puedes remplazar y dejar esa seccion con $

Para esto hago el curso wujuuu

excelente

ahi siffff.

Esta clase si que me voló la mente, mas que nada para la inserción se bases de datos, excelente clase

increíble potencial 😱

Para todas las 10681 líneas:

^\d+::([\w\s\.,·\[\]\+'"\*\-:æáéíóúàèìòùäëïöüâêîôûåãñýç¿?¡!\$\#½ß@ø³°/\(\)&]+\s)(\(\d{4}\))::.*$

Cuando hiciste reemplazo fue genial

Herramienta sensacional!

Épico.

Uff esta clase estuvo muy buena aprendí a ver las cosas desde otra perspectiva

En mis tiempos de gestor de bases de datos me hubiera servido bastante estos comando. Para otra oportunidad será -.-

Que barbaridad esto 🤯

Brutal la potencia de la RegEx

Estuvo genial esta caso de uso para las expresiones regulares. Anteriormente me había conseguido con problemas de este tipo, y los solucionaba de una forma muy complicada. Muchísimas gracias.

increlibleeeeee!!!

Demasiado genial, el poder de las ER

Muchas gracias Alberto, que clase super poderosa, increible las ilustraciones y aplicaciones

Super Pontente

^\d+::([\w\s:,'\.&-\/!;\$#\?(\)]+)\s\((\d\d\d\d)\)::.*$

me quedo asi, y matchea todo es medio arriesgado pero, funcion en el archivo de 10k de registros.

(^\d+)::(.+)\((\d{4,4})\)

basicamente:

capturo el año -> (^\d+) esto va a ser $1
matcheo los 2 puntos -> ::
capturo el titulo -> (.+) todo los caracteres hasta, esto queda en $2
capturo el año (matcheo los “()”) -> \((\d{4,4})\) esto queda en $3

^\d{1,4}::([\w\s,.\(\):'\?\-&!\/#\*\$;]{1,})(\(\d{4,4}\))::(.*)$

Comparto mi función 😃 Con ella logró extraer el nombre de la película, el año y el primer género de la película.

^\d+::([\w\s,\(\)\.'\-&!\/é]+:?[\w\s,\(\)\.'\-&!\/é]*:?[\w\s,\(\)\.'\-&!\/é]*)\s\((\d{4})\)::([\w]+).*$

Mi aporte!

Este curso no deja de sorprenderme, pero definitivamente esta clase ha sido la más increíble de todas las que he visto en Platzi hasta el momento (luego de 30+ cursos que he hecho). Me acaba de dar muchas ideas para implementar JSONs muy fácilmente en mis proyectos.

Debido a la vastedad de caracteres que hay en los titulos de peliculas, ubique un patrón común (\d\d\d\d) y reemplace por {\d\d\d\d}. Seguido de esto apliqué la siguiente expresión:

\d+:😦[^{]*){(\d{4})}

Y con esto obtuve el 100% de reemplazos 😃

mi solucion

^\d+::(.*)\((\d{4})\).*$

replace $1 | $2

\(.*\)

replace
y ahora me quedo solo con el nombre de la pelicula en ingles y su fecha de estreno , algo que creo es que no necesariamente tenemos que resolver el problema con una expresion regular, podemos usar una detras de otra y nos quitamos de problemas

Que gran potencial !!

La hice así

^\d+::(.*)(\(\d{4}\))::.*

Sheesh, están muy guapas las regex

Ta potente

Esto me dejó boquiabierto! El buscar patrones ya era algo muy genial pero el remplazar me ha dado muchas ideas para simplificar clases que uso para leer csv.

Esto es magia pura!

probando con la expresion regular llegue a esta para parsear los titulos, año y genero:

^\d+::(.*)\(([\d]+)\)::(.*)$

y al hacer el remplazo en formato json ocupe:

{ genre:"$3", title:"$1", year:$2 }

intente hacerlo con una clase especial tuve problemas con los titulos con el caracter “:” dentro del titulo, intente con esta:

^\d+::([\w\s\(\),\.',\-&!\/\?\$\*#;áéíóúì]+)\(([\d]+)\)::(.*)$

pero no encontre como forzar que el : fuera solo uno dentro del primer “grupo”

probando con la expresion regular llegue a esta para parsear los titulos, año y genero:

^\d+:😦.)\s(([\d]+)):😦.)$

y al hacer el remplazo en formato json ocupe:

{ genre:"$3", title:"$1", year:$2 }

intente hacerlo con una clase especial tuve problemas con los titulos con el caracter “:” dentro del titulo, intente con esta:
^\d+:😦[\w\s():,.’,-&!/?$*#;áéíóúì]+)(([\d]+)):😦.*)$

pero no encontre como forzar que el : fuera solo uno dentro del primer “grupo”

Definitivamente esto me explotó la cabeza, ¡Que potencial tan grande!

Yo utilice SublimeText 3, y esta fue la expresión que utilice para reconocer todas las lineas:

^\d+::([\w\s,:'\-\(\)\.&!\/\?\#;\$\*]+?)\s\((\d{4,})\)::.*$

SI les da problea esta expresion regular es por el espacio entre los grupo 1 y 2

Solución:

^\d+::([\w\s:\-\!&\$#\/\',\(\'.\*\?;)]+?)\((\d{4})\)::.*$

Manejar strings es igual a manejar expresiones regulares.

() -> agrupar
Expresión para buscar películas

^\d+::([\w\s:,\(\)\.\'\-&!\/\?]+)\((\d\d\d\d)\)::.*$
$1, $2 separa por grupos

de aquí pasar a otros formatos ya es muy rápido

puede agregar para que me saque el genero de la pelicula

^\d+::([\w\s:,\(\)'\.\-&!\/]+)\s\((\d{4,4})\)::([\w|']+)

Excelente herramienta las expresiones regulares.

Esta clase me ha servido mucho. Con esto cobra completamente sentido todo lo aprendido anteriormente.

Excelente!

Woowww super cool. Sin esto convertir un archivo de estos en sql o json es un dolor de cabeza.

Wao! genial

🤯🤯 Excelente ejemplo de cómo podemos usar las expresiones regulares.

Realmente fantástico!

Impresionante el uso que tienen las expresiones regulares, esto ahorra bastante trabajo cuando se quiere representar datos en una aplicación partiendo en un formato como JSON, también nos facilitara la conversión a otros formatos al aplicar la expresión adecuada. Muchas gracias por enseñarnos esta gran utilidad instructor Alberto.

Hola a todos,

Comparto con ustedes los resultados que obtuve durante esta lección.

La expresión regular que utilicé es la siguiente:^\d*::([a-zA-Z0-9 :',\/\.\(\)!&\-\?]+)(\s\(\d{4}\))::[a-zA-z |'\-]+$

Encontré 3878 de 3883 con esa regex

Excelente para ingenieria de datos, tiene superpoderes parecidos a los de pandas.

Es** bestial** la funcionalidad de las expresiones regulares!!!