Ok, muy buenos días, bienvenidos, gracias por estar acá, es para mi gusto presentarles a Víctor Terrón, quien nos hablará acerca del módulo Eater Tools. Al final una ronda de preguntas de cinco minutos, así vamos por favor con un aplauso.

¿Se me oye? Muy bien, creo que hay otros que dicen no propadece, mira fijamente tenemos un montón de material, si alguien tiene alguna objeción que levante la mano. Todos sabemos cómo se itera sobre el elemento de una lista, vamos muy rápido, nos lo enseñan siempre cuando empezamos, nos dicen tenemos una lista de números, para cada número de la lista haz algo con el número y eso es un bucle fort y a todos nos dicen y nos insisten un montón, eso es mucho

mucho mejor que hacer esta otra cosa, que si venimos de otros lenguajes de programación podemos estar tentados de hacer y es no, yo voy a iterar sobre los índices, voy a generar toda la lista de índices y entonces para cada índice haced el elemento y hago lo que quiero con el elemento, por ejemplo en este caso voy a imprimirlo y nos dicen no, eso no se hace, de hecho aún aún aún peor es quien intenta hacer esto y es que dice bueno para que utiliza

range yo puedo manipular números por mí mismo y entonces crean su índice y lo van incrementando su valor en cada iteración y van decidiendo los índices etcétera y nos dicen no, no se hace así, ese no es el camino de python, el camino de python es que digamos simplemente no, esto es un bucle, lo que en otros lenguajes de programación se conoce como for each,

verdad? Y nos dicen sí sí python que nosotros lo sentimos y realmente sabemos que es mucho mejor porque tenemos más nivel de abstracción, es un código podríamos argumentar más legible, más claro y sobre todo no estamos pensando en índices, simplemente nosotros decimos para cada cosa en eso, gran precisión, a lo que quieras con esa cosa, de hecho quizá no tan

importante pero también lo es, es que no estamos manipulando los índices y eso es otra ventaja, no solamente el código más legible sino que también hay menos sitios donde podemos equivocarnos, de hecho yo argumentaría que no puede equivocarte ningún

sitio con un bucle for each porque es imposible que metas la pata, sin embargo aquí podría ocurrir que se nos fuera la mano y nos estamos pasando con el índice y hemos puesto, no hemos parado en el n-1, hemos parado en el n y como empezamos a contar por cero, el código explota, índice error. Por supuesto no solamente funciona con listas, aunque es con lo que siempre se empieza cuando damos nuestros primeros pasitos de

También podemos utilizarlo por ejemplo con cadenas, de hecho para cada letra en esta cadena de vocales haz algo con la letra y la imprimo A E I O U, también si tenemos un conjunto podemos iterar sobre el conjunto aunque siempre sabemos de talla de implementación de que no tenemos ninguna garantía respecto al orden, pero la cosa es que podemos iterar sobre los elementos del conjunto o si tenemos un diccionario, por ejemplo utilizando items podemos decir muy

bien para cada clave y su valor asociado en el diccionario haz algo con ellos, una vez más un bucle for, del mismo modo que si tenemos un fichero abrimos el fichero, y podemos iterar sobre el fichero objeto SFD de file descriptor que siempre utilizamos cuando trabajamos con ficheros y podemos imprimir cada una de las líneas con lo

cual es siempre lo mismo lo cual es muy bueno la index de la estandarización de hecho resulta que si miramos la documentación el bucle for se puede utilizar con cualquier cosa que sea iterable lo cual traslada la pregunta y que algo que sea iterable pues nos podemos ir a la documentación que es un iterable y resulta que todas las del universo no están solamente en esta cover flow también tenemos documentación y

en el glossario bastante abandonado no porque no esté bien mantenido sino porque nadie lo lee resulta que nos explican que un iterable es un objeto que es capaz de devolver sus miembros uno a uno bla bla bla y lo importante es que tenemos que tener implementado un método mágico el iter o el get item que bueno para la para esta charla vamos a centrarnos

en el iter es decir que tenemos que implementar iter muy bien pues tenemos que volver a la documentación y responder la pregunta y que existe por resulta que éste es un método que es al que se llama cuando necesitamos un iterador para un objeto contenedor y nos tiene que devolver un nuevo iterador vale demasiado texto en el parfo dice tienes

que implementar éster y tienes que hacer que devuelva un iterador y tú cada vez que utilices la función built in de este lenguaje éster se llamará de forma implícita a este método mágico vale y de hecho resulta que es cierto si no me creéis si tenemos una lista de números 1 2 3 e imprimimos el método mágico yter no hemos puesto los paréntesis

porque no queremos llamar al método solamente queremos ver que está ahí nos dice efectivamente yter es un objeto de un método del objeto lista si utilizamos la función iter sobre nuestra lista de números nos devuelve un iterador de hecho si imprimimos el valor de it nos dice esto es un objeto iterador de una lista o sea que es cierto

vale muy bien estamos devolviendo un iterador pero ahora es otra pregunta y que es un para ser un iterador tienes que adecuarte a lo que se conoce como el protocolo iterador también en la documentación y eso significa que tienes que implementar dos métodos el primer método tiene que ser una vez más iter y tienes que de hecho la documentación nos dice

tienes que el iterador tiene que implementar el método iter y tiene que devolverse a sí mismo lo cual de hecho tiene sentido cuando lo piensa un rato pero la primera vez que nos encontramos con él es como vale lo que sea o sea que tenemos que hacer una cosa un poco tonta y es esto porque ahora estamos en nuestra en nuestro tenemos el objetivo de

implementar nuestra clase iteradora entonces vamos a hacer esto muy bien implementó iter y devuelvo self puedo seguir instrucciones y lo segundo y lo importante es que tenemos que implementar el método mágico next y este es el método mágico que cada vez que nosotros trabajando con un iterador le digamos dame el siguiente elemento será llamado de forma implícita por el lenguaje de hecho nosotros tenemos una función que es next y cada vez que nosotros

utilizamos sobre el objeto iterador nos devolverá el siguiente elemento como la segunda frase yo tampoco la entiendo y este método mágico next con los guioncitos bajos era lo que en python 2 que ya nadie usa ni recuerda era punto next así que lo podemos hacer estamos vamos a hacer nuestra propia clase iteradora que itera sobre los elementos de una de unos

