Python

Cabe resaltar que en python 2 si se puede imprimir de esta manera

 print "%s\n" % res.group(1)

Pero a partir de la versión 3.6 se puede implementar así

print(f"{res.group(1)}\n")

Si están trabajando en windows y les sale el error

File "C:\Python31\lib\encodings\cp1252.py", line 23, in decode
return codecs.charmap_decode(input,self.errors,decoding_table)[0]
UnicodeDecodeError: 'charmap' codec can't decode byte 0x90 in position 2907500: character maps to <undefined>

La solución es simple, añaden encoding=“utf8” en la línea que abren el archivo, así:

f = open("files/results.csv", "r", encoding="utf8")

Like si googleaste del partido de Australia 🇦🇺 con Samoa 🇼🇸 Americana 😊

“El partido de fútbol celebrado el miércoles 11 de abril de 2001 entre las selecciones de Australia y Samoa Americana, que concluyó con un resultado de 31-0 a favor de los australianos, es la mayor victoria de una selección internacional de fútbol en partido oficial.​“ Wikipedia

En python 3.9 la palabra “with” cierra el archivo automáticamente cuando no se requiera más acceso a este por lo que no necesitamos usar “close” al final.

import re

filename = "results.csv"

pattern = re.compile(r'^([\d]{4,4})\-.*$')

with open(filename, "r", encoding="utf-8") as f:
    for line in f:
        res = re.match(pattern, line)
        if res:
            print(f"{res.group(1)}\n")

ya entendi como mr cheap calcula sus mamadas

Para los que estén interesados en tener más información, Platzi tiene su guía de expresiones regulares en Python: https://platzi.com/blog/expresiones-regulares-python/

Yo creo que Misterchip usa REGEX con una base de datos amplia.

me sucedía el siguiente error:

'charmap' codec can't decode byte 0x81 in position 6915: character maps to <undefined>

Para solucionarlo se debe especificar el formato del texto que se leera, porque quizas existen caracteres raros dentro del archivo:

f= open("resultados.csv", "r", encoding='utf-8')

Santo Dios… con python todo es hemoso

Python Regex Cheatsheet
https://www.debuggex.com/cheatsheet/regex/python

Sintaxis con Python 3.9, me parece mucho más fácil de leer:

import re #Traemos las expresiones regulares
"""
date,home_team,away_team,home_score,away_score,tournament,city,country,neutral
1872-11-30,Scotland,England,0,0,Friendly,Glasgow,Scotland,FALSE
"""
pattern = re.compile(r'^([\d]{4,4})\-\d\d-\d\d,(.+),(.+),(\d+),(\d+),.*$')

f = open("./results.csv", "r")

for line in f:
  res = re.match(pattern, line)
  if res:
    total = int(res.group(4)) + int(res.group(5))
    if total > 20:
      print(f"Goles: {total} - Fecha:{res.group(1)} | {res.group(2)} [{res.group(4)}] -{res.group(3)} [{res.group(5)}]")

f.close()

import re

csv_data = r'C:\Users\Alfonso Zapata\jupyter\Cursos\Junio 2022\Curso de expresiones regulares - platzi\results.csv'
  
# print(csv_data)

# 2000-01-08,Trinidad and Tobago,Canada,0,0,Friendly,Port of Spain,Trinidad and Tobago,FALSE

pattern = re.compile(r'^(20[0-9]{2,2}\-\d\d\-\d\d),(.+),(.+),(\d),(\d),(.*),(.*),(.*),(.*)$')

with open(csv_data, 'r', encoding="utf8") as f:
    for line in f:
        res = re.match(pattern, line)
        if res:
            if res.group(4) == res.group(5):
                resultado = 'Empataron'
            elif res.group(4) > res.group(5):
                resultado = res.group(2)
            elif res.group(4) < res.group(5):
                resultado = res.group(3)
            print(f'''
            La fecha {res.group(1)}:
            {res.group(2)} vs {res.group(3)}
            Marcador: {res.group(4)} a {res.group(5)}
            Gano: {resultado}
            El partido se jugo por {res.group(6)}
            El encuentro se jugo en {res.group(7)}, {res.group(8)}
            La cancha fue neutral? {res.group(9)}''')

