Patricio Páez Serrato
17 de Noviembre de 2002
Python es un lenguaje de alto nivel, interpretado, orientado a objetos, simple, extensible, libre, multiplataforma.
Python es denominado lenguaje de 'scripting' en forma similar a Perl, con mayor funcionalidad que el shell. Será el languaje para scripting en Koffice. Elementos de C, Lisp, Modula-3.
www.python.org/doc/essays/comparisons.html
Python fué desarrollado por Guido Van Rossum en el centro de investigación en Matematicas CWI en Holanda. Guido se basó en su trabajo anterior con el lenguaje abc. El nombre viene de un programa de la BBC 'Monty Python's flying circus'.
Python toma las mejores características de varios lenguajes en una sintaxis sencilla, elegante, sin ambigüedades. Aporta la indentación como delimitador de bloques.
Los programas en Python suelen ser más cortos que en otro lenguaje por sus tipos de datos de alto nivel, la indentación y que no son necesarias las declaraciones de variables ni argumentos de funciones. A pesar de esto último, tiene más verificación de errores que C.
Python es compatible hacia atrás, los programas hechos en versiones anteriores funcionan en las versiones nuevas.
Python funciona en Gnu/Linux, Windows, Solaris, Sistema de la MacIntosh.
Puedes usarlo si tienes una PC con Windows o Gnu/Linux, una MacIntosh, etc. La versión actual es 2.2. Las anteriores son 2.1, 2.0 y 1.5.2.
Son cinco los principales:
Dependiendo de tu mejor forma de aprender, tienes los siguientes recursos para seleccionar:
En el manual del Tutorial de Guido, vienen explicados.
En la Referencia de la Biblioteca, hay ejemplos para varios módulos.
Adam Kuchling tiene algunos ejemplos en www.amk.ca/python.
Existen ya varios en O'Reilly www.or.com y los puedes consultar en internet antes de comprar. También hay en www.amazon.com. Hay desde referencias de bolsillo hasta introducciones a la programación usando Python llenos de ejemplos.
Usenet: comp.lang.python
web: www.python.org/doc/howto
google.com python+example
| python | entra a modo interactivo |
| python nombre-script | corre el script y termina |
| python -i nombre-script | corre el script y queda en modo interactivo |
| python -c 'comando' [argumentos] | ejecutar comandos de python y termina |
Salir de modo interactivo: caracter EOF. Control-D Unix, Control-Z Windows.
Interrumpir programa: control-D.
| c-A c-E, inicio/fin | Cursor a inicio/fin del renglón. |
| c-B c-F, cursor izquierda/derecha | Avanzar/retroceder un caracter. |
| c-K | Borrar de cursor hasta fin de renglón. |
| c-Y | Pegar últimos caracteres borrados. |
| c-_ | Deshacer |
| _ | Última expresión impresa |
| Cursor arriba, c-P | Comando anterior |
| Cursor abajo, c-N | Comando siguiente |
| c-R c-S | Buscar comandos hacia atrás/adelante |
Crear archivo /.pythonrc conteniendo:
Import rlcompleter, readline
readline.parse_and_bind( 'esc: complete' )
Antes de correr python: export PYTHONSTARTUP=/.pythonrc
Más detalles en Apéndice A del Tutorial.
import sys
sys.argv lista de cadenas
sys.argv[0] es el nombre del script
sys.argv[1:] 1er. parámetro, 2do, etc.
Integrated DeveLopment Environment para ambiente de ventanas.
Permite ejecutar paso a paso y muestra valores de variables.
| alt-P | Comando anterior |
| alt-N | Comando siguiente |
| alt-/ | Expandir palabra |
Más info en menú Help.
IDE (Integrated Developement Environment) poderoso, disponible en Windows, y con las siguientes facilidades:
Vim, activepython: www.activestate.com
Para correr programas ya hechos en máquinas que no tienen python. Limitaciones.
| Para más detalles sobre: | consultar: |
| Comandos | Referencia del Lenguaje |
| Funciones y módulos | Refencia de la Biblioteca |
Todo lo que esté a la derecha de #. Permitidos al final de líneas de continuación implícita.
Línea lógica: una o mas líneas físicas, siguiendo las reglas de juntar líneas.
| Explícita | '\' al final del renglón. |
| Implícita | (, [, y { pueden continuarse en siguiente línea física. |
Varias instrucciones en el mismo renglón: separadas con ;.
Todo dato en python, incluso el código mismo, es un objeto. Los objetos tienen:
| identidad | dirección en memoria, no cambia | id() |
| tipo | define qué operaciones y valores puede tomar | type() |
| valor | mutable, inmutable |
Algunos objetos son contenedores, es decir, tiene referencias a otros objetos.
Los tipos básicos son:
| Números | inmutables | enteros sencillos | -2,147,483,648 a 2,147,483,647 | OverflowError |
| enteros largos | sin límite | |||
| punto flotante | doble precisión | |||
| complejos | pareja de números de punto flotante | z.real, z.imag | ||
| Secuencias | ||||
| inmutables | cadenas | '' 'a' ``hola`` ``````hola ``````& | ||
| tuples | ( ), (1,), (1,2) | |||
| mutables | listas | [ ], [1], [1,2,3] | ||
| Mapeos | mutables | diccionarios | { },{a:123, b:456} | |
| dbm, gdbm |
Método: función que pertenece a un objeto.
Objeto.método
Otroobjeto.método
| Falso | Valor cero, contenedor vacío, None |
| Verdadero | Todo lo demás, Ellipsis. |
| cmp( x, y ) | 0 si x=y, 1 si x>y, -1 si x<y |
| Enteros | decimal | 234890 |
| octal | 0766 | |
| hexadecimal | 0x0fee | |
| Enteros largos | 1L | |
| Punto flotante | 1.5, 1e100 | |
| Complejos | ( 5, 7j ) |
| int( x, [base] ) | str o int -> int trunca |
| long( x ) | str o int -> long |
| float( x ) | str o int -> float |
| hex( i ) | int -> str |
| oct( x ) | int -> str |
| round( x, n) | float -> float, n=0 |
| trunc( x ) | xxx -> xxx |
| abs( x ) | valor absoluto |
| inmutables | cadenas | '' 'a' 'ab' |
| tuplas | () (1,) (1,2) | |
| mutables | listas | [] [0] [0,1] |
nombre[ índice ]
| nombre[0] | primer elemento |
| nombre[1] | segundo elemento |
| nombre[-1] | último elemento |
| nombre[-2] | penúltimo elemento |
Índice fuera de rango es un error.
nombre[ índiceinferior : índicesuperior ]
Longitud del corte = índicesuperior - índiceinferior
| nombre[:fin] | Primer índice omitido vale 0. |
| nombre[inicio:] | Segundo índice omitido vale tamaño del objeto. |
| nombre[:] | Copia del objeto. |
| nombre[0:1] | Primer elemento. |
| nombre[0:2] | Primero y segundo elementos |
| nombre[-2:] | Últimos dos elementos |
Índices fuera de rango se aceptan: topan con 0 y el tamaño del objeto
nombre[:i] + nombre[i:] es igual a nombre.
| max(s | Mayor elementos de s |
| min( s ) | Menor elementos de s |
| len( s ) | Cantidad de elementos |
| + | Concatenación. |
| * | Multiplicación. |
| 'aaa' 'bbb' | Concatenación implícita. |
| > < == | Comparaciones - lexicográficamente. |
| e[not] in s | Membresía |
| range( [inicio,] fin [, incremento] ) | inicio=0, incremento=1[0, 1, ... incremento < fin] |
| inicio+i*incremento < fin | |
| [inicio, inicio+i*incremento, ...] | |
| xrange() | ídem, para rangos muy grandes |
| filter( función, secuencia ) | if función( elemento ): tomar elemento |
| map( función, secuencia [,secuencia...] ) | función( elemento [, elemento...] ) |
| reduce( función, secuencia ) | función( elemento0, elemento1), etc. |
| zip( secuencia [,secuencia...] ) | Lista de tuplas con elemento i de cada secuencia) |
| ''& Cadena vacía | |
| 'c' | Caracter |
| 'abc' | Comillas sencillas |
| ``abc``& Comillas dobles | |
| 'dice ``hola``' | Comillas dobles dentro de sencillas |
| ``buyer's guide``& Comilla sencilla dentro de dobles | |
| '``buyer\'s`` guide' | Comilla con escape |
| ``````hola``````& Pueden contener varios renglones y comillas. | |
| '''hola''' | ídem |
| capitalize() | Iniciales con mayúsculas |
| s.join( secuencia ) | Concatena secuencia con la cadena s |
| lower() | Minúsculas |
| lstrip() | Quita espacio en blanco al inicio |
| rstrip() | Quita espacio en blanco al final |
| splitlines( [keepends]) | Lista de renglones |
| strip() | Quita espacio en blanco |
| upper() | Mayúsculas |
Son cadenas de longitud 1, no hay tipo char.
| ord( c ) | código ascii del caracter |
| chr( i ) | caracter correspondiente |
| str( o ) | cadena para imprimir representación del objeto |
| repr( o ) | ídem, para usarse en eval() |
| Secuencia de escape | Significado |
| \\ | \ |
| \' | ' |
| \¨ | `` |
| \f | formfeed |
| \n | linfeed |
| \r | carriage return |
| \t | tab |
| \ooo | caracter ascii ooo octal |
Prefijo r son cadenas raw: no se eliminan los \.
| tuple( secuencia ) | tupla con los elementos de la secuencia |
| append(x) | Agrega un elemento. Equivale a a[len(a):] = [x] |
| extend(L) | Extiende la lista agregando los elementos de la lista. Equivale a[len(a):] = L |
| insert( i, x) | Inserta un elemento en la posición dada. |
| insert( 0, x) | Inserta al principio |
| remove(x) | Elimina el primer elemento cuyo valor es x. Error si no existe |
| pop([i]) | Elimina el elemento en la posición dada, y regresa su valor. |
| Sin parámetro es el último elemento. | |
| index(x) | Regresa el índice del primer elemento con valor x. Error si no existe |
| count(x) | Regresa el número de veces que x aparece en la lista. |
| sort([cmpfunc]) | Ordena los elementos, sobre la lista misma. |
| cmpfunc( x y, ) regresa 1 si x>y, 0 si x==y, -1 si x<y. cmp(x, y) | |
| reverse() | Ordena los elementos al revés, sobre la lista misma. |
| del a[n] | Borra elemento |
| del[ x:y] | Borra sección |
| list( secuencia ) | Lista con elementos de la secuencia |
| Pila LIFO | append(x), pop() |
| Cola FIFO | append(x), pop(0) |
| Matriz | L[r][c] |
| Lista recursiva | L.append(L) |
| len(a) | Cantidad de elementos en a |
| a[k] | Elemento de a cuya llave es k (subscripción) |
| a[k] = x | Asignar valor x a a[k] |
| del a[k] | Eliminar a[k] de a |
| a.clear() | Eliminar todos los elementos de a |
| a.copy() | Una copia de a |
| a.has_key(k) | 1 si a tiene llave k, 0 de lo contrario |
| a.items() | Una copia de la lista de parejas (llave, valor) de a |
| a.keys() | Una copia de la lista de llaves de a |
| a.update(b) | for k, v in b.items(): a[k] = v |
| a.values() | Una copia de la lista de valores de a |
| a.get(k[, x]) | a[k] si a.has_key(k), x de lo contrario |
| eval( expresión ) | Evalúa expresión |
| exec( comando) | Ejecuta instruccion(es) |
nombre = expresión
a,b = c,d (pack, unpack)
Las asignaciones no copian datos, ligan nombres a objetos. Siempre van al ámbito interno.
| máxima prioridad | ||
| llamada a función | f(argumentos) | |
| sección | x[índice:índice] | |
| subscripción | x[índice] | |
| referencia a un atributo | x.atributo | |
| unitarios | + - | |
| potencia | ** | |
| aritméticos | * / % | |
| + - | ||
| desplazar bits | » « | |
| a nivel bits | #1713#> | |
| xor | ||
| | | or | |
| comparaciones | < > == >= <= <> != | Se pueden encadenar: x < y < z |
| identidad | is [not] | |
| membresía | [not] in | |
| booleanos | not x | |
| and | ||
| or | ||
| lambda | expresión lambda |
if expresión:
instruccion(es)
[elif:
instruccion(es)]
[else:
instruccion(es)]
while expresión:
instruccion(es)
[else:
instruccion(es)]
for elemento in lista:
instruccion(es)
| continue | siguiente ciclo |
|---|---|
| break | salir del ciclo, no se ejecuta else |
| pass | no hace nada, sigue |
| Renglón en blanco | |
| print x,y,z | Separados por un espacio |
| print alfa, | Evita línea nueva al final |
| print 'cadena-de-formato' % (expresiones) | '%10s, %5d' como en printf() |
| print 'cadena-de-formato' % diccionario | '%(llave)formato' |
| rawinput( [mensaje] ) | Entrada de datos. Import readline opcional. |
import string
print string.ljust( expr, ancho), string.center( expr, ancho), string.rjust( expr, ancho)
| f=open( 'ruta-a-archivo' [, modo]) | modo: 'r', 'w', 'a', 'rb', 'wb', 'ab' |
| f.read( [bytes] ) | bytes=todos |
| f.readline( [bytes] ) | '\n' incluído al final de la cadena. |
| eof es cuando regresa cadena vacía. | |
| f.readlines( [bytesaprox] ) | bytesaprox=todos |
| f.write( expresión ) | |
| f.writelines( lista ) | |
| f.tell() | |
| f.seek( offset, respectoa) | 0 principio, 1 posición actual, 2 fin del archivo. |
| f.close() |
Predefinidos: sys.stdin sys.stdout sys.stderr
import pickle
pickle.dump( objeto, archivo)
objeto = pickle.load( archivo)
def nombre ( [parámetros] ):
''Cadena de documentación.''
instruccion(es)
[return [expresion(es)] ]
| Posicionales | nombre, ... |
| Con valor por omisión | nombre=valor_por_omisión, ... |
| Opcionales | *nombre |
nombre( [argumentos] )
| Posicionales | valor, ... |
| Con nombre | nombre=valor, ... |
| Por tupla | *tupla |
| Por diccionario | *diccionario |
Orden: de arriba a abajo.
Los argumentos pasan por referencia al objeto.
lambda parámetros: expresión. Solamente una instrucción.
Empieza con mayúscula, termina con punto, no incluye el nombre del objeto. Segunda línea vacía si tiene más líneas.
Espacio de nombres: mapeo de nombres a objetos. Implementado con diccionarios.
Alias: varios nombres pueden apuntar a un mismo objeto.
Ámbito: región de texto de un programa de python donde un nombre es accesible directamente (con referencia sin calificar). Determinados estáticamente, usados dinámicamente.
Siempre 3 ámbitos, se buscan en este orden:
| Interno | Nombres locales de la función actual. | locals(), dir(), vars() |
| Intermedio | Nombres globales del módulo actual. | globals() |
| Externo | Nombres interconstruídos |
class nombre:
instruccion(es) (usualmente definiciones de funciones)
[def __init__ (self):] se ejecuta en cada instanciación
inal de ejecutar la definición se crea un objeto clase, el nombre de la clase se liga al objeto clase en el espacio de nombres local.
rencias de atributo nombreclase.atributo
Asignaciones de atributo nombreclase.atributo = expresión
x = nombre( [argumentos-para-init] )
Atributo: x.atributo - variables
Método: x.metodo( [argumentos] ) - funciones
Primer argumento es el objeto al que pertenece: def metodo(self [,parametro(s)] ):
class clasederivada( [modulo.]clasebase [, clasebase2 ...] ):
Pueden remplazar los métodos de la clase base.
Módulo es un archivo que contiene instrucciones de pyhton y definiciones de funciones o clases.
Dado módulo.py:
import módulo
from módulo import *
reload módulo
| dir( [módulo]) | Nombres que define el módulo. |
| dir() | Nombres locales, equivale a dir( __main__ ) |
| import __builtin__ | |
| dir( __builtin_ ) | Nombres interconstruídos. |
| vars( [módulo] ) | Diccionario de símbolos del módulo. |
| __main__ | Instrucciones ejecutadas en el interpretador, con script o interactivo. |
| __builtin__ | Funciones y variables intercontruídas. |
sys.path = directorio actual, PYTHONPATH, ruta de la instalación de Python.
Al importar por primera vez, el interpretador genera código de bytes y crea el archivo módulo.pyc.
Es posible correr con .pyc solamente.
Un directorio con subdirectorios y uno o más módulos.
Debe existir __init__.py en directorio principal y cada subdirectorio, puede estar vacío.
Variable __all__ indica cuáles módulos importar con from paquete import *.
import paquete.módulo.submódulo
from paquete import módulo, ...
Revisar en news:comp.lang.python.announce
csv www.object-craft.com.au/projects/csv lectura de archivos exportados de Excel, etc.
pydoc.py genera documentación automáticamente.
inspect.py
Python 2.0 en adelante:
[python setup.py build [ -build-base=/ruta] ]
python setup.py install
try:
instruccion(es)
except [excepción(es):
instruccion(es)
else:
instruccion(es)
sys.exc_info() tupla con (tipo, valor, traza)
import exceptions; dir(exceptions)
Principales opciones para tener interfase gráfica en una aplicación de python.
| Toolkit gráfico | Módulo python | Gnu/Linux | Windows | Mac | Usado en |
| Tk | Tkinter | sí | sí | sí | Tcl |
| GTK | pygtk | sí | sí | sí | Gnome |
| Qt | pyQt | sí | sí | sí | KDE |
| wxWindows | wxpython | sí | sí | sí | Chandler |
Widgets: elementos de una interfase: botones, menús, ventana, marco, etc.
Ligas (bindings): interfase de programación de un toolkit a un lenguaje.
Jerarquía: relación de los widgets que forman una interfase.
Empacar: colocar un widget en otro contenedor.
Marco: Agrupador de otros widgets en diseños complejos. Clase base para implementar widgets compuestos.
Señales: acción del usuario con el teclado o el ratón.
Eventos: función que responde a una señal.
Manejadores (handlers): función que ejecuta un evento.
Tk incluído en distribuciones de Linux v 8.3..., y en el instalador de python para Windows.
Tkinter módulo Tkinter. Tix contiene widgets de mayor complejidad.
An introduction to Tkinter. Fredrik Lundh. Muchos ejemplos.
www.pythonware.com/library/an-introduction-to-tkinter.html.
pysol www.oberhumer.com/opensource/pysol
from Tkinter import *
root = Tk()
algo = nombre-widget(root)
algo.pack()
root.mainloop()
nombre-widget: Menu, Scrollbar, Button, TopLevel, Frame, Canvas, Text, etc.
Gimp Toolkit. www.gtk.org. www.gtk.org/api/FAQ y /tutorial
pygtk módulo pygtk www.daa.com.au/james/pygtk
pygnome módulo gnome.ui www.daa.com.au/james/gnome
Uso de widgets desde pygtk, por James Henstridge: www.gnome.org/james/pygtk-docs.
Se puede bajar pygtk-docs.tar.gz.
www.async.com.br/faq preguntas y respuestas.
theopenlab.uml.edu/pygtools
/usr/share/doc/pygtk-0.6.8/exampes/... testgtk, neil, glade, imlib
/usr/share/doc/pygnome-1.4.1/examples/...
PyGTK tutorial, John Finlay. Excelente introducción a Gtk.
www.moeraki.com/pygtktutorial/pygtktutorial.tgz
Python Gnome Tutorial, Daniel Kornhauser. daniel@bq.unam.mx
laguna.fmedic.unam.mx/daniel/pygtktutorial
Permite que aplicaciones carguen la interfase de un archivo XML durante la ejecución. Automáticamente conecta manejadores a las señales definidas en el archivo XML. Usa gtk.
pygtk-libglade módulo libglade.
pygnome-libglade módulo libglade para widgets gnome.
developer.gnome.org/doc/API/libglade/libglade.html (desde C)
Un generador visual de interfases gráficas para GTK. glade.gnome.org.
Guía de usuario (muy completa), Preguntas más frecuentes (acerca de señales y manejadores), y Tutorial. En Help de Glade, y /usr/share/gnome/help/glade/c/.
| Gtk | Gnome |
| GtkWindow | GnomeApp |
| GtkDialog | GnomeDialog |
| GtkFileSelection | GnomeMessageBox |
| GtkColorSelectionDialog | GnomeAbout |
| GtkFontSelectionDialog | GnomePropertyBox |
| GtkInputDialog |
Glade y libglade en python. Parte 1.
Hilarie Fernandes hilaire@ofset.org
www.linuxfocus.org/English/July2000/article160.shtml bajar y renombrar:
color_glade.txt -> color.glade, couleur_py.txt -> couleur.py
Parte 2.
www.linuxfocus.org/English/January2001/article224.shtml ????
Pygnome, pygtk and libglade tutorial.
autor...
sjbrown.geeky.net/metagame-sector/tutorial.html. hello y simple.
Writing gnome applications with Glade and Python, Robert Laing.
www.icon.co.zq/zapr/project1.html
www.trolltech.com. Es GPL desde Noviembre 2001.
www.wxwindows.org, www.wxpython.org
Karel el robot pykarel.sourceforge.net