elementos que recibe cuando se construye ahí en init nos guardamos una copia de los elementos hemos hecho esa cosa que nos dijeron que no entendemos en el fondo de que iter se devuelva a sí mismo y luego implementamos el método mágico next y next lo que hace que cada vez que se llame nos va a devolver un elemento como lo hacemos muy bien devolvemos el elemento

que corresponde al índice actualizamos el índice y en el momento en el cual ya nos hayamos pasado del tope de objetos que tenemos vamos a devolver esto y te deis porque esa excepción es la que tenemos que un iterador ha de lanzar siempre cuando no así que no muy útil pero hemos implementado nuestro propio iterador de hecho podemos ver que

es cierto perdón voy a ir atrás podemos ver que creamos nuestro iterador ahí decimos mi iterador trabajando sobre una lista y llamamos a next tres veces y cada una de las veces nos devuelve el siguiente elemento 1 2 3 la cuarta vez como no quedan elementos de devolver esto pide es por supuesto y hay mención obligada next sólo se puede utilizar sobre

incluso que nuestra clase sea iterable necesitamos un iterador para poder iterar sobre ella aquí si llamamos muy convencido next sobre la lista no funciona tenemos que hacer lo de siempre tenemos que llamar a iter y tener no devolver un iterador y ya con el iterador podemos llamar next todas las veces que queramos hasta que alcancemos el final stop iteration de hecho

exactamente eso es lo que hace entre bastidores el bucle for el bucle for hace exactamente eso ya utiliza iter obtiene un iterador y entonces de forma repetidas veces va llamando a next obteniendo el siguiente elemento hasta que finalmente alcanza esto petition si quisiéramos re implementar sin ningún motivo justificable el bucle for y utilizar el bucle

nuestro bucle for en vez del bucle for de python podríamos hacerlo así un wild true en el cual vamos a estar llamando a next hasta que la excepción nos haga parar y funcionaría también otra cosa que cuando empezamos a leer nos puede surgir la duda pero si el iterador va a lanzar una excepción como es que nosotros no vemos la excepción pues porque

for está escuchando de forma explícita a ese a esa excepción cuando for b stop iteration para porque sabe que es la forma en la cual nosotros señalamos que hemos de parar pero por supuesto ese stop iteration solamente se considera un motivo de parada cuando ocurre

el iterador cuando llamamos a next si dentro del bucle si dentro del cuerpo de nuestro bucle for nosotros hicieramos lanzar una excepción por supuesto que vamos a romper nuestro programa y otro desvío que son los generadores los generadores son tipo unos tipos especiales de iteradores porque todos sabemos como una función aquí todo el mundo sabe cómo funciona

una bastante tonto pero cómo funciona una función normal pues nosotros entramos en la función vamos haciendo ejecutando líneas una detrás de otra en orden muy secuencial y cuando alcanzamos el final de la función devolvemos si tenemos un retorno devolvemos algo si no es uno y sobre todo lo sabíamos pero nunca lo habíamos pensado una función todo lo que hace tiene que devolverlo de golpe verdad por ejemplo aquí tenemos un

único punto de salida la entramos en la función ejecutamos la primera línea ejecutamos la segunda línea última línea y salimos o podemos tener múltiples puntos de salida aquí dependiendo del valor de la variable de entrada haremos saldremos por un sitio por la por el primer retorno o por el segundo la cosa es que una vez que alcanzamos uno de retorno saldremos de la función para nunca regresar si no ponemos nada eso es un nono

porque todas las funciones en python devuelven algo entonces esto es un nono implícito nuestra función está devolviendo algo digamos ahora que queremos trabajar con números pares queremos hacer una función que nos vuelve a todos los números pares hasta un umbral esto pues podríamos decir muy bien puede hacerlo versión tonto motivado que es creando la lista a mano nosotras o podemos utilizar range y generar los todos la cosa es que

tenemos un problema la lista que generamos la deje de golpe con lo cual si en algún momento queremos sumar un montón de números por ejemplo billones y billones de números que si éramos que al curar la suma de todos esos números pares no hay suficientes modulitos de ram que podamos comprar para nuestro ordenador con lo cual no funciona esto si lo intentáis tarde o temprano el ordenador dirá a memoria si tenéis suerte aquí es

cuando se utilizan los generadores los generadores son funciones mágicas porque lo que pueden hacer es devolver valores de uno a uno lo que hacemos utilizar return en vez de return y eso significa que cada vez que llegamos a un yield devolvemos un valor y la función se queda congelada ahí esperando hasta la siguiente llamada de hecho formalmente

un generador una función generadora devuelve un generador un iterador generador un iterador generador pero la práctica lo que decimos que son generadores y bueno y nos devuelve la función generadora nos devuelve un generador por ejemplo aquí está este generador simple en vez de utilizar return tiene yield 1 2 3 con lo cual podemos ver que cuando llamamos a la función

nos devuelve un iterador un generador y cada vez que llamamos a next nos va devolviendo uno de los valores la primera llamada va al primer yield la segunda continúa va llega el segundo y tercera y como todos los iteradores cuando terminamos devuelve stop iteration con lo cual ahora podríamos hacer lo que queríamos hacer de que nuestra función generadora devuelva todos los números pares o bueno perdón todos los números naturales podemos hacerlo

porque ahora tenemos un while true dentro de nuestra función y pero nos da igual porque no vamos a estar siempre ahí dentro cada vez que alcancemos un yield nos vamos a quedar congelado después de devolver ese valor y así podríamos llamar next indefinidamente si lo intentamos con una función normal no funciona por favor no ejecutar este código porque no termina nunca por el wild true en resumen 10 minutos 56 segundos los iteradores

son unos objetos sobre los cuales podemos llamar next es lo único que nos importa los generadores devuelven elementos uno a uno y todo generador es un iterador pero no a por supuesto también los generadores son un framework que nos simplifica nuestra vida en casos simples todo lo que podemos hacer con un generador podríamos hacerlo con un iterador

una clase de iteradora fea como lo que hemos visto antes que hiciera lo que necesitamos pero lo chulo de los generadores que ya toda la lógica de mantener el estado y no tener que pensar en qué va a ocurrir hasta la siguiente iteración ya está hecha por nosotros extra como medimos un generador no podemos llamar al en porque los generadores van devolviendo elementos uno a uno si lo intentamos dice type error entonces podemos decir bueno pues lo voy a convertir a lista lo convierto a lista y entonces ya si puedo llamar