Versión 2022

"""Ejercicio de expresiones regulares con python."""

import re

pattern = re.compile(
    r'^([\d]{4,4})\-\d\d\-\d\d,'
    '(.+),'
    '(.+),'
    '(\d+),'
    '(\d+),'
    '.*$'
)

with open('results.csv', 'r', encoding='utf-8') as infile:
    for line in infile:
        res = re.match(pattern, line)
        if res:
            total = int(res.group(4)) + int(res.group(5))
            if total > 30:
                print(
                    f'goles {total} | {res.group(1)} | {res.group(2)}'
                    f' vs {res.group(3)} [{res.group(4)} a {res.group(5)}]'
                )

Para la primera parte el string %s me daba error, asi que lo modifique y ahora funciona bien, corriendo en un ambiente virtual.

import re

pattern = re.compile(r’^([\d]{4,4})-.*$’)

f = open(“resultsclase.csv”, “r”, encoding=“utf8”)

for line in f:
res = re.match(pattern, line)
if res:
print(f"{res.group(1)}")

f.close()

Python python de mi corazón dicen que es malo enamorarse de una tecnología pero miren la cantidad de lineas que coloco para poder hacer lo que hizo a comparación de php. Por esta razón es que python les esta comiendo el pastel a muchos otros lenguajes.

Acá les comparto los flags o banderas que se pueden usar en Python, estos van al final acompañados de la sintaxis flags= [expresión regular a utilizar] se pueden usar más de una expresión regular uniendolas con |:

re.IGNORECASE o re.I = Esto hace que la expresión regular ya no sea case sensitive, no diferenciará entre mayúsculas o minúsculas.

re.MULTILINE o re.M = La expresión regular buscará en más de una línea.

re.DOTALL o re.S = Esto hace que el . haga match con todos los caracteres y además con el salto de línea.

re.UNICODE o re.U = Esto hace que \w, \b y \W, \B sigan las reglas UNICODE.

re.LOCALE o re.L = Esto hace que \w, \b y \W, \B sigan las reglas de el entorno local.

re.VERBOSE o re.X = Esto hace que puedas realizar comentarios dentro de la expresión regular.

El script version python3.8 con la ventaja de los fStrings

#!/usr/bin/python3

import re


pattern = re.compile(r'^([\d]{4,4})\-\d\d\-\d\d,(.+),(.+),(\d+),(\d+),.*$')

f = open('./results.csv', 'r')

for line in f:
    res = re.match(pattern, line)
    if res:
        total = int(res.group(4)) + int(res.group(5))
        if total > 15:
            print(
                f'goles: {total}, {res.group(1)} '
                f'{res.group(2)}, {res.group(3)} '
                f'[{res.group(4)}, {res.group(5)}]'
            )

f.close()

#!/usr/bin/python3
#1872-11-30,Scotland,England,0,0,Friendly,Glasgow,Scotland,FALSE
#Buscar los partidos amistosos en los que empataron de manera goleadora

import re

pattern = re.compile(r'^(\d{4}\-\d{2}\-\d{2}),(.+),(.+),(\d+),(\d+),Friendly,.*$')

empates_amistosos = 0
no_empates_amistosos = 0
total = 0

f = open("../results_4f052c2d-43b0-40fc-97a4-6672a196f4fb.csv", "r")

for line in f:
    res = re.match(pattern, line)
    if res:
        if (res.group(4) == res.group(5)) and ((int(res.group(4)) + int(res.group(5))) > 8):
            print(f"{res.group(1)}: {res.group(2)} {res.group(4)} - {res.group(3)} {res.group(5)}")
            empates_amistosos+=1
        else:
            no_empates_amistosos+=1
    else:
        no_empates_amistosos+=1
    total+=1

