Python en español

Python en español #18: Tertulia 2021-02-02


Listen Later

Anotaciones de tipos: ¿Son pythónicas? También versiones de paquetes y grafos de dependencias https://podcast.jcea.es/python/18

En este audio hay un hablante que no identifico. ¿Quien es?. Es

quien habla, por ejemplo, en 01:06:00 o en 01:12:00. ¿Antoni?

Participantes:

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

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

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

    programador python y amante de
    vim, conectando desde Huelva.

  • Dani, conectando desde Málaga.

  • Eduardo Castro, email:

    [email protected]. Conectando desde A
    Guarda.

    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.

    • [00:52] Preámbulo.

      • Design of CPython’s Garbage Collector:

        https://devguide.python.org/garbage_collector/.

      • Dificultades con el horario de la tertulia.

        • Podría haber más tertulias en otros horarios, llevadas
        • por otras personas.
        • Problemas para publicar los audios.

          • Editar es un infierno.

          • Las notas de los audios tienen una importancia

            transcendental.

          • Dinámica de las tertulias.

            • Antiguo podcast "Python en español":
            • https://podcast.jcea.es/python/.
            • [08:32] Presentaciones.

              • Raspberry Pi Pico:

                https://www.raspberrypi.org/products/raspberry-pi-pico/.

              • Micropython: https://www.micropython.org/.

              • [13:32] El aviso legal para poder grabar los audios.

              • [14:32] Bugs sobre "pickle"

                https://docs.python.org/3/library/pickle.html en el módulo
                __main__.

                Se trata de un problema conocido.

                • Ejemplo de código: https://pastebin.com/vGM1sh8r.

                • Issue24676: Error in pickle using cProfile

                  https://bugs.python.org/issue24676.

                • Issue9914: trace/profile conflict with the use of

                  sys.modules[__name__] https://bugs.python.org/issue9914.

                • Issue9325: Add an option to pdb/trace/profile to run library

                  module as a script https://bugs.python.org/issue9325.

                • [16:27] Lo importante que es abrir bugs, para que puedan

                  solucionarse. Queja productiva.

                • [18:12] Nueva versión de MYPY http://mypy-lang.org/ y MYPYC

                  https://github.com/mypyc/mypyc, que aprovechan Python 3.9.

                  Sigue fallando mucho.

                • [20:42] pyannotate https://pypi.org/project/pyannotate/ para

                  meter anotaciones de tipos de forma automática.

                  • Las dificultades de meter tipos en un proyecto ya maduro.
                  • [22:52] Puedes usar tipos o no. Son opcionales. Ventajas en

                    equipos grandes.

                    • Linter: https://es.wikipedia.org/wiki/Lint.

                    • Impone disciplina y una cultura.

                    • Las anotaciones de tipos no se verifican en tiempo de

                      ejecución. Se usan en el sistema de test e integración
                      continua.

                    • Una de la ventaja de los "__slots__" es que si te

                      equivocas en el nombre de atributo en una asignación, te
                      dará un error claro. Los tipos ayudan aquí también.

                    • "pyannotate" https://pypi.org/project/pyannotate/.

                    • Las anotaciones de tipos te permiten luego compilar Python

                      para ganar rendimiento "sin coste".

                    • Las anotaciones se pueden meter en el mismo código o en un

                      fichero "compañero".

                      • Usar un fichero "compañero" es útil para poder usar

                        anotaciones modernas en versiones antiguas de Python.

                      • Evitar "contaminar" el sistema de control de versiones

                        con cambios masivos irrelevantes que ofuscan la historia
                        de un proyecto. Por ejemplo, el autor original del código.

                      • Que los creadores de código y los etiquetadores de tipos

                        sean personas diferentes.

                      • "typeshed": Collection of library stubs for Python, with

                        static types: https://github.com/python/typeshed.

                      • ¿Y meter tipos en los comentarios, como se hacía

                        antiguamente?

                      • Hay mucha literatura de ingeniería de software sobre si es

                        bueno documentar tipos o no, según el tipo de equipo y el
                        tipo de proyecto.

                      • [40:17] Python podría ser mucho más rápido aunque no se usen

                        tipos. Podría ser mucho más inteligente.

                        • Descubrimiento de tipos en tiempo de ejecución.

                        • Tema recurrente.

                        • Numba: https://numba.pydata.org/.

                        • Javascript V8:

                          https://en.wikipedia.org/wiki/V8_(JavaScript_engine).

                        • [43:06] Habiendo tantos compiladores, ¿por qué no se integra

                          alguno en el intérprete normal de Python?

                          • Complejidad y compatibilidad.

                          • Faltan manos.

                          • Hay muchos "gérmenes" que no germinan.

                          • Dispersión de esfuerzos.

                          • [46:12] Puntos de dolor de Python para la gente que viene de

                            otros lenguajes:

                            • Tipos.

                            • Velocidad.

                            • Espacios significantes.

                            • [46:37] ¿Qué es "Python"?

                              • Cada novedad de sintaxis de Python cambia el lenguaje. ¿Qué

                                es Python?

                                • Problemas para los que llegan nuevos al lenguaje.
                                • Hay organizaciones grandes que un lenguaje sin tipos ni

                                  siquiera lo consideran.

                                • [51:22] Cultura común en todos los proyectos Python. Baja

                                  barrera de entrada si conoces esa cultura.

                                • La cultura va evolucionando.

                                • Solución de compromiso: Meter tipos solo en la frontera.

                                • [53:02] El tipado avanzado de Python 3.9 da un error de sintaxis

                                  al importar el código en una versión anterior de Python.

                                • [54:46] El operador morsa no se puede usar dentro de un "list

                                  comprehension":

                                  >>> [i for i in ('a', '' ,'b') if i := i.strip()]
                                  File "", line 1
                                  [i for i in ('a', '' ,'b') if i := i.strip()]
                                  ^
                                  SyntaxError: invalid syntax

                                  No queda otra que escribirlo como:

                                  >>> [i.strip() for i in ('a', '' ,'b') if i.strip()]
                                  ['a', 'b']

                                  duplicando el i.strip().

                                • [56:40] En versiones de Python anteriores a 3.8 no se podría

                                  usar un continue en un finally. El texto era
                                  https://docs.python.org/3.7/reference/compound_stmts.html#the-try-statement:

                                  When a return, break or continue statement is executed in

                                  the try suite of a try...finally statement, the finally clause
                                  is also executed ‘on the way out.’ A continue statement is
                                  illegal in the finally clause. (The reason is a problem with
                                  the current implementation — this restriction may be lifted in
                                  the future).

                                  • Eso se solucionó en Issue32489: Allow 'continue' in
                                  • 'finally' clause: https://bugs.python.org/issue32489.
                                  • [57:47] f-string con datetime

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

                                    • Ya está en los propios ejemplos de PEP 498: Literal String
                                    • Interpolation: https://www.python.org/dev/peps/pep-0498/.
                                    • [59:22] Modo depuración en f-strings en Python 3.8:

                                      >>> a = 5
                                      >>> f'{a=}'
                                      'a=5'

                                      Útil para el loging.

                                    • [01:00:47] Versiones fijas de dependencias y actualizar un

                                      despliegue.

                                      • Herramientas para esto: "pip"

                                        https://pypi.org/project/pip/, "virtualenv"
                                        https://pypi.org/project/virtualenv/.

                                      • "pipenv" https://pypi.org/project/pipenv/.

                                      • "Poetry": https://pypi.org/project/poetry/.

                                      • Grafo de dependencias "pip-tree": https://pypi.org/project/pip-tree/.

                                      • Paralelismos con el enlazado estático y dinámico.

                                      • [01:14:22] ¿Por qué se ha instalado este paquete, qué paquetes

                                        exige y qué paquetes dependen de él?

                                        • pip show.

                                        • Grafo de dependencias "pip-tree": https://pypi.org/project/pip-tree/.

                                        • [01:19:22] Visualizar el grafo de versiones de un sistema de

                                          control de versiones moderno. Por ejemplo con Mercurial: "hg
                                          glog" https://www.mercurial-scm.org/.

                                        • [01:23:07] Recogida de basuras:

                                          • Design of CPython’s Garbage Collector:

                                            https://devguide.python.org/garbage_collector/.

                                          • Hora de sacar la basura garbage collector - Pablo Galindo y

                                            Victor Terrón - PyConES 2018
                                            https://www.youtube.com/watch?v=G9wOSExzs5g.

                                          • La recolección de basura de la generación más antigua

                                            funciona de forma diferente. En vez de ser por un número
                                            fijo de desequilibrio entre creación y destrucción de
                                            objetos, funciona por porcentaje.

                                          • [01:31:37] Divagación: Powerball https://powerball.org.uk/.

                                          • [01:31:52] Explicación de cómo funciona "__slots__"

                                            https://docs.python.org/3/reference/datamodel.html.

                                          • [01:34:22] Libro "CPython Internals":

                                            https://realpython.com/products/cpython-internals-book/.

                                            • Website de "Real Python": https://realpython.com/. Merece

                                              bastante la pena.

                                            • También tienen podcast: "The Real Python Podcast: Python

                                              Tips, Interviews, and More"
                                              https://realpython.com/podcasts/rpp/.

                                            • [01:36:42] Más sobre "__slots__"

                                              https://docs.python.org/3/reference/datamodel.html.

                                              • Técnica estándar.

                                              • Un diccionario vacío ocupa 64 bytes: sys.getsizeof({}).

                                              • Se puede usar para evitar errores mecanográficos al escribir

                                                en atributos.

                                              • [01:38:52] "AutoScraper: A Smart, Automatic, Fast and

                                                Lightweight Web Scraper for Python"
                                                https://pypi.org/project/autoscraper/. Búsquedas "borrosas".

                                                • Seguimos sin encontrar la biblioteca de scraping de foros de
                                                • la que ha hablado Eduardo en tertulias anteriores.
                                                • [01:43:02] Librería para dibujar grafos: graphviz

                                                  https://pypi.org/project/graphviz/.

                                                  • Le das un texto describiendo nodos y conexiones entre nodos

                                                    y calcula un gráfico.

                                                  • Sería trivial para dibujar el grafo de dependencias de

                                                    "pip".

                                                  • Ejemplo:

                                                    • El gráfico de antes, con ciclos:

                                                      https://lists.es.python.org/pipermail/general/attachments/20201229/0c14bc58/attachment-0002.png.

                                                    • El gráfico de después, sin ciclos:

                                                      https://lists.es.python.org/pipermail/general/attachments/20201229/0c14bc58/attachment-0003.png.

                                                    • [01:47:22] ¿Cómo asegurarse que el nombre de un fichero no tenga

                                                      caracteres extraños? ¡Problema de seguridad!

                                                      • Expresiones regulares. Cuidado con el unicode

                                                        https://en.wikipedia.org/wiki/Unicode. Mejor usar una
                                                        lista blanca que una lista negra.

                                                      • Usar pathlib.is_relative_to()

                                                        https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.is_relative_to.
                                                        Novedad en Python 3.9.

                                                      • [01:52:07] ¡Usa la versión actual de Python, leches! Ahora

                                                        mismo, Python 3.9.

                                                        • Ventajas de compilar el intérprete desde código fuente para

                                                          no depender de la versión que te proporciona el sistema
                                                          operativo.

                                                        • Puedes tener tu propio intérprete de Python dentro de un

                                                          "virtualenv" https://pypi.org/project/virtualenv/.

                                                        • Proyectos "llave en mano". El cliente quiere algo que se

                                                          instale como un componente en lo que ya conoce. Por ejemplo,
                                                          en un panel de configuración en un servicio de hospedaje.

                                                        • [01:56:47] Jesús Cea repite una vez más la anécdota de que

                                                          al principio de los tiempos para conducir un coche tenías
                                                          que ser mecánico, pero ya no.

                                                          Falta toda la base, pero... ¿Hace falta?

                                                        • [01:59:12] Memoria escasa en un microcontrolador.

                                                        • [01:59:55] 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