el list a problema una vez más estamos construyendo una lista temporal si hubiéramos muchos elementos no funcionaría una cosa que se ve mucho utilizar sum decir bueno voy a sumar un montón de números uno por cada elemento del generador que por supuesto voy a recorrer el generador voy a agotarlo pero si podemos hacerlo aún más idiomático podemos utilizar una un guión bajo bajo para indicar que la convención según le queda estilo de que

no nos interesa ese valor realmente no estamos haciendo nada con x en el ejemplo de arriba si lo hacemos así lo que estamos diciendo es vale no me importa simplemente sumando uno por cada cosa y que bien que haya agua y ahora yo quiero hablar de números primos me encanta los números primos y diría cómo determinamos un número es primo pues en muchas formas de matemáticas de verdad

pero una muy simple es que voy a hacer bueno lo voy a hacer por fuerza bruta porque un número primo que es aquel que sólo tiene dos números dos divisores verdad uno y sí mismo vale pues yo voy a probar todos los demás números que estén entre perdón entre uno entre perdón todos los números que estén entre esos dos entre dos y el número menos uno voy a probar todos los posibles números si alguno de ellos divide a mi numerito en

es que el número no es primo si no ningún divisor es primo por supuesto podríamos hacerlo así empezando con nuestros divisor desde dos pero hay una forma mucho mejor que es con con range para qué voy a manipular una vez más para que voy a manipular yo índice y funciona podemos utilizar nuestra función una estimización obligatoria sin entrar en demasiadas matemáticas es que solamente tenemos que comprobar a los divisores

hasta la raíz cuadrada del número esto lo pongo solamente como excusa para decir que si podemos bajar la complejidad de odn o de raíz de n y hay una explicación para humanos en esta cover flow que es la única que entendí y con álgebra se puede demostrar que si no eres un número primo tendrá un divisor por debajo de la raíz y bueno vale pues muy bien pues entonces en mi range en vez de ir hasta él en vez de ir a esta n voy a ir hasta la

raíz cuadrada y eso es un montón de mejoras y ya tengo mi super función y ahora voy a utilizar la función para factorizar el número primo es decir quiero descomponerlo en el producto de sus factores por ejemplo 8 es 2 por 2 por 2 no 2 elevado al cubo y una vez más hay muchas matemáticas muy ninjas pero yo voy a hacerlo por la forma más simple que el método del trail division este que voy a ir probando todos los números primos y si un número

primo dividió mi número pues es que es un factor y sigo así hasta que no me quede nada es decir voy a decir muy bien voy a empezar con todo pero bueno para eso necesito hacer una cosa necesito generar todos los números primos que podrían dividir mi número por lo que hemos dicho de la raíz cuadrada aquella entonces voy a decir muy bien voy a empezar intento uno como voy a generar un quiero un método que me vuelva un montón

de nuevos primos entonces voy a empezar con una lista vacía y voy a ir calculando números primos es decir estos primos si pues añade la lista es 3 primos y añade la lista 4 no puede el siguiente y cuando tengo los n primos en los tantos n primos números primos que quiero los devuelvo pero el problema estamos devolviendo todos los primos a la vez por lo cual según trabajamos con un número muy muy muy grande puede que no quepa nuestra raspberry pi así

que lo que voy a hacer es muy bien pues voy a utilizar un generador que lo acabamos de aprender y entonces voy a ir devolviendo los números primos que necesito uno a uno pero aquí hay casi que dos cosas que podrían salir mal porque estamos haciendo dos cosas a la vez estamos llevando la cuenta de cuántos números primos hemos generado y de cuál es el siguiente número primo y cuantas en cuantas más cosas tengamos que pensar es más peligroso con lo

que lo podría decir muy bien hay un problema perdón no podemos utilizar range porque reyes necesita saber dónde determina entonces es donde podemos utilizar hay tertulis que era la excusa por la que venimos a esta charla hay tres hay tres tools tiene un montón de funciones una de ellas es caúnt y caúnt es un range sin cielo con range con caúnt lo que hacemos que le decimos muy bien vas a empezar a

a partir de aquí y en saltitos de tanto que por defecto va a empezar a contar en cero como hay que hacer y va a ir de uno en uno y nos va a devolver un iterador cada vez que le demos a next nos va a devolver el siguiente elemento es decir range sin tope con lo cual podemos simplificar nuestro código un poquito porque lo que podemos decir es muy bien pues esa lista de candidatos lo que vamos a hacer es por cada número en y tertulis caúnt va a ir

recorriéndote números candidatos y va a ir probándolo cada uno de ellos pero de nuevo estamos haciendo dos cosas estamos en un mismo bucle for bastante feo estamos haciendo generando primos y estamos comprobando cuántos números primos hemos generado hasta la fecha vamos a hacer la cosa vamos a partirlo en dos trozos vamos a hacer primes que va a ser una función que nos va generadora que nos va a devolver el número primo uno detrás de otro y ya lo que

hagamos con con esos valores que no devuelva es otro tema y es lo que hacemos en la segunda función en la segunda función lo que vamos a hacer es decir muy bien va a ir recorriendo todos los números primos y va a ir llevando la cuenta de cuánto ha devuelto cuando devuelva lo suficiente para de hecho podemos simplificar la función de arriba aún más

podríamos utilizar una función generadora un generador por comprensión porque podemos decir simplemente muy bien dame todos los números dame todos los números que me vaya devolviendo y tertulis caúnt si pero solamente aquellos que sean primos o quizá incluso este sea uno de esos casos en los cuales el filter es aún más legible porque estamos simplemente

filtrando unos valores sin hacer nada con ese porque ese n for n siempre un poco raro podemos decir muy bien para también simplemente aquellas valores que satisfagan esta condición y que como detalle histórico para la gente que esté en arqueología y tertulis filter era antes hay filter en aiter tools pero nadie recuerda paisón 2 con lo cual podemos

combinarlo todo y hacer que nuestra función sea mucho más sencilla vamos a decir muy bien tengo una serie de infinitas de números primos que es la que obtenemos con filter y perdón pero que llevo 15 no no eran 45 yo sigo hablando sí no es un detalle

importante por no ser sentido 45 minutos vale vale aquí tengo 17 que llevo 17 vale vamos más rápido todavía podemos decir muy bien y tengo esa lista infinidad de