f.close()

print(f"Empates amistosos goleadores: {empates_amistosos}, no empates amistosos goleadores: {no_empates_amistosos}")
print(f"Total contados: {total}, total suma: {empates_amistosos + no_empates_amistosos}")

Poner una r antes de las comillas simples ‘’ quiere decir “raw” o que nos traiga el texto crudo y la diferencia viene sobre todo con caracteres invisibles como el tab o el salto de línea básicamente le pedimos a python que no lo aplique y nos lo muestre explícitamente o de forma cruda ejemplo:
print('\t ejemplo')
ejemplo
print(r'\t ejemplo')
\t ejemplo

esto es util para datos y corroborar lineas
un servidor web desmenuza los querys con expresiones regulares
con un cast se convierte un data a otro tipo

Otra manera de codificar:

import re

pattern = re.compile(r'^([\d]{4,4})\-[\d]{2,2}\-[\d]{2,2},(.+),(.+),(\d+),(\d+),.*$')
f_csv = None
partidos = 0

def file_csv():
    global f_csv
    global partidos
    with open('/home/romero/Descargas/results_6aeb6252-c531-449d-bf29-e11193358b8c.csv', mode='r') as f:
        f_csv = [line for line in f]
        for line in f_csv:
            res = re.match(pattern, line)
            if res:
                total = int(res.group(4)) + int(res.group(5))
                if total > 10:
                    print("goles: {}, {}, {} [{}-{}] {}\n".format(total, res.group(1), res.group(2),
                         int(res.group(4)), int(res.group(5)), res.group(2)))
                    partidos += 1
        print('Son {} partidos los que estan impresos\n'.format(int(partidos/2)))

if __name__ == '__main__':

    file_csv()

Por que siento que con Python todo es mejor?

Por si les da curiosidad la goleada a American Saoma:

https://www.youtube.com/watch?v=1wg9ox9F7Vw&t=120s

Hola estoy cambiando la historia 😄

me fui a buscar el partido de Australia vs Samoa Americana … y si que fue una goleada

casi el 92% de los partidos tienen 1 gol o más.

Estoy impresionado por lo que aprendi un poco de python, creo que comenzare a parender python para entenderlo mucho mejor. Pero su manera de codificar me agrada mas que perl y php

Empates amistosos

#!/usr/bin/python3
#1872-11-30,Scotland,England,0,0,Friendly,Glasgow,Scotland,FALSE
#Buscar los partidos amistosos en los que empataron

import re

pattern = re.compile(r'^\d{4}\-\d{2}\-\d{2},(.+),(.+),(\d+),(\d+),Friendly,.*$')

empates_amistosos = 0
no_empates_amistosos = 0
total = 0

f = open("../results_4f052c2d-43b0-40fc-97a4-6672a196f4fb.csv", "r")

for line in f:
    res = re.match(pattern, line)
    if res:
        if res.group(3) == res.group(4):
            print(f"{res.group(1)} {res.group(3)} - {res.group(2)} {res.group(4)}")
            print(line)
            empates_amistosos+=1
        else:
            no_empates_amistosos+=1
    else:
        no_empates_amistosos+=1
    total+=1

f.close()

print(f"Empates amistosos: {empates_amistosos}, no empates amistosos: {no_empates_amistosos}")
print(f"Total contados: {total}, total suma: {empates_amistosos + no_empates_amistosos}")

Muy buena, me ayudo a repasar python3 y regex !

Esta la la forma en que lo hice

#!/usr/bin/python

import re
# pattern = re.compile(r'^([\d]{4,4})\-\d\d-\d\d,(.*),Friendly.*$')

pattern = re.compile(r'^([\d]{4,4})\-\d\d-\d\d,(.+),(.+),(\d+),(\d+),.*$')

