Python en español

Python en español #14: Tertulia 2021-01-05


Listen Later

Detalles internos de rendimiento de Python y exabruptos sobre asyncio https://podcast.jcea.es/python/14

Participantes:

  • Jesús Cea, email: [email protected], twitter:

    @jcea, https://blog.jcea.es/,
    https://www.jcea.es/. Conectando desde Madrid.

  • Eduardo Castro, email:

    [email protected]. Conectando desde A
    Guarda.

  • Javier, conectando desde Madrid.

  • Víctor Ramírez, twitter: @virako,

    programador python y amante de vim, conectando desde Huelva.

  • Juan Carlos, conectando desde Bilbao.

    Audio editado por Pablo Gómez, twitter:

    @julebek.

    La música de la entrada y la salida es "Lightning Bugs", de Jason

    Shaw. Publicada en https://audionautix.com/ con licencia
    - Creative Commons Attribution 4.0 International
    License.

    • [01:32] Nuevas versiones: Python 3.10a4 y Numpy.

    • [01:57] Don’t Use Recursion In Python Any More,Python Closure —

      A Pythonic technique you must know

      • Don’t Use Recursion In Python Any More,Python Closure — A

        Pythonic technique you must know:
        https://towardsdatascience.com/dont-use-recursion-in-python-any-more-918aad95094c.

      • Hilo en la lista de correo de Python Madrid:

        https://lists.es.python.org/pipermail/madrid/2021-January/004838.html.

      • Closure:

        https://es.wikipedia.org/wiki/Clausura_(inform%C3%A1tica).

      • Mixin: https://es.wikipedia.org/wiki/Mixin.

      • [10:02] ¿Qué es ser "Pythónico"?

        • Twisted daña el cerebro: https://twistedmatrix.com/trac/.

        • unittest: https://docs.python.org/3/library/unittest.html.

        • Black: https://pypi.org/project/black/.

        • from __future__ import braces.

        • [14:52] Python Ideas:

          • https://mail.python.org/mailman3/lists/python-ideas.python.org/.
          • [16:52] ¿Comillas simples o comillas dobles? ' o ".

            • Diferencias semánticas con otros lenguajes como C.
            • [23:07] Tamaño de columnas: ¿80?, ¿120?, ¿132?

            • [31:02] Primar la legibilidad, no el rendimiento.

              • Cuando tienes if ... else ..., ¿Qué caso pones primero?,

                ¿el corto o el largo? ¿Primero la condición normal?

              • Microoptimizaciones que complican la legibilidad sin

                ganancia de rendimiento que importe en realidad.

              • [41:57] En las variables locales, la longitud del nombre de una

                variable no impacta en el rendimiento.

              • [43:02] Curiosear el "bytecode"

                https://es.wikipedia.org/wiki/Bytecode que genera Python.

                • Dispositivo de Duff:

                  https://es.wikipedia.org/wiki/Dispositivo_de_Duff.

                • El "bytecode" https://es.wikipedia.org/wiki/Bytecode que

                  genera Python no está nada optimizado. Es mejorable.

                • [46:22] Bytecode generado para a + a:

                  >>> dis.dis(lambda a: a + a)
                  1 0 LOAD_FAST 0 (a)
                  2 LOAD_FAST 0 (a)
                  4 BINARY_ADD
                  6 RETURN_VALUE
                  • ¡Guardas!

                  • Sí se hacen algunas optimizaciones simples:

                    >>> dis.dis(lambda : 5 + 3)
                    1 0 LOAD_CONST 1 (8)
                    2 RETURN_VALUE
                  • [50:12] Python deja su pila de evaluación vacía al terminar de

                    calcular una expresión.

                    • Máquina virtual de registros en vez de máquina virtual

                      orientada a pila.

                      • El compilador debe ser más sofisticado, pero puede
                      • reutilizar valores.
                      • Muchas operaciones redundantes:

                        >>> import dis
                        >>> def suma(valores):
                        ... s=0
                        ... for i in valores:
                        ... s+=i
                        ... return s
                        ...
                        >>> dis.dis(suma)
                        2 0 LOAD_CONST 1 (0)
                        2 STORE_FAST 1 (s)
                        3 4 LOAD_FAST 0 (valores)
                        6 GET_ITER
                        >> 8 FOR_ITER 12 (to 22)
                        10 STORE_FAST 2 (i)
                        4 12 LOAD_FAST 1 (s)
                        14 LOAD_FAST 2 (i)
                        16 INPLACE_ADD
                        18 STORE_FAST 1 (s)
                        20 JUMP_ABSOLUTE 8
                        5 >> 22 LOAD_FAST 1 (s)
                        24 RETURN_VALUE
                      • ¿Qué ocurre a la hora de depurar o para gestionar

                        excepciones?

                      • [56:32] Que un hilo modifique variables de otro hilo.

                        • ¡Guardas!

                        • NOTA DESDE EL FUTURO:

                          • Python 3.9.5:

                            https://docs.python.org/release/3.9.5/whatsnew/changelog.html.

                          • Traceback objects allow accessing frame objects without

                            triggering audit hooks:
                            https://bugs.python.org/issue42800.

                          • [58:37] Pensábais que las interioridades del intérprete de

                            Python son aburridas, pero no...

                            • La complejidad debe estar en tu programa, no en el lenguaje

                              o el intérprete.

                            • Compiladores optimizadores. Python se está quedando atrás.

                            • Hacer caché al buscar atributos:

                              • Issue1616125: Cached globals+builtins lookup optimization:

                                https://bugs.python.org/issue1616125.

                              • issue43452: Microoptimize PyType_Lookup for cache hits

                                https://bugs.python.org/issue43452.

                              • Detectar cambios en un diccionario, incluyendo

                                diccionarios internos como locals o __builtins__:
                                PEP 509 Add a private version to dict:
                                https://www.python.org/dev/peps/pep-0509/.

                              • [01:06:52] Huevos de pascua en Python:

                                • from __future__ import braces.

                                • import antigravity.

                                • import this.

                                • import __hello__.

                                • [01:08:27] Usar pass o ... (ellipsis).

                                  • Ellipsis:
                                  • https://docs.python.org/3/library/constants.html#Ellipsis
                                    y
                                    https://docs.python.org/3/library/stdtypes.html?highlight=ellipsis#the-ellipsis-object.
                                  • [01:09:22] El PEP 509 no es para hacer diccionarios inmutables.

                                    • Es algo interno para el API de C. No está accesible desde

                                      Python.

                                    • Cambios pequeños pueden abrir posibilidades interesantes.

                                      ¡Guardas!.

                                    • [01:13:07] Curiosidades encontradas esta semana:

                                      • traceback.clear_frames(tb):

                                        https://docs.python.org/3/library/traceback.html#traceback.clear_frames.

                                      • inspect: https://docs.python.org/3/library/inspect.html.

                                      • Manipular frame.back.

                                      • Que una función sepa si se le está llamando de una forma

                                        síncrona o asíncrona.

                                      • [01:17:02] Los problemas filosóficos que tiene Jesús Cea con

                                        la programación asíncrona tal y como está implementada en Python.

                                        • Una biblioteca debe decidir si es síncrona o asíncrona y

                                          "contamina" todo tu código.

                                        • Hacer corrutinas "de verdad":

                                          https://es.wikipedia.org/wiki/Corrutina.

                                        • Persistencia y programación asíncrona.

                                        • Concepto de "awaitable":

                                          https://docs.python.org/3/library/asyncio-task.html#awaitables.

                                        • future.result():

                                          https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future.result.

                                        • [01:32:17] Es difícil plantear temas tan esotéricos sin una

                                          preparación formal de la charla o sin avisar con tiempo para
                                          que la gente se lo pueda ver con calma antes.

                                        • [01:33:32] Problemas con el control de carga de asyncio

                                          https://docs.python.org/3/library/asyncio.html.

                                          • Vuelve a tratarse el tema de si la biblioteca estándar debe

                                            crecer o adelgazar.

                                          • Según Jesús Cea, asyncio

                                            https://docs.python.org/3/library/asyncio.html es la peor
                                            opción.

                                          • Alternativas a asyncio:

                                            • Curio: https://curio.readthedocs.io/en/latest/.

                                            • Trio: https://trio.readthedocs.io/en/stable/.

                                              Monkey patching:
                                              https://en.wikipedia.org/wiki/Monkey_patch.

                                            • La dificultad de luchar con una biblioteca que está incluída

                                              en la biblioteca estándar.

                                            • [01:42:32] La programación asíncrona es útil para muchas más

                                              cosas además de para gestionar peticiones de la red.

                                              • Por ejemplo, operaciones de ficheros locales. Aprovechar
                                              • tanto que el disco sea lento como para lanzar operaciones
                                                concurrentes a discos duros.
                                              • [01:44:12] Mejor usar concurrent.futures

                                                https://docs.python.org/3/library/concurrent.futures.html que
                                                threading https://docs.python.org/3/library/threading.html
                                                directamente.

                                                • Transportar excepciones entre hilos.

                                                • Control de carga y paralelismo.

                                                • [01:45:42] Referencia al bug solucionado en la tertulia

                                                  anterior: Issue35930: Raising an exception raised in a "future"
                                                  instance will create reference cycles
                                                  https://bugs.python.org/issue35930.

                                                  • Queda por ultimar el detalle de cómo solucionar el problema

                                                    exactamente y enviar el parche para que se integre
                                                    oficialmente en Python.

                                                  • Jesús Cea describe las dos opciones que está barajando:

                                                    weakrefs https://docs.python.org/3/library/weakref.html o
                                                    try ... finally.

                                                  • [01:50:57] Ya hubo "flames" brutales con Guido cuando se

                                                    introdujo el operador ternario en Python.

                                                  • [01:55:02] Despedida.

                                                  • [01:55:50] Final.

                                                    ...more
                                                    View all episodesView all episodes
                                                    Download on the App Store

                                                    Python en españolBy Jesús Cea


                                                    More shows like Python en español

                                                    View all
                                                    Libros para Emprendedores by Luis Ramos

                                                    Libros para Emprendedores

                                                    1,115 Listeners