números primos y lo que voy haciendo con ello es que voy a ir llamando al next hasta que haya tenido los suficientes pero resulta que eso es un patrón habitual ese patrón es un patrón de desliterable dame tantos elementos y eso no tenemos que hacer la mano cuando ya está hecho con nosotros por supuesto no podemos utilizar la función los slices no podemos utilizar lo que hace utilizamos con el list una secuencia normal

una cadena porque no sabemos cuántos elementos hay en un generador hasta que llegue el momento con lo cual si intentamos utilizar nuestros corchetitos nos va a decir type error pero tenemos aislice y aislice es en el módulo aiter tools una notación de corchetitos pero para cualquier cosa que es iterable incluyendo generadores y por supuesto como es muy vaga lo va a ir evaluando todo uno a uno conforme va ocurriendo por

ejemplo aquí le digo muy bien de aquella esa cosa que me devuelve aiter tools count dame solamente los cinco primeros que es ese cinco que está como segundo argumento y vemos que aunque aiter tools count no termina nunca el iterador que nos devuelve aislice si termina y por supuesto funciona con todas las cosas que sean iterables no solamente con generadores por ejemplo aquí podemos tener las primeras tres letras de una cadena o podemos y por

lo que la lógica habitual de que podemos empezar por otra cosa que no sea cero o podemos ir dando saltitos que no sean de uno como hacemos siempre con lo cual si queremos los primeros n números primos lo que podemos hacer es decir muy bien pues voy a decir muy bien quiero decir primero muy bien y slice y dame los 10 primero y funciona con lo

cual podemos reescribir nuestra función y podemos decir muy bien pues voy a utilizar filter y voy a hacer por cada de esos números que hay en lo que me devuelve aislice voy a hacer un gild de n y esto pero esto se siente esto es un poco raro porque lo que estamos haciendo es iterar sobre algo y solamente haciendo un gild y resulta que para eso entre otras cosas inventó gild from gild from lo que nos permite es delegar parte de un

permite que un generador de delegue parte de sus operaciones a otro delega a otro generador un subgenerador es decir cada vez que nuestro generador que utiliza next from escuche un next lo que va a hacer es a su vez preguntarle al otro generador oye dame tu siguiente y

va a devolverlo directamente es decir nos estamos ahorrando ese bucle tonto de for n en algo gild n podemos decir simplemente gild from en este ejemplo tenemos spam y spam realmente no está haciendo nada lo único que está haciendo es delegando todo el trabajo a full con lo cual cuando yo llamo next en spam a su vez spam llama hace un next a full con lo cual

nuestra bueno y por supuesto una vez más funciona con cualquier cosa que sea iterable no solamente con generadores con lo cual si nuestra función vocales hacen un gild from de todas las vocales pues bueno cada vez que hagamos una llamada nos devolverá una de las vocales con lo cual podemos reescribir nuestra función simplemente en dos líneas lo que antes era mucho más feo podemos decir muy bien que estoy haciendo componiendo

nuestro trabajo en dos pasos obtengo una lista de todos los números primos y cojo los que me hacían falta paso 1 y perdona me puedes confirmar que terminamos 15 vale sí sí y eso sería dejando cinco minutos de preguntas vale muy bien vamos muy bien no sobre tiempo hasta para

y ahora vale está muy bien está todo súper guay 20 minutos aquí todavía no hemos hecho nada porque lo que queríamos nosotros queremos factorizar el número primo y para factorizar un número primo no tenemos que decir dame cinco números primos lo que queremos es decir dame todos los primos hasta esa raíz cuadrada con lo cual lo que tenemos que hacer es generar números primos hasta un umbral es decir queremos decir muy bien dame

números primos hasta este valor y entonces tenemos que hacerlo no llevando la cuenta de cuánto hemos generado sino de cuál es el valor actual por lo cual tenemos que hacerlo así utilizo mi lista de números primos y lo que voy haciendo es muy bien es hemos llegado ya a ese umbral esto porque nos habían pedido y si no es el caso continuamos si no no te tenemos y ese es otro patrón habitual es decir estamos iterando sobre algo hasta que una

condición deje de cumplirse en este caso por ejemplo que seamos menores o iguales que esa x y eso es take while take while lo que hace es devolver una vez más como todo en intertools devolver un iterador que lo que hace es que para de recorrer elementos sobre lo que es lo que tiene como entrada en el momento en el cual la condición ya no se cumple no se está así solamos verlo mucho en utilizado junto con funciones landa por ejemplo aquí lo que

tenemos en numbers que hay un montón de números y lo que estamos diciendo muy bien coge números siempre y cuando sean menores que 4 lambda x no x menor que 4 lo cual significa que la primera vez que llamamos a next va el que va que va a ver take while va a ver 1 y 1 es menor que 4 con lo cual lo devuelve lo mismo ocurre con 2 con 3 pero tal o temprano llegamos

a 4 y 4 no es menor que 4 con lo cual hemos terminado y como todos los iteradores no hay nada que devolver esto y entonces nos devuelve esto a pit de edición por supuesto las funciones landa no son obligatorias si tuéramos una función que hiciera casualmente lo que necesitáramos como por ejemplo aquí una función que nos dijera si un valor es menor que 10 pues podríamos utilizarlo y funciona igual solamente vamos a estar

en los números que cumplían la condición una vez que llegamos al tope paramos con lo cual nuestra versión kung fu lo que queríamos hacer es simplemente dos cositas nuestra lista de números nuestra lista infinita de números primos y nuestro yield from de lo que nos devuelve take while donde comprobamos que no hemos llegado todavía al valor tope y por cierto cual es lo opuesto lo opuesto es drop while drop while lo que hace es que va

ignorando todos los elementos hasta que llega a un punto en el cual la condición ya no se cumple y en ese momento a partir de ese momento lo devuelve todo es decir lo utilizamos para ignorar la parte del comienzo de un iterador potencialmente infinito por ejemplo aquí tenemos un montón de números de nuevo y lo que le decimos es muy bien vas a ignorar

todos los números que son menores que cuatro entonces digo drop while es decir descarta elementos mientras que y con la función landa lo que estamos viendo si los números son menores que cuatro con lo cual la primera que llamamos a next que va a ver drop while va a ver un 1 y entonces como uno es menor que cuatro lo va a ignorar luego ocurre ahora mismo con dos con tres y cuando llegamos a cuatro ya cuatro no es menor que