# 1877-03-03,England,Scotland,1,3,Friendly,London,England,FALSE

def main():
    f = open("/home/fgarcia/regexp/PartidosFutbol.csv", "r")

    for line in f:
        result = re.match(pattern, line)
        if result:
            total = int(result.group(4)) + int(result.group(5))
            if total > 10:
                print("goles: {0}, {1} {2},{3} [{4}-{5}]".format(total,
                                                            result.group(1),
                                                            result.group(2),
                                                            result.group(3),
                                                            int(result.group(4)),
                                                            int(result.group(5))))

    f.close()


if __name__ == '__main__':
    main()

Analogía válida

¡que bien! viendo python

Australia 31 - 0 Samoa Americana

Excelente

Que goleada tan brutal 😮

Como aporte los records en partidos internacionales:

1. Vanuatu vs Micronesia; 46 - 0
2. Fiji vs Micronesia; 38 - 0
3. Australia vs American Samoa; 31 - 0
4. Tahiti vs Micronesia; 30 - 0
   Estos marcadores duelen…

Realmente estoy muy agradecido con este curso, el poder la rapidez de las expresiones regulares no lo puedo explicar con palabras Gracias totales!

Objetivo: Prestar atención
Obstáculo: Partido American Samoa

Genial

El partido de fútbol celebrado el miércoles 11 de abril de 2001 entre las selecciones de Australia y Samoa Americana, que concluyó con un resultado de 31-0 a favor de los australianos, es la segunda mayor victoria de una selección internacional de fútbol en un partido oficial después del Vanuatu contra Micronesia en los Juegos del Pacífico de 2015. Fuente

Que genial!!! me encanta la herramienta que es esto de las expresiones regulares

esto es muy útil.

Demasiado util!! jeje Buenisimo!!

Las expresiones regulares lo son todo

Excelente.

super

#!/usr/bin/python

import re

pattern = re.compile(r’^([\d]{4,4})-\d\d-\d\d,(.+),(.+),(\d+),(\d+),.*$’)

f = open("./results.csv", “r”)

for line in f:
res = re.match(pattern, line)
if res:
total = int(res.group(4)) + int(res.group(5))
if total > 10:
print “goles: %d, %s %s,%s [%d-%d]” %
(total, res.group(1), res.group(2),
res.group(3), int(res.group(4)),
int(res.group(5)))

f.close()

Mi lenguaje preferido es Python, y creo que entrare tambien al mundo de JS

Estupenda clase instructor Alberto sobre cómo usar nuestra navaja suiza en Python e interesante el dato de Australia vs American Samoa.

Muy buena clase, siempre es que Python viene siendo mi lenguaje preferido y que bueno poder aprender en distintos lenguajes sobre Regex.

😄

#Flywheel ,Color,English,USA,Drama,,baby|car salesman|christian film|pregnancy|used car salesman,Alex Kendrick,Shannen Fields,Lisa Arnold,Janet Lee Dapper

pattern = re.compile(r'^.*,([a-zA-Z]+)\|([a-zA-Z]+)?\|?([a-zA-Z]+)?\|?([a-zA-Z]+)?\|?.*$')
for line in f:
  res = re.match(pattern, line)
  if res:
    print(pattern.findall(line))

Codigo con comentarios

#!/usr/bin/python
import re #importar regular expresions

pattern = re.compile(r'^([\d]{4,4})\-\d\d\-\d\d,(.+),(.+),(\d+),(\d+),.*$')
#Clase de 4 digitos 
#res.group(1) es el grupo 1 = ([\d]{4,4}) que es el año 
#res.group(2) es el grupo 2 = (.+) Pais1
#res.group(3) es el grupo 3 = (.+) Pais2
#res.group(4) es el grupo 4 = (\d+) Score1 del pais1
#res.group(5) es el grupo 5 = (\d+) Score2 del pais2
#1879-04-05,England,Scotland,5,4,Friendly,London,England,FALSE

