Python en español

Python en español

By Jesús CeaTechnology
Download on the App Store

Python en español episodes

  • Python en español #9: Tertulia 2020-12-01
    Persistencia de datos en Python https://podcast.jcea.es/python/9

    Escucharme (Jesús Cea) es agotador.

    ¡Persistencia!

    Participantes:

    • Eduardo Castro [email protected].

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

      @jcea, https://blog.jcea.es/,
      https://www.jcea.es/.

    • Sergio, desde Moaña.

    • Adrián, desde Vigo.

    • Juan Carlos, desde Bilbao.

    • Javier, desde Madrid.

      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] Amplia comunidad tecnológica en Vigo.

      • [05:22] Contexto y estilo de las tertulias.

      • [08:52] Proyectos importantes e interesantes que pasan

        desapercibidos.

        • Apache Airflow: https://airflow.apache.org/.

        • Tryton: https://www.tryton.org/.

          El mundo es muy grande...

        • [12:52] Antes de empezar un proyecto nuevo hay que investigar el

          estado del ecosistema.

        • [14:12] La mayoría de las charlas Python se centran en librerías

          concretas.

          A mí me interesa el lenguaje concreto o técnicas útiles para

          cualquier programador Python.

        • [16:37] ¿Compatibilidad hacia atrás? Poner límites a la

          compatibilidad, por salud mental.

          La compatibilidad hacia atrás te limita a la hora de adoptar

          novedades en el lenguaje o hacer limpieza en el código.

          Soportar solo las versiones soportadas de Python.

        • [23:22] ¿Qué pasa si la versión nueva de la librería solo funciona

          en Python 3 pero la está instalando en Python 2?

          PIP no permite imprimir nada en pantalla, a menos que sea un error.

          Las versiones modernas de PIP permiten especificar la compatibilidad con versiones de Python.

        • [27:52] Interfaces de usuario en Python.

          • wxWidgets: https://wxwidgets.org/.

          • Kivi: https://kivy.org/.

          • Usar directamente HTML/JS/CSS con un microservidor en

            127.0.0.1. Una ventaja adicional es que permite el acceso
            remoto.

          • [31:40] Compilar y distribuir módulos binarios Python para MS

            Windows.

            ¿Por qué nadie ha sacado un generador de instaladores

            mutiplataforma? Poder generar un instalador para MS Windows desde
            Linux?

            ¿Algún servicio al que mandas código fuente y te devuelva una

            versión compilada para MS Windows?

          • [38:32] ¡Persistencia!

            Persistencia de objetos nativos de Python comparado con los

            ORM. Adaptación de impedancias entre lenguajes: Python/SQL.

            • ZODB: http://www.zodb.org/en/latest/.

            • Durus: https://www.mems-exchange.org/software/DurusWorks/.

            • Ecosistemas pequeños.

            • Migración de versiones.

            • [56:22] Nuevo "resolver" de PIP:

              https://pyfound.blogspot.com/2020/11/pip-20-3-new-resolver.html.

            • [01:00:52] Diferencia entre "file.readlines()" y

              "string.splitlines()".

              • CBOR: https://tools.ietf.org/html/rfc7049.

              • JSON no mola.

              • [01:12:07] ¿Ya habeis migrado a Python 3.9? Mejoras.

                ¿Cual es la versión más antigua que estáis usando?. Python 3.6

                es la versión más antigua aún soportado. "Async" pasó a ser una
                palabra reservada.

                Mantener la compatibilidad impide usar las novedades del

                lenguaje, por ejemplo, f-strings o "dataclasses"
                https://docs.python.org/3/library/dataclasses.html.

                Paquete externo "dataclasses" para versiones antiguas de

                Python: https://pypi.org/project/dataclasses/.

              • [01:19:12] Cacheo de números -5..256.

                • En CPython los destructores se invocan inmediatamente.

                • Deuda técnica que hay que pagarla... o no.

                • [01:21:42] Volvemos a persistencia / SQL. Abstracciones.

                  ¿Qué pasa cuando actualizas Python?

                  Actualizaciones de tu programa. Migraciones.

                • [01:34:52] Profundizamos en cómo funciona la persistencia.

                • [01:48:17] Profiling de memoria.

                  • memory-profiler https://pypi.org/project/memory-profiler/.

                  • tracemalloc

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

                  • Algunos trucos para ayudar, por ejemplo, etiquetar las

                    estructura de datos.

                  • Manhole: https://pypi.org/project/manhole/.

                  • Volcar la memoria de un proceso sin matar el proceso: gcore

                    https://www.linux.org/docs/man1/gcore.html.

                  • Top 5 Python Memory Profilers

                    https://stackify.com/top-5-python-memory-profilers/.

                  • [01:59:22] Cierre de la tertulia y administratrivia.

                  • [02:03:37] Arggg, ¡otra vez persistencia! ¡Menudo rollo!

                    • Pyramid https://trypyramid.com/.

                    • ZODB: http://www.zodb.org/en/latest/.

                    • Durus: https://www.mems-exchange.org/software/DurusWorks/.

                      2 hr 9 min
                    • Python en español #8: Tertulia 2020-11-24
                      Doblegando a la culebra https://podcast.jcea.es/python/8

                      Se me oye (Jesús Cea) muy mal y es muy cansado porque hablo mucho

                      y tengo mala calidad de sonido. Lo siento.

                      Se han eliminado las pausas en la edición, así que es bastante

                      cansado oír a Jesús Cea hablar a toda velocidad y sin respirar. Lo
                      haremos mejor la próxima vez.

                      Se oye mucho tecleo.

                      Participantes:

                      • Eduardo Castro, email:

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

                        @jcea, https://blog.jcea.es/,
                        https://www.jcea.es/.

                      • Sara Sáez, twitter:

                        @saruskysaez.

                      • Luis.

                        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:42] API limitado

                          API limitado de Python para asegurar compatibilidad binaria de

                          extensiones en C entre versiones diferentes del intérprete de
                          Python. PEP 384: https://www.python.org/dev/peps/pep-0384/.

                        • [03:42] Por qué empecé a usar Python.

                        • [06:52] Eduardo: Cartas de restaurante con códigos QR: https://www.qrico.eu/.

                        • [10:42] ¿Es mejor que una biblioteca esté en la biblioteca

                          estándar de Python o ser una librería externa?

                          Tema recurrent. Pros y contras.

                        • [18:34] Soporte de Python en MS Windows. Distribución de

                          librerías precompiladas.

                          ¿Cómo compilar una extensión C en MS Windows?

                        • [20:52] Problema de las distribuciones binarias cuando sale una

                          nueva versión de Python.

                          Es una de las motivaciones para usar el API limitado definido en PEP 384: https://www.python.org/dev/peps/pep-0384/.

                        • [23:22] Sistema de notificación de actualizaciones de librerías.

                          Por ejemplo:

                          • https://libraries.io/.
                          • Feed RSS de PYPI: https://pypi.org/rss/updates.xml.
                          • ¿Actualizas a la última versión? Pros y contras.

                          • [28:22] Mejor entrar con vídeo a la tertulia.

                          • [29:12] Debugging de uso de memoria y memory leaks.

                            • Flamegraphs: http://www.brendangregg.com/flamegraphs.html.

                            • Tracemalloc: https://docs.python.org/3/library/tracemalloc.html.

                            • [33:52] Virtualenv, ¿qué usa cada uno? ¿Y en MS Windows?

                            • [35:52] Soporte de Python en MS Windows.

                              La mayor parte del uso de Python es en MS Windows, pero los

                              "core developers" no usar MS Windows. Eso causa problemas de
                              soporte.

                            • [40:52] Guido van Rosum y Microsoft.

                              Guido van Rosum ha empezado a trabajar para Microsoft:

                              https://www.msn.com/en-us/news/technology/python-creator-guido-van-rossum-joins-microsoft/ar-BB1aXmPu.

                            • [44:22] ¿Ya estáis usando Python 3.9?

                              El API limitado se va ampliando versión a versión de Python.

                              PEP 384: https://www.python.org/dev/peps/pep-0384/.

                            • [45:22] Opciones para acelerar la ejecución de código Python.

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

                              • Cython https://cython.org/. Pero una vez que empiezas

                                etiquetar tipos, el código resultante ya no es Python. El
                                futuro es type hinting: PEP 484
                                https://www.python.org/dev/peps/pep-0484/.

                              • Programar una extensión en C nativo.

                              • PyPy https://www.pypy.org/. Ojo con la compatibilidad.

                              • [54:32] Métodos para enlentecer Python :-)

                              • [55:12] Protección de código en Python.

                                • Cython https://cython.org/.
                                • [58:47] Mezclar código C en Python.

                                  • Programar un módulo C.

                                  • CFFI: https://cffi.readthedocs.io/en/latest/.

                                  • [01:01:52] Guido van Rosum y Microsoft (segunda parte)

                                    Volvemos al tema de Guido van Rosum trabajando para Microsoft: https://www.msn.com/en-us/news/technology/python-creator-guido-van-rossum-joins-microsoft/ar-BB1aXmPu.

                                    La polémica del "walrus operator" u "operador morsa".

                                  • [01:05:22] "Operador morsa" o "Walrus operator".

                                    PEP 572 https://www.python.org/dev/peps/pep-0572/.

                                    Tema recurrrente: Python se está complicando cada vez más.

                                    Problema para los novatos.

                                  • [01:14:32] Opciones para acelerar la ejecución de código Python (2).

                                    • Otra forma de acelerar Python: MYPY http://mypy-lang.org/

                                      y MYPYC https://github.com/mypyc/mypyc.

                                    • Type hinting. PEP 484

                                      https://www.python.org/dev/peps/pep-0484/.

                                    • [01:17:42] ¿Python con tipos? Motivación.

                                    • [01:20:52] ¿Quien paga los tests?

                                    • [01:22:37] Los tests como documentación.

                                    • [01:23:32] ¿Qué usais para tests?

                                    • [01:26:22] ¿Qué hace cada uno con Python?

                                      • Hobby, Zope https://zope.readthedocs.io/en/latest/,

                                        imágenes, numpy https://numpy.org/, Jupyter
                                        https://jupyter.org/.

                                      • Persistencia de datos y ORMs.

                                      • Integrar Python dentro de otros proyectos, como en Kodi

                                        https://www.kodi.tv/.

                                      • Django https://www.djangoproject.com/, micropython

                                        http://www.micropython.org/.

                                      • [01:33:12] Colofón y mi motivación para las tertulias.

                                        1 hr 41 min
                                      • Python en español #7: ¡Metapodcast de relanzamiento! (versión corregida)
                                        Relanzamiento del podcast, tertulias semanales y el proceso de producción https://podcast.jcea.es/python/7

                                        Esta sesión es una meta grabación. Es decir, es una grabación en

                                        la que hablamos de cómo grabamos.

                                        Participamos Pablo Gómez, el sufrido editor del audio de las

                                        tertulias y Jesús Cea, el anfitrión habitual.

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

                                          @jcea, https://blog.jcea.es/,
                                          https://www.jcea.es/.

                                        • Pablo Gómez, twitter: @julebek.

                                          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:02] Antecedentes de "Python en español":

                                            https://podcast.jcea.es/python/.

                                            • ¿Por qué hemos reutilizado el podcast?
                                            • [02:05] Nuevas publicaciones: Tertulias semanales.

                                              • Calidad de audio regulera.

                                              • Tertulia abierta a cualquiera.

                                              • Sin temática fija excepto que hay que hablar de Python

                                                https://www.python.org/. Usos prácticos del propio
                                                lenguaje, no hablar de librerías concretas.

                                              • [04:50] ¿Cómo grabamos?

                                              • [05:30] Pablo Gómez explica cómo se editan las tertulias.

                                                • ¿Cuál es su motivación?

                                                • Edición con Ardour https://ardour.org/.

                                                • Cada interlocultor tiene una calidad de audio distinta y nos

                                                  pisamos mucho.

                                                • Ecualización de cada voz por separado.

                                                • Eliminar el máximo de ruido.

                                                • Normalizar el nivel de las voces.

                                                • Recortar trozos inútiles: silencios y segmentos de mala

                                                  calidad.

                                                • Proceso trabajoso y lento.

                                                • Pablo tarda unas cinco horas en procesar un audio de dos

                                                  horas de duración.

                                                • [10:02] Tenemos unas 16 tertulias pendientes de publicar, en el

                                                  momento de grabar este audio.

                                                • [10:23] Pasos finales para publicar:

                                                  • Codificar los audios en MP3

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

                                                  • Actualizar los feed RSS

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

                                                  • Subirlos a una plataforma de podcast

                                                    https://es.wikipedia.org/wiki/Podcasting. Normalmente las
                                                    plataformas de podcast se alimentan automáticamente de los
                                                    feeds RSS.

                                                  • Difusión en redes sociales como Twitter

                                                    https://twitter.com/Python_podCAST.

                                                  • [10:50] Formatos de audio y las comeduras de coco de Jesús.

                                                    • El más conocido es el MP3

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

                                                      Es ubícuo y compatible con todo, pero es el más antiguo,

                                                      el que proporciona peor calidad y el más limitado en
                                                      opciones avanzadas.

                                                      • No todos los reproductores soportar bien todo lo que

                                                        puede ofrecer MP3.

                                                        • Explicación entre la diferencia entre CBR

                                                          https://es.wikipedia.org/wiki/Tasa_de_bits_constante
                                                          y VBR https://es.wikipedia.org/wiki/VBR.

                                                        • Impacto de esa diferencia al moverte adelante y

                                                          atrás en un
                                                          MP3.

                                                        • Las cosas no han avanzado nada en una década.

                                                        • Opus es moderno y mola mucho

                                                          https://es.wikipedia.org/wiki/Opus_(c%C3%B3dec), pero no
                                                          sabes si la gente lo va a poder oír.

                                                        • Lo peor de los dos mundos: Publicar los audios en ambos

                                                          formatos. ¡Ideología!

                                                        • [16:09] Nueva andadura del podcast.

                                                          Los compañeros originales del podcast, Samuel de Ancos y Juan

                                                          Ignacio Rodríguez, me han dado permiso para seguir en solitario.

                                                        • [17:05] ¿Calidad?

                                                          Aclaramos que al hablar de calidad, Jesús se refiere "para un

                                                          bitrate determinado", comparando codecs de audio.

                                                        • [19:30] Cabecera ID3 https://es.wikipedia.org/wiki/ID3 para

                                                          indexado de MP3.

                                                          Por convención, los MP3

                                                          VBR incluyen una cabecera
                                                          ID3 que permite saltar a
                                                          cualquier a cualquier punto del audio con una precisión del
                                                          1%.

                                                          Es decir, hay un índice con cien posiciones en el fichero que

                                                          permiten saltar directamente ahí con precisión.

                                                          Lamentablemente, en una canción de 3 minutos, intentar

                                                          movernos a un segundo concreto puede tener un error de dos
                                                          segundos, pero en un podcast de dos horas, el error puede ser
                                                          de más de un minuto.

                                                          Esto es un problema siempre, pero si el podcast tiene

                                                          capítulos, los hace inútiles.

                                                        • [20:18] Marcas por posición en bytes en la extensión de

                                                          capítulos de MP3.

                                                          Se pueden especificar posiciones exactas en el fichero de

                                                          audio, pero Jesús no ha visto ningún software que las genere y
                                                          no sabe si algún software soportará esa opción.

                                                          Pero aunque esto funcionase, para moverte entre capítulos del

                                                          audio, no va a funcionar para moverte arrastrando la posición con
                                                          el dedo (en tu móvil).

                                                        • [22:25] ¡Avanzar el estado del arte!

                                                        • [22:50] Opus

                                                          no tiene ninguno de estos problemas.

                                                          Explicación de cómo funciona "moverse" adelante y atrás por un

                                                          fichero de audio.

                                                        • [26:15] Meta Podcast.

                                                          • Jesús está escribiendo software para meter capítulos en
                                                          • ficheros de audio. Toc2audio
                                                            https://docs.jcea.es/toc2audio/.
                                                          • [27:40] Final.

                                                            29 min
                                                          • Python en español #6: Debate Python 2 vs Python 3
                                                            Dos entran, uno sale http://podcast.jcea.es/python/6

                                                            Notas:

                                                            • 00:00: Presentación del programa.
                                                            • 00:45: Comentamos los últimos eventos de la comunidad Python en España.
                                                              • 02:40: ¡PyConES 2015!. Llamada a ponencias
                                                              • abierta hasta el 1 de septiembre.

                                                              • 03:45: Debate sobre Python2/Python3 con Jesús, Juan Ignacio y Samuel.
                                                                • 12:00: Factores fundamentales a la hora de migrar un lenguaje, según Jesús. Python 3
                                                                • lo está cumpliendo.

                                                                  • No tener problemas de dependencias.
                                                                  • Que la migración aporte ventajas.
                                                                  • 13:10: Samuel: La aparición de otros lenguajes que compiten con Python 3 por los programadores
                                                                  • que migran desde Python 2.

                                                                    • La postura de Jesús:
                                                                      1. El que programa en el lenguaje de la empresa, sin interés personal.
                                                                      2. El coleccionista de lenguajes.
                                                                      3. El programador profesional de Python.
                                                                      4. 18:00: Juan Ignacio: Python sigue siendo el mejor lenguaje para mis necesidades.
                                                                      5. 20:13: Escribir código compatible Python 2 y Python 3.
                                                                        • Jesús se opone a esa idea: Si te limitas a usar el subconjunto común no aprovecharás
                                                                        • las mejoras que se van incorporando en Python 3.

                                                                        • 23:10: Jesús nos cuenta detalles del debate de los Core Developers
                                                                        • de Python en 2008 sobre cómo gestionar la migración.

                                                                        • 26:36 Juan Ignacio está encantado de que la migración esté siendo lenta, tranquila y
                                                                        • sin presión.

                                                                        • 32:50: El problema de los entornos empotrados (embedded) y del código abandonado
                                                                        • que sigue funcionando.

                                                                        • 35:10: La migración está yendo lenta, ¡pero está yendo bien!.
                                                                        • 36:20: El ecosistema Python es tan inmenso que migrarlo todo lleva tiempo. Es inevitable.
                                                                        • 37:40: El "muro de la vergüenza", actualmente llamado
                                                                        • "Python 3 Wall of Superpowers"
                                                                          porque está casi todo en verde. Es decir, migrado a Python 3.

                                                                          La nota final de la página pone: Note that this subdomain's called "python3wos" -

                                                                          when the status was below 50%, the title of the site was "Python 3 Wall of Shame". I kid you not.

                                                                        • 41:00: El caso de la librería PIL,
                                                                        • ahora Pillow.

                                                                        • 42:41: Comentamos los emails y comentarios en
                                                                        • twitter de los oyentes.

                                                                        • 45:20: Despedida, email,
                                                                        • twitter y Web
                                                                          para contactar con nosotros.
                                                                          47 min
                                                                        • Python en español #6: Debate Python 2 vs Python 3
                                                                          Dos entran, uno sale https://podcast.jcea.es/python/6

                                                                          Notas:

                                                                          • 00:00: Presentación del programa.
                                                                          • 00:45: Comentamos los últimos eventos de la comunidad Python en España.
                                                                            • 02:40: ¡PyConES 2015!. Llamada a ponencias
                                                                            • abierta hasta el 1 de septiembre.

                                                                            • 03:45: Debate sobre Python2/Python3 con Jesús, Juan Ignacio y Samuel.
                                                                              • 12:00: Factores fundamentales a la hora de migrar un lenguaje, según Jesús. Python 3
                                                                              • lo está cumpliendo.

                                                                                • No tener problemas de dependencias.
                                                                                • Que la migración aporte ventajas.
                                                                                • 13:10: Samuel: La aparición de otros lenguajes que compiten con Python 3 por los programadores
                                                                                • que migran desde Python 2.

                                                                                  • La postura de Jesús:
                                                                                    1. El que programa en el lenguaje de la empresa, sin interés personal.
                                                                                    2. El coleccionista de lenguajes.
                                                                                    3. El programador profesional de Python.
                                                                                    4. 18:00: Juan Ignacio: Python sigue siendo el mejor lenguaje para mis necesidades.
                                                                                    5. 20:13: Escribir código compatible Python 2 y Python 3.
                                                                                      • Jesús se opone a esa idea: Si te limitas a usar el subconjunto común no aprovecharás
                                                                                      • las mejoras que se van incorporando en Python 3.

                                                                                      • 23:10: Jesús nos cuenta detalles del debate de los Core Developers
                                                                                      • de Python en 2008 sobre cómo gestionar la migración.

                                                                                      • 26:36 Juan Ignacio está encantado de que la migración esté siendo lenta, tranquila y
                                                                                      • sin presión.

                                                                                      • 32:50: El problema de los entornos empotrados (embedded) y del código abandonado
                                                                                      • que sigue funcionando.

                                                                                      • 35:10: La migración está yendo lenta, ¡pero está yendo bien!.
                                                                                      • 36:20: El ecosistema Python es tan inmenso que migrarlo todo lleva tiempo. Es inevitable.
                                                                                      • 37:40: El "muro de la vergüenza", actualmente llamado
                                                                                      • "Python 3 Wall of Superpowers"
                                                                                        porque está casi todo en verde. Es decir, migrado a Python 3.

                                                                                        La nota final de la página pone: Note that this subdomain's called "python3wos" -

                                                                                        when the status was below 50%, the title of the site was "Python 3 Wall of Shame". I kid you not.

                                                                                      • 41:00: El caso de la librería PIL,
                                                                                      • ahora Pillow.

                                                                                      • 42:41: Comentamos los emails y comentarios en
                                                                                      • twitter de los oyentes.

                                                                                      • 45:20: Despedida, email,
                                                                                      • twitter y Web
                                                                                        para contactar con nosotros.
                                                                                        47 min
                                                                                      • Python en español #5: Frameworks Web
                                                                                        Frameworks, microframeworks, medioframeworks y WSGI http://podcast.jcea.es/python/5

                                                                                        Notas:

                                                                                        • 00:00: Presentación.
                                                                                        • 00:40: Comentamos los últimos eventos
                                                                                        • sobre Python en España.

                                                                                        • 06:20: Samuel, Jesús y Juan Ignacio presentan varios Frameworks Web para Python.
                                                                                          • 06:40: Jesús nos habla sobre ZOPE
                                                                                          • con sus idiosincrasias y limitaciones, el abuelo de los frameworks web.

                                                                                            • 14:55: Samuel hace referencia a Plone.
                                                                                            • 15:40: A Juan Ignacio le gustaba el lenguage de plantillas
                                                                                            • DTML.

                                                                                            • 17:05: Jesús habla de otros lenguages de plantillas de
                                                                                            • ZOPE, como TAL
                                                                                              y METAL.

                                                                                            • 19:25: Tras una referencia a Grok por
                                                                                            • parte de Juan Ignacio, Jesús aprovecha para contar la historia de ZOPE.

                                                                                            • 25:30: Juan Ignacio nos habla sobre Django
                                                                                            • y Flask.

                                                                                              • Charlas Python Madrid:
                                                                                                • Using
                                                                                                • Django like Flask: Andrey Antukh dio hace unos años una charla
                                                                                                  sobre las bondades de Flask. Su argumento en esta ocasión, tras
                                                                                                  años de experiencia, es que es preferible usar Django
                                                                                                  incluso para las tareas para las que normalmente se usaría Flask.

                                                                                                • 28:00: Consistencia entre proyectos y que el framework tome decisiones por ti.
                                                                                                • 36:10: Samuel nos habla sobre Tornado,
                                                                                                • WebPy y Bottle.

                                                                                                • 43:50: Nombramos a TurboGears,
                                                                                                • web2py y CherryPy.

                                                                                                • 45:45: Jesús nos comenta sobre un par alternativas que no son frameworks en sí:
                                                                                                  • 46:05: Nicola: Generador estático de contenidos.
                                                                                                  • Nombramos a Pelican, un producto similar.

                                                                                                  • 51:45: WSGI y
                                                                                                  • mod_wsgi.

                                                                                                    • PEP 0333 --
                                                                                                    • Python Web Server Gateway Interface v1.0.

                                                                                                    • PEP 3333 --
                                                                                                    • Python Web Server Gateway Interface v1.0.1.

                                                                                                    • 01:00:20: Comentamos los emails y comentarios en twitter de los oyentes.
                                                                                                    • 01:03:38: Despedida, Email, twitter y Web para contactar con nosotros.
                                                                                                    • 1 hr 6 min
                                                                                                    • Python en español #5: Frameworks Web
                                                                                                      Frameworks, microframeworks, medioframeworks y WSGI https://podcast.jcea.es/python/5

                                                                                                      Notas:

                                                                                                      • 00:00: Presentación.
                                                                                                      • 00:40: Comentamos los últimos eventos
                                                                                                      • sobre Python en España.

                                                                                                      • 06:20: Samuel, Jesús y Juan Ignacio presentan varios Frameworks Web para Python.
                                                                                                        • 06:40: Jesús nos habla sobre ZOPE
                                                                                                        • con sus idiosincrasias y limitaciones, el abuelo de los frameworks web.

                                                                                                          • 14:55: Samuel hace referencia a Plone.
                                                                                                          • 15:40: A Juan Ignacio le gustaba el lenguage de plantillas
                                                                                                          • DTML.

                                                                                                          • 17:05: Jesús habla de otros lenguages de plantillas de
                                                                                                          • ZOPE, como TAL
                                                                                                            y METAL.

                                                                                                          • 19:25: Tras una referencia a Grok por
                                                                                                          • parte de Juan Ignacio, Jesús aprovecha para contar la historia de ZOPE.

                                                                                                          • 25:30: Juan Ignacio nos habla sobre Django
                                                                                                          • y Flask.

                                                                                                            • Charlas Python Madrid:
                                                                                                              • Using
                                                                                                              • Django like Flask: Andrey Antukh dio hace unos años una charla
                                                                                                                sobre las bondades de Flask. Su argumento en esta ocasión, tras
                                                                                                                años de experiencia, es que es preferible usar Django
                                                                                                                incluso para las tareas para las que normalmente se usaría Flask.

                                                                                                              • 28:00: Consistencia entre proyectos y que el framework tome decisiones por ti.
                                                                                                              • 36:10: Samuel nos habla sobre Tornado,
                                                                                                              • WebPy y Bottle.

                                                                                                              • 43:50: Nombramos a TurboGears,
                                                                                                              • web2py y CherryPy.

                                                                                                              • 45:45: Jesús nos comenta sobre un par alternativas que no son frameworks en sí:
                                                                                                                • 46:05: Nicola: Generador estático de contenidos.
                                                                                                                • Nombramos a Pelican, un producto similar.

                                                                                                                • 51:45: WSGI y
                                                                                                                • mod_wsgi.

                                                                                                                  • PEP 0333 --
                                                                                                                  • Python Web Server Gateway Interface v1.0.

                                                                                                                  • PEP 3333 --
                                                                                                                  • Python Web Server Gateway Interface v1.0.1.

                                                                                                                  • 01:00:20: Comentamos los emails y comentarios en twitter de los oyentes.
                                                                                                                  • 01:03:38: Despedida, Email, twitter y Web para contactar con nosotros.
                                                                                                                  • 1 hr 6 min
                                                                                                                  • Python en español #4: Noticias y podcasts a gogó
                                                                                                                    Noticias y revisión de unos cuantos podcasts sobre Python http://podcast.jcea.es/python/4

                                                                                                                    Notas:

                                                                                                                    • 00:00: Presentación Python en Españo, capítulo 4.
                                                                                                                    • 00:47: Hablamos sobre los últimos eventos Python en España
                                                                                                                    • del calendario.

                                                                                                                      • Python Vigo.
                                                                                                                      • 04:40: Samuel y Jesús comentan sobre
                                                                                                                      • Python 3.5 Alpha 4 (última alpha).

                                                                                                                      • 06:00: Hablamos sobre el anuncio oficial de
                                                                                                                      • PyConES 2015 en Valencia.

                                                                                                                        • 08:33: Hablamos sobre los
                                                                                                                        • vídeos y
                                                                                                                          fotos de
                                                                                                                          la anterior PyConES (2014).

                                                                                                                        • 09:40: Las actas.
                                                                                                                        • 11:00: Hablamos sobre la ampliación del Call For Proposals de
                                                                                                                        • EuroPython 2015.

                                                                                                                        • 13:27: Comentamos sobre la reciente publicación de
                                                                                                                        • los vídeos de
                                                                                                                          PyCon Americana.

                                                                                                                        • 14:00: Jesús Cea nos comenta cosas sobre la última asamblea de la Asociación Python España.
                                                                                                                          • 16:45: Las actas.
                                                                                                                          • 18:15: Comentamos los últimos podcast sobre Python a nivel mundial que han surgido.
                                                                                                                            • 18:55: Jesús nos presenta el podcast "Talk Python To Me".
                                                                                                                            • 19:37: Jesús nos presenta el podcast "Podcast.__init__".
                                                                                                                            • 20:00: Jesús habla sobre el último podcast
                                                                                                                            • de CAChemE sobre Python.

                                                                                                                            • 21:20: Jesús habla sobre el último número del podcast
                                                                                                                            • de Entre Dev y Ops a raíz de la entrevista
                                                                                                                              de dos organizadores de EuroPython.

                                                                                                                            • 22:48: Jesús presenta la última feature de este podcast, shownotes en tu reproductor preferido!
                                                                                                                            • 23:45: Juan Ignacio habla sobre el podcast
                                                                                                                            • "from Python import Podcast".

                                                                                                                            • 24:45: Jesús nos presenta uno de los primero podcast historicos sobre python:
                                                                                                                            • "Python 411".

                                                                                                                            • 26:51: Juan Ignacio nos habla sobre los tutoriales y post de Adrian Rosebrock sobre
                                                                                                                            • OpenCV en
                                                                                                                              su página http://www.pyimagesearch.com/.

                                                                                                                            • 31:53: Pedimos feedback, sugerencias, críticas! y hablamos sobre el twitter del podcast.
                                                                                                                            • 33:26: Nos despedimos como siempre informado sobre nuestro email y twitter para que contactéis con nosotros.
                                                                                                                            • 35 min
                                                                                                                            • Python en español #4: Noticias y podcasts a gogó
                                                                                                                              Noticias y revisión de unos cuantos podcasts sobre Python https://podcast.jcea.es/python/4

                                                                                                                              Notas:

                                                                                                                              • 00:00: Presentación Python en Español, capítulo 4.
                                                                                                                              • 00:47: Hablamos sobre los últimos eventos Python en España
                                                                                                                              • del calendario.

                                                                                                                                • Python Vigo.
                                                                                                                                • 04:40: Samuel y Jesús comentan sobre
                                                                                                                                • Python 3.5 Alpha 4 (última alpha).

                                                                                                                                • 06:00: Hablamos sobre el anuncio oficial de
                                                                                                                                • PyConES 2015 en Valencia.

                                                                                                                                  • 08:33: Hablamos sobre los
                                                                                                                                  • vídeos y
                                                                                                                                    fotos de
                                                                                                                                    la anterior PyConES (2014).

                                                                                                                                  • 09:40: Las actas.
                                                                                                                                  • 11:00: Hablamos sobre la ampliación del Call For Proposals de
                                                                                                                                  • EuroPython 2015.

                                                                                                                                  • 13:27: Comentamos sobre la reciente publicación de
                                                                                                                                  • los vídeos de
                                                                                                                                    PyCon Americana.

                                                                                                                                  • 14:00: Jesús Cea nos comenta cosas sobre la última asamblea de la Asociación Python España.
                                                                                                                                    • 16:45: Las actas.
                                                                                                                                    • 18:15: Comentamos los últimos podcast sobre Python a nivel mundial que han surgido.
                                                                                                                                      • 18:55: Jesús nos presenta el podcast "Talk Python To Me".
                                                                                                                                      • 19:37: Jesús nos presenta el podcast "Podcast.__init__".
                                                                                                                                      • 20:00: Jesús habla sobre el último podcast
                                                                                                                                      • de CAChemE sobre Python.

                                                                                                                                      • 21:20: Jesús habla sobre el último número del podcast
                                                                                                                                      • de Entre Dev y Ops a raíz de la entrevista
                                                                                                                                        de dos organizadores de EuroPython.

                                                                                                                                      • 22:48: Jesús presenta la última feature de este podcast, shownotes en tu reproductor preferido!
                                                                                                                                      • 23:45: Juan Ignacio habla sobre el podcast
                                                                                                                                      • "from Python import Podcast".

                                                                                                                                      • 24:45: Jesús nos presenta uno de los primero podcast historicos sobre python:
                                                                                                                                      • "Python 411".

                                                                                                                                      • 26:51: Juan Ignacio nos habla sobre los tutoriales y post de Adrian Rosebrock sobre
                                                                                                                                      • OpenCV en
                                                                                                                                        su página http://www.pyimagesearch.com/.

                                                                                                                                      • 31:53: Pedimos feedback, sugerencias, críticas! y hablamos sobre el twitter del podcast.
                                                                                                                                      • 33:26: Nos despedimos como siempre informado sobre nuestro email y twitter para que contactéis con nosotros.
                                                                                                                                      • 35 min
                                                                                                                                      • Python en español #3: Yield from EuroPython
                                                                                                                                        Entrevista a los organizadores de la EuroPython http://podcast.jcea.es/python/3

                                                                                                                                        Notas:

                                                                                                                                        • 00:00: Presentación capítulo 3.
                                                                                                                                        • 01:25: Samuel y Juan Ignacio comentan los eventos Python del calendario.
                                                                                                                                          • 04:02: Comentamos la futura pero próxima Asamblea General de Socios de Python España.
                                                                                                                                          • 05:48: Entrevistamos Oier Etxaniz, Francisco Fernandez, Alexandre Manhães y Manuel Graña,
                                                                                                                                          • organizadores de EuroPython 2015.

                                                                                                                                            • 05:59: Presentación y por qué Python.
                                                                                                                                            • 08:56: Conocemos cómo comenzó la aventura de organizar
                                                                                                                                            • EuroPython.

                                                                                                                                            • 12:03: Conocemos qué tipo de ayuda tienen como organizadores.
                                                                                                                                            • 14:47: Nos hablan sobre las becas y ayudas para personas que no puedan permitirse el evento.
                                                                                                                                            • 19:40: ¿Habrá track científico?
                                                                                                                                            • 20:06: ¿Habrá algo diferente que otras
                                                                                                                                            • EuroPython?

                                                                                                                                            • 21:22: Nos hablan sobre hacer la sociedad "más mejor" :P
                                                                                                                                            • 22:50: Hablamos sobre Python a nivel nacional con nuestro invitados.
                                                                                                                                            • 26:27: ¿Cuántos tracks habrá?
                                                                                                                                            • 29:40: ¿Cómo convencer a tu jefe para que te pague el evento?
                                                                                                                                            • 32:40: Nos despedimos de nuestros invitados.
                                                                                                                                            • 33:55: Leemos y comentamos los comentarios de Twitter.
                                                                                                                                              • 34:10: Hablamos sobre corrutinas (gracias a
                                                                                                                                              • @NN2ed_s4ur0n).

                                                                                                                                              • 43:30: Seguimos con los demás comentarios de Twitter.
                                                                                                                                              • 45:25: Recordamos nuestros cauces para contactarnos y despedida.
                                                                                                                                              • 47 min

                                                                                                                                              About Python en español

                                                                                                                                              From the publisher's feed

                                                                                                                                              'Feed' de Python en español.

                                                                                                                                              More shows like Python en español

                                                                                                                                              Libros para Emprendedores by Luis Ramos

                                                                                                                                              Libros para Emprendedores

                                                                                                                                              1,118 Listeners