cuatro con lo cual ya aquí la condición ya no se cumple y ya puedo volver todos los elementos y ya devolverá 456 hasta el infinito combinando las dos podríamos hacer una cosa un maja que es que podríamos generar todos los números primos dentro de un rango por ejemplo cojo cojo drop while para descartar todos los números primos hasta llegar al

comienzo en el que queremos empezar a ver números primos y el literador que me devuelve a su vez se lo paso a take while hasta llegar al tope y si teníamos unos valores por defecto que fueran dos que el primer número primo e infinito podríamos hacer que nuestra función nos diera solamente números primos en un rango que quisiéramos por supuesto empezando desde donde quisiéramos y terminando donde quisiéramos y ahora esto que decirlo es

obligatorio cuál es el algoritmo de facturación de facturización de números primos pues lo que vamos a hacer es que vamos a ir iterando sobre todos los números primos y si en algún momento es divisible el número sobre ese número primo p es un factor entonces lo guardamos y básicamente iteramos de forma recursiva el caso base es que no nos quede

nada o el número que nos quede sea primo y entonces ese es otro factor no tenemos que entrar a las detalles pero por ejemplo tengo 30 empiece por el primer número primo con el primer número primo 2 es 30 divisible entre 2 sí entonces 2 es un factor hago la división y entonces me queda 15 entonces ahora y tengo luego de forma recursiva con 15 2 no divide pero tres sí entonces trae otro factor etcétera y tarde temprano terminamos y nos

queda que efectivamente tenemos todos los factores del número factores primos por ejemplo lo podríamos hacer elegantemente con nuestra función basada en itertools de primes until y podríamos hacerlo así como estamos utilizando recursividad lo que hacemos es que cada factor que encontramos lo encachulamos lo metemos en una listita

que encadenamos con la lista que nos va a devolver la llamada recursiva y así con toda la llamada recursiva encadenando listas obtendremos una lista con todos los factores y lo mejor es que funciona ni yo me lo creo cuando me sale y no sé para qué se puede utilizar pero ahí está el comando y unique vamos muy bien de tiempo el comando y unique lo que hace lo es de esas cosas que te encuentras cuando está cobre float y dicen

se hace así elimina líneas duplicadas que estén consecutivas en un fichero bueno lo que reciba por entrada es el tipo de cómo quito cómo elimino líneas duplicadas de un fichero en linux que dicen sort menos un o sort y se lo pasas a unique es decir que como a a a están consecutivas y son básicamente la misma línea pues nos las quita y nos deja solamente una es decir queremos escribir queremos hacer esto y por simplicidad vamos a decir

vale solamente quiero aceptar cadenas como entrada pues si quisiéramos hacerlo tendríamos que decir vale pues una de las formas hay otras más posiblemente más rápidas pero una que se puede entender sin morir en el intento sería muy bien voy a llevar la cuenta de cuáles son cuál es mi resultado para cada nueva letra que veo en la cadena lo que voy a decir es voy a

ignorar voy a ignorar la letra si es igual que la última que ya tengo el resultado y una vez que termino lo concateno todo sí pero si puede hacer en una línea porque tenemos group by y group by es lo más difícil de entender de esta charla porque group by al principio en esas cosas que la documentación está es completa no es muy amigable para principiantes

group by lo que hace es devolver a un iterador que nos da grupos consecutivos de clave y valor donde un grupo empieza cada vez que el valor de la clave cambia lo vamos a entender ahora a su vez los grupos los grupos objeto que nos devuelve esos grupos son unos iteradores es decir si yo le digo muy bien tengo una cadena y a a b c c y digo vamos a agrupar vamos a hacer

los grupitos de esta cadena y imprimo grupos país nos dice es un group by object gracias muy claro todo y ahora llamo next llamo next y nos devuelve el primer grupo y la primera clave cuál es la primera la primera clave a porque lo que hay en este grupo y qué es group bueno nos dice que es un objeto grouper o sea tampoco me ha quedado muy claro

pero si llamo next porque se ha quedado un iterador veo que tiene una una una y luego cuando lo intento nada más me dice esto habita edición no me ha quedado nada claro lo que pasa es que cada llamada a next está devolviendo dos elementos vale la clave es lo que el grupo contiene y el grupo son la ocurrencia cuántas veces esa cosa que es la clave aparece

por ejemplo con b le digo muy bien cuál es la clave del segundo grupo pues me dice por b es decir este grupo tiene vez y cuántas ocurrencias debe hay que otra forma de verlo pues solamente hay una con lo cual grupo si lo imprimo veo que tiene una vez y lo mismo con c solo que hace resulta que tiene tres c es quizá una forma más fácil de visualizarlo es así

hago utilizo un bucle for y voy recorriéndolo y lo que digo es muy bien pues para cada clave para cada grupo imprimir la clave imprimir el grupo y puedo ver que hay tres grupos que tienen a b y c y podemos ver que el grupo tiene las ocurrencias del mismo esto parece muy tonto pero es súper potente aunque no lo parezca al principio por ejemplo nuestra función kung fu de esta eliminación de duplicado es tan sencilla como hacer una agrupación y para

cada uno de los grupos que nos encontramos y generar la ocurrencia que más me da que haya tres 8 o 15 lo único que quiero es una por cada solamente quiero una así que cojo la clave y las en cada las concateno todas con un join y he terminado incluso lo podemos hacer en una única línea si lo preferimos con una lista por utilizarlo para como entrada

al join esto es una pregunta habitual en algunas entrevistas de trabajo se encuentra en internet si lo pone y es a un algoritmo de compresión que coge una cadena y me la comprima por ejemplo ahí como tengo tres as quiero que devuelva a tres y si tengo una b pues quiero que devuelva b1 queremos hacer esto cómo lo hacemos bueno pues una forma

que nos llena de dolor sufrimiento y lágrimas es hacer un monstruo como éste porque es muy feo pero que realmente es que no hay otra forma de hacerlo porque tengo que llevar la cuenta de cuál es el grupo en el que estoy cuántas palabras he visto hasta la fecha y cada vez que veo una nueva ocurrencia tengo que incrementar el contador y cuando termino no se me puede olvidar que le pasa todo el mundo que aunque te haya salido el bucle for tu estabas en un

grupo con lo cual tiene no puede olvidar el último grupo ahí en línea justo antes del retorno y ya al final lo convino y lo devuelve todo y esto es como no esto no se va a ocurrir en una entrevista pues sangre y dolor y lágrimas pero quien conoce itertools hace una cosa muy sencilla y es que dice muy bien si ya está todo hecho por mí solamente

