Document Actions

Introducción al Lenguaje de Programación Python

by Lorenzo Gil Sanchez — last modified 23-10-2004 11:15 PM

Imparte: Lorenzo Gil Sánchez. Fecha: 21 de Enero de 2003

`Titulo de la charla: Introduccion al lenguaje de programacion Python.`
`Impartida por: Lorenzo Gil Sanchez`
`Licenciado en Ingenieria Informatica por la Universidad de Granada.`
`Hora: 22:00 (21:00 UTC)`
`Lugar: canal #gcubo irc.freenode.net`
`Para mas informacion visita: http://www.gcubo.org`
`lgs`	`cuando quieras tar`
`--- tar fija modo +m #gcubo`
`--- tar ha cambiado el tópico a: #gcubo GCUBO -- Grupo de Usuarios y Desarrolladores de Software Libre en Granada \| http://www.gcubo.org \| Charla: Introduccion a Python, por Lorenzo Gil Sanchez \| 22:00 (21:00 UTC) preguntas a tar`
`tar`	`buenas noches a todos`
`tar`	`esta noche la charla será sobre python`
`tar`	`una pequeña introcduccion para aquellos q no tenemos mucha idea sobre el mismo`
`tar`	`la impartirá Lorenzo Gil Sanchez`
`tar`	`Ingeniero informatico y miembro de gcubo`
`tar`	`en caso de alguna pregunta debeis dirigiros a mi`
`tar`	`en caso de mi ausencia por cualquier motivo dirigiros a NinaNutz`
`tar`	`buenas noches Loren, cuando quieras`
`lgs`	`gracias tar`
`lgs`	`Python es un lenguaje de programación interpretado, orientado a objetos, de alto nivel, que tiene semánticas dinámicas. Dispone de estructuras de datos de alto nivel y tipos y ligaduras dinámicos.`
`lgs`	`Sin embargo, probablemente nada de esto os interese ahora mismo. Lo que os interesa saber es que Python es el lenguaje más sencillo de aprender y esto no le quita potencia en absoluto.`
`lgs`	`Y lo que es más importante, su nombre procede del genial grupo cómico inglés Monty Python.`
`lgs`	`Python nació en 1989 de la mano de Guido van Rossum y ya va por su versión 2.2.2. Su licencia es muy parecida a la BSD, es decir, impone menos restricciones que la conocida licencia libre GPL.`
`lgs`	`Es un lenguaje con mucho crecimiento como lo demuestra que empresas como Google esten buscando programadores en Python. (http://www.python.org/Jobs.html)`
`lgs`	`Para terminar la introduccion, las principales razones para usar Python son portabilidad, facilidad de uso y su genial libreria estandar.`
`lgs`	`Para los que nunca han programado, una librería es un conjunto de módulos ya programados que los puedes utilizar en tus programas`
`lgs`	`Ahora os cuento los pasos necesarios para instalaros en entorno de programación Python`
`lgs`	`perdon, EL entorno de programación Python`
`--> nauj27 (~nauj27@245.Red-80-36-17.pooles.rima-tde.net) ha ingresado en #gcubo`
`--- ChanServ da estatus de operador de canal a nauj27`
`lgs`	`Python esta disponible en númerosas plataformas, como Linux, Windows, DOS, OS/2, Mac, Amiga....`
`--- tar elimina estatus de operador de chanal de nauj27`
`--- ChanServ da estatus de operador de canal a nauj27`
`lgs`	`Si usas Linux es muy probable que ya esté incluido en tu distribución ya que la mayoria de las distribuciones lo estan usando en sus programas de administración. En cualquier caso escribe`
`lgs`	`python -V`
`tar`	`<bitland> ¿puedes explicar mejor que es interpretado y lo de semánticas dinámicas?`
`lgs`	`desde la shell para ver si lo tienes instalado.`
`--> dax5 (dax5@cliente-217216120231.cm128.grnpb.supercable.es) ha ingresado en #gcubo`
`lgs`	`hay dos tipos de lenguajes de programación`
`lgs`	`los compilados y los interpretados`
`lgs`	`por ejemplo C es un lenguaje compilado`
`lgs`	`tu escribes un programa en C y al compilarlo se convierte en un archivo con ceros y unos`
`lgs`	`que solo el ordenador entiende`
`lgs`	`un lenguaje interpretado necesite de un programa auxiliar`
`lgs`	`llamado interprete`
`lgs`	`que va leyendo tu programa y ejecutando las cosas que pone en dicho programa`
`lgs`	`en cuanto a lo de semanticas dinamicas quiero decir que el tipo de una variable puede ir cambiando`
`lgs`	`durante el transcurso de la ejecucion del programa`
`lgs`	`pero no os preocupeis si no entendeis estas cosas`
`lgs`	`no os van a hacer falta en absoluto`
`lgs`	`bueno, sigo`
`lgs`	`si escribes desde la shell, python -V`
`lgs`	`os dira la version de Python que teneis instalada`
`lgs`	`o un error si no la teneis`
`lgs`	`Si no fuera asi basta con hacer un apt-get install python desde Debian o utilizar una de las utilidades de instalación de paquetes de Redhat, Mandrake o Suse. Si todo lo anterior falla siempre puedes bajarte las fuentes y compilarlo, como decía Sid Vicious; do it yourself (hazlo tu mismo).`
`lgs`	`Si utilizas Windows solo tienes que instalar este archivo http://www.python.org/ftp/python/2.2.2/Python-2.2.2.exe.`
`lgs`	`para tener todo lo necesario para programar en Python`
`lgs`	`y ya nos dejamos de charla y vamos a empezar a programar`
`lgs`	`En el mundo de la programación es casi obligatorio empezar a enseñar un lenguaje con el programa "Hola Mundo".`
`lgs`	`Este útil programa se limita a imprimir un mensaje en el ordenador que diga "Hola Mundo".`
`lgs`	`Para ello abrimos un editor de texto y escribimos la siguiente línea:`
`--> Esqizo (AMD@cliente-217216123035.cm128.grnpb.supercable.es) ha ingresado en #gcubo`
`lgs`	`print "Hola Mundo"`
`lgs`	`Ahora lo salvamos como "hola.py" (sin las comillas) y lo ejecutamos desde la shell (Linux) o una ventana MS-DOS (Windows) escribiendo`
`lgs`	`python hola.py`
`lgs`	`como veis, aqui el programa interprete se llama python y nuestro programa se llama hola.py`
`lgs`	`python leerá nuestro archivo e irá ejecutando lo que se vaya encontrando`
`lgs`	`en este caso, la salida de nuestro programa es:`
`lgs`	`Hola Mundo`
`lgs`	`De todas formas hay trucos para evitar tener que poner python antes de nuestro programa, como poner el texto #!/usr/bin/env python al principio de hola.py y dandole permisos de ejecución o, si usamos Windows, basta con doble click en el icono de hola.py (aunque puede que no nos de tiempo a ver la salida del programa)`
`lgs`	`Y ahora pasamos a cosas más útiles`
`lgs`	`Lo más importante cuando se programa en Python es que hay que pensar casi en pseudocódigo. Así, ¿cuántas veces hemos querido intercambiar los valores de dos variables x e y?`
`lgs`	`en otros lenguajes si tenemos las variables x e y debemos hacer algo así`
`lgs`	`tmp = x;`
`lgs`	`x = y;`
`lgs`	`y = tmp;`
`lgs`	`es decir, necesitamos una variable auxiliar`
`lgs`	`en Python podemos hacer algo como:`
`lgs`	`x, y = y, x`
`lgs`	`que se lee como, mete en x el contenido de la variable y, y al mismo tiempo mete en y el contenido de la variable x`
`lgs`	`Esto se acerca bastante a cómo estamos acostumbrados a pensar`
`lgs`	`Cada variable tiene un tipo concreto, es decir puede almacenar datos de un determinado tipo:`
`lgs`	`a = 55`
`lgs`	`b = "texto"`
`lgs`	`como veis a es una variable de tipo número entero y b es una variable de tipo cadena de carácteres`
`lgs`	`Ahora viene lo de semánticas dinámicas, bitland`
`lgs`	`En Python podemos hacer lo siguiente:`
`lgs`	`mivariable = "soy una cadena de texto"`
`lgs`	`mivariable = 666`
`lgs`	`mivariable = "ahora soy otra vez una cadena"`
`lgs`	`como veis, hemos cambiado el tipo de la variable mivariable dos veces`
`lgs`	`es más, en otros lenguajes hay que especificar el tipo de una variable, en Python no es necesario`
`lgs`	`Como en C, C++, Java el operador = se usa para asignar algo a una variable y el operador == se usa para comprobar si dos variables son iguales.`
`lgs`	`asi si la variable P vale 5 y la variable Q vale 10`
`lgs`	`P == Q`
`lgs`	`devolverá falso`
`lgs`	`o lo que es lo mismo, un 0`
`lgs`	`en Python, como en otros muchos lenguajes, el 0 se interpreta como falso y el 1 como verdadero`
`lgs`	`Pasemos a las estructuras de control, algo imprescindible para hacer programas verdaderamente útiles`
`lgs`	`En Python amigos, no hay llaves. Para los bloques se usa la identacion. Aqui podemos ver algunas estructuras de control comunes:`
`lgs`	`veamos ejemplos`
`lgs`	`if x < 5 or (x > 10 and x < 20):`
`lgs`	`print "El valor es correcto."`
`lgs`	`esto quiere decir lo siguiente: si el valor de la variable x es menor que 5 o`
`lgs`	`es mayor que 10 y menor que 20`
`lgs`	`entonces imprime el mensaje "El valor es correcto"`
`--> DrNACHETE (sRsRa@cliente-217216210049.uBRgra01.supercable.es) ha ingresado en #gcubo`
`lgs`	`cuando digo que en Python no hay llaves me refiero a que lo normal en muchos otros lenguajes hubiera sido poner`
`lgs`	`if x < 5 or (x > 10 and x < 20)`
`lgs`	`{`
`lgs`	`print "El valor es correcto"`
`lgs`	`}`
`--- nauj27 elimina estatus de operador de chanal de nauj27`
`lgs`	`es decir delimitamos el trozo de codigo que queremos que se ejecute si la condición del if es verdadera con un par de llaves`
`lgs`	`Python ha sido muy criticado (y alabado) por mandar las llaves a tomar viento`
`lgs`	`en Python los bloques se indican con la indentacion`
`lgs`	`veamos más ejemplos`
`lgs`	`if x < 5 or 10 < x < 20:`
`lgs`	`print "El valor es correcto."`
`lgs`	`esta es otra forma más sencilla y legible de poner el ejemplo anterior`
`lgs`	`for i in [1,2,3,4,5]:`
`lgs`	`print "Pasada numero", i`
`lgs`	`este trozo de codigo es lo que se llama un bucle`
`tar`	`<bitland> pero eso es muy peligroso, ¿con qué formato habría que guardar los archivos para que no se destrozase la estructura de identación si pasan de un So a otro?`
`lgs`	`el formato recomendado por Guido es los espacios`
`lgs`	`pero se pueden usar tabuladores si quieres`
`lgs`	`la unica regla importantísima es`
`lgs`	`que en un mismo fichero no puedes mezclar tabuladores con espacios`
`lgs`	`hoy en día cualquier editor de programación comprueba eso`
`lgs`	`pero sí, bitland, una de las criticas era que a veces había errores muy dificiles de detectar`
`lgs`	`por eso mismo que tu dices`
`lgs`	`pero sabiendolo, es fácil hacerlo bien`
`lgs`	`bueno, sigo con los bucles`
`lgs`	`un bucle lo que hace es ejecutar varias veces el código que se encuentre en su cuerpo`
`lgs`	`en el caso anterior el cuerpo del bucle es`
`lgs`	`print "Pasada numero", i`
`lgs`	`lo que hace el bucle for es ir dandole los valores de la lista de la derecha a la variable i`
`lgs`	`por lo que la salida de ese programa sería algo así como`
`lgs`	`Pasada numero 1`
`lgs`	`Pasada numero 2`
`lgs`	`Pasada numero 3`
`lgs`	`Pasada numero 4`
`lgs`	`Pasada numero 5`
`lgs`	`Veamos otro tipo de bucle en otro ejemplo`
`lgs`	`while x >= 10:`
`lgs`	`print "x aun no es negativo"`
`lgs`	`x = x - 1`
`lgs`	`como veis el cuerpo de un bucle puede estar formado por más de una linea`
`lgs`	`este bucle se ejecuta mientras la condición x >= 10 sea cierta`
`lgs`	`y como veis en cada pasada del bucle, decrementamos la variable x en uno`
`lgs`	`alguién le ve un fallo gordo a ese código?`
`lgs`	`tic tac tic tac`
`lgs`	`esta bien`
`lgs`	`si no inicializamos la variable x antes del bucle`
`lgs`	`no sabemos cuantas vueltas dará ese bucle`
`lgs`	`imaginate que x valiera 3 billones y pico`
`lgs`	`nos saldría barba antes de que el programa terminara`
`lgs`	`bueno sigamos con más cosas`
`lgs`	`¡Ah! se me olvidaba, los comentarios se ponen con el simbolo # y son comentarios de linea.`
`lgs`	`normalmente se ponen comentarios en un programa para que sean más legibles`
`lgs`	`así si ponemos la línea`
`lgs`	`# ahora voy a hacer el algoritmo de gram schmitt`
`lgs`	`python se la salta y la ignora`
`lgs`	`me avisa tar que más de uno sabía la respuesta a la pregunta de antes`
`lgs`	`pero he sido muy rápido`
`lgs`	`No me gusta que no sea posible poner comentarios de bloque pero al menos podemos poner cadenas que ocupen mas de una linea usando la triple comilla.`
`lgs`	`por ejemplo:`
`lgs`	`uso = """Uso de miprograma:`
`lgs`	`miprograma [opciones] entrada salida`
`lgs`	`donde opciones puede ser ....`
`lgs`	`"""`
`lgs`	`Esto es bastante util para instrucciones de uso, por poner un ejemplo:`
`lgs`	`normalmente muchos programas que se usan desde la linea de comandos`
`lgs`	`como el tipico ls`
`lgs`	`necesitan guardar las instrucciones de uso de alguna forma`
`lgs`	`con la triple comilla de Python es bastante sencillo`
`lgs`	`Como habeis visto antes, el bucle for recorria los elementos de una lista.`
`lgs`	`lo recuerdo`
`tar`	`<bitland> ¿se pueden hacer entonces programas con gui para cualquier plataforma y existen compiladores a pesar de ser interpretado?`
`lgs`	`for i in [1,2,3,4,5]:`
`lgs`	`print "Pasada numero", i`
`lgs`	`[1,2,3,4,5] es una lista`
`lgs`	`se pueden hacer programas con gui para cualquier plataforma`
`lgs`	`pero no entiendo eso de si existen compiladores a pesar de ser interpretado`
`lgs`	`hay una utilidad para windows`
`lgs`	`que se llama py2exe`
`lgs`	`que convierte un programa en python en un .exe`
`lgs`	`pero no es exactamente un compilador`
`--- tar da voz a bitland`
`lgs`	`y hay una utlidad en la distribución estandar de python`
`bitland`	`lgs: dices que necesita de un interprete para su ejecución, ¿se pueden ejecutar sin ayuda de uno?`
`lgs`	`llamada freeze`
`lgs`	`que hace lo mismo`
`lgs`	`si se puede bitland`
`lgs`	`pero te aviso de que no es sencillo`
`lgs`	`si tu programa es complejo y usa muchas librerías`
`lgs`	`probablemente tengas problemas`
`lgs`	`para programas pequeños no hay problemas`
`lgs`	`pero por ejemplo lo que hace el py2exe`
`lgs`	`es hacer un ejecutable gigantesco, que tiene el interprete de python metido dentro`
`lgs`	`una chapucilla, vamos`
`lgs`	`te he contestado bitland?`
`bitland`	`sip :-)`
`--- tar retira voz de bitland`
`lgs`	`sigamos`
`lgs`	`Otra de las ventajas de Python es que nos ofrece estructuras de datos muy utiles como las listas, las tuplas, los diccionarios.... Por supuesto tambien tenemos enteros, reales y cadenas. No hay caracteres (son cadenas de longitud 1), pero si tenemos complejos "de fabrica".`
`lgs`	`todos esos son algunos de los tipos básicos de Python`
`lgs`	`ejemplos de listas, tuplas y diccionarios:`
`lgs`	`milista = [pepe, manzanas, 23, [peras, "coconut"]] # quien dijo que no se mezclaran manzanas con peras?`
`lgs`	`unatupla = ("uno", "dos", "tres")`
`lgs`	`# cuanto pesa laurita?`
`lgs`	`respuesta = pesos["laurita"]`
`lgs`	`pesos = { "pepito" : "40 kg", "jaimito" : "38 kg", "laurita" : "32 kg" }`
`lgs`	`perdon he copiado la linea de pesos despues de la pregunta de laurita`
`lgs`	`cosas de emacs`
`lgs`	`comentarios sobre estas lineas: una lista puede contener cosas que no sean del mismo tipo`
`lgs`	`incluso puede contener listas dentro de ella misma`
`lgs`	`para acceder al primer elemento de milista pondriamos`
`lgs`	`milista[0]`
`lgs`	`al segundo seria milista[1]`
`lgs`	`otra pregunta para el que se ha quedado con ganas antes`
`lgs`	`como le asignaria a la variable pepito el valor "coconut"`
`lgs`	`usando 'milista'?`
`lgs`	`ahora dejo mas tiempo`
`lgs`	`veamos, doy pistas`
`lgs`	`pepito = ....`
`lgs`	`pepito = milista[3]....`
`lgs`	`nadie?`
`tar`	`<bitland> pepito = milista[3,1] 0-)`
`lgs`	`casi bitland`
`lgs`	`te has acercado mucho`
`lgs`	`seria asi`
`lgs`	`pepito = milista[3][1]`
`lgs`	`veamos, milista[3] es igual a [peras, "coconut"]`
`lgs`	`es como si hicieramos`
`lgs`	`otralista = milista[3]`
`lgs`	`y luego`
`lgs`	`pepito = otralista[1]`
`lgs`	`es sólo cuestión de práctica`
`lgs`	`las listas de Python son extremadamente fáciles de usar`
`lgs`	`y las tuplas y los diccionarios son muy parecidos`
`lgs`	`Python hace una separacion entre tipos mutables y tipos inmutables, asi, podemos modificar las listas y los diccionarios, pero no las tuplas, las cadenas o los enteros.`
`lgs`	`es decir, podemos meter más cosas en una lista o borrar elementos de un diccionario`
`lgs`	`pero no podemos cambiar de longitud una tupla o cambiar el caracter número 3 de una cadena`
`lgs`	`Ojo, una cosa es que no podamos modificar la tupla (manzana, pera, platano) y otra muy distinta es que podamos modificar las variables que la componen.`
`lgs`	`Mas cosas. Si queremos usar el bucle for como toda la vida se ha hecho (me refiero a otros lenguajes), podemos usar la funcion range, que devuelve una lista:`
`lgs`	`# imprime los valores desde el 2 al 20 con incrementos de 3`
`lgs`	`for i in range(2, 20, 3):`
`lgs`	`print i`
`lgs`	`la lista que devuelve range(2, 20, 3) sería`
`lgs`	`[2, 5, 8, 11, 14, 17, 20]`
`lgs`	`es decir, empieza en 2, llega hasta 20 y los incrementos son de 3`
`lgs`	`Una operacion interesante de las lista es el corte. Podemos obtener sublistas dentro de una lista sin mas que indicandole los elementos iniciales o finales o solo uno de ellos.`
`lgs`	`Ejemplo:`
`lgs`	`milista = [1, 2, 3, 4, 5, 6]`
`lgs`	`print milista[2:5] # imprime [3,4,5]`
`lgs`	`print milista[3:] # imprime [4,5,6]`
`lgs`	`print milista[:2] # imprime [1,2]`
`lgs`	`cuando ponemos milista[2:5] queremos decir que nos de la sublista que va desde el elemento 2 hasta el 5`
`lgs`	`Para terminar con la charla hablare de las funciones, elemento basico de todo languaje de programacion.`
`lgs`	`Una función es un trozo de código que se puede reutilizar en más de una ocasión y por eso se aisla en una función:`
`lgs`	`def cuadrado(x):`
`lgs`	`return x*x #no olvides la indentacion`
`lgs`	`print cuadrado(2) #imprime un 4`
`lgs`	`solo con usar la palabra reservada 'def' ya podemos definir una función`
`lgs`	`cuando hacemos`
`lgs`	`print cuadrado(2)`
`lgs`	`estamos llamando a nuestra función con el valor de x igual a 2`
`lgs`	`Para los que lo entendais, los parametros de una funcion se pasan por referencia (como en Java). Para los que no lo entendais, olvidad esta frase :)`
`lgs`	`Python tiene listas de argumentos variables para las funciones, argumentos con nombre y argumentos por omision. Miraros el tutorial de Guido si teneis curiosidad.`
`lgs`	`Bueno, creo que ya es mas que suficiente. Os cito algunas de las caracteristicas que me he dejado en el tintero:`
`lgs`	`Construcciones de programacion funcional, modulos y paquetes de Python, programacion orientada a objetos en Python, etc, etc...`
`lgs`	`Muchos de estos aspectos darian para una charla completa, pero lo mejor es que los mireis vosotros mismos.`
`lgs`	`El contenido de esta charla se basa en gran medida en el documento Python instantaneo ( http://www.arrakis.es/~rapto/AprendaPython.html )`
`lgs`	`Si quereis saber mas de Python mirad esta pagina http://www.python.org/doc/2.2.2/index.html y empezad por el tutorial de Guido.`
`lgs`	`Si no sabeis ingles no teneis excusa: http://usuarios.lycos.es/arturosa/`
`lgs`	`me dice tar`
`lgs`	`que quereis saber más sobre las diferencias de python con otros lenguajes`
`lgs`	`en esta pagina http://www.python.org/doc/Comparisons.html teneis mas informacion que la que os voy a dar ahora`
`tar`	`<Pummel> ¿que tal se comporta con bases de datos?`
`lgs`	`hay interfaces para la mayoria de las bases de datos existentes`
`lgs`	`como db2, oracle, mysql, posgresql, odbc`
`lgs`	`yo lo he usado y me ha ido bastante bien`
`lgs`	`en cuanto a las diferencias os explico`
`tar`	`<Pummel> ¿hay posibilidad de usar expresiones regulares a lo perl?`
`lgs`	`os explico, si me deja Pummel :)`
`lgs`	`tiene un modulo en la libreria estandar que hace exactamente eso Pummel`
`lgs`	`Python es de más alto nivel que Java`
`lgs`	`al igual que Java lo es de C`
`lgs`	`es decir, el lenguaje tiene construcciones que hacen que sea más sencillo programar`
`lgs`	`lo que en C suelen ser 500 lineas de código`
`lgs`	`en Java suelen ser 200`
`lgs`	`y en Python pueden quedarse en menos de 100`
`lgs`	`en tratamiento de cadenas Perl se comporta mejor`
`lgs`	`pero el problema de Perl es que en cuanto hacer un programa de más de 100 lineas`
`lgs`	`a los 5 días se hace inmantenible`
`lgs`	`porque su sintáxis ayuda poco`
`lgs`	`mucha gente dice que Python se autodescribe`
`lgs`	`y que es necesario poner pocos comentarios para entender lo que se está haciendo`
`lgs`	`por no decir que tiene verdadera orientación a objetos a diferencia de Perl`
`lgs`	`Python también tiene utilidades de lenguajes funcionales`
`lgs`	`pero sigue teniendo una orientación procedural`
`lgs`	`no sé, preguntadme sobre aspectos más concretos para que pueda compararlo con otros lenguajes`
`lgs`	`ah y otra cosa, Python también da de comer. Ahora mismo estoy tengo un trabajo en el que hago interfaces gráficas en Python :)`
`lgs`	`tar, doy por finalizada mi charla`
`lgs`	`desmodera el canal`
`tar`	`alguna pregunta más?`
`lgs`	`y que la gente haga más preguntas directamente si quiere`
`tar`	`<Pummel> ¿la funcionalidad de python reside en paquetes externos como CPAN asiste a perl? ¿o viene casi todo integrado, como php?`
`lgs`	`sobre todo espero que no se haya perdido mucha gente`
`lgs`	`yo diría que viene casi todo integrado`
`lgs`	`cuando instalas la distribución de python tienes un mogollón de paquetes disponibles`
`lgs`	`hasta una interfaz gráfica, que usa Tcl/Tk`
`lgs`	`otra ventaja de Python es que es muy fácil de extender si se quiere`
`lgs`	`el intérprete esta hecho en C`
`lgs`	`y es fácil de modificar`
`lgs`	`y además tiene una API muy bien definida, para poder hacer dos cosas fácilmente:`
`lgs`	`a) si tienes un programa en C puedes ampliarlo añadiendole módulos en Python`
`lgs`	`b) Si tienes un programa en Python y necesitas acelerar ciertas partes, puedes implementar estas partes en C y acoplarlo todo`
`tar`	`<NinaNutz> que es una API?`
`lgs`	`a ver si lo digo bien, Application Programming Interface, no?`
`lgs`	`en cristiano quiere decri`
`lgs`	`decir`
`lgs`	`el conjunto de instrucciones que ofrece una librería para que los demás puedan usarlo`
`lgs`	`cuando digo instrucciones me refiero a instrucciones como de un manual de instrucciones`
`lgs`	`es decir, Python está muy bien documentado para poder hacer las cosas que antes he puesto`
`tar`	`<bitland> ¿las interfaces gráficas las haces para programas en python, o se puede usar para hacer librerías para otros lenguajes?`
`tar`	`<bitland> ¿y qué tal va la integración en Mono? (el equivalente libre a .NET, y que los puristas me perdonen)`
`lgs`	`veamos`
`lgs`	`no entiendo muy bien la primera pregunta, intento contestarte`
`lgs`	`si tienes un programa en python y quieres hacerle una interfaz gráfica, se puede hacer y es sencillo`
`lgs`	`si tienes un programa en otro lenguaje y quieres hacerle una interfaz grafica en python`
`lgs`	`se puede hacer si ese otro lenguaje es C o Java, ya que Python se lleva muy bien con C y hay un interprete de Python escrito en Java, llamado Jython`
`lgs`	`que permite que desde Python puedas usar Java y viceversa`
`lgs`	`en cuanto a la integración con Mono es una lástima que Jaime no esté aqui`
`lgs`	`porque yo de Mono estoy muy pegado`
`lgs`	`y no sé como está la cosa ahora mismo entre monos y serpientes`
`lgs`	`alguna pregunta más?`
`tar`	`<bitland> ¿entonces python por ser interpretado se entiende que no es muy apto para grandes cargas de trabajo?`
`lgs`	`no bitland`
`lgs`	`para lo que no es apto es para cosas que requieran mucha velocidad`
`lgs`	`que no siempre es lo mismo`
`lgs`	`python se usa en los buscadores de google, si eso te parece carga suficiente`
`lgs`	`y también en los efectos especiales de Industrial Light & Magic`
`lgs`	`mucha gente dice que es el lenguaje pegamento ideal`
`lgs`	`es decir el lenguaje que sirve para acoplar programas hechos en lenguajes diferentes`
`lgs`	`también se usa en level51`
`lgs`	`si conoceis a Eric S. Raymon, el también dice maravillas de Python`
`tar`	`<bitland> a eso me refería :), y otra cosa, ¿cuáles son las principales aplicaciones a las que se destina, además de las citadas?`
`lgs`	`mmm, es dificil responder`
`lgs`	`como curiosidad os diré que anaconda`
`lgs`	`el programa de instalación de RedHat está hecho en Python`
`lgs`	`en esta página, veis proyectos comerciales que usan Python http://www.python.org/psa/Projects.html`
`lgs`	`y si alguno conoce el videojuego Blade, para mi el mejor juego hecho por españoles, os diré que todo lo que no son gráficos en ese juego`
`lgs`	`esta hecho con Python`
`lgs`	`como veis, son aplicaciones muy heterogeneas`
`tar`	`<Pummel> curiosidad morbosa: ¿que es wxPython? ¿es el paso para portar a windows un programa en python? ¿es lo mismo el python de ActiveState que el de cualquier distribucion Linux? ¿por qué pregunto tanto? :P`
`lgs`	`veamos`
`lgs`	`wxwindows es una libreria para hacer guis ( y otras cosas) multiplataforma escrita en C++`
`lgs`	`es como las Qt, vamos`
`lgs`	`y wxpython es una módulo de python para que puedas usar dicha librería`
`lgs`	`una de las ventajas de python es que cómo se lleva tan bien con C`
`lgs`	`cualquier cosa escrita en C es muy fácil que exista para Python`
`lgs`	`porque basta con hacer un módulo que se comunique con dicha librería y ya esta`
`lgs`	`la segunda pregunta`
`lgs`	`no se lo que es ActiveState :)`
`lgs`	`perdón, esa era la tercera pregunta`
`lgs`	`creo que la segunda esta contestada con lo que he dicho`
`tar`	`<Pummel> http://www.activestate.com/Solutions/Programmer/Python.plex`
`lgs`	`ahi me has pillado Pummel`
`lgs`	`es la primera vez que veo eso :)`
`tar`	`<bitland> ¿entonces la instalación de RH lanza un intérprete de python y ejecuta el instalador gráfico? en caso afirmativo, ¿ésto significa que un intérprete de python necesita muy pocos recursos?`
`lgs`	`si bitland`
`lgs`	`a ambas cosas`
`lgs`	`no estoy seguro pero creo que que anaconda utiliza las GTK+`
`lgs`	`es decir, es un programa en Python con bindings a la libreria GTK+`
`lgs`	`me dice tar que no hay más preguntas`
`lgs`	`espero que le hayais perdido el miedo a programar`
`lgs`	`como nota curiosa os diré`
`lgs`	`que cuando yo estudié programación`
`lgs`	`primero te enseñaban a programar con lápiz y papel en un lenguaje llamado`
`lgs`	`pseudocódigo que se acerca mucho a nuestra forma de hablar y pensar`
`lgs`	`y luego nos enseñaban C`
`lgs`	`hoy día hay varias facultades de informática que directamente empiezan con Python`
`lgs`	`y luego se pasan a C`
`lgs`	`como veis, no nos libramos de C`
`lgs`	`bueno ya me callo`
`lgs`	`gracias a todos por venir`
`lgs`	`desmodera tar`
`tar`	`pues si no hay nada más dar las gracias a Lorenzo por esta magnifica charla e invitarte a que repitas cuando quieras`
`tar`	`muchas gracias a todos`
`--- tar fija modo -m #gcubo`
`tar`	`plas plas plas plas plas plas plas plas`
`lgs`	`gracias a tar por su inestimable ayuda`
`Pummel`	`plas plas plas plas plas plas`
`MiguelQuiros`	`Enhorabuena, Lorenzo. Me he enterado de casi todo. No solo de Python sino de algún que otro concepto general de programación.`
`DrNACHETE`	`xD`
`bitland`	`plas`
`bitland`	`plas plas`
`dax5`	`Plas,plas,plas, gracias por la charla.`
`* lgs se ruboriza`
`nauj27`	`muy bien loren :)`
`bitland`	`plas plas plas`
`NinaNutz`	`plas plas`
`NinaNutz`	`plas plas plas plas plas plas`
* linuxino cubre a lgs con confetti~;``~`;.~``~` lgs ~`;. ~`;.`;.`~`~`~` ;.~ lgs `;.`;.`~;.`;.`~;`~ lgs `~` ; ;.`;.``~`~`. lgs ~``~` ~`;.~`;.`;. lgs `~`~`~` ;.~`;~`;.``` lgs ~`; ~``~`*~` lgs ~`; ~``~`
`bitland`	`:-DD, instructiva, quizás algún día retome la programación :-DD`
`DrNACHETE`	`plis plis`
`Esqizo`	`muchas gracias por la informacion aportada`
`Pummel`	`me ha gustao si señor :)`
`lgs`	`de regalo dos fotos frikis http://lgs.homelinux.net/download/empollando-python1.jpg y http://lgs.homelinux.net/download/empollando-python2.jpg`
`bitland`	`linuxino: :-DDDDDD`
`Pummel`	`jajajaja`
`Esqizo`	`es la primera vez q me apunto a algo de esto, pero sin duda no sera la ultima`
`lgs`	`Esqizo: lo mejor es que yo también :)`
`lgs`	`no sé si me he alargado más de la cuenta, son las 11.30 ya`
`Esqizo`	`:)`

GCubo

Sections

Personal tools

Document Actions

Introducción al Lenguaje de Programación Python