f = open("results.csv", "r", encoding='utf8')

for linea in f:
	res = re.match(pattern, linea)
	if res:
		total=int(res.group(4))+int(res.group(5))
		if total>10:
			print ("%d,%s %s-%s [%d-%d]" % (total,res.group(1),res.group(2),res.group(3),int(res.group(4)),int(res.group(5))))
		#print ("%s\n" % res.group(2))
	#print (linea)

f.close()

Python

• pattern = re.compile(r’’)
• res = re.match(pattern, line)
• res.group

Para la segunda parte

import re

#1883-03-17,Northern Ireland,Wales,1,1,Friendly,Belfast,Ireland,FALSE
pattern = re.compile(r’^([\d]{4,4})-\d\d-\d\d,(.+),(.+),(\d+),(\d+),.*$’)

f = open(“resultsclase.csv”, “r”, encoding=“utf8”)

for line in f:
res = re.match(pattern, line)
if res:
total = int(res.group(4))+int(res.group(5))
#print(f"El marcador del local {res.group(4)} y el marcador del visitante {res.group(5)}")
if total > 10:
print(f"Suma de marcadores igual a: {total} \n donde jugo {res.group(2)} contra {res.group(3)} [{res.group(4)}-{res.group(5)}]")

f.close()

#!/usr/bin/python

import re


def transform_file():
    # 1875-03-06,England,Scotland,2,2,Friendly,London,England,FALSE
    pattern = re.compile(r'^([\d]{4})-\d+-\d+,(.+),(.+),(\d+),(\d+),.*$')
    matches = 0
    no_matches = 0
    with open('../files/results.csv', mode='rt') as file:
        list_line = [line for line in file]

        for line in list_line:
            resultado = re.match(pattern, line)

            if resultado:
                if resultado.group(4) > resultado.group(5):
                    lugar = "Local:    "
                elif resultado.group(4) < resultado.group(5):
                    lugar = "Visitante:"
                else:
                    lugar = "Empate:   "

                print(
                    f"{lugar} \t{resultado.group(2)}, {resultado.group(3)} => [{resultado.group(4)} - {resultado.group(5)}]")
                matches += 1
            else:
                no_matches += 1

    print(f"\nSe encontraron coincidencias: {matches} y sin coincidencias: {no_matches}")


if __name__ == '__main__':
    transform_file()

Me hubiera gustado que también se hiciera el ejercicio para ver el tiempo que tomó el script, pero hasta ahora todo excelente

Versión en Python 3

#!/usr/bin/python3

import re

#1882-03-25,Scotland,Wales,5,0,Friendly,Glasgow,Scotland,FALSE
pattern = re.compile(r'^(\d{4,4})\-\d\d\-\d\d,(.+),(.+),(\d+),(\d+),.*$')

f = open("../Curso de Expresiones Regulares/results.csv", "r")

for line in f:
    res = re.match(pattern, line)
    if res:
        #print(line)
        #print "%s\n" % res.group(1)                   Formato Py2
        total = int(res.group(4)) + int(res.group(5))
        if total >= 10:
            print("goles: {0:d}, {1:s}: {2:s} [{4:d} - {5:d}] {3:s}\n"
                .format(total, res.group(1), res.group(2), res.group(3), \
                        int(res.group(4)), int(res.group(5))))

Aquí le dejo el script para python 3

# !/user/bin/python

import re

pattern = re.compile(r'^(\d{4,4})\-\d{2,2}\-\d{2,2},(.+),(.+),(\d+),(\d+),.*$');

f = open("./results.csv", "r", encoding="utf-8");

for line in f:
    match = re.match(pattern, line);
    if match:
        total = int(match.group(4)) + int(match.group(5));

        if total >= 30: #for-the-lols
            print(f"goles: {total}, {match.group(1)} {match.group(2)},{match.group(3)} [{match.group(4)}-{match.group(5)}]")

f.close();