tengo que coger la clave y que cuántas ocurrencias quiere que me ha dicho que cuente cuántas ocurrencias hay muy bien tengo el grupo convierto el grupo en una lista y llamo alén y ya tengo exactamente si hay una vez o hay 70 y las conca bueno y lo y mi algoritmo funciona ahora la cosa es que por defecto en group by está comparando a con

a decir a igual a porque a igual a es que estamos comparando las cosas como son y eso aunque es útil a veces lo el verdadero poder está cuando queremos utilizar un criterio diferente es decir esta función es exactamente igual que tenemos en sort o en sortis cuando queremos ordenar en base a otro criterio que no sea el de simple y llana igualdad decimos

este es el criterio en base al cual va a ordenar por ejemplo quiero agrupar letras por longitud tengo una serie de palabras y quiero que azul y gris en inglés estén juntitas estén emparejadas porque tienen las dos cuatro caracteres pues podemos hacerlo y a una solución muy digna tengo una tabla has un diccionario en python y lo que voy a hacer es que bueno

pues para cada palabra comprobó su longitud voy a esa clave y añado la palabra allí sí pero tenemos la versión kung fu la versión kung fu es que le digo muy bien va a agrupar todas las palabras en base a qué criterio su longitud y ya está dos notas de mención obligada primero tenemos que ordenar la lista antes si no solamente funcionaría si estamos agrupando lo se está si estuvieran contiguas del mismo modo que si hay un

fichero de linux hay que hacer sort antes de ordenarlo en la terminal de eliminar los duplicados y también que esta solución es cierto que la complejidad en el algoritmo de n porque hay una llamada a un algoritmo de ordenación pero yo argumentaría que si podemos permitirnos permitirnos lo es mucho más legible porque de hecho que estamos diciendo

en lenguaje casi natural lo que queremos hacer estamos diciendo agrupa esas palabras en base a un criterio cuál es el criterio la longitud aún más chulo matemáticas los que estáis cerca de la puerta podéis ir corriendo digamos que tenemos esta función que hemos encontrado en internet sin saber lo que hace y como no queremos pensar utilizamos numpy y podemos incluso imprimirla podemos crear un objeto polinomio y podemos ver qué es lo que hace

y resulta que la función hace bueno tiene esta forma en este rango arbitrariamente escogido y no tenemos ni idea de lo que es pero como es un ejemplo vamos a asumir que es tiempo versus algo verdaderamente importante es algo muy importante que estamos monitorizando y que no puede salir mal y estamos en el trabajo y queremos que suene una alarma sin algún momento

hemos pasado más de tres segundos por debajo de ese valor cero de algo muy importante tenía un compañero tenía un compañero que estaba haciendo esto el otro día fue un no es muy fácil porque podemos ver que entre cero y tres básicamente ahí tenemos ahí estamos más de tres segundos de bajito de cero pero cómo hacemos eso en código para simplificarlo

podemos asumir que solamente vamos a evaluar en los enteros con lo cual podemos rehacer la pregunta podemos reformular la pregunta hemos estado tres o más hay tres o más valores seguidos aquí en esta lista de valores que tengan signo negativo pues es realmente muy simple

porque lo que vamos a decir es muy bien pues vamos a agrupar estos valores en base a un criterio cuál es el criterio no el valor de los valores per se sino simplemente sus signos es decir si el criterio ese argumento aquí es simplemente eres negativo o no que será en cada momento la clave pues la clave que aquí hemos llamado es negativo la clave nos dirá verdadero o falso en función de si el valor de la clave para esos elementos

es verdadero no es decir como este grupo tiene números negativos será verdadero como este grupo tiene positivo será falso y luego ya en grupo tendremos los valores por sí mismo con lo cual si tramos podemos decir muy bien si en algún momento la clave es negativa y tenemos más de tres valores puede hacer que suene la alarma y funciona y funciona aunque

nosotros por supuesto dijimos bueno esto es una línea de código pero por lo menos hasta el martes y esto estaba en la propuesta de charlas así que hay que incluirlo como el tramo indefinidamente entre un montón tenemos 10 minutos vamos súper bien como el tramo indefinidamente entre dos valores menos 1 y 1 por la versión completamente principiante

la de que salpica sangre así a la primera línea de asistentes digo un bucle wild y para cada uno de los valores pues cuando tengo un 1 paso menos uno y cuando tengo menos uno pues le asigno el otro valor y bueno esto no es buena idea ejecutar esto una versión un poquito menos principiante es que no tenemos que ir asignando manualmente menos uno y uno lo que vamos a decir es bueno multiplico por menos uno porque resulta que

así nos iremos cambiando el signo multiplicando por menos uno pero sigue siendo mala idea porque es un bucle wild básicamente allí pegado en nuestro código la versión estaba prestando atención con lo cual se cual es la respuesta es por supuesto utilizar un generador podríamos utilizar ese bucle wild horrendo podemos ponerlo dentro de una

función generadora y entonces ya no tenemos ningún problema porque no vamos a ejecutarlo el ese buque wild no va a intentar ejecutarse hasta el infinito simplemente se congelará hasta la siguiente llamada a next con lo cual nuestras llamadas a next vemos que efectivamente funciona y nos va alternando entre 1 y menos 1 pero bueno que tenemos la versión kung fu la versión kung fu es una única llamada a cycle que es lo que

hace cycle cycle lo que hace es devolvernos un iterador lo que no hacen una vez más nos guarda una copia de todos los valores que hemos visto y una vez que no quedan más valores que devolver ya lo que va haciendo es dar vueltas sin fin sobre lo que le dimos es decir no es

una una novia por ejemplo aquí si estamos dan ciclando sobre las vocales vamos a recorrernos todas las vocales y una vez que llegamos a la última pues empezar otra vez por la primera ad infinitum como esto es un generador infinito para no morir lo que hice fue utilizar para solamente imprimir 10 y vemos que efectivamente damos un par de vueltas

por supuesto hemos dicho devuelve una copia por ejemplo aquí aunque estamos haciendo el cycle sobre un generador por comprensión que cuando llegue al final ya no va a tener más valores vemos que aunque las llamadas a las llamadas a ese generador no funcionan ya no dan un stop iteration porque ya no queda nada cycle aguarda una copia con lo cual podemos seguir no tenemos que preocuparnos porque pasaba con el argumento de entrada que

y ahora la cosa es como estaríamos sobre dos o más iterables digamos que estamos jugando a carvald space program y queremos así hacer una cuenta muy rara de lanzamiento queremos ir hasta 10 perdón que sí queremos ir hasta 10 y luego bajamos pero luego realmente no llegamos a despegar nunca y volvemos otra vez a 10 queremos ir de uno a 10 y de 10

vuelvo a bajar hasta uno y subo y estamos haciendo esto voy a pasárselo a cycle verdad pero resulta que no funciona porque cycle solamente acepta un iterable de hecho por la pregunta la podemos reformular cómo iteramos sobre dos iterables tenemos que encadenar dos bucles por tengo un 2 3 y todas las vocales quiero imprimirlo todo por pantalla como lo hago dos bucles por resulta que tenemos chain lo que hace devolvernos un

iterable que nos va devolviendo cositas a cada llamada del primer iterable una vez que no quede nada en el primer iterable se moverá el segundo etcétera con lo cual estamos efectivamente encadenando todos los iterables y así podemos simplemente con única llamada un único bloque por podemos recorrernos recorrernos todo regresando el ejemplo

que teníamos si generamos las dos secuencias de número de 1 a 10 y luego hacia arriba y hacia abajo podemos simplemente encadenarlas y si se lo pasamos eso y así que a un iterador como argumento a cycle pues funciona y podríamos generar infinitamente esos números y ya lo

si tiramos dos dados de 6 caras cuántas combinaciones hay pues el producto cartesiano me acuerdo del instituto eso es un bucle por anidado me recorro para generar son todas las parejas de baile una fiesta verdad pues dos bucles por complejidad cuadrática me voy a recorrer la primera serie me voy a recorrer la segunda y lo combino todo y te dice muy bien

si son tres dados y tú dices tres bucles por y resulta que eso generalizar los muy feos y si son en dados que no sabes cuántos van a ser no sé hacerlo de hecho se puede hacer con recursividad que lo que tenemos que hacer es que para cada elemento tenemos que generar

recursivamente todos los subproductos y lo vamos encadenando todo en un monstruo la versión iterativa es bueno yo me decante por la por decir es muy feo implementar esto esta es la solución sencilla pero bueno pero al menos funciona es decir si tiro por ejemplo aquí tenemos tres dados y entonces pues veo que específicamente si le digo que

se tiren dado dado dado que son tres listas de 16 pues funciona pero es que resulta que tenemos product en either tools podemos es un iterador que nos va a devolver el producto cartesiano de todos los argumentos de entrada si queremos calcular el producto con nosotros mismos lo que hacemos es simplemente utilizar repeat por ejemplo aquí 1 y 2 o en

lo que hace es efectivamente calcular el producto de las cuatro combinaciones que tenemos 1 a 1 b 2 a 2 b no tenemos que repetir el argumento de entrada si son el mismo si queremos tirar

solamente dos dados pues lo que le digo es muy bien pues entonces utilizo repeat 2 y entonces efectivamente estamos tirando dos dados no hay que ni siquiera tenemos que repetir una pregunta tonta pero es fácil ahora que sabemos un montón de ater tools si tenemos cuatro dados de seis caras cuántas combinaciones hay en las cuales nos salen un 5 sumando todas sus caras

pues bueno pues vamos a tirar primero cuatro dados utilizando el producto cartesiano y vamos a hacer un filter para coger solamente aquellos que cumplen una aquella combinación como no son combinaciones no son combinaciones aquellos resultados vamos a coger aquellos resultados en los cuales la salida la suma con una función landa exactamente el valor que

queremos que es 5 y bueno pues la única combinación que tiene la única forma que hay de que no salga un 5 y si tenemos un 2 en uno de los dados y un 3 en un uno en los otros tres como último ejemplo pongamos que estamos trabajando con pixels tenemos un montón de pixels en nuestra pantalla y queremos hacer algo con ellos entonces muy bien quiero que quiera encapsular el concepto de pixel que hago pues voy a crear mi

pixel y tengo mi constructor en init donde guardo filas y columnas y luego como quiero poder imprimirlo por pantalla utilizo un rep y entonces ya puedo verlo por pantalla esto es muy habitual y a cosas que tener esto es un caso de libro en el cual podemos utilizar una námez tuple del módulo collections una tupla con nombre porque esto de aquí antes

es mucho trabajo redundante es muy tonto porque lo único que estamos haciendo en el guardar valores es decir además con el mismo nombre x lo guardo en x y lo guardo en y y es un poquito aburrido porque podemos simplificarlo un montón el trabajo ya está hecho si utilizamos una námez tuple que podemos utilizar siempre y cuando sirva sé que nuestra clase si no

necesitamos que nuestra clase sea mutable podemos despacharlo con una námez tuple porque nos da init nos da rep y otras cuantas cosas es decir aquí puedo crear una tupla nombrada módulo collections siempre nos salva y podemos decir muy bien voy a crear una nueva tupla nombrada que es una subclase de tupla que se llama pixel y que tiene dos atributos tiene dos

dos miembros tiene filas y columnas y eso ya nos devuelve pixel el de la izquierda que es un objeto que es la nueva clase que podemos utilizar para instanciar nuevos objetos y lo tenemos ya hecho por nosotros si queremos añadir un método podemos utilizar herencia hago lo que hemos hecho antes pero en vez de terminar pongo dos puntitos y entonces puedo añadir

mis propios métodos vía herencia por ejemplo aquí para calcular la distancia euclídea entre y ahora lo que yo quería hacer con mi muchos písele era calcular todos los vecinos a decir tengo un písel pero me voy a tener que bueno y quiero un método que me vuelva su ocho vecinos porque me puedo mover hacia arriba arriba abajo hacia los lados y en las cuatro esquinas entonces

cómo luego bueno pues la primera y el primer intento puede utilizar un generador eso sí pero y digo muy bien pues voy a crear yo a mano todos los vecinos pero esto es un montón de trabajo para tan poquito para tan poquita funcionalidad porque lo que podemos hacer en vez de pensar en términos de instanciar nosotros manualmente cada uno de los objetos porque no creamos los objetos en un bucle for utilizando desplazamientos en vez de nosotros

pensar en que tenemos que añadir lo que voy a hacer es calcular el producto cartesiano de los desplazamientos posibles porque en todo momento solamente me va a ver o menos uno o nada o uno en cada uno de los dos ejes utilizo mi repit 2 tengo que tener en cuenta que hay una combinación que es cero cero en la cual no me estoy moviendo y sería devolver el

mismo písel con lo cual ese caso lo ignoro y es muy fácil ventaja añadida si algún día nos movemos a una pantalla de ordenador tridimensional creo que eso no tiene sentido podríamos podríamos calcular cambiar simplemente el repit poner un 3 y podríamos calcular desplazamiento en un también en z para puntos extra no escribimos

a mano el porque aquí estamos diciendo créame un nuevo objeto de la clase pixel cuando hacemos el yield eso tiene el inconveniente aunque sea pequeñito de que estamos escribiendo de nuevo el nombre de la clase con lo cual si algún día renombramos la clase tendríamos que ir allí cambiarlo también podemos utilizar type y si en la primera línea de la función decimos type de self que no puede volver eso no puede

volver a la clase de la clase en la que estamos exactamente y podemos utilizar esa variable que aquí he llamado cls para instanciar los nuevos objetos pero esto para punto extra simplemente para despedirme quería decir que hemos visto un montón de material

un montón pero realmente en el fondo solamente hemos rascado la superficie porque tiene un montón de cosas y podríamos seguir en la documentación hay una parte de recetas y hay infinito ejemplos los cuales nos simplifica un montón en la existencia y lo último es que

todos los bloquecitos que nos da y ter tools realmente están inspirados en lenguajes como haskell de hecho todos los ejemplos de las transparencias tienen un paralelismo directo con en este caso aquí haskell con lo cual estábamos aprendiendo y ter tools estamos en la palla estamos en la euro python pero realmente lo que estábamos

aprendiendo era programación funcional que es básicamente otro paradigma distinto al que quizás cuando empezamos estamos acostumbrados así que la reflexión que un poco tonta es si no habéis echado un ojo a la programación funcional porque asusta un montón se mete la

wikipedia y la definición de las mónadas la vuelve a leer y acaba cerrando el navegador porque no lo entiende entonces intimida un poco pero es un es algo así como que abre un momento un poquito los ojos y entonces hay muchos problemas que eran súper difíciles y que resulta que ahora con group by que lo que la gente de haskell lleva haciendo décadas eran

una única línea y parece que mucho más listo de lo que era realmente así que bueno quizá merezca la pena y muchas gracias si hay alguna pregunta creo que nos queda un poquito de tiempo gracias victor lamento la confusión en cuanto al tiempo no no pero la culpa

fue mía gracias por tu comprensión alguien desea ser una pregunta tenemos por allí que miedo me da esto ahora siempre no sé no sé nada solo por curiosidad si si filtres lo que antes conocemos como hay filter sí porque es la es no es lo que antes conocemos

como es la es perdón la última frase porque filter filter antes era y filter está en el módulo aiter tools y porque es la es no es lo que o sea porque no existe un o sea porque porque a ver porque en la antigüedad filter hacía no era lazy no era vago filter lo evaluaba

todo de golpe entonces como hacía falta una versión que no hiciera esa esa cosa pues entonces en el módulo aiter tools se añadió pero cuando los primigenios hace ya miles de años abandonaron el viejo mundo decidieron que filter ya iba a portarse bien todo tu vida has conocido filter como debe ser pero filter antes era feo entonces ahora filter funciona

de forma igual que cip y porque es la is no porque es la es y llamándose vale pero porque es una buena pregunta que en cuanto baje de aquí será súper tonta las colas respuestas no porque vamos a ver porque porque es la y las slides funcionan con secuencias donde esa otra cosa del glossario las secuencias son todas las cosas que podemos

acceder aleatoriamente uno de sus miembros si soporta es el get item es decir si yo puedo decir dame el cuarto elemento en python haré una secuencia como una cadena de texto o una secuencia o una lista o etcétera entonces para que funcionará tú te refieres a que por qué no está funcionando de forma vaga y slice perdona la notación con los corchetitos

porque no siempre nos sirve eso porque porque la pega que tiene y slice es que no es si tú con slice le dices dame el elemento 100 mil millones el pobre slice tiene que es decir empieza por ahí tú le dices empieza a contar a partir del 100 mil millones el pobre slice tiene que recorrerse uno a uno todos los demás porque no tiene acceso aleatorio tiene

acceso tiene acceso secuencial entonces podríamos si cambiáramos la notación con los corchetitos para hacer eso tendría un no tendría no sería instantáneo como si lo es trabajar ahora con los corchetes cuando queremos por ejemplo tener una sublista no sé si me ha explicado

perfecto ahora es alguien más había muchos casos los cuales sería un desastre en términos de acceder porque tendría que recorrerse todo tengo una duda entiendo que convertir una lista un generador una lista no es gratis cuál es el coste de eso bueno que

tenemos que ver tenemos que recorrer todos los elementos tenemos que almacenar la memoria con lo cual el caso que lo digo mucho pero que no ocurre nunca que tengan muchos números y luego dejando de lado el consumo de memoria extra que podría ser un problema bueno hay un detalle secundario que si lo convierte a lista obviamente el generador solamente es de un solo uso es un camino solamente se puede recorrer una vez que

hay una pega cuando la gente quiere por ejemplo pasa con los casos de group by que la gente dice quiero ver cuántos elementos hay en el grupo y dice muy bien pues lo convierto lista y llamo alén pero si eso no lo guarda en una variable ya te ha agotado el grupo porque el grupo se va a tener que hacer algo en ese grupo si queremos ver el número de elementos en un generador y hacemos el truquito de llamo a sum pierdo los

pierdo los valores con lo cual tengo que guardarlos si los necesito la única pega es que tienes que guardar la memoria y otra pregunta el grupo cuando haces por ejemplo el de la comprensión del string si ganas con grupo y o que ganas con una expresión regular aparte del dolor de escribir la expresión regular que si ganas en coste

no tengo seguramente ni idea pero me gusta me gustan las cosas me gusta mucho hay gente que la odia me gusta mucho las expresiones regulares pero no no sé qué sería más rápido creo que sería más legible si lo puede hacer con group by porque era agrupa por longitud pero

no lo sé gracias hay la última pregunta para dejarme mal lleva seis meses pensándola pero muchas gracias gracias victor por esta interesante ponencia