Materiales Del Entrenamiento de Programación en Python - Nivel Básico
Materiales Del Entrenamiento de Programación en Python - Nivel Básico
Leonardo J. Caballero G.
07 de septiembre de 2022
I
7. Operaciones de E/S y manipulación de archivos 151
7.1. Entrada/Salida en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
7.2. Manipulación de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
II
B.10. Lección 10 - Decoradores y la librería estándar . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
C. Operadores 267
C.1. Operadores de asignaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
C.2. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
C.3. Operadores relacionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
C.4. Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
E. Glosario 277
F. Licenciamientos 281
F.1. Reconocimiento-CompartirIgual 3.0 Venezuela de Creative Commons . . . . . . . . . . . . . . . 281
Índice 283
III
IV
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Repositorio de manuales y recursos del entrenamiento «Programación en Python 2.71 - Nivel básico» realizado
por la empresa Covantec R.L2 .
Para dominar el lenguaje de programación se tiene pensado como un entrenamiento de 2 a 3 días para las
personas que son nuevas usándolo o los que quieren aprender acerca de las mejores prácticas actuales del
desarrollo en Python.
La planificación de este entrenamiento se estima en:
Un entrenamiento de nivel básico (2 a 3 días) que cubre los diez (10) capítulos.
Tabla de contenidos:
1 https://docs.python.org/2.7/
2 https://github.com/Covantec
Índice general 1
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
2 Índice general
CAPÍTULO 1
Python es un lenguaje de programación de propósito general muy poderoso y flexible, a la vez que sencillo y fácil
de aprender.
En esta lección se busca introducir al lenguaje Python, sus características, modos de instalación, soporte comu-
nitario, y los recursos mas destacados disponibles en la Web para tomar en cuenta. A continuación el temario de
esta lección:
Python es un lenguaje de programación de propósito general muy poderoso y flexible, a la vez que sencillo y fácil
de aprender. Es un lenguaje de alto nivel, que permite procesar fácilmente todo tipo de estructuras de datos, tanto
numéricos como de texto.
Este lenguaje fue creado a principios de los noventa por Guido van Rossum3 en los Países Bajos.
Es relativamente joven (Fortran 1957, Pascal 1970, C 1972, Modula-2 1978, Java 1991). Toma características de
lenguajes predecesores, incluso, compatibilizando la solución de varios de ellos. Por ejemplo, habilita tres formas
de imprimir el valor de una variable: desde el entorno interactivo escribiendo su nombre (como en Basic), usando
la función print, con concatenación de elementos (al estilo del write de Pascal) o bien con patrones de formato
(al estilo del printf de C).
Es software libre, y está implementado en todas las plataformas (página 9) y sistemas operativos habituales.
3 https://es.wikipedia.org/wiki/Guido_van_Rossum
3
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Python se desarrolla bajo una licencia de Open source o código abierto aprobada por OSI, por lo que se puede
usar y distribuir libremente, incluso para uso comercial.
La Python Software Foundation (PSF) es una corporación sin fines de lucro 501 (c) (3) que posee los derechos de
propiedad intelectual detrás del lenguaje de programación Python. Administramos las licencias de código abierto
para Python versión 2.1 y posteriores, y poseemos y protegemos las marcas comerciales asociadas con Python.
También realiza la conferencia PyCon de Norteamérica anualmente, apoyamos otras conferencias de Python en
todo el mundo y financiamos el desarrollo relacionado con Python con nuestro programa de subvenciones7 y
financiamos proyectos especiales.
La misión de Python Software Foundation es promover, proteger y avanzar el lenguaje de progra-
mación Python, y apoyar y facilitar el crecimiento de una comunidad diversa8 e internacional de
programadores de Python.
—De la página de la Declaración de la Misión9 .
1.1.2 Aplicaciones
El Python Package Index (PyPI)10 o en español significa Índice de paquetes de Python alberga miles de módulos
de terceros para Python.
Tanto la biblioteca estándar de Python como los módulos aportados por la comunidad permiten infinitas posibili-
dades.
Desarrollo web e Internet11 .
Acceso a la base de datos12 .
GUIs de escritorio13 .
Científico y numérico14 .
Educación15 .
Programación de red16 .
6 https://www.python.org/psf-landing/
7 https://www.python.org/psf/grants/
8 https://www.python.org/psf/diversity/
9 https://www.python.org/psf/mission/
10 https://pypi.org/
11 https://www.python.org/about/apps/#web-and-internet-development
12 https://www.python.org/about/apps/#database-access
13 https://www.python.org/about/apps/#desktop-guis
14 https://www.python.org/about/apps/#scientific-and-numeric
15 https://www.python.org/about/apps/#education
16 https://www.python.org/about/apps/#network-programming
1.1.3 Comunidad
El gran software es soportado por grandes personas. La base de usuarios es entusiasta, dedicada a fomentar el uso
del lenguaje y comprometida a que sea diversa y amigable.
Declaración de Diversidad
La Python Software Foundation (página 5) y la comunidad a nivel mundial de Python dan la bienvenida y fomentan
la participación de todos. La comunidad se basa en el respeto mutuo, la tolerancia y el aliento, y estamos trabajando
para ayudarnos mutuamente a cumplir con estos principios. Queremos que nuestra comunidad sea más diversa:
sea quien sea, y cualquiera sea su experiencia, le damos la bienvenida.
17 https://www.python.org/about/apps/#software-development
Listas de correo
Existen listas de correo de Python y grupos de noticias como recursos de la comunidad. Estos recursos están
disponibles públicamente de python.org, y son usando como un canal de información o discusión sobre ideas
nuevas, e incluso históricamente como otra vía soporte en linea.
Ademas hay la guía de recursos de Python que no están en inglés, que incluye listas de correo, documentación
traducida y original que no está en inglés, y otros recursos.
Existen muchos canales relacionados con Python en la red Internet Relay Chat (IRC) de Freenode. Todos los
canales esta disponibles en el servidor de IRC en Freenode18 . Para conectarse al servidor IRC use irc.freenode.net
o puede usar la interfaz web de chat IRC de Freenode19 .
Para preguntas cortas, usted puede obtener ayuda inmediata visitando el canal #python. Usted necesitará regis-
trar su apodo con FreeNode, usando la guiá de instrucciones para registrar apodo20 .
Foros
Comunidades locales
Siendo Python un proyecto Open source (página 4) el cual es mantenido por toda una gran comunidad de usuarios
y desarrolladores a nivel mundial, la cual ofrece soporte comunitario del proyecto Python en Sudamérica.
Comunidad(es) de Python en Argentina Nuestro objetivo es nuclear a los usuarios de Python. Pretendemos
llegar a personas y empresas, promover el uso de Python e intercambiar información. Más información
visite http://www.python.org.ar/
Comunidad(es) de Python en Brasil La comunidad Python Brasil reúne grupos de usuarios en todo el Brasil
interesados en difundir e divulgar a lenguaje de programación. Más información visite http://python.org.br
Comunidad(es) de Python en Chile Una comunidad de amigos apasionados por la tecnología e informática, que
busca compartir conocimiento de forma libre y sin fines de lucro, con el fin de fortalecer a los miembros de
la comunidad para generar un impacto positivo en la región. Más información visite https://pythonchile.cl/
comunidad/
18 https://freenode.net/view/Main_Page
19 https://webchat.freenode.net/
20 https://old.freenode.net/kb/answer/registration
21 https://python-forum.io/
22 https://www.python-forum.de/
23 https://www.reddit.com/r/learnpython/
24 https://wiki.python.org/moin/
Comunidad(es) de Python en Colombia Somos una comunidad enfocada en extender en el territorio nacional el
uso y aprendizaje de las distintas tecnologías Python y sus numerosas aplicaciones. Más información visite
https://www.python.org.co/
Comunidad(es) de Python en Ecuador Somos una comunidad independiente, conformada por entusiastas de
Python, con la filosofía común de que el conocimiento debe ser libre. No lucramos con ningún evento, y
esperamos llegar a todos aquellos que desean aprender. Más información visite https://python.ec/
Comunidad(es) de Python en Perú Comunidad de estudiantes, profesionales e interesados en tener un espacio
donde conversar, preguntar e intercambiar ideas todo acerca del lenguaje de programación Python. Más
información visite https://www.meetup.com/es/pythonperu/
Comunidad(es) de Python en Paraguay Las comunidades de Python están presentes en todo el mundo, con
el objeto de apoyar a los usuarios de este lenguaje y difundirlo. En Paraguay lo conforman un grupo de
entusiastas de Python, que creemos que podemos sumar ganas y esfuerzo para lograr difundir y ayudar
a toda aquella persona que se interese por Python a crecer dentro del sus interés. Entre las funciones de
la comunidad organizamos eventos de distinto tipo para difundir el lenguaje, desde PyDay, meetup hasta
simples reuniones para comentar ideas y experiencias. Más información visite https://pythonpy.org
Comunidad(es) de Python en Uruguay Para más información visite https://python.uy
Comunidad(es) de Python en Venezuela La Fundación Python de Venezuela (FPyVE) es una organización sin
fines de lucro creada el 2 de febrero de 2015 dedicada a fomentar al lenguaje de programación Python. El
objetivo principal es el desarrollo, ejecución y/o consultoría de proyectos científicos, tecnológicos y pro-
ductivos, para cumplir fines de interés público en torno al desarrollo Nacional, haciendo uso y promoviendo
para tal fin, el uso del lenguaje de programación Python y las tecnologías asociadas a éste. Más información
visite http://pyve.github.io/
Ver también:
Consulte la sección de lecturas suplementarias (página 261) del entrenamiento para ampliar su conocimiento en
esta temática.
1.2 Características
El fuertemente tipado30 significa que el tipo de valor no cambia repentinamente. Un string (página 46) que contiene
solo dígitos no se convierte mágicamente en un número. Cada cambio de tipo requiere una conversión explícita.
A continuación un ejemplo de este concepto:
25 https://es.wikipedia.org/wiki/Python#Características_y_paradigmas
26 https://es.wikipedia.org/wiki/Lenguaje_interpretado
27 https://es.wikipedia.org/wiki/Categor%C3%ADa:Lenguajes_de_programaci%C3%B3n_multiparadigma
28 https://es.wikipedia.org/wiki/Programación_imperativa
29 https://es.wikipedia.org/wiki/Programación_funcional
30 https://es.wikipedia.org/wiki/Lenguaje_de_programación_fuertemente_tipado
# varible "valor1" guarda un valor entero, varible "valor2" guarda un valor cadena
valor1, valor2 = 2, "5"
# se usa el metodo int() para convertir a entero
total = valor1 + int(valor2)
# se usa el metodo str() para convertir a cadena
print ("El total es: " + str(total))
El tipado dinámico31 significa que los objetos en tiempo de ejecución (valores) tienen un tipo, a diferencia del
tipado estático donde las variables tienen un tipo. A continuación un ejemplo de este concepto:
1.2.3 Multiplataforma
Python es multiplataforma32 , lo cual es ventajoso para hacer ejecutable su código fuente entre varios sistema
operativos, eso quiere decir, soporta las siguientes plataformas para su ejecución:
Versiones Python para Microsoft Windows (y DOS)33 (arquitectura x86/x86-64 en presentación de ejecuta-
ble, archivo Zip, instalador basado en la Web).
Truco: Para mayor información consulte la sección Instalando Python en Windows (página 12).
Versiones Python para macOS (Macintosh)34 (arquitectura 32bit/64bit en presentación de instalador ejecu-
table).
Truco: Para mayor información consulte la sección Instalando Python en una Mac (página 12).
Versiones Python en código fuente35 (archivo tarball del código fuente comprimido con XZ y con Gz). Para
las mayoría de los sistemas Linux/UNIX, usted debe descargar y compilar el código fuente.
Truco: Para mayor información consulte la sección Instalando Python en un Linux (página 12).
1.2. Características 9
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Nota: Tenga en cuenta que estos migraciones a menudo están muy por detrás de la última versión de
Python.
Es una colección de 20 principios de software que influyen en el diseño del Lenguaje de Programación Python, de
los cuales 19 fueron escritos por Tim Peters en junio de 1999. El texto es distribuido como dominio público.
El Zen de Python está escrito como la entrada informativa número 20 de las propuestas de mejoras de Python
(Python Enhancement Proposals - PEP), y se puede encontrar en el sitio oficial de Python.
Los principios están listados a continuación:
Bello es mejor que feo.
Explícito es mejor que implícito.
Simple es mejor que complejo.
Complejo es mejor que complicado.
Plano es mejor que anidado.
Disperso es mejor que denso.
La legibilidad cuenta.
Los casos especiales no son tan especiales como para quebrantar las reglas.
Lo práctico gana a lo puro.
39 https://www.pypy.org/
40 https://github.com/stackless-dev/stackless/wiki/
41 http://micropython.org/
42 https://www.python.org/download/other/
43 http://omz-software.com/pythonista/index.html
44 https://www.activestate.com/products/python/
A continuación se presentan algunas ventajas y desventajas que están presentan en el lenguaje Python:
1.3.1 Ventajas
1.3.2 Desventajas
Librerías incluidas Algunas librerías que trae por defecto no son del gusto de amplio de la comunidad, y optan
a usar librerías de terceros.
1.4 Instalación
Debido al soporte multiplataforma (página 9) de Python, se ofrecen ciertos recursos para los sistemas operativos
más populares:
En una distribución estándar Linux dispone por defecto el interprete Python instalado, para comprobar la correcta
instalación solamente debería ejecutar el comando en la consola:
python
Python 2.7.13 (default, Sep 26 2018, 18:42:22)
[GCC 6.3.0 20170516] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
Si le muestra los mensajes anteriores esta correctamente instalado el interprete Python en su Linux.
Si al ejecutar el comando anterior muestra el mensaje:
python
bash: python: no se encontró la orden
Esto es debido a que no tiene instalado el interprete, así que debe ejecutar el siguiente comando:
Ver también:
Consulte la sección de lecturas suplementarias (página 261) del entrenamiento para ampliar su conocimiento en
esta temática.
En informática, un programa Hola Mundo es el que imprime el texto «¡Hola, Mundo!» en un dispositivo de
visualización, en la mayoría de los casos una pantalla de monitor. Este programa suele ser usado como introducción
al estudio de un lenguaje de programación, siendo un primer ejercicio típico, y se lo considera fundamental desde
el punto de vista didáctico.
45 https://www.youtube.com/watch?v=VTykmP-a2KY
46 https://es.wikibooks.org/wiki/Python/Instalaci%C3%B3n_de_Python/Python_en_Mac_OS_X
El Hola Mundo se caracteriza por su sencillez, especialmente cuando se ejecuta en una interfaz de línea de co-
mandos. En interfaces gráficas la creación de este programa requiere de más pasos.
El programa Hola Mundo también puede ser útil como prueba de configuración para asegurar que el compilador,
el entorno de desarrollo y el entorno de ejecución estén instalados correctamente y funcionando.
Python 3.x:
print("Hola Mundo");
1.5.2 Ejecución
Dependiendo del sistema operativo que este usando debe realizar procedimientos distintos para cada plataforma
cuando usted quiere escribir y ejecutar un programa Python. A continuación un procedimiento básico para las
principales plataformas:
Cree un directorio llamado proyectos la unidad C:\ y dentro de este, cree un archivo de texto plano con el
siguiente nombre holamundo.py y escriba la sintaxis de Python 2 (página 13) o Python 3 (página 13) respecti-
vamente.
Luego ejecute desde la consola de MS-DOS el siguiente comando:
C:\Python27\python C:\proyectos\holamundo.py
Cree un directorio llamado proyectos el home de su usuario y dentro de este, cree un archivo de texto plano
con el siguiente nombre holamundo.py y escriba la sintaxis de Python 2 (página 13) o Python 3 (página 13)
respectivamente.
Luego ejecute desde la consola de comando el siguiente comando:
python $HOME/proyectos/holamundo.py
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código holamundo.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python holamundo.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python siendo un lenguaje interpretado tiene a disposición un shell de comando para hacer introspección
del lenguaje, ademas también existe una forma de hacer mas interactiva la introspección del lenguaje, usando el
paquete ipython.
En esta lección se busca introducir a la introspección del lenguaje Python usando el interprete como el modo
interactivo del paquete adicional ipython, y las ventajas aplicar la técnica de introspección en sus practicas de
programación diarias con el lenguaje. A continuación el temario de esta lección:
La inmersión al modo interactivo le permite a cualquier usuario el cual NUNCA ha trabajando con el interprete de
Python47 pueda tener un primer acercamiento SIN PROGRAMAR, solamente con conocer el uso del interprete
y sus comandos básicos usando la técnica de introspección.
En Python como usted lo ira entendiendo todo en Python es un objeto, y la técnica de introspección, no es más
que código el cual examina como objetos otros módulos y funciones en memoria, obtiene información sobre ellos
y los que los maneja.
De paso, usted podrá definir las funciones sin nombre, las llamará a funciones con argumentos sin orden, y podrá
hacer referencia a funciones cuyos nombres desconocemos.
15
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
programadores Python se acostumbraron a estudiar su código de esta forma, así que le recomiendo que use
el interprete python para eso.
Hoy en día existente herramientas que te permiten generar documentación desde los códigos fuentes Python
como Sphinx50 .
La forma mas fácil es iniciar tu relación con Python simplemente ejecutando el comando python de la siguiente
forma:
python
Python 2.7.13 (default, Sep 26 2018, 18:42:22)
[GCC 6.3.0 20170516] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> help
Type help() for interactive help, or help(object) for help about object.
>>> help()
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/2.7/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
Para ejecutar la ayuda disponible sobre la sintaxis Python ejecute el siguiente comando:
help> modules
Enter any module name to get more help. Or, type "modules spam" to search
for modules whose descriptions contain the word "spam".
help> os
Help on module os:
NAME
os - OS routines for NT or Posix depending on what system we're on.
FILE
/usr/lib/python2.7/os.py
MODULE DOCS
https://docs.python.org/library/os
DESCRIPTION
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
- os.extsep is the extension separator ('.' or '/')
- os.altsep is the alternate pathname separator (None or '/')
- os.pathsep is the component separator used in $PATH etc
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
- os.defpath is the default search path for executables
- os.devnull is the file path of the null device ('/dev/null', etc.)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
:
>>> import os
>>>
Previamente importada la librería usted puede usar la función dir() para listar o descubrir que atributos, métodos
de la clase están disponibles con la importación
>>> dir(os)
['EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR', 'EX_NOHOST',
'EX_NOINPUT', 'EX_NOPERM', 'EX_NOUSER', 'EX_OK', 'EX_OSERR', 'EX_OSFILE',
'EX_PROTOCOL', 'EX_SOFTWARE', 'EX_TEMPFAIL', 'EX_UNAVAILABLE',
'EX_USAGE', 'F_OK', 'NGROUPS_MAX', 'O_APPEND', 'O_CREAT', 'O_DIRECT',
'O_DIRECTORY', 'O_DSYNC', 'O_EXCL', 'O_LARGEFILE', 'O_NDELAY',
'O_NOCTTY', 'O_NOFOLLOW', 'O_NONBLOCK', 'O_RDONLY', 'O_RDWR', 'O_RSYNC',
'O_SYNC', 'O_TRUNC', 'O_WRONLY', 'P_NOWAIT', 'P_NOWAITO', 'P_WAIT',
'R_OK', 'SEEK_CUR', 'SEEK_END', 'SEEK_SET', 'TMP_MAX', 'UserDict',
'WCONTINUED', 'WCOREDUMP', 'WEXITSTATUS', 'WIFCONTINUED', 'WIFEXITED',
'WIFSIGNALED', 'WIFSTOPPED', 'WNOHANG', 'WSTOPSIG', 'WTERMSIG',
'WUNTRACED', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__',
'__doc__', '__file__', '__name__', '_copy_reg', '_execvpe', '_exists',
'_exit', '_get_exports_list', '_make_stat_result',
'_make_statvfs_result', '_pickle_stat_result', '_pickle_statvfs_result',
'_spawnvef', 'abort', 'access', 'altsep', 'chdir', 'chmod', 'chown',
'chroot', 'close', 'confstr', 'confstr_names', 'ctermid', 'curdir',
'defpath', 'devnull', 'dup', 'dup2', 'environ', 'errno', 'error',
'execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp',
'execvpe', 'extsep', 'fchdir', 'fdatasync', 'fdopen', 'fork', 'forkpty',
'fpathconf', 'fstat', 'fstatvfs', 'fsync', 'ftruncate', 'getcwd',
'getcwdu', 'getegid', 'getenv', 'geteuid', 'getgid', 'getgroups',
'getloadavg', 'getlogin', 'getpgid', 'getpgrp', 'getpid', 'getppid',
'getsid', 'getuid', 'isatty', 'kill', 'killpg', 'lchown', 'linesep',
'link', 'listdir', 'lseek', 'lstat', 'major', 'makedev', 'makedirs',
'minor', 'mkdir', 'mkfifo', 'mknod', 'name', 'nice', 'open', 'openpty',
'pardir', 'path', 'pathconf', 'pathconf_names', 'pathsep', 'pipe',
'popen', 'popen2', 'popen3', 'popen4', 'putenv', 'read', 'readlink',
'remove', 'removedirs', 'rename', 'renames', 'rmdir', 'sep', 'setegid',
'seteuid', 'setgid', 'setgroups', 'setpgid', 'setpgrp', 'setregid',
'setreuid', 'setsid', 'setuid', 'spawnl', 'spawnle', 'spawnlp',
'spawnlpe', 'spawnv', 'spawnve', 'spawnvp', 'spawnvpe', 'stat',
'stat_float_times', 'stat_result', 'statvfs', 'statvfs_result',
'strerror', 'symlink', 'sys', 'sysconf', 'sysconf_names', 'system',
'tcgetpgrp', 'tcsetpgrp', 'tempnam', 'times', 'tmpfile', 'tmpnam',
'ttyname', 'umask', 'uname', 'unlink', 'unsetenv', 'urandom', 'utime',
'wait', 'wait3', 'wait4', 'waitpid', 'walk', 'write']
>>>
Otro ejemplo de uso, es poder usar el método file para determinar la ubicación de la librería importada de la
siguiente forma:
>>> os.__file__
'/usr/lib/python2.7/os.pyc'
>>>
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
(continué en la próxima página)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
>>>
>>> exit()
Para mejorar la experiencia con el interprete Python le sugerimos instalar el paquete ipython, según su docu-
mentación:
Según Wikipedia
«ipython es un shell interactivo que añade funcionalidades extra al modo interactivo52 incluido con
Python, como resaltado de líneas y errores mediante colores, una sintaxis adicional para el shell, com-
pletado automático mediante tabulador de variables, módulos y atributos; entre otras funcionalidades.
Es un componente del paquete SciPy53 .»
Para mayor información visite su página principal de ipython54 y si necesita instalar este programa ejecute el
siguiente comando:
Luego cierra sesión de root y vuelve al usuario y sustituya el comando python por ipython de la siguiente
forma:
ipython
Python 2.7.13 (default, Sep 26 2018, 18:42:22)
Type "copyright", "credits" or "license" for more information.
In [1]:
Un ejemplo de uso del comando help es consultar la ayuda del comando dir y se ejecuta de la siguiente forma:
In [1]: help(dir)
Help on built-in function dir in module __builtin__:
(continué en la próxima página)
52 https://es.wikipedia.org/wiki/Python#Modo_interactivo
53 https://en.wikipedia.org/wiki/SciPy
54 https://ipython.readthedocs.io/
dir(...)
dir([object]) -> list of strings
In [2]: import os
También consultar los detalles acerca del “objeto” para esto use como ejemplo la librería os ejecutando el si-
guiente comando:
In [2]: os?
Type: module
String form: <module 'os' from '/usr/lib/python2.7/os.pyc'>
File: /usr/lib/python2.7/os.py
Docstring:
OS routines for NT or Posix depending on what system we're on.
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
- os.extsep is the extension separator ('.' or '/')
- os.altsep is the alternate pathname separator (None or '/')
- os.pathsep is the component separator used in $PATH etc
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
- os.defpath is the default search path for executables
- os.devnull is the file path of the null device ('/dev/null', etc.)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
Escriba la librería os. y luego escribe dos underscore y presione dos veces la tecla tabular para usar la completado
automático del interprete al estilo de completación de lineas de comandos55 en el shell UNIX/Linux para ayudar
a la introspección del lenguaje y sus librerías.
In [3]: os.__
os.__all__ os.__file__
os.__builtins__ os.__name__
os.__doc__ os.__package__
55 https://en.wikipedia.org/wiki/Command_line_completion
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
- os.extsep is the extension separator ('.' or '/')
- os.altsep is the alternate pathname separator (None or '/')
- os.pathsep is the component separator used in $PATH etc
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
- os.defpath is the default search path for executables
- os.devnull is the file path of the null device ('/dev/null', etc.)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
NAME
os - OS routines for NT or Posix depending on what system we're on.
FILE
/usr/lib/python2.7/os.py
MODULE DOCS
https://docs.python.org/library/os
DESCRIPTION
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
- os.extsep is the extension separator ('.' or '/')
- os.altsep is the alternate pathname separator (None or '/')
- os.pathsep is the component separator used in $PATH etc
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
- os.defpath is the default search path for executables
- os.devnull is the file path of the null device ('/dev/null', etc.)
(continué en la próxima página)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
:
Alternativamente puedes usar el paquete bpython que mejora aun mas la experiencia de trabajo con el paquete
ipython.
Para mayor información visite su página principal de interprete bpython56 y si necesita instalar este programa
ejecute el siguiente comando:
sudo apt-get install python-pip
sudo pip install bpython
Luego cierra sesión de root y vuelve al usuario y sustituya el comando python por ipython de la siguiente
forma:
bpython
Dentro de interprete Python puede apreciar que ofrece otra forma de presentar la documentación y la estructura
del lenguaje, con los siguientes comandos de ejemplos:
>>> print 'Hola Mundo'
Hola Mundo
>>> for item in xrange(
+ +
xrange: ([start, ] stop[, step])
xrange([start,] stop[, step]) -> xrange object
<C-r> Rewind <C-s> Save <F8> Pastebin <F9> Pager <F2> Show Source
2.1.5 Conclusiones
Como puede apreciar este tutorial no le enseña a programar sino a simplemente aprender a conocer como manejar-
se en shell de Python y en el modo interactivo usando el paquete ipython y otros adicionales como bpython,
con el fin de conocer a través de la introspección del lenguaje, las librerías estándar y módulos propios escritos en
Python que tienes instalado en tu sistema.
Ver también:
56 https://bpython-interpreter.org/
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python tiene varios tipos de datos compuestos estándar disponibles por defecto en el interprete, como los tipos
numéricos, secuencias, mapeos y conjuntos usados para agrupar otros valores.
Para el caso de las estructuras de datos se usan variables y constantes las cuales usan operadores para tratar los
tipos de datos estándar.
En esta lección se describen las variables, operadores y sus tipos de datos en el lenguaje Python, los cuales se
resumieron en esta tabla. A continuación el temario de esta lección:
A continuación se muestra una lista de los tipos que están integrados en Python. Los módulos de extensión (escritos
en C, Java u otros lenguajes, dependiendo de la implementación) pueden definir tipos adicionales. Las versiones
futuras de Python pueden agregar tipos a la jerarquía de tipos (por ejemplo, números racionales, arrays de enteros
almacenados eficientemente, etc.).
Algunas de las descripciones de tipo a continuación contienen un párrafo que enumera los «atributos especiales».
Estos son atributos que proporcionan acceso a la implementación y no están destinados para uso general. Su
definición puede cambiar en el futuro.
En Python tiene varios tipos de datos compuestos estándar disponibles por defecto en el interprete, como los tipos
numéricos, secuencias, mapeos y conjuntos usados para agrupar otros valores.
Para el caso de las estructuras de datos se usan variables y constantes las cuales usan operadores para tratar los
tipos de datos estándar.
3.1.1 Clasificación
Los tipos de datos compuestos estándar se pueden clasificar como los dos siguientes:
Mutable: su contenido (o dicho valor) puede cambiarse en tiempo de ejecución.
Inmutable: su contenido (o dicho valor) no puede cambiarse en tiempo de ejecución.
Se pueden resumir los tipos de datos compuestos estándar en la siguiente tabla:
25
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Los objectos Type representan los diversos tipos de objetos. Un objecto type es accedido por la función integrada
type() (página 122). No hay operaciones especiales en los tipos. El módulo estándar types defines los nombres
para todos los tipos integrados estándar.
Los tipos son escritos como esto: «<type “int”>».
3.2.1 Variables
Es un nombre que se refiere a un objeto que reside en la memoria. El objeto puede ser de alguno de los tipos vistos
(número o cadena de texto), o alguno de los otros tipos existentes en Python.
Cada variable debe tener un nombre único llamado identificador. Eso es muy de ayuda pensar las variables como
contenedores que contienen data el cual puede ser cambiado después a través de técnicas de programación.
Las variables en Python son locales por defecto. Esto quiere decir que las variables definidas y utilizadas en el
bloque de código de una función (página 100), sólo tienen existencia dentro de la misma, y no interfieren con otras
variables del resto del código.
A su vez, las variables existentes fuera de una función (página 100), no son visibles dentro de la misma.
En caso de que sea conveniente o necesario, una variable local puede convertirse en una variable global declarán-
dola explícitamente como tal con la sentencia global (página 31).
Ejemplos de variables
Como puede ver en Python, a diferencia de muchos otros lenguajes, no se declara el tipo de la variable al crearla.
En Java, por ejemplo, definir una variable seria así:
String c = "Hola Mundo";
int e = 23;
También nos ha servido el pequeño ejemplo para presentar los comentarios en linea en Python: cadenas de carac-
teres que comienzan con el carácter # y que Python ignora totalmente. Hay más tipos de comentarios (página 49),
de los cuales se tratarán más adelante.
Si usted quiere asignar el mismo valor a múltiples variables al mismo tiempo, usted puede hacer lo siguiente:
>>> x = y = z = True
>>> print x
True
>>> print y
True
>>> print z
True
El segundo programa asigna el mismo valor booleano a todas las tres variables x, y, z.
3.2.2 Constantes
Una constante es un tipo de variable la cual no puede ser cambiada. Eso es muy de ayuda pensar las constantes
como contenedores que contienen información el cual no puede ser cambiado después.
En Python, las constantes son usualmente declaradas y asignadas en un módulo. Aquí, el módulo significa un
nuevo archivo que contiene variables, funciones, etc; el cual es importada en el archivo principal. Dentro del
módulo, las constantes son escritas en letras MAYÚSCULAS y separadas las palabras con el carácter underscore
_.
Constantes integradas
Un pequeño número de constantes vive en el espacio de nombres incorporado. Son las siguientes:
None Más información consulte sobre None (página 210).
NotImplemented Más información consulte sobre NotImplemented (página 210).
Ellipsis Más información consulte sobre Ellipsis (página 210).
False El valor falso del tipo booleano (página 44).
True El valor verdadero del tipo booleano (página 44).
__debug__ Esta constante su valor es True si Python no se inició con una opción -O. Véase también la
sentencia assert (página 186).
Nota: Los nombres None (página 210) y __debug__ no se pueden reasignar (asignaciones a ellos, incluso como
un nombre de atributo, causa una excepción SyntaxError (página 192)), por lo que pueden considerarse constantes
«verdaderas».
Ejemplo de constantes
IP_DB_SERVER = "127.0.0.1"
PORT_DB_SERVER = 3307
USER_DB_SERVER = "root"
PASSWORD_DB_SERVER = "123456"
DB_NAME = "nomina"
import constantes
python main.py
En el programa anterior, existe un archivo de módulo constantes.py. Entonces en este se asignan los va-
lores de constantes IP_DB_SERVER, PORT_DB_SERVER, USER_DB_SERVER, PASSWORD_DB_SERVER y
DB_NAME. Ademas, existe el archivo de módulo main.py el cual importa el módulo constantes. Finalmente,
se imprime una linea de conexión del comando scp de Linux usando la función integrada en la librería estándar
Python llamada format() (página 131).
Nota: En realidad, no se usa las constantes en Python. El módulo globals o constants es usado a lo largo
de los programas de Python.
Existen ciertas palabras que tienen significado especial para el intérprete de Python. Estas no pueden utilizarse
para ningún otro fin (como ser nombrar valores) excepto para el que han sido creadas. Estas son:
and (página 86).
as.
assert (página 186).
break (página 89).
class (página 200).
continue (página 89).
def (página 100).
del (página 31).
elif (página 84).
else (página 84).
except (página 184).
exec.
finally (página 188).
for (página 90).
from (página 162).
global (página 31).
if (página 84).
import (página 159).
in (página 84).
is (página 84).
lambda (página 112).
not (página 86).
or (página 86).
pass (página 104).
print (página 153).
raise (página 186).
Puede verificar si una palabra esta reservada utilizando el módulo integrado keyword, de la siguiente forma:
Algunas reglas y convenciones de nombres para las variables (página 26) y constantes (página 28):
Nunca use símbolos especiales como !, @, #, $, %, etc.
El primer carácter no puede ser un número o dígito.
Las constantes son colocadas dentro de módulos Python y significa que no puede ser cambiado.
Los nombres de constante y variable debería tener la combinación de letras en minúsculas (de a a la z) o
MAYÚSCULAS (de la A a la Z) o dígitos (del 0 al 9) o un underscore (_). Por ejemplo:
• snake_case
• MACRO_CASE
• camelCase
• CapWords
Los nombres que comienzan con guión bajo (simple _ o doble __) se reservan para variables con significado
especial
No pueden usarse como identificadores, las palabras reservadas (página 29) .
La sentencia del se define recursivamente muy similar a la forma en el cual se define la asignación. A continua-
ción unos ejemplos donde se inicializan variables:
Luego de inicializar las variables del código anterior, usted puede usar la función vars() (página 122) para obtener
un diccionario conteniendo ámbito actual de las variables, ejecutando:
>>> vars()
{'tupla': (11, 'Chao Plone', True, None),
'__builtins__': <module '__builtin__' (built-in)>,
'numero': 123456, '__package__': None, 'cadena': 'Hola Plone',
'diccionario': {'apellido': 'Caballero', 'nombre': 'Leonardo'},
'__name__': '__main__', 'lista': [7, 8, 9, 0], '__doc__': None}
Como pudo ver en el ejemplo anterior que elimino la referencia a la variable cadena, incluso al volver a la
función vars() (página 122) ya no sale en el ámbito de variables disponibles.
La eliminación de una lista de objetivos elimina recursivamente cada objetivo, de izquierda a derecha.
Como pudo ver en el ejemplo anterior que elimino las referencias a las variables numero, lista, tupla,
diccionario que incluso al volver a la función vars() (página 122) ya no están en el ámbito de variables
disponibles.
La eliminación de un nombre elimina el enlace de ese nombre del espacio de nombres local o global, dependiendo
de si el nombre aparece en una sentencia «global (página 31)» en el mismo bloque de código. Si el nombre no
está vinculado, se generará una excepción «NameError (página 192)».
Truco: Es ilegal eliminar un nombre del espacio de nombres local si aparece como una variable libre en un bloque
anidado.
La eliminación de las referencias de atributos, suscripciones y segmentaciones se pasa al objeto primario involu-
crado; la eliminación de un corte es en general equivalente a la asignación de un corte vacío del tipo correcto (pero
incluso esto está determinado por el objeto cortado).
La sentencia global es una declaración que se mantiene para todo el bloque de código actual. Eso significa que
los identificadores listados son interpretados como globales. Eso podría ser imposible asignar a una variable global
sin la sentencia global, aunque las variables libres pueden referirse a globales sin ser declaradas globales.
Como se puede ver, después de llamar a la función variable_global(), la variable variable1 queda
modificada. En general, este procedimiento debe utilizarse con precaución.
Importante: Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:
constantes.py y main.py.
Truco: Para ejecutar el código constantes.py y main.py, abra una consola de comando, acceda al direc-
torio donde se encuentra ambos programas:
leccion3/
constantes.py
main.py
python main.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
3.3.1 Operador =
El operador igual a, (=), es el más simple de todos y asigna a la variable del lado izquierdo cualquier variable o
resultado del lado derecho.
3.3.2 Operador +=
El operador += suma a la variable del lado izquierdo el valor del lado derecho.
>>> r = 5; r += 10; r
15
En el ejemplo anterior si la variable «r» es igual a 5 y r += 10, entonces la variable «r» sera igual a 15. Su
equivalente seria el siguiente:
>>> r = 5; r = r + 10; r
15
3.3.3 Operador -=
El operador -= resta a la variable del lado izquierdo el valor del lado derecho.
>>> r = 5; r -= 10; r
-5
En el ejemplo anterior si la variable «r» es igual a 5 y r -= 10, entonces la variable «r» sera igual a -5. Su
equivalente seria el siguiente:
>>> r = 5; r = r - 10; r
-5
3.3.4 Operador *=
El operador *= multiplica a la variable del lado izquierdo el valor del lado derecho.
>>> r = 5; r *= 10; r
50
En el ejemplo anterior si la variable «r» es igual a 5 y r *= 10, entonces la variable «r» sera igual a 50. Su
equivalente seria el siguiente:
>>> r = 5; r = r * 10; r
50
3.3.5 Operador /=
El operador /= divide a la variable del lado izquierdo el valor del lado derecho.
>>> r = 5; r /= 10; r
0
En el ejemplo anterior si la variable «r» es igual a 5 y r /= 10, entonces la variable «r» sera igual a 0. Su
equivalente seria el siguiente:
>>> r = 5; r = r / 10; r
0
El operador **= calcula el exponente a la variable del lado izquierdo el valor del lado derecho.
En el ejemplo anterior si la variable «r» es igual a 5 y r **= 10, entonces la variable «r» sera igual a 9765625.
Su equivalente seria el siguiente:
>>> r = 5; r = r ** 10; r
9765625
El operador //= calcula la división entera a la variable del lado izquierdo el valor del lado derecho.
En el ejemplo anterior si la variable «r» es igual a 5 y r //= 10, entonces la variable «r» sera igual a 0. Su
equivalente seria el siguiente:
>>> r = 5; r = r // 10; r
0
3.3.8 Operador %=
El operador %= devuelve el resto de la división a la variable del lado izquierdo el valor del lado derecho.
>>> r = 5; r %= 10; r
5
En el ejemplo anterior si la variable «r» es igual a 5 y r %= 10, entonces la variable «r» sera igual a 5. Su
equivalente seria el siguiente:
>>> r = 5; r = r % 10; r
5
Es frecuente que una variable tenga que ser definida de nuevo en función de sí misma. Normalmente usted escribir
la siguiente sintaxis:
El código anterior, se puede abreviar a su equivalente, usando la asignación aumentada, de la siguiente manera:
>>> contador += 1
El código anterior, no sólo es más corto de escribir, sino también más eficiente en tiempo de ejecución.
3.3.10 Ejemplos
a, b, c = 21, 10, 0
c = a + b
(continué en la próxima página)
c += a
print ("Operador += | El valor de variable 'c' es ", c)
c *= a
print ("Operador *= | El valor de variable 'c' es ", c)
c /= a
print ("Operador /= | El valor de variable 'c' es ", c)
c = 2
c %= a
print ("Operador %= | El valor de variable 'c' es ", c)
c **= a
print ("Operador **= | El valor de variable 'c' es ", c)
c //= a
print ("Operador //= | El valor de variable 'c' es ", c)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código operadores_asignaciones.py, abra una consola de comando, acceda al
directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_asignaciones.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Los valores numéricos son además el resultado de una serie de operadores aritméticos y matemáticos:
>>> -7
-7
>>> 2 * 6
12
>>> 2 ** 6
64
>>> 3.5 / 2
1.75
>>> 3.5 // 22
1.0
No obstante hay que tener en cuenta que si utilizamos dos operandos enteros, Python determinará que quiere que
la variable resultado también sea un entero, por lo que el resultado de, por ejemplo, 3 / 2 y 3 // 2 sería el
mismo: 1.
Si quisiéramos obtener los decimales necesitaríamos que al menos uno de los operandos fuera un número real,
bien indicando los decimales:
r = 3.0 / 2
O bien utilizando la función float() (página 125) para convertir a entero coma flotante o real:
r = float(3) / 2
Esto es así porque cuando se mezclan tipos de números, Python convierte todos los operandos al tipo más complejo
de entre los tipos de los operandos.
El operador módulo no hace otra cosa que devolver el resto de la división entre los dos operandos. En el ejemplo,
7 / 2 sería 3, con 1 de resto, luego el módulo es 1.
>>> 7 % 2
1
>>> 2**1/12
0.16666666666666666
>>>
Más igualmente usted puede omitir este orden de precedencia de ejecución de los operadores aritméticos usando
paréntesis () anidados entre cada nivel calculo, por ejemplo:
>>> 2**(1/12)
1.0594630943592953
>>>
3.4.10 Ejemplos
Ejemplo de operador aritmético Suma, Añade valores a cada lado del operador.
print (a + b)
Ejemplo de operador aritmético Resta, Resta el operando de la derecha del operador del lado izquierdo.
print (c - a)
Ejemplo de operador aritmético Multiplicación, Multiplica los valores de ambos lados del operador.
print (d * c)
Ejemplo de operador aritmético Exponente, Realiza el cálculo exponencial (potencia) de los operadores.
print (c ** 2)
print (float(c) / a)
print (7 / 3)
Ejemplo de operador aritmético Cociente de una división, la división de operandos que el resultado es el
cociente en el cual se eliminan los dígitos después del punto decimal.
print (a // c)
Ejemplo de operador aritmético Módulo, el cual divide el operando de la izquierda por el operador del lado
derecho y devuelve el resto.
print (7 % 3)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código operadores_aritmeticos.py, abra una consola de comando, acceda al
directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_aritmeticos.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Los valores booleanos son además el resultado de expresiones que utilizan operadores relacionales (comparaciones
entre valores):
3.5.1 Operador ==
El operador == evalúa que los valores sean iguales para varios tipos de datos.
>>> 5 == 3
False
>>> 5 == 5
True
>>> "Plone" == 5
False
>>> "Plone" == "Plone"
True
>>> type("Plone") == str
True
3.5.2 Operador !=
>>> 5 != 3
True
>>> "Plone" != 5
True
>>> "Plone" != False
True
El operador < evalúa si el valor del lado izquierdo es menor que el valor del lado derecho.
>>> 5 < 3
False
El operador > evalúa si el valor del lado izquierdo es mayor que el valor del lado derecho.
>>> 5 > 3
True
El operador <= evalúa si el valor del lado izquierdo es menor o igual que el valor del lado derecho.
>>> 5 <= 3
False
El operador >= evalúa si el valor del lado izquierdo es mayor o igual que el valor del lado derecho.
>>> 5 >= 3
True
3.5.7 Ejemplos
a, b, a1, b1, c1 = 5, 5, 7, 3, 3
cadena1, cadena2 = 'Hola', 'Adiós'
lista1, lista2 = [1, 'Lista Python', 23], [11, 'Lista Python', 23]
c = a == b
print (c)
d = a1 != b
print (d)
f = b1 < a1
print (f)
e = a1 > b1
print (e)
h = b1 <= c1
print (h)
g = b1 >= c1
print (g)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código operadores_relacionales.py, abra una consola de comando, acceda al
directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_relacionales.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Estos tipos de datos se crean mediante literales numéricos y se devuelven como resultados por operadores aritmé-
ticos y funciones aritméticas integradas. Los objetos numéricos son inmutables; Una vez creado su valor nunca
cambia.
Por supuesto, los números de Python están fuertemente relacionados con los números matemáticos, pero están
sujetos a las limitaciones de la representación numérica en las computadoras.
Python distingue entre enteros, números de punto flotante y números complejos:
3.6.1 Enteros
Los números enteros son aquellos que no tienen decimales, tanto positivos como negativos (además del cero). En
Python se pueden representar mediante el tipo int (de integer, entero) o el tipo long (largo). La única diferencia
es que el tipo long permite almacenar números más grandes. Es aconsejable no utilizar el tipo long a menos que
sea necesario, para no malgastar memoria.
El tipo int de Python se implementa a bajo nivel mediante un tipo long de C. Y dado que Python utiliza C
por debajo, como C, y a diferencia de Java, el rango de los valores que puede representar depende de la plata-
forma. En la mayor parte de las máquinas el long de C se almacena utilizando 32 bits, es decir, mediante el
uso de una variable de tipo int de Python puede almacenar números de -231 a 231 – 1, o lo que es lo mismo,
de -2.147.483.648 a 2.147.483.647. En plataformas de 64 bits, el rango es de -9.223.372.036.854.775.808 hasta
9.223.372.036.854.775.807.
Ejemplo de enteros
entero = 7
print (entero, type(entero))
El tipo long de Python permite almacenar números de cualquier precisión, limitado por la memoria disponible
en la máquina.
Al asignar un número a una variable esta pasará a tener tipo int, a menos que el número sea tan grande como
para requerir el uso del tipo long.
>>> entero = 23
>>> type(entero)
<type 'int'>
También puede indicar a Python que un número se almacene usando long añadiendo una L al final:
El literal que se asigna a la variable también se puede expresar como un octal, anteponiendo un cero:
enterol = 23L
print (enterol, type(enterol))
Los números reales son los que tienen decimales. En Python se expresan mediante el tipo float. En otros
lenguajes de programación, como C, tiene también el tipo double, similar a float pero de mayor precisión
(double = doble precisión).
Python, sin embargo, implementa su tipo float a bajo nivel mediante una variable de tipo double de C, es
decir, utilizando 64 bits, luego en Python siempre se utiliza doble precisión, y en concreto se sigue el estándar
IEEE 754: 1 bit para el signo, 11 para el exponente, y 52 para la mantisa. Esto significa que los valores que puede
representar van desde ±2,2250738585072020 x 10-308 hasta ±1,7976931348623157×10308 .
La mayor parte de los lenguajes de programación siguen el mismo esquema para la representación interna. Pero
como muchos sabréis esta tiene sus limitaciones, impuestas por el hardware.
Por eso desde Python 2.4 cuenta también con un nuevo tipo Decimal57 , para el caso de que se necesite representar
fracciones de forma más precisa. Sin embargo este tipo está fuera del alcance de este tutorial, y sólo es necesario
para el ámbito de la programación científica y otros relacionados.
Para aplicaciones normales puedes utilizar el tipo float sin miedo, como ha venido haciéndose desde hace años,
aunque teniendo en cuenta que los números en coma flotante no son precisos (ni en este ni en otros lenguajes de
programación).
Para representar un número real en Python se escribe primero la parte entera, seguido de un punto y por último la
parte decimal.
real = 0.2703
También se puede utilizar notación científica, y añadir una e (de exponente) para indicar un exponente en base 10.
Por ejemplo:
real = 0.1e-3
real = 0.56e-3
print (real, type(real))
57 https://www.python.org/dev/peps/pep-0327/
3.6.4 Complejos
Los números complejos son aquellos que tienen parte imaginaria. Si no conocías de su existencia, es más que
probable que nunca lo vayas a necesitar, por lo que puede saltarte este apartado tranquilamente.
De hecho la mayor parte de lenguajes de programación carecen de este tipo, aunque sea muy utilizado por inge-
nieros y científicos en general.
En el caso de que necesite utilizar números complejos, o simplemente tiene curiosidad, este tipo, llamado
complex en Python, también se almacena usando coma flotante, debido a que estos números son una exten-
sión de los números reales.
En concreto se almacena en una estructura de C, compuesta por dos variables de tipo double, sirviendo una de
ellas para almacenar la parte real y la otra para la parte imaginaria.
Los números complejos en Python se representan de la siguiente forma:
complejo = 3.14j
print (complejo, complejo.imag, complejo.real, type(complejo))
Para convertir a tipos numéricos (página 40) debe usar las siguientes funciones integradas (página 113) en el
interprete Python:
La función int() (página 126) devuelve un tipo de datos número entero (página 41).
La función long() (página 126) devuelve un tipo de datos número entero long (página 41).
La función float() (página 125) devuelve un tipo de datos número entero float (página 42).
La función complex() (página 125) devuelve un tipo de datos número complejo (página 43).
Usted puede consultar toda la documentación disponible sobre las números enteros desde la consola interactiva
(página 15) de la siguiente forma:
>>> help(int)
>>> help(long)
>>> help(float)
>>> help(complex)
Truco: Para más información consulte las funciones integradas para operaciones numéricas (página 124).
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_numericos.py, abra una consola de comando, acceda al directorio
donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_numericos.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
El tipo booleano sólo puede tener dos valores: True (verdadero) y False (falso). Estos valores son especialmente
importantes para las expresiones condicionales y los bucles, como verá más adelante.
En el contexto de las operaciones booleanas, y también cuando las expresiones son usadas bajo sentencias de flujo
de control, los siguientes valores son interpretados como False:
False.
None (página 210).
Número cero (página 40) en todos los tipos.
Cadena de caracteres (página 46) vaciás.
Contenedores, incluyendo cadenas de caracteres, tuplas (página 63), listas (página 58), diccionarios (pági-
na 65) y conjuntos (página 75) mutables e inmutables.
A continuación, varios ejemplos en códigos de los citado previamente:
>>> False
False
>>> False == False
True
>>> 0 == False
True
>>> "" == False
False
>>> None == False
False
>>> [] == False
False
>>> () == False
False
>>> {} == False
False
>>> ['', ''] == False
False
Todos los otros valores son interpretados por defecto a True. El operador lógico not (página 86) produce True
si su argumento es falso, False de lo contrario.
Los tipos integrados False y True son solamente dos instancias de la clase bool. En realidad el tipo bool es
una subclase (página 202) del tipo int o entero plano, es decir, sus valores son 0 y 1 respectivamente, en casi
todos los contextos:
>>> int(False)
0
>>> int(True)
1
En el ejemplo anterior se convierte tipos booleanos a tipo enteros, siempre devuelve sus valores numéricos 0 y 1.
La excepción a la regla anterior sucede cuando un tipo booleano es convertido a un tipo de cadenas de caracteres
(página 46), las cadenas “False” y/o “True” son retornadas, respectivamente:
>>> type(True)
<type 'bool'>
>>> str(True)
'True'
>>> type(str(True))
<type 'str'>
>>>
>>> type(False)
<type 'bool'>
>>> str(False)
'False'
>>> type(str(False))
<type 'str'>
Puede que esto para usted, no lo entienda mucho, si no conoces los términos de la orientación a objetos (pági-
na 194), que se tocará más adelante, aunque tampoco es nada importante.
Para convertir a tipos booleanos debe usar la función bool() (página 129) la cual esta integrada (página 113) en el
interprete Python.
3.7.2 Ejemplos
Usted puede consultar toda la documentación disponible sobre los booleanos desde la consola interactiva (pági-
na 15) de la siguiente forma:
>>> help(bool)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_booleanos.py, abra una consola de comando, acceda al directorio
donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_booleanos.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Las cadenas de caracteres, son secuencias inmutables que contienen caracteres encerrado entre comillas.
Son caracteres encerrados entre grupo comillas triples simples (''') o dobles ("""), están son generalmente son
referenciadas como cadenas de triple comillas.
3.8.3 Clases
A continuación, una lista de clases integradas Python para los tipos de cadenas de caracteres:
basestring
str
unicode
>>> u'Jekechitü'
u'Jekechit\xfc'
u/U, el cual indica, que se trata de una cadena que utiliza codificación unicode (página 47).
Para escapar caracteres dentro de cadenas de caracteres se usa el carácter \ seguido de cualquier carácter ASCII.
También es posible encerrar una cadena entre triples comillas (simples o dobles). De esta forma puede escribir el
texto en varias líneas, y al imprimir la cadena, se respetarán los saltos de línea que se introdujeron sin tener que
recurrir a los caracteres escapados y las comillas como los anteriores.
3.8.6 Operaciones
El operador multiplicación (página 36) para repetir la cadena de caracteres por N veces definidas en la
multiplicación:
>>> c = "tres"
>>> c * 3
'trestrestres'
El operador modulo (página 37) usado la técnica de interpolación variables dentro de una cadena de carac-
teres. Más información consulte la sección formateo % (página 53).
3.8.7 Comentarios
Son cadenas de caracteres las cuales constituyen una ayuda esencial tanto para quien está desarrollando el progra-
ma, como para otras personas que lean el código.
Los comentarios en el código tienen una vital importancia en el desarrollo de todo programa, algunas de las
funciones más importantes que pueden cumplir los comentarios en un programa, son:
Brindar información general sobre el programa.
Explicar qué hace cada una de sus partes.
Aclarar y/o fundamentar el funcionamiento de un bloque específico de código, que no sea evidente de su
propia lectura.
Indicar cosas pendientes para agregar o mejorar.
El signo para indicar el comienzo de un comentario en Python es el carácter numeral #, a partir del cual y hasta el
fin de la línea, todo se considera un comentario y es ignorado por el intérprete Python.
El carácter # puede estar al comienzo de línea (en cuyo caso toda la línea será ignorada), o después de finalizar
una instrucción válida de código.
Comentarios multilínea
A continuación, una comparación entre comentarios multilínea y comentarios en solo una linea:
Entonces existen al menos dos (02) alternativas para introducir comentarios multilínea son:
Comentar cada una de las líneas con el carácter #: en general todos los editores de programación y entornos
de desarrollo (IDEs) disponen de mecanismos que permiten comentar y descomentar fácilmente un conjunto
de líneas.
Utilizar triple comillas (simples o dobles) para generar una cadena multilínea: si bien este método es acep-
tado.
A continuación, un ejemplo de Comentarios multilínea y de solo una linea:
Los comentarios multilínea usado con mucha frecuencia como en las varias sintaxis Python como comentarios de
documentación (página 50) a continuación se listan las sintaxis más comunes:
Módulos (página 159).
Funciones (página 100).
Clases (página 200).
Métodos (página 198).
3.8.8 Docstrings
En Python todos los objetos cuentan con una variable especial llamada __doc__, gracias a la cual puede describir
para qué sirven los objetos y cómo se usan. Estas variables reciben el nombre de docstrings, o cadenas de
documentación58 .
Ten en cuenta, una buena documentación siempre dará respuesta a las dos preguntas:
¿Para qué sirve?
¿Cómo se utiliza?
Funciones
Python implementa un sistema muy sencillo para establecer el valor de las docstrings en las funciones, úni-
camente tiene que crear un comentario en la primera línea después de la declaración.
Puede puede consultar la documentación de la función hola() debe utilizar la función integrada help() (pági-
na 118) y pasarle el argumento del objeto de función hola():
>>> help(hola)
hola(arg)
El docstring de la función
>>>
>>> print hola.__doc__
El docstring de la función
Clases y métodos
De la misma forma puede establecer la documentación de la clase después de la definición, y de los métodos,
como si fueran funciones:
class Clase
| El docstring de la clase
|
| Methods defined here:
|
| __init__(self)
| El docstring del método constructor de clase
|
| metodo(self)
| El docstring del método de clase
>>> o.__doc__
'El docstring de la clase'
>>> o.__init__.__doc__
'El docstring del método constructor de clase'
>>> o.metodo.__doc__
'El docstring del método de clase'
Scripts y módulos
Cuando tiene un script o módulo, la primera línea del mismo hará referencia al docstrings del módulo, en él
debe explicar el funcionamiento del mismo:
En el archivo mi_modulo.py debe contener el siguiente código:
def despedir():
"""El docstring de la función despedir"""
print "Adiós! desde función despedir() del módulo prueba"
Entonces, usted debe importar el módulo anterior, para consultar la documentación del módulo mi_modulo debe
utilizar la función integrada help() (página 118) y pasarle el argumento el nombre de módulo mi_modulo, de la
siguiente manera:
NAME
mi_modulo - El docstring del módulo
FUNCTIONS
despedir()
El docstring de la función despedir
saludar()
El docstring de la función saludar
También puede consultar la documentación de la función despedir() dentro del módulo mi_modulo, usando
la función integrada help() (página 118) y pasarle el argumento el formato nombre_modulo.nombre_funcion, es
decir, mi_modulo.despedir, de la siguiente manera:
>>> help(mi_modulo.despedir)
despedir()
El docstring de la función despedir
Opcionalmente , usted puede listar las variables y funciones del módulo con la función dir(), de la siguiente
manera:
>>> dir(mi_modulo)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'despedir',
'saludar']
Como puede apreciar, muchas de estas variables son especiales, puede comprobar sus valores:
Python soporta múltiples formas de formatear una cadena de caracteres. A continuación se describen:
Formateo %
El carácter modulo % es un operador integrado en Python. Ese es conocido como el operador de interpolación.
Usted necesitará proveer el % seguido por el tipo que necesita ser formateado o convertido. El operador % entonces
substituye la frase “ %tipodato” con cero o mas elementos del tipo de datos especificado:
También aquí se puede controlar el formato de salida. Por ejemplo, para obtener el valor con 8 dígitos después de
la coma:
Clase formatter
formatter es una de las clases integradas string. Ese provee la habilidad de hacer variable compleja de
substituciones y formateo de valores usando el método format() (página 53). Es le permite crear y personalizar
sus propios comportamientos de formatos de cadena de caracteres para reescribir los métodos públicos y con-
tiene: format(), vformat(). Ese tiene algunos métodos que son destinado para ser remplazados por las
sub-clases: parse(), get_field(), get_value(), check_unused_args(), format_field() y
convert_field().
format()
Este método devuelve una versión formateada de una cadena de caracteres, usando substituciones desde argu-
mentos args y kwargs. Las substituciones son identificadas entre llaves { } dentro de la cadena de caracteres
(llamados campos de formato), y son sustituidos en el orden con que aparecen como argumentos de format(),
contando a partir de cero (argumentos posicionales).
Esto es una forma más clara y elegante es referenciar objetos dentro de la misma cadena, y usar este método para
sustituirlos con los objetos que se le pasan como argumentos.
Los objetos también pueden ser referenciados utilizando un identificador con una clave y luego pasarla como
argumento al método:
Formateo avanzado
Este método soporta muchas técnicas de formateo, aquí algunos ejemplos:
Alinear una cadena de caracteres a la derecha en 30 caracteres, con la siguiente sentencia:
Alinear una cadena de caracteres a la izquierda en 30 caracteres (crea espacios a la derecha), con la siguiente
sentencia:
Alinear una cadena de caracteres a la derecha en 30 caracteres con truncamiento de 9, con la siguiente sentencia:
Formateo de números enteros, rellenados con espacios, con las siguientes sentencias:
Formateo de números enteros, rellenados con ceros, con las siguientes sentencias:
Formateo de números flotantes, rellenados con espacios, con las siguientes sentencias:
Formateo de números flotantes, rellenados con ceros, con las siguientes sentencias:
Para convertir a tipos cadenas de caracteres debe usar la función str() (página 136) la cual esta integrada (pági-
na 113) en el interprete Python.
Truco: Para más información consulte las funciones integradas para operaciones en cadenas de caracteres (pá-
gina 129).
3.8.11 Ejemplos
cadena5 = "Cadena" * 3
print (cadena5 + ",", type(cadena5))
>>> help(len)
len(...)
len(object) -> integer
>>> help(int)
class int(object)
| int(x=0) -> int or long
| int(x, base=10) -> int or long
(continué en la próxima página)
NAME
datetime - Fast implementation of the datetime type.
FILE
(built-in)
CLASSES
__builtin__.object
date
datetime
Usted puede consultar toda la documentación disponible sobre las cadenas de caracteres (página 47) desde la
consola interactiva (página 15) de la siguiente manera:
>>> help(str)
>>> help(unicode)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_cadenas.py, abra una consola de comando, acceda al directorio donde
se encuentra el mismo, y ejecute el siguiente comando:
python tipo_cadenas.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python tiene varios tipos de datos compuestos y dentro de las secuencias, están los tipos de cadenas de carac-
teres (página 46). Otro tipo muy importante de secuencia son las listas.
Entre las secuencias, el más versátil, es la lista, para definir una, usted debe escribir es entre corchetes, separando
sus elementos con comas cada uno.
La lista en Python son variables que almacenan arrays, internamente cada posición puede ser un tipo de datos
distinto.
>>> factura[0]
'pan'
>>> factura[3]
1234
La función len() (página 118) devuelve la longitud de la lista (su cantidad de elementos).
>>> len(factura)
4
Los índices de una lista inicia entonces de 0 hasta el tamaño de la lista menos uno (len(factura) - 1):
>>> len(factura) - 1
3
Pueden usarse también índices negativos, siendo -1 el índice del último elemento.
>>> factura[-1]
1234
Los índices negativos van entonces de -1 (último elemento) a -len(factura) (primer elemento).
>>> factura[-len(factura)]
'pan'
A través de los índices, pueden cambiarse los elementos de una lista en el lugar.
De esta forma se cambia el valor inicial de un elemento de la lista lo cual hacen una la lista mutable
3.9.1 Métodos
append()
count()
Este método recibe un elemento como argumento, y cuenta la cantidad de veces que aparece en la lista.
extend()
index()
Este método recibe un elemento como argumento, y devuelve el índice de su primera aparición en la lista.
El método admite como argumento adicional un índice inicial a partir de donde comenzar la búsqueda, opcional-
mente también el índice final.
insert()
pop()
Opcionalmente puede recibir un argumento numérico, que funciona como índice del elemento (por defecto, -1)
remove()
Este método recibe como argumento un elemento, y borra su primera aparición en la lista.
reverse()
sort()
El método sort() admite la opción reverse, por defecto, con valor False. De tener valor True, el ordena-
miento se hace en sentido inverso.
>>> versiones_plone.sort(reverse=True)
>>> print versiones_plone
[6, 5, 4, 3.6, 2.5, 2.1]
Para convertir a tipos listas debe usar la función list() (página 139) la cual esta integrada (página 113) en el
interprete Python.
Truco: Para más información consulte las funciones integradas para operaciones de secuencias (página 137).
3.9.3 Ejemplos
Usted puede consultar toda la documentación disponible sobre las listas desde la consola interactiva (página 15)
de la siguiente forma:
>>> help(list)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_listas.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python tipo_listas.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Las tuplas son objetos de tipo secuencia, específicamente es un tipo de dato lista (página 58) inmutable. Esta no
puede modificarse de ningún modo después de su creación.
3.10.1 Métodos
Son muy similares a las listas (página 58) y comparten varias de sus funciones y métodos integrados, aunque
su principal diferencia es que son inmutables. El objeto de tipo tupla integra una serie de métodos integrados a
continuación:
count()
Este método recibe un elemento como argumento, y cuenta la cantidad de veces que aparece en la tupla.
index()
Comparte el mismo método index() (página 59) del tipo lista. Este método recibe un elemento como argumento, y
devuelve el índice de su primera aparición en la tupla.
Para convertir a tipos tuplas debe usar la función tuple() (página 139), la cual está integrada (página 113) en el
interprete Python.
Truco: Para más información consulte las funciones integradas para operaciones de secuencias (página 137).
3.10.3 Ejemplos
x, y, z = tupla
conexion_bd = "127.0.0.1","root","qwerty","nomina",
print ("Conexión típica:", conexion_bd)
print (type(conexion_bd))
conexion_completa = conexion_bd, "3307","10",
print ("\nConexión con parámetros adicionales:", conexion_completa)
print (type(conexion_completa))
print ("\n")
Usted puede consultar toda la documentación disponible sobre las tuplas desde la consola interactiva (página 15)
de la siguiente forma:
>>> help(tuple)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_tuplas.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python tipo_tuplas.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Un objeto mapping mapea valores hashable a objetos arbitrariamente. Los objetos Mapeos son objetos mutable.
El diccionario es el único tipo de mapeo estándar actual. Para otro contenedores ver los integrados en las clases
«lista (página 58)», «conjuntos (página 75)», y «tupla (página 63)», y el modulo «collections».
Los diccionarios pueden ser creados colocando una lista separada por coma de pares «key:value» entre {}, por
ejemplo: «{'python': 27, 'plone': 51}» o «{27:'python', 51:'plone'}», o por el construc-
tor «dict() (página 138)».
>>> diccionario = {
... "clave1":234,
... "clave2":True,
... "clave3":"Valor 1",
... "clave4":[1,2,3,4]
... }
>>> print diccionario, type(diccionario)
{'clave4': [1, 2, 3, 4], 'clave1': 234,
'clave3': 'Valor 1', 'clave2': True} <type 'dict'>
Usted puede acceder a los valores del diccionario usando cada su clave, se presenta unos ejemplos a continuación:
>>> diccionario['clave1']
234
>>> diccionario['clave2']
True
>>> diccionario['clave3']
'Valor 1'
>>> diccionario['clave4']
[1, 2, 3, 4]
Un diccionario puede almacenar los diversos tipos de datos integrados en Python usando la función type() (pági-
na 122), usted puede pasar el diccionario con la clave que usted desea determinar el tipo de dato, se presenta unos
ejemplos a continuación:
>>> type(diccionario['clave1'])
<type 'int'>
>>> type(diccionario['clave2'])
<type 'bool'>
>>> type(diccionario['clave3'])
<type 'str'>
>>> type(diccionario['clave4'])
<type 'list'>
3.11.1 Operaciones
Los objetos de tipo diccionario permite una serie de operaciones usando operadores integrados en el interprete
Python para su tratamiento, a continuación algunos de estos:
Esta operación le permite acceder a un valor especifico del diccionario mediante su clave.
Esta operación le permite asignar el valor especifico del diccionario mediante su clave.
Iteración in
Este operador es el mismo operador integrado in (página 84) en el interprete Python pero aplicada al uso de la
secuencia de tipo diccionario.
En el ejemplo anterior este operador devuelve True si la clave esta en el diccionario versiones, de lo contrario
devuelve False.
3.11.2 Métodos
Los objetos de tipo diccionario integra una serie de métodos integrados a continuación:
clear()
copy()
fromkeys()
Este método crea un nuevo diccionario con claves a partir de un tipo de dato secuencia. El valor de value por
defecto es el tipo None (página 210).
En el ejemplo anterior inicializa los valores de cada clave a None, mas puede inicializar un valor común por
defecto para cada clave:
get()
Este método devuelve el valor en base a una coincidencia de búsqueda en un diccionario mediante una clave, de
lo contrario devuelve el objeto None (página 210).
has_key()
Este método devuelve el valor True si el diccionario tiene presente la clave enviada como argumento.
items()
Este método devuelve una lista de pares de diccionarios (clave, valor), como 2 tuplas.
iteritems()
Este método devuelve un iterador (página 92) sobre los elementos (clave, valor) del diccionario. Lanza una ex-
cepción StopIteration (página 192) si llega al final de la posición del diccionario.
iterkeys()
Este método devuelve un iterador (página 92) sobre las claves del diccionario. Lanza una excepción StopIteration
(página 192) si llega al final de la posición del diccionario.
itervalues()
Este método devuelve un iterador (página 92) sobre los valores del diccionario. Lanza una excepción StopIteration
(página 192) si llega al final de la posición del diccionario.
keys()
pop()
Este método remueve específicamente una clave de diccionario y devuelve valor correspondiente. Lanza una
excepción KeyError (página 192) si la clave no es encontrada.
popitem()
Este método remueve y devuelve algún par (clave, valor) del diccionario como una 2 tuplas. Lanza una excepción
KeyError (página 192) si el diccionario esta vació.
setdefault()
Este método es similar a get(key, default_value) (página 68), pero además asigna la clave key al valor por
default_value para la clave si esta no se encuentra en el diccionario.
D.setdefault(key[,default_value])
A continuación un ejemplo de como trabaja el método setdefault() cuando la clave esta en el diccionario:
Si el valor no es proveído, el valor default_value será el tipo objeto integrado None (página 210).
A continuación un ejemplo de como trabaja el método setdefault() la clave no esta en el diccionario pero
esta vez el default_value es proveído:
A continuación otro ejemplo en donde puedes agrupar N tuplas (página 63) por el valor el cual se repite más y
construir un diccionario que cuyas claves son los valores mas repetidos y cuyos valores este agrupados en tipo
listas (página 58):
En el tipo tupla PKGS los elementos mas repetidos son 'zope' y 'plone' estos se convierten en clave del
diccionario paquetes y los otros elementos se agrepan en listas como sus respectivos valores.
A continuación un mejor aprovechamiento implementando el método setdefault():
En el ejemplo anterior puede ver que el aprovechamiento del método setdefault() a comparación de no usar
el respectivo método.
update()
Este método actualiza un diccionario agregando los pares clave-valores en un segundo diccionario. Este método
no devuelve nada.
El método update() toma un diccionario o un objeto iterable de pares clave/valor (generalmente tuplas). Si se
llama a update() sin pasar parámetros, el diccionario permanece sin cambios.
Como puede apreciar este método no devuelve nada, más si muestra de nuevo el diccionario versiones puede
ver que este fue actualizado con el otro diccionario versiones_adicional.
values()
viewitems()
Este método devuelve un objeto como un conjunto mutable proveyendo una vista en los elementos del diccionario:
viewkeys()
Este método devuelve un objeto proveyendo una vista de las claves del diccionario.
viewvalues()
Este método devuelve un objeto proveyendo una vista de los valores del diccionario.
3.11.3 Funciones
Los objetos de tipo diccionario tienen disponibles una serie de funciones integradas en el interprete Python para
su tratamiento, a continuación algunas de estas:
cmp()
Esta función es la misma función integrada cmp() (página 125) en el interprete Python pero aplicada al uso de la
secuencia de tipo diccionario.
La función cmp() es usado en Python para comparar valores y claves de dos diccionarios. Si la función devuelve
el valor 0 si ambos diccionarios son igual, devuelve el valor 1 si el primer diccionario es mayor que el segundo
diccionario y devuelve el valor -1 si el primer diccionario es menor que el segundo diccionario.
len()
Esta función es la misma función integrada len() (página 118) en el interprete Python pero aplicada al uso de la
secuencia de tipo diccionario.
>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> len(versiones)
3
3.11.4 Sentencias
Los objetos de tipo diccionario tienen disponibles una serie de sentencias integradas en el interprete Python para
su tratamiento, a continuación algunas de estas:
del
Esta sentencia es la misma sentencia integrada del (página 31) en el interprete Python pero aplicada al uso de la
secuencia de tipo diccionario.
>>> versiones = dict(python=2.7, zope=2.13, plone=5.1, django=2.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}
>>> del versiones['django']
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
En el código fuente anterior se usa la sentencia del para eliminar un elemento del diccionario mediante su
respectiva clave.
Para convertir a tipos diccionarios debe usar la función dict() (página 138) la cual esta integrada (página 113) en
el interprete Python.
Truco: Para más información consulte las funciones integradas para operaciones de secuencias (página 137).
3.11.6 Ejemplos
Usted puede consultar toda la documentación disponible sobre los diccionarios desde la consola interactiva (pá-
gina 15) de la siguiente forma:
>>> help(dict)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_diccionarios.py, abra una consola de comando, acceda al directorio
donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_diccionarios.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
Un conjunto, es una colección no ordenada y sin elementos repetidos. Los usos básicos de éstos incluyen verifi-
cación de pertenencia y eliminación de entradas duplicadas.
3.12.1 Métodos
Los objetos de tipo conjunto mutable y conjunto inmutable integra una serie de métodos integrados a continua-
ción:
add()
Este método agrega un elemento a un conjunto mutable. Esto no tiene efecto si el elemento ya esta presente.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> print set_mutable1
set([1, 2, 3, 4, 5, 7, 11])
>>> set_mutable1.add(22)
>>> print set_mutable1
set([1, 2, 3, 4, 5, 7, 11, 22])
clear()
Este método remueve todos los elementos desde este conjunto mutable.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> print set_mutable1
set([1, 2, 3, 4, 5, 7, 11])
>>> set_mutable1.clear()
>>> print set_mutable1
set([])
copy()
Este método devuelve una copia superficial del tipo conjunto mutable o conjunto inmutable:
>>> set_mutable = set([4.0, 'Carro', True])
>>> otro_set_mutable = set_mutable.copy()
>>> set_mutable == otro_set_mutable
True
difference()
Este método devuelve la diferencia entre dos conjunto mutable o conjunto inmutable: todos los elementos que
están en el primero, pero no en el argumento.
>>> set_mutable1 = set([4, 3, 11, 7, 5, 2, 1, 4])
>>> set_mutable2 = set([11, 5, 9, 2, 4, 8])
>>> print set_mutable1
set([1, 2, 3, 4, 5, 7, 11])
>>> print set_mutable2
set([2, 4, 5, 8, 9, 11])
>>> print set_mutable1.difference(set_mutable2)
(continué en la próxima página)
difference_update()
Este método actualiza un tipo conjunto mutable llamando al método difference_update() con la diferen-
cia de los conjuntos.
Si proyecto1 y proyecto2 son dos conjuntos. La diferencia del conjunto proyecto1 y conjunto
proyecto2 es un conjunto de elementos que existen solamente en el conjunto proyecto1 pero no en el
conjunto proyecto2.
discard()
El conjunto mutable permanece sin cambio si el elemento pasado como argumento al método discard() no
existe.
intersection()
Este método devuelve la intersección entre los conjuntos mutables o conjuntos inmutables: todos los elementos
que están en ambos.
intersection_update()
Este método actualiza un conjunto mutable con la intersección de ese mismo y otro conjunto mutable.
El método intersection_update() le permite arbitrariamente varios numero de argumentos (conjuntos).
La intersección de dos o mas conjuntos es el conjunto de elemento el cual es común a todos los conjuntos.
isdisjoint()
Este método devuelve el valor True si no hay elementos comunes entre los conjuntos mutables o conjuntos
inmutables.
issubset()
Este método devuelve el valor True si el conjunto mutable es un subconjunto del conjunto mutable o del
conjunto inmutable argumento.
issuperset()
Este método devuelve el valor True si el conjunto mutable o el conjunto inmutable es un superset del conjunto
mutable argumento.
pop()
Este método remueve arbitrariamente y devuelve un elemento de conjunto mutable. El método pop() no toma
ningún argumento. Si el conjunto mutable esta vacío se lanza una excepción KeyError (página 192).
Tenga en cuenta que usted podría obtener diferente salida devueltas usando el método pop() por que remueve
aleatoriamente un elemento.
remove()
Este método busca y remueve un elemento de un conjunto mutable, si debe ser un miembro.
Si el elemento no es existe en el conjunto mutable, lanza una excepción KeyError (página 192). Usted puede
usar el método discard() (página 77) si usted no quiere este error. El conjunto mutable permanece sin cambio si
el elemento pasado al método discard() no existe.
Un conjunto es una colección desordenada de elementos. Si usted quiere remover arbitrariamente elemento un
conjunto, usted puede usar el método pop() (página 79).
symmetric_difference()
Este método devuelve todos los elementos que están en un conjunto mutable e conjunto inmutable u otro, pero
no en ambos.
symmetric_difference_update()
union()
Este método devuelve un conjunto mutable y conjunto inmutable con todos los elementos que están en alguno
de los conjuntos mutables y conjuntos inmutables.
update()
Este método agrega elementos desde un conjunto mutable (pasando como un argumento) un tipo tupla (pági-
na 63), un tipo lista (página 58), un tipo diccionario (página 65) o un tipo conjunto mutable llamado con el
método update().
A continuación un ejemplo de agregar nuevos elementos un tipo conjunto mutable usando otro tipo conjunto
mutable:
>>> version_plone_dev = set([5.1, 6])
>>> version_plone_dev
set([5.1, 6])
>>> versiones_plone = set([2.1, 2.5, 3.6, 4])
>>> versiones_plone
set([2.5, 3.6, 2.1, 4])
>>> versiones_plone.update(version_plone_dev)
>>> versiones_plone
set([2.5, 3.6, 4, 6, 5.1, 2.1])
A continuación un ejemplo de agregar nuevos elementos un tipo conjunto mutable usando otro tipo cadena de
caracteres (página 46):
>>> cadena = 'abc'
>>> cadena
'abc'
>>> conjunto = {1, 2}
>>> conjunto.update(cadena)
>>> conjunto
set(['a', 1, 2, 'b', 'c'])
A continuación un ejemplo de agregar nuevos elementos un tipo conjunto mutable usando otro tipo diccionario
(página 65):
>>> diccionario = {'key': 1, 2:'lock'}
>>> diccionario.viewitems()
dict_items([(2, 'lock'), ('key', 1)])
>>> conjunto = {'a', 'b'}
>>> conjunto.update(diccionario)
>>> conjunto
set(['a', 2, 'b', 'key'])
Para convertir a tipos conjuntos debe usar las funciones set() (página 140) y frozenset() (página 138), las cuales
están integradas (página 113) en el interprete Python.
Truco: Para más información consulte las funciones integradas para operaciones de secuencias (página 137).
3.12.3 Ejemplos
Conjuntos set
Conjuntos frozenset
Los elementos de un set son únicos (sin repeticiones dentro del set), y deben ser objetos inmutables: números,
cadenas de caracteres, tuplas y sets inmutables, pero no listas ni sets mutables.
Usted puede consultar toda la documentación disponible sobre los conjuntos set desde la consola interactiva
(página 15) de la siguiente forma:
>>> help(set)
Usted puede consultar toda la documentación disponible sobre los conjuntos frozenset desde la consola interac-
tiva (página 15) de la siguiente forma:
>>> help(frozenset)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código tipo_conjuntos.py, abra una consola de comando, acceda al directorio
donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_conjuntos.py
Ver también:
Consulte la sección de lecturas suplementarias (página 262) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python tiene las estructuras de control como if (elif, else); for, while (else, break, continue,
pass); las funciones range() (página 120) y xrange() (página 121); ademas de los tipos iteradores (página 92).
En esta lección se describen las estructuras de control del lenguaje Python, mostrando ejemplos prácticos y útiles.
A continuación el temario de esta lección:
4.1 Condicional if
La sentencia condicional if se usa para tomar decisiones, este evaluá básicamente una operación lógica, es decir
una expresión que de como resultado True o False, y ejecuta la pieza de código siguiente siempre y cuando el
resultado sea verdadero.
A continuación un de estructura condicional if/elif/else completo:
if numero < 0:
numero = 0
print ('El número ingresado es negativo cambiado a cero.\n')
elif numero == 0:
print ('El número ingresado es 0.\n')
elif numero == 1:
print ('El número ingresado es 1.\n')
else:
print ('El número ingresado es mayor que uno.\n')
83
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
4.1.1 Sentencia if
La sentencia if EXPRESION, significa, Si se cumple la expresión condicional (página 84) se ejecuta el bloque
de sentencias seguidas.
La sentencia elif EXPRESION, significa, De lo contrario Si se cumple la expresión condicional (página 84)
se ejecuta el bloque de sentencias seguidas.
La sentencia else, significa, De lo contrario se cumple sin evaluar ninguna expresión condicional (página 84) y
ejecuta el bloque de sentencias seguidas.
4.1.4 Operador is
El operador is, significa, que prueba identidad: ambos lados de la expresión condicional debe ser el mismo
objecto:
>>> 1 is 1.
False
>>> a, b = 1, 1
>>> a is b
True
4.1.5 Operador in
El operador in, significa, para cualquier colección del valor del lado izquierdo contenga el valor del lado derecho:
>>> b = [1, 2, 3]
>>> 2 in b
True
>>> 5 in b
False
En el ejemplo anterior, si b es una lista, este prueba que 2 y 5 sean elementos de la lista b.
El operador not in, el contrario de operador in (página 84), devuelve True cuando un elemento no está en una
secuencia.
>>> b = [1, 2, 3]
>>> 4 not in b
True
>>> 1 not in b
False
En el ejemplo anterior, si b es una lista, este prueba que 4 y 1 sean elementos de la lista b.
Expresión if
La expresión de la sentencia if se evaluá a False cuando se cumple las siguientes expresiones están presente:
Cualquier numero igual a cero (0, 0.0, 0+0j).
Un contenedor vació (lista (página 58), tupla (página 63), conjunto (página 75), diccionario (página 65)).
False, None.
De lo contrario evaluá a True cuando se cumple la siguiente expresión esta presente:
cualquier cosa de lo contrario.
if EXPRESION:
pass
Expresión ==
Expresión is
Expresión in
4.1.8 Ejemplos
if (dato1 == dato2):
print ("'dato1' y 'dato2' son iguales.")
else:
print ("'dato1' y 'dato2' no son iguales.")
if (dato1 != dato2):
print ("'dato1' y 'dato2' son distintas/diferentes.")
else:
print ("'dato1' y 'dato2' no son distintas/diferentes.")
if (dato1 != dato2):
print ("'dato1' y 'dato2' son distintas/diferentes.")
else:
print ("'dato1' y 'dato2' no son distintas/diferentes.")
4.1. Condicional if 85
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código condicional_if.py, abra una consola de comando, acceda al directorio
donde se encuentra el mismo, y ejecute el siguiente comando:
python condicional_if.py
Ver también:
Consulte la sección de lecturas suplementarias (página 263) del entrenamiento para ampliar su conocimiento en
esta temática.
Estos son los distintos tipos de operadores con los que puede trabajar con valores booleanos, los llamados opera-
dores lógicos o condicionales:
El operador and evalúa si el valor del lado izquierdo y el lado derecho se cumple.
4.2.2 Operador or
Si la expresión es True el valor devuelto es False, de lo contrario si la expresión es False el valor devuelto es
True.
4.2.4 Ejemplos
a, b = 10, 20
if (a and b):
print ("Las variables 'a' y 'b' son VERDADERO.")
else:
print ("O bien la variable 'a' no es VERDADERO " + \
"o la variable 'b' no es VERDADERO.")
if (a or b):
print ("O bien la variable 'a' es VERDADERA " + \
"o la variable 'b' es VERDADERA " + \
"o ambas variables son VERDADERAS.")
else:
print ("Ni la variable 'a' es VERDADERA ni " + \
"la variable 'b' es VERDADERA.")
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código operadores_logicos.py, abra una consola de comando, acceda al directorio
donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_logicos.py
Ver también:
Consulte la sección de lecturas suplementarias (página 263) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python tiene una palabra reservada llamada while que nos permite ejecutar ciclos, o bien secuencias perió-
dicas que nos permiten ejecutar código múltiples veces.
El ciclo while nos permite realizar múltiples iteraciones basándonos en el resultado de una expresión lógica que
puede tener como resultado un valor True o False.
A continuación, se presenta un ejemplo del uso del bucle while controlado por conteo:
suma, numero = 0, 1
En este ejemplo tiene un contador con un valor inicial de cero, cada iteración del while manipula esta variable
de manera que incremente su valor en 1, por lo que después de su primera iteración el contador tendrá un valor de
1, luego 2, y así sucesivamente.
Eventualmente cuando el contador llegue a tener un valor de 10, la condición del ciclo numero <= 10 sera
False, por lo que el ciclo terminará arrojando el siguiente resultado.
A continuación, se presenta un ejemplo del uso del bucle while controlado por Evento:
En este casi el evento que se dispara cuando el usuario ingresa el valor -1, causando que el bucle while se
interrumpo o no se inicie.
Al igual que la sentencia if (página 84), la estructura while también puede combinarse con una sentencia else
(página 84)).
El nombre de la sentencia else (página 84) es equivocada, ya que el bloque else se ejecutará en todos los casos,
es decir, cuando la expresión condicional del while sea False, (a comparación de la sentencia if (página 84)).
grado = int(input(mensaje))
while grado != -1:
total = total + grado
contar += 1
grado = int(input(mensaje))
else:
promedio = total / contar
print ("Promedio de notas del grado escolar: " + str(promedio))
La sentencia else tiene la ventaja de mantener el mismo nombre y la misma sintaxis que en las demás estructuras
de control.
A continuación, se presentan algunos ejemplos del uso de sentencias utilitarias usadas en el bucle while:
Sentencia break
A continuación, se presenta un ejemplo del uso del bucle while controlado la sentencia break:
variable = 10
Adicionalmente existe una forma alternativa de interrumpir o cortar los ciclos utilizando la palabra reservada
break.
Esta nos permite salir del ciclo incluso si la expresión evaluada en while (o en otro ciclo como for) perma-
nece siendo True. Para comprender mejor use el mismo ejemplo anterior pero se interrumpe el ciclo usando la
sentencia break.
Sentencia continue
A continuación, se presenta un ejemplo del uso del bucle while controlado la sentencia continue:
variable = 10
La sentencia continue hace que pase de nuevo al principio del bucle aunque no se haya terminado de ejecutar
el ciclo anterior.
4.3.3 Ejemplos
Sucesión de Fibonacci
a, b = 0, 1
while b < 100:
print (b,)
a, b = b, a + b
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código bucle_while.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python bucle_while.py
Ver también:
Consulte la sección de lecturas suplementarias (página 263) del entrenamiento para ampliar su conocimiento en
esta temática.
La sentencia for en Python difiere un poco de lo que uno puede estar acostumbrado en lenguajes como C o
Pascal. En lugar de siempre iterar sobre una progresión aritmética de números (como en Pascal) o darle al usuario
la posibilidad de definir tanto el paso de la iteración como la condición de fin (como en C), la sentencia for
de Python itera sobre los ítems de cualquier secuencia (una lista o una cadenas de caracteres), en el orden que
aparecen en la secuencia.
A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos listas (página 58):
A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos listas (página 58)
con la función range() (página 120) y la función len() (página 118):
Si se necesita iterar sobre una secuencia de números. Genera una lista conteniendo progresiones aritméticos, por
ejemplo, como se hace en el fragmento de código fuente anterior.
A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos Tuplas (página 63):
conexion_bd = "127.0.0.1","root","123456","nomina"
for parametro in conexion_bd:
print (parametro)
A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de datos diccionarios
(página 65):
datos_basicos = {
"nombres":"Leonardo Jose",
"apellidos":"Caballero Garcia",
"cedula":"26938401",
"fecha_nacimiento":"03/12/1980",
"lugar_nacimiento":"Maracaibo, Zulia, Venezuela",
"nacionalidad":"Venezolana",
"estado_civil":"Soltero"
}
clave = datos_basicos.keys()
valor = datos_basicos.values()
cantidad_datos = datos_basicos.items()
El ejemplo anterior itera un diccionario (página 65) con datos básicos de una persona.
Al igual que la sentencia if (página 83) y el bucle while (página 88), la estructura for también puede combinarse
con una sentencia else (página 84).
El nombre de la sentencia else (página 84) es equivocada, ya que el bloque else (página 84) se ejecutará en todos
los casos, es decir, cuando la expresión condicional del bucle for sea False, (a comparación de la sentencia if
(página 83)).
db_connection = "127.0.0.1","5432","root","nomina"
for parametro in db_connection:
print (parametro)
else:
print ("""El comando PostgreSQL es:
$ psql -h {server} -p {port} -U {user} -d {db_name}""".format(
server=db_connection[0], port=db_connection[1],
user=db_connection[2], db_name=db_connection[3]))
La sentencia else tiene la ventaja de mantener el mismo nombre y la misma sintaxis que en las demás estructuras
de control.
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código bucle_for.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python bucle_for.py
Ver también:
Consulte la sección de lecturas suplementarias (página 263) del entrenamiento para ampliar su conocimiento en
esta temática.
4.5 Iteradores
Para entender los la filosofía de los Iteradores, busca la simplicidad de las operaciones, evitando la duplicación del
esfuerzo, el cual es un derroche y busca reemplazar varios de los enfoques propios con una característica estándar,
normalmente, deriva en hacer las cosas más legibles además de más interoperable.
Guido van Rossum — Añadiendo tipado estático opcional a Python (Adding Optional Static Typing
to Python60 ).
Un iterador es un objeto adherido al iterator protocol61 , básicamente esto significa que tiene una función next()
(página 139), es decir, cuando se le llama, devuelve la siguiente elemento en la secuencia, cuando no queda nada
para ser devuelto, lanza la excepción StopIteration (página 192) y se causa el detener la iteración. Pero si se llama
de forma explícita puede ver que, una vez que el iterador esté agotado, al llamarlo nuevamente verá que se lanza
la excepción comentada anteriormente.
A continuación el uso de iteradores usando del método especial __iter__() incluido en el objeto integrado file
(página 214):
60 https://www.artima.com/weblogs/viewpost.jsp?thread=86641
61 https://docs.python.org/dev/library/stdtypes.html#iterator-types
En el ejemplo, el método especial __iter__(), hace lo mismo que la función integrada iter(archivo) (pági-
na 138).
Los iteradores se usan con los tipos de secuencias estándar. A continuación, se describen algunos ejemplos:
Iterar sobre la secuencia inmutable cadena de carácter
A continuación, un ejemplo del uso de los iteradores con la secuencia inmutable de tipo cadena de caracteres
(página 46) ASCII:
En el ejemplo anterior, cuando se itera en la secuencia frase, al llegar al final mediante el iterador letra se
llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Iterar sobre la secuencia inmutable cadena Unicode
4.5. Iteradores 93
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
A continuación, un ejemplo del uso de los iteradores con la secuencia inmutable de tipo cadena de caracteres
(página 47) Unicode:
>>> frase = u'Jekechitü'
>>> letra = iter(frase)
>>> letra.next()
u'J'
>>> letra.next()
u'e'
>>> letra.next()
u'k'
>>> letra.next()
u'e'
>>> letra.next()
u'c'
>>> letra.next()
u'h'
>>> letra.next()
u'i'
>>> letra.next()
u't'
>>> letra.next()
u'\xfc'
>>> letra.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
En el ejemplo anterior, cuando se itera en la secuencia frase, al llegar al final mediante el iterador letra se
llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Iterar sobre la secuencia inmutable tupla
A continuación, un ejemplo del uso de los iteradores con la secuencia inmutable de tipo tupla (página 63):
>>> valores = ("Python", True, "Zope", 5)
>>> valores
('Python', True, "Zope", 5)
>>> valores.__iter__()
<tupleiterator object at 0x7fa44b9fa450>
>>> valor = valores.__iter__()
>>> valor.next()
'Python'
>>> valor.next()
True
>>> valor.next()
'Zope'
>>> valor.next()
5
>>> valor.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
En el ejemplo anterior, cuando se itera en la secuencia valores, al llegar al final mediante el iterador valor se
llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Iterar sobre la función inmutable xrange
A continuación, un ejemplo del uso de los iteradores con la secuencia inmutable con la función integrada xrange()
(página 121):
>>> lista = iter(xrange(5))
>>> lista
(continué en la próxima página)
En el ejemplo anterior, cuando se itera en la secuencia lista, al llegar al final se llama a la excepción StopItera-
tion (página 192) y se causa el detener la iteración.
Iterar sobre la secuencia mutable lista
A continuación, un ejemplo del uso de los iteradores con la secuencia mutable de tipo lista (página 58):
>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> iter(versiones_plone)
<listiterator object at 0x7fa44b9fa450>
>>> version = iter(versiones_plone)
>>> version
<listiterator object at 0x7fa44b9fa550>
>>> version.next()
2.1
>>> version.next()
2.5
>>> version.next()
3.6
>>> version.next()
4
>>> version.next()
5
>>> version.next()
6
>>> version.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
version se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Usted puede devolver un objeto iterador en orden inverso sobre una secuencia mutable de tipo lista (página 58)
usando su función integrada __reversed__().
>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> versiones_plone.__reversed__()
<listreverseiterator object at 0xb712ebec>
>>> version = versiones_plone.__reversed__()
>>> version.next()
6
>>> version.next()
5
>>> version.next()
4
(continué en la próxima página)
4.5. Iteradores 95
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
version se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
También puede acceder al uso del método especial __iter__() incluido en la secuencia mutable del tipo
integrado lista (página 58):
>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> versiones_plone.__iter__()
<listiterator object at 0x7fa44b9fa510>
En el ejemplo anterior, cuando se itera en la secuencia lista, al llegar al final se llama a la excepción StopItera-
tion (página 192) y se causa el detener la iteración.
Los iteradores se usan con los tipos de conjuntos estándar. A continuación, se describen algunos ejemplos:
Iterar sobre el conjunto mutable
A continuación, un ejemplo del uso de los iteradores con el conjunto mutable de tipo conjuntos (página 75):
>>> versiones_plone = set([2.1, 2.5, 3.6, 4, 5, 6, 4])
>>> version = iter(versiones_plone)
>>> version
<setiterator object at 0x7fac9c7c7a50>
>>> version.next()
2.5
(continué en la próxima página)
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
version se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Iterar sobre el conjunto inmutable
A continuación, un ejemplo del uso de los iteradores con el conjunto inmutable de tipo conjuntos (página 75):
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
version se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Los iteradores se usan con los tipos de secuencias estándar. A continuación, se describen algunos ejemplos:
Iterar sobre las claves del diccionario
A continuación, un ejemplo del uso de los iteradores con la secuencia de mapeo, tipo diccionario (página 65), por
defecto muestra la clave de la secuencia:
4.5. Iteradores 97
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
paquete se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Iterar sobre los valores del diccionario
A continuación, un ejemplo del uso de los iteradores con la secuencia de mapeo, tipo diccionario (página 65) para
mostrar el valor de una clave usando el método integrado itervalues() (página 69):
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
version se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Iterar sobre los elementos del diccionario
A continuación, un ejemplo del uso de los iteradores con la secuencia de mapeo, tipo diccionario (página 65) para
mostrar el par clave/valor usando el método integrado iteritems() (página 68):
En el ejemplo anterior, cuando se itera en la secuencia versiones_plone, al llegar al final mediante el iterador
paquete se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
Ver también:
Consulte la sección de lecturas suplementarias (página 266) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python tiene las estructuras de functions los cuales son bloques de código fuente que pueden contener
sentencias reusables de código fuente que puede ser personalizables vía parámetros.
En esta lección se describen las estructuras de funciones del lenguaje Python, mostrando ejemplos prácticos y
útiles. A continuación el temario de esta lección:
Entre las ventajas de la programación estructurada sobre el modelo anterior (hoy llamado despectivamente código
espagueti), cabe citar las siguientes:
Los programas son más fáciles de entender, pueden ser leídos de forma secuencial y no hay necesidad de
tener que rastrear saltos de líneas (GOTO) dentro de los bloques de código para intentar entender la lógica
interna.
99
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
La estructura de los programas es clara, puesto que las sentencias están más ligadas o relacionadas entre sí.
Se optimiza el esfuerzo en las fases de pruebas y depuración. El seguimiento de los fallos o errores del
programa (debugging), y con él su detección y corrección, se facilita enormemente.
Se reducen los costos de mantenimiento. Análogamente a la depuración, durante la fase de mantenimiento,
modificar o extender los programas resulta más fácil.
Los programas son más sencillos y más rápidos de confeccionar.
Se incrementa el rendimiento de los programadores.
Importante: Seguidamente se presenta el concepto de funciones poniendo en practica forma de secuencia, im-
plementado las estructuras condicionales if (página 83) y los bucles o iteraciones existen while (página 88) y for
(página 90).
Ver también:
Consulte la sección de lecturas suplementarias (página 264) del entrenamiento para ampliar su conocimiento en
esta temática.
5.2 Funciones
Una función es un bloque de código con un nombre asociado, que recibe cero o más argumentos como entrada,
sigue una secuencia de sentencias, la cuales ejecuta una operación deseada y devuelve un valor y/o realiza una
tarea, este bloque puede ser llamados cuando se necesite.
El uso de funciones es un componente muy importante del paradigma de la programación llamada estructurada
(página 99), y tiene varias ventajas:
modularización: permite segmentar un programa complejo en una serie de partes o módulos más simples,
facilitando así la programación y el depurado.
reutilización: permite reutilizar una misma función en distintos programas.
Python dispone de una serie de funciones integradas (página 113) al lenguaje, y también permite crear funciones
definidas por el usuario para ser usadas en su propios programas.
La sentencia def es una definición de función usada para crear objetos funciones definidas por el usuario.
Una definición de función es una sentencia ejecutable. Su ejecución enlaza el nombre de la función en el names-
pace local actual a un objecto función (un envoltorio alrededor del código ejecutable para la función). Este objeto
función contiene una referencia al namespace local global como el namespace global para ser usado cuando la
función es llamada.
La definición de función no ejecuta el cuerpo de la función; esto es ejecutado solamente cuando la función es
llamada.
La sintaxis para una definición de función en Python es:
def NOMBRE(LISTA_DE_PARAMETROS):
"""DOCSTRING_DE_FUNCION"""
SENTENCIAS
RETURN [EXPRESION]
Advertencia: Los bloques de function deben estar indentado como otros bloques estructuras de control.
La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la función en el ejemplo
anterior hola() y la lista de parámetros formales entre paréntesis. Las sentencias que forman el cuerpo de la
función empiezan en la línea siguiente, y deben estar indentado.
La primer sentencia del cuerpo de la función puede ser opcionalmente una cadenas de caracteres literal; esta es
la cadenas de caracteres de documentación de la función, o docstrings. (Puedes encontrar más acerca de
docstrings en la sección Cadenas de texto de documentación (página 50)).
Hay herramientas que usan las docstrings para producir automáticamente documentación en línea o impri-
mible, o para permitirle al usuario que navegue el código en forma interactiva; es una buena práctica incluir
docstrings en el código que uno escribe, por lo que se debe hacer un hábito de esto.
La ejecución de la función hola() muestra la impresión de un mensaje Hola Plone ! que se imprime por consola.
Devolver el objeto por los valores de retorno opcionales.
La ejecución de una función introduce una nueva tabla de símbolos usada para las variables locales de la función.
Más precisamente, todas las asignaciones de variables en la función almacenan el valor en la tabla de símbolos
local; así mismo la referencia a variables primero mira la tabla de símbolos local, luego en la tabla de símbolos
local de las funciones externas, luego la tabla de símbolos global, y finalmente la tabla de nombres predefinidos.
Así, no se les puede asignar directamente un valor a las variables globales dentro de una función (a menos se las
nombre en la sentencia global (página 31)), aunque si pueden ser referenciadas.
Los parámetros reales (argumentos) de una función se introducen en la tabla de símbolos local de la función
llamada cuando esta es ejecutada; así, los argumentos son pasados por valor (dónde el valor es siempre una
referencia a un objeto, no el valor del objeto). Cuando una función llama a otra función, una nueva tabla de
símbolos local es creada para esa llamada.
La definición de una función introduce el nombre de la función en la tabla de símbolos actual. El valor del nombre
de la función tiene un tipo que es reconocido por el interprete como una función definida por el usuario. Este valor
puede ser asignado a otro nombre que luego puede ser usado como una función. Esto sirve como un mecanismo
general para renombrar.
Al definir una función los valores los cuales se reciben se denominan parámetros, pero durante la llamada los
valores que se envían se denominan argumentos.
Por posición
Cuando enviá argumentos a una función, estos se reciben por orden en los parámetros definidos. Se dice por tanto
que son argumentos por posición:
Por nombre
Sin embargo es posible evadir el orden de los parámetros si indica durante la llamada que valor tiene cada pará-
metro a partir de su nombre:
Al momento de llamar una función la cual tiene definidos unos parámetros, si no pasa los argumentos correcta-
mente provocará una excepción TypeError (página 193):
>>> resta()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: resta() takes exactly 2 arguments (0 given)
Para solucionar la excepción TypeError (página 193) ejecutada al momento de la llamada a una función sin argu-
mentos, entonces usted puede asignar unos valores por defecto nulos a los parámetros, de esa forma puede hacer
una comprobación antes de ejecutar el código de la función:
Como puede ver el el código anterior, se indica el final de la función luego de la sentencia print (página 153),
usando la sentencia return (página 104) aunque no devuelva nada.
En alguna ocasión usted no sabe previamente cuantos elementos necesita enviar a una función. En estos casos
puede utilizar los parámetros indeterminados por posición y por nombre.
Por posición
Usted debe crear una lista dinámica de argumentos, es decir, un tipo tupla (página 63), definiendo el parámetro
con un asterisco, para recibir los parámetros indeterminados por posición:
Por nombre
Para recibir un número indeterminado de parámetros por nombre (clave-valor o en inglés keyword args), usted
debe crear un diccionario dinámico de argumentos definiendo el parámetro con dos asteriscos:
Al recibirse como un diccionario, puede iterarlo y mostrar la clave y valor de cada argumento:
Si requiere aceptar ambos tipos de parámetros simultáneamente en una función, entonces debe crear ambas colec-
ciones dinámicas. Primero los argumentos indeterminados por valor y luego los cuales son por clave y valor:
Los nombres args y kwargs no son obligatorios, pero se suelen utilizar por convención.
Muchos frameworks y librerías los utilizan por lo que es una buena practica llamarlos así.
Es una operación nula — cuando es ejecutada, nada sucede. Eso es útil como un contenedor cuando una sentencia
es requerida sintácticamente, pero no necesita código que ser ejecutado, por ejemplo:
Las funciones pueden comunicarse con el exterior de las mismas, al proceso principal del programa usando la
sentencia return. El proceso de comunicación con el exterior se hace devolviendo valores. A continuación, un
ejemplo de función usando return:
def devuelve_fibonacci(n):
'''devuelve la sucesión Fibonacci hasta n'''
resultado = []
a, b = 0, 1
while b < n:
resultado.append(b)
a, b = b, a + b
return resultado
>>> devuelve_fibonacci(10)
[1, 1, 2, 3, 5, 8]
Nota: Por defecto, las funciones retorna el valor None (página 210).
Retorno múltiple
Una característica interesante, es la posibilidad de devolver valores múltiples separados por comas:
En el código anterior los valores múltiples se tratan en conjunto como una tupla (página 63) inmutable y se pueden
reasignar a distintas variables:
En el código anterior puede observa como se asignar a distintas variables en base a los valores de la tupla (pági-
na 63) inmutable.
def iva():
'''función básica para el calculo del IVA'''
iva = 12
costo = int(input('¿Cual es el monto a calcular?: '))
calculo = costo * iva / 100
print ("El calculo de IVA es: " + str(calculo) + "\n")
Invocar funciones
A continuación, se presenta un ejemplo del uso de llamar funciones:
>>> iva()
¿Cual es el monto a calcular?: 300
36
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código funciones.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python funciones.py
Ver también:
Consulte la sección de lecturas suplementarias (página 264) del entrenamiento para ampliar su conocimiento en
esta temática.
Las funciones de predicado no es más que una función la cual dice si algo es True o False, es decir, es una
función que devuelve un tipo de datos booleano (página 44).
Una función anónima, como su nombre indica es una función sin nombre. Es decir, es posible ejecutar una función
sin referenciar un nombre, en Python puede ejecutar una función sin definirla con def.
De hecho son similares pero con una diferencia fundamental, el contenido de una función anónima debe ser
una única expresión en lugar de un bloque de acciones.
Las funciones anónimas se implementan en Python con las funciones o expresiones lambda (página 106), esta es
unas de las funcionalidades más potentes de Python, pero a la vez es la más confusas para los principiantes.
Más allá del sentido de función que usted tiene hasta el momento, con su nombre y sus acciones internas, una
función en su sentido más trivial significa realizar algo sobre algo. Por tanto se podría decir que, mientras las
funciones anónimas lambda sirven para realizar funciones simples, las funciones definidas con def sirven para
manejar tareas más extensas.
Si deconstruye una función sencilla, puede llegar a una función lambda. Por ejemplo la siguiente función es para
doblar un valor de un número:
>>> def doblar(numero):
... resultado = numero*2
... return resultado
>>> doblar(2)
4
>>> type(doblar)
<type 'function'>
>>> doblar(2)
4
>>> type(doblar)
<type 'function'>
Usted puede todavía simplificar más, escribirlo todo en una sola línea, de la siguiente forma:
Esta notación simple es la que una función lambda intenta replicar, observe, a continuación se va a convertir la
función en una función anónima:
En este ejemplo tiene una función anónima con una entrada que recibe numero, y una salida que devuelve
numero * 2.
Lo único que necesita hacer para utilizarla es guardarla en una variable y utilizarla tal como haría con una función
normal:
Con la flexibilidad de Python usted puede implementar infinitas funciones simples. Usted puede encontrar más
ejemplos de funciones anónimas usando lambda en la sección ejemplos de funciones avanzadas (página 107).
Usted puede explotar al máximo la función lambda utilizándola en conjunto con otras funciones como filter()
(página 109) y map() (página 110).
Ver también:
Consulte la sección de lecturas suplementarias (página 264) del entrenamiento para ampliar su conocimiento en
esta temática.
Las funciones recursivas son funciones que se llaman a sí mismas durante su propia ejecución. Ellas funcionan
de forma similar a las iteraciones, pero debe encargarse de planificar el momento en que dejan de llamarse a sí
mismas o tendrá una función recursiva infinita.
Estas funciones se estilan utilizar para dividir una tarea en sub-tareas más simples de forma que sea más fácil
abordar el problema y solucionarlo.
Un ejemplo de una función recursiva sin retorno, es el ejemplo de cuenta regresiva hasta cero a partir de un
número:
Un ejemplo de una función recursiva con retorno, es el ejemplo del calculo del factorial de un número corresponde
al producto de todos los números desde 1 hasta el propio número. Es el ejemplo con retorno más utilizado para
Ver también:
Consulte la sección de lecturas suplementarias (página 264) del entrenamiento para ampliar su conocimiento en
esta temática.
Las funciones de Python pueden tomar funciones como parámetros y devolver funciones como resultado. Una
función que hace ambas cosas o alguna de ellas se llama función de orden superior.
5.5.1 filter()
La función filter() es una función la cual toma un predicado (página 106) y una lista y devuelve una lista con
los elementos que satisfacen el predicado. Tal como su nombre indica filter() significa filtrar, ya que a partir
de una lista o iterador y una función condicional, es capaz de devolver una nueva colección con los elementos
filtrados que cumplan la condición.
Todo esto podría haberse logrado también usando listas por comprensión (página 231) que usaran predicados. No
hay ninguna regla que diga cuando usar la función map() (página 110) o la función filter() en lugar de las
listas por comprensión (página 231), simplemente debe decidir que es más legible dependiendo del contexto.
Por ejemplo, suponga que tiene una lista varios números y requiere filtrarla, quedando únicamente con los números
múltiples de 5, eso seria así:
>>> # Primero declaramos una función condicional
def multiple(numero):
# Comprobamos si un numero es múltiple de cinco
if numero % 5 == 0:
# Sólo devolvemos True si lo es
return True
Si ejecuta el filtro obtiene una lista los números múltiples de 5. Por tanto cuando utiliza la función filter()
tiene que enviar una función condicional, para esto, puede utilizar una función anónima lambda, como se muestra
a continuación:
Así, en una sola línea ha definido y ejecutado el filtro utilizando una función condicional anónima y devolviendo
una lista de números.
Filtrando objetos
Sin embargo, más allá de filtrar listas con valores simples, el verdadero potencial de la función filter() sale a
relucir cuando usted necesita filtrar varios objetos de una lista.
Por ejemplo, dada una lista con varias personas, a usted le gustaría filtrar únicamente las cuales son menores de
edad:
Este es un ejemplo sencillo, con el cual usted puede realizar filtrados con objetos, de forma amigable.
5.5.2 map()
La función map() toma una función y una lista y aplica esa función a cada elemento de esa lista, produciendo
una nueva lista. Va a ver su definición de tipo y como se define.
Esta función trabaja de una forma muy similar a filter() (página 109), con la diferencia que en lugar de aplicar una
condición a un elemento de una lista o secuencia, aplica una función sobre todos los elementos y como resultado
se devuelve un lista de números doblado su valor:
Usted puede simplificar el código anterior usando una función lambda para substituir la llamada de una función
definida, como se muestra a continuación:
La función map() se utiliza mucho junto a expresiones lambda ya que permite evitar escribir bucles for (pági-
na 90).
Además se puede utilizar sobre más de un objeto iterable con la condición que tengan la misma longitud. Por
ejemplo, si requiere multiplicar los números de dos listas:
>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> map(lambda x,y : x*y, a,b)
[6, 14, 24, 36, 50]
>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> c = [11, 12, 13, 14, 15]
>>> map(lambda x,y,z : x*y*z, a,b,c)
[66, 168, 312, 504, 750]
Mapeando objetos
Evidentemente, siempre que la función map() la utilice correctamente podrá mapear una serie de objetos sin
ningún problema:
Claro que en este caso tiene que utilizar una función definida porque no necesitamos actuar sobre la instancia, a
no ser que usted se tome la molestia de rehacer todo el objeto:
5.5.3 lambda
La expresión lambda, es una función anónima que suelen ser usadas cuando necesita una función una sola vez.
Normalmente usted crea funciones lambda con el único propósito de pasarlas a funciones de orden superior.
En muchos lenguajes, el uso de lambdas sobre funciones definidas causa problemas de rendimiento. No es el
caso en Python.
>>> import os
>>> archivos = os.listdir(os.__file__.replace("/os.pyc", "/"))
>>> print filter(lambda x: x.startswith('os.'), archivos)
['os.pyc', 'os.py']
En el ejemplo anterior se usa el método os.__file__ para obtener la ruta donde esta instalada el módulo os
en su sistema, ejecutando la siguiente sentencia:
>>> os.__file__
'/usr/lib/python2.7/os.pyc'
Si con el método os.__file__ obtiene la ruta del módulo os con el método replace("/os.pyc", "/")
busca la cadena de carácter «/os.pyc» y la remplaza por la cadena de carácter «/»
Luego se define la variable archivos generando una lista de archivos usando la función os.listdir(),
pasando el parámetro obtenido de la ruta donde se instalo el módulo os ejecutando en el comando previo, con la
siguiente sentencia:
De esta forma se define en la variable archivos un tipo lista (página 58) con un tamaño de 433, como se puede
comprobar a continuación:
>>> type(archivos)
<type 'list'>
>>> len(archivos)
443
Opcionalmente puede comprobar si la cadena de caracteres os.pyc se encuentras una de las posiciones de la lista
archivos, ejecutando la siguiente sentencia:
Ya al comprobar que existe la cadena de caracteres «os.pyc» se usa una función lambda como parámetro de la
función filter() (página 109) para filtrar todos los archivos del directorio «/usr/lib/python2.7/ » por medio del fun-
ción os.listdir() que inicien con la cadena de caracteres «os.» usando la función startswith() (página 135).
Así de esta forma se comprueba que existe el archivo compilado «os.pyc» de Python junto con el mismo módulo
Python «os.py».
Truco: Más detalle consulte la referencia de las expresiones lambda (página 106).
Ver también:
Consulte la sección de lecturas suplementarias (página 264) del entrenamiento para ampliar su conocimiento en
esta temática.
El interprete Python tiene un número de funciones integradas (built-in) dentro del módulo __builtins__, las
cuales están siempre disponibles. Estas funciones están listadas en orden alfabéticos a continuación:
apply()
La función apply() devuelve el resultado de una función o objeto clase llamado con argumentos soportados.
callable()
>>> callable([1,2,3])
False
>>> callable(callable)
True
>>> callable(False)
False
>>> callable(list)
True
Una función se puede llamar, una lista no se puede llamar. Incluso la función integrada callable() se puede
llamar.
compile()
La función compile() devuelve un código objeto Python. Usted usa la función integrada Python para convertir
de la cadena de caracteres de código al código objeto.
>>>
>>> exec(compile('a=5\nb=7\nprint a+b','','exec'))
12
Aquí, exec es el modo. El parámetro anterior que eso es el nombre del archivo para la forma del archivo el cual
el código es leído. Finalmente, es ejecutado usando la función exec().
credits()
>>> credits()
Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
for supporting Python development. See www.python.org for more information.
copyright()
>>> copyright()
Copyright (c) 2001-2016 Python Software Foundation.
All Rights Reserved.
dir()
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
De lo contrario, devuelve una lista alfabética de nombres que comprende (alguno(s) de) los atributos de un objeto
dato, y de los atributos legibles desde este.
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError',
'BaseException', 'BufferError', 'BytesWarning',
'DeprecationWarning', 'EOFError', 'Ellipsis',
'EnvironmentError', 'Exception', 'False', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
'ImportWarning', 'IndentationError', 'IndexError', 'KeyError',
'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError',
'None', 'NotImplemented', 'NotImplementedError', 'OSError',
'OverflowError', 'PendingDeprecationWarning', 'ReferenceError',
'RuntimeError', 'RuntimeWarning', 'StandardError',
'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
'SystemExit', 'TabError', 'True', 'TypeError',
'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning',
'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError',
'_', '__debug__', '__doc__', '__import__', '__name__',
'__package__', 'abs', 'all', 'any', 'apply', 'basestring',
'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable',
'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex',
'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter',
'float', 'format', 'frozenset', 'getattr', 'globals',
'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int',
'intern', 'isinstance', 'issubclass', 'iter', 'len',
'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',
'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',
'property', 'quit', 'range', 'raw_input', 'reduce', 'reload',
'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',
'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr',
'unicode', 'vars', 'xrange', 'zip']
Si el objeto soporta un método llamado __dir__, ese será usado; de lo contrario se usa la lógica dir() prede-
terminada y devuelve:
para un objeto módulo: los atributos del módulo.
>>> import os
>>> type(os)
<type 'module'>
>>> dir(os)
['EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR',
'EX_NOHOST', 'EX_NOINPUT', 'EX_NOPERM', 'EX_NOUSER',
'EX_OK', 'EX_OSERR', 'EX_OSFILE', 'EX_PROTOCOL',
'EX_SOFTWARE', 'EX_TEMPFAIL', 'EX_UNAVAILABLE', 'EX_USAGE',
'F_OK', 'NGROUPS_MAX', 'O_APPEND', 'O_ASYNC', 'O_CREAT',
'O_DIRECT', 'O_DIRECTORY', 'O_DSYNC', 'O_EXCL', 'O_LARGEFILE',
'O_NDELAY', 'O_NOATIME', 'O_NOCTTY', 'O_NOFOLLOW', 'O_NONBLOCK',
'O_RDONLY', 'O_RDWR', 'O_RSYNC', 'O_SYNC', 'O_TRUNC', 'O_WRONLY',
'P_NOWAIT', 'P_NOWAITO', 'P_WAIT', 'R_OK', 'SEEK_CUR', 'SEEK_END',
'SEEK_SET', 'ST_APPEND', 'ST_MANDLOCK', 'ST_NOATIME', 'ST_NODEV',
'ST_NODIRATIME', 'ST_NOEXEC', 'ST_NOSUID', 'ST_RDONLY',
'ST_RELATIME', 'ST_SYNCHRONOUS', 'ST_WRITE', 'TMP_MAX', 'UserDict',
'WCONTINUED', 'WCOREDUMP', 'WEXITSTATUS', 'WIFCONTINUED', 'WIFEXITED',
'WIFSIGNALED', 'WIFSTOPPED', 'WNOHANG', 'WSTOPSIG', 'WTERMSIG',
'WUNTRACED', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__',
(continué en la próxima página)
This exports:
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
- os.path is one of the modules posixpath, or ntpath
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
- os.curdir is a string representing the current directory ('.' or ':')
- os.pardir is a string representing the parent directory ('..' or '::')
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
...
...
...
para un objeto clase: sus atributos, y recursivamente los atributos de sus clases bases.
para cualquier otro objecto: sus atributos, sus atributos de clases, y recursivamente los atributos de esas
clases bases de las clases.
>>> type(int)
<type 'type'>
>>> dir(int)
['__abs__', '__add__', '__and__', '__class__', '__cmp__',
'__coerce__', '__delattr__', '__div__', '__divmod__',
'__doc__', '__float__', '__floordiv__', '__format__',
'__getattribute__', '__getnewargs__', '__hash__', '__hex__',
'__index__', '__init__', '__int__', '__invert__', '__long__',
'__lshift__', '__mod__', '__mul__', '__neg__', '__new__',
'__nonzero__', '__oct__', '__or__', '__pos__', '__pow__',
'__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__',
'__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__',
'__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__',
'__rshift__', '__rsub__', '__rtruediv__', '__rxor__',
'__setattr__', '__sizeof__', '__str__', '__sub__',
'__subclasshook__', '__truediv__', '__trunc__', '__xor__',
'bit_length', 'conjugate', 'denominator', 'imag', 'numerator',
'real']
eval()
>>> numero = 10
>>> eval('numero * 10 - 5')
95
execfile()
La función execfile() lee y ejecuta un script Python desde un archivo. Los globals y locals son diccio-
narios, por defecto a los actuales globals y locals. Si solamente globals es dado, locals es por defecto
a la misma.
>>> execfile('./holamundo.py')
Hola Mundo
globals()
La función globals() devuelve un diccionario conteniendo ámbito actual global de las variables.
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>,
'__package__': None, '__name__': '__main__', '__doc__': None}
La función globals() puede ser usada para devolver los nombres en el namespaces global dependiendo en
la locación desde donde ella es llamada.
Si la función globals() es llamada desde una función, eso devolverá todos los nombres que pueden ser acce-
sibles globalmente desde esa función.
El tipo de dato devuelto por función es un tipo diccionario. Por lo tanto, los nombres pueden ser extraídos usando
la función integrada keys().
help()
>>> help()
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/2.7/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
help>
id()
La función id() devuelve la identidad de un objecto. Esto garantiza ser el único entre objetos simultáneamente
existentes. (Sugerencia: es la dirección de memoria del objeto).
len()
license()
>>> license
Type license() to see the full license text
>>> license()
A. HISTORY OF THE SOFTWARE
==========================
Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC. Guido remains Python's
principal author, although it includes many contributions from others.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com). In 2001, the Python Software
Foundation (PSF, see https://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property. Zope Corporation is a sponsoring member of
the PSF.
locals()
La función locals() devuelve un diccionario conteniendo ámbito actual local de las variables.
>>> locals()
{'__builtins__': <module '__builtin__' (built-in)>,
'__package__': None, '__name__': '__main__', '__doc__': None}
La función locals() puede ser usadas para devolver los nombres en el namespaces local dependiendo en la
locación desde donde ella es llamada.
Si la función locals() es llamada desde una función, eso devolverá todos los nombres que pueden ser accesibles
localmente desde esa función.
El tipo de dato devuelto por la función es un tipo diccionario. Por lo tanto, los nombres pueden ser extraídos
usando la función integrada keys().
open()
La función open() es definida dentro del modulo integrado io, esta le permite abrir un archivo (página 154)
usando el tipo objeto file, devuelve un objeto del tipo file (página 214) (ej. archivo), y se llama habitualmente
con de dos a tres argumentos:
Mo- Notas
do
r el archivo se abre en modo de solo lectura, no se puede escribir (argumento por defecto).
w modo de solo escritura (si existe un archivo con el mismo nombre, se borra).
a modo de agregado (append), los datos escritos se agregan al final del archivo.
r+ el archivo se abre para lectura y escritura al mismo tiempo.
b el archivo se abre en modo binario, para almacenar cualquier cosa que no sea texto.
U el archivo se abre con soporte a nueva linea universal, cualquier fin de linea ingresada sera como
un \n en Python.
buffering, si este argumento es dado, 0 significa sin búfer, 1 significa búfer de línea y los números más
grandes especifican el tamaño del búfer.
Para crear y abrir un archivo, seria así:
El archivo será creado si no existe cuando es abierto para escribir o agregar data. Es archivo sera truncado cuando
es abierto para escritura.
Agregue una “U” a modo para abrir el archivo para la entrada con soporte de nueva línea universal. Cualquier
línea que termine en el archivo de entrada se verá como “n” en Python. Además, un archivo así abierto gana el
atributo newlines; el valor para este atributo es uno de Ninguno (aún no se ha leído una nueva línea), \r, \n,
\r\n o una tupla que contiene todos los tipos de nueva línea que se han visto.
Truco: Ver para futura información desde el modo interactivo (página 15) Python, lo siguiente:
>>> file.__doc__
range()
La función range() devuelve una lista conteniendo una progresión aritmética de enteros.
range(inicio, detener[, paso]) -> lista de enteros
>>> range(3,9)
[3, 4, 5, 6, 7, 8]
range(i, j) devuelve [i, i+1, i+2, ..., j-1]; inicia (!) por defecto en 0.
Cuando el paso es definido como un tercer argumento, ese especifica el incremento (o decremento).
>>> range(3,9,2)
[3, 5, 7]
En el ejemplo anterior, la función range(3,9,2) devuelve [3, 5, 7], es decir, el rango inicia en 3 y termina en
9 incrementando cada 2 números.
range(detener) -> lista de enteros
>>> range(4)
[0, 1, 2, 3]
En el ejemplo anterior, la función range(4) devuelve [0, 1, 2, 3]. ¡El punto final es omitido! Hay exactamente
los indices validos para una lista de 4 elementos.
reload()
Cuando el modulo es importado dentro de un script, el código en la porción del nivel superior de un modulo es
ejecutado solamente una vez.
Por lo tanto, si usted quiere volver a ejecutar la porción del nivel superior el código de un modulo, usted puede
usar la función reload(). Esta función importa otra vez un modulo previamente importado. La sintaxis de la
función reload() es la siguiente:
>>> reload(module_name)
Aquí, module_name es el nombre del modulo que usted quiere volver a cargar y no la cadena de caracteres
(página 46) contendiente el nombre del modulo. Por ejemplo, para recargar el modulo clases.py, debe hacer
lo siguiente:
xrange()
El tipo xrange es un tipo secuencia inmutable utilizada normalmente en bucles. La ventaja de la función
xrange() sobre la función range(), es que devuelve un objeto xrange el cual ocupa siempre la misma
cantidad de memoria, independientemente del rango el cual represente.
Como la función xrange(), devuelve un objeto el cual genera los números en el rango a demanda. Para bucles,
esto es un poco mas rápido que la función range() y más eficiente en la memoria.
La ventaja de la función xrange() es excepto en hardware impedido en cuestión de memoria (por ejemplo,
MS-DOS) o cuando nunca se utilizan todos los elementos del rango (por ejemplo, porque se suele interrumpir la
ejecución del bucle con la sentencia break (página 89)).
type()
La función type() devuelve el tipo del objeto que recibe como argumento.
>>> type(2)
<type 'int'>
>>> type(2.5)
<type 'float'>
>>> type(True)
<type 'bool'>
>>> type("Hola Mundo")
<type 'str'>
>>> type(int)
<type 'type'>
>>> type(str)
<type 'type'>
>>> type(None)
<type 'NoneType'>
>>> type(object)
<type 'type'>
>>> import os
>>> type(os)
<type 'module'>
>>> type(format)
<type 'builtin_function_or_method'>
Truco: La función type() devuelve el tipo del objeto, en base al modulo integrado types, el cual define los
nombres para todos los símbolos tipo conocidos en el interprete estándar.
NAME
types - Define names for all type symbols known in the standard interpreter.
FILE
/usr/lib/python2.7/types.py
MODULE DOCS
https://docs.python.org/library/types
DESCRIPTION
Types that are part of optional modules (e.g. array) are not listed.
CLASSES
__builtin__.basestring(__builtin__.object)
__builtin__.str
__builtin__.unicode
>>>
vars()
>>> vars()
{'__builtins__': <module '__builtin__' (built-in)>, '__package__':
None, '__name__': '__main__', '__doc__': None}
La función vars() sin argumentos, equivale a la función locals() (página 119). Si se llama con un argumento
equivale a la sentencia object.__dict__.
input()
En el caso que quiera ingresar una cadena de caracteres (página 46) desde la entrada estándar usando la función
input(), debe colocar la cadena de caracteres entre comillas simples o dobles, como el siguiente ejemplo:
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: leonardo
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
NameError: name 'leonardo' is not defined
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: "leonardo"
'leonardo'
<type 'str'>
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: leonardo caballero
File "<string>", line 1
leonardo caballero
^
SyntaxError: unexpected EOF while parsing
>>> dato = input("Por favor, ingresa un dato: "); dato; type(dato)
Por favor, ingresa un dato: "leonardo caballero"
'leonardo caballero'
<type 'str'>
raw_input()
Lee una cadena de caracteres (página 46) desde la entrada estándar. La nueva línea final es despojada. Si el usuario
indica un EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), lanza una excepción EOFError (página 191). En
sistemas Unix, la librería GNU readline es usada si es habilitada. El prompt de la cadena de caracteres, si es
dado, es impreso sin una nueva línea final antes de leer.
abs()
>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-2.5)
2.5
bin()
Devuelve una representación binaria de un número entero (página 41) o entero long (página 41), es decir, lo
convierte de entero a binario.
>>> bin(10)
'0b1010'
cmp()
La función cmp() devuelve un valor negativo si x<y, un valor cero si x==y, un valor positivo si x>y:
>>> cmp(1,2)
-1
>>> cmp(2,2)
0
>>> cmp(2,1)
1
complex()
La función complex() devuelve un número complejo complex. Es un constructor, que crea un entero com-
plex (página 43) a partir de un entero (página 41), entero long (página 41), entero float (página 42) (cadenas de
caracteres formadas por números y hasta un punto), o una cadena de caracteres (página 46) que sean coherentes
con un número entero.
>>> complex(23)
(23+0j)
>>> complex(23L)
(23+0j)
>>> complex(23.4)
(23.4+0j)
>>> complex("23")
(23+0j)
>>> complex("23.6")
(23.6+0j)
La función complex() sólo procesa correctamente cadenas que contengan exclusivamente números.Si la cadena
contiene cualquier otro carácter, la función devuelve una excepción ValueError (página 193).
>>> complex("qwerty")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string
divmod()
Debe recibir dos argumentos numéricos, y devuelve dos valores: resultado de la división entera, y el resto.
>>> divmod(22, 4)
(5, 2)
float()
La función float() devuelve un número coma flotante float. Es un constructor, que crea un coma flotante
(página 42) a partir de un entero (página 41), entero long (página 41), entero float (página 42) (cadenas de carac-
teres formadas por números y hasta un punto) o una cadena de caracteres (página 46) que sean coherentes con un
número entero.
>>> float(2)
2.0
>>> float(23L)
23.0
>>> float(2.5)
2.5
(continué en la próxima página)
hex()
Devuelve una representación hexadecimal de un número entero (página 41) o entero long (página 41), es decir, lo
convierte de entero a hexadecimal.
>>> hex(10)
'0xa'
int()
La función int() devuelve un número entero. Es un constructor, que crea un entero (página 41) a partir de un
entero float (página 42), entero complex (página 43) o una cadena de caracteres (página 46) que sean coherentes
con un número entero.
>>> int(2.5)
2
>>> int("23")
23
La función int() sólo procesa correctamente cadenas que contengan exclusivamente números. Si la cadena
contiene cualquier otro carácter, la función devuelve una excepción ValueError (página 193).
>>> int("2.5")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '2.5'
>>>
>>> int("doscientos")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'doscientos'
long()
La función long() devuelve un número entero long. Es un constructor, que crea un entero long (página 41) a
partir de un entero (página 41), entero float (página 42) o una cadena de caracteres (página 46) que sean coherentes
con un número entero.
>>> long(23)
23L
>>> long(23.4)
23L
>>> long("23")
23
La función long() sólo procesa correctamente cadenas que contengan exclusivamente números. Si la cadena
contiene cualquier otro carácter, la función devuelve una excepción ValueError (página 193).
>>> long("23.4")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: '23.4'
>>>
>>> long("23,4")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: '23,4'
max()
Si recibe un solo argumento, devuelve el mayor de sus elementos. Debe ser un objeto iterable; puede ser una
cadena de caracteres (página 46), o alguno de los otros tipos de secuencia o colección.
>>> max("Hola, Plone")
'o'
>>> type(max("Hola, Plone"))
<type 'str'>
min()
pow()
La función pow() si recibe dos (02) argumentos, eleva el primero argumento a la potencia del segundo argumento.
>>> pow(2, 3)
8
>>> pow(10, 2)
100
>>> pow(10, -2)
0.01
>>> pow(2, 3, 3)
2
reduce()
La función reduce() aplica una función de dos argumentos de forma acumulativa a los elementos de un tipo de
secuencia, de izquierda a derecha, para reducir la secuencia a un solo valor. La sintaxis seria la siguiente:
A continuación un ejemplo:
round()
La función round() redondea un número flotante a una precisión dada en dígitos decimal (por defecto 0 dígitos).
Esto siempre devuelve un número flotante. La precisión tal vez sea negativa.
En el siguiente ejemplo redondeo de un número flotante a entero, mayor o igual a .5 al alza:
>>> round(5.5)
6.0
>>> round(5.4)
5.0
sum()
La función sum() devuelve una lista ordenada de los elementos de la secuencia que recibe como argumento (lista
o cadena). La secuencia original no es modificada.
oct()
La función oct() convierte un número entero en una cadena en base octal, antecedida del prefijo “0”.
>>> oct(8)
'010'
>>> oct(123)
'0173'
bool()
La función bool(), es un constructor, el cual crea un tipo de datos booleanos (página 44), devuelve un tipo
booleano True cuando el argumento dado es True, de lo contrario False.
>>> bool()
False
>>> bool(True)
True
>>> bool(0)
False
>>> bool(1)
True
Convertir desde un tipo entero float (página 42) de forma recursiva usando la función int() (página 126) a tipo
booleano:
>>> bool(int(0.1))
False
>>> bool(int(1.0))
True
Convertir desde un tipo cadena de caracteres (página 46) de forma recursiva usando la función str() (página 136)
y la función int() (página 126) a tipo booleano:
>>> bool(int(str('0')))
False
>>> bool(int(str('1')))
True
capitalize()
La función capitalize() devuelve una cadenas de caracteres (página 46) con MAYÚSCULA la primera
palabra.
chr()
La función chr() recibe como argumento un entero, y devuelve una cadena con el carácter cuyo código Unicode
corresponde a ese valor. El rango válido para el argumento es de 0 a 256.
>>> chr(64)
'@'
>>> chr(36)
'$'
>>> chr(94)
'^'
>>> chr(126)
'~'
endswith()
La función endswith() devuelve un valor booleano True o False si coincide que la cadena termine con el
criterio enviado por parámetros en la función.
expandtabs()
La función expandtabs() devuelve una copia de la cadena de caracteres (página 46) donde todos los caracte-
res tab (tabulación) son remplazados por uno o más espacios, depende en la actual columna y el tamaño del tab
dado.
find()
format()
La función integrada format() devuelve una representación formateada de un valor dato controlado por el
especificador de formato.
La función integrada format() es similar al método format() (página 53) disponible en el tipo de cadena de
caracteres (página 46). Internamente, ambos llaman al método __format__() de un objecto.
Mientras, la función integrada format() es una implementación de bajo nivel para formatear un objeto usando
__format__() internamente, el método format() (página 53) del tipo de cadena de caracteres es una implemen-
tación de alto nivel disponible para ejecutar operaciones de formateo complejas en múltiples objeto de cadena de
caracteres (página 46).
La sintaxis de la función integrada format() es:
format(value[, format_spec])
A continuación, un ejemplo de un valor número float (página 42), seria de la siguiente forma:
A continuación, un ejemplo de un valor número entero (página 41) con formato especifico, seria de la siguiente
forma:
En el ejemplo anterior cuando se formatea el número entero (página 41) 1234, usted especifico el especificador de
formato *<+7,d. Seguidamente, se describe cada opción a continuación:
* Es la opción del carácter de relleno, el cual rellena los espacio vacío después del formato.
> Es la opción de alineación a la derecha, el cual alinea la cadena de caracteres de salida a la derecha.
+ Es la opción de signo, el cual obliga al número a ser firmado (con un signo a su izquierda).
7 Es la opción ancho, el cual obliga el número que tome un mínimo de ancho de 7, otros espacios serán
rellenado por el carácter de relleno.
, Ese es el operador miles, el cual coloca un carácter coma entre todos los números miles.
d Es la opción tipo que especifica que el número es un número entero (página 41).
A continuación, un ejemplo de un valor número float (página 42) con formato especifico, seria de la siguiente
forma:
En el ejemplo anterior cuando se formatea el número float (página 42) 123.4567, usted especifico el especificador
de formato ^-09.3f. Seguidamente, se describe cada opción a continuación:
^ Es la opción de alineación centrar, el cual alinea la cadena de caracteres de salida al centro del espacio
restante.
- Es la opción de signo el cual obliga solo a los números negativos a mostrar el signo.
0 Ese es el carácter, el cual es colocado en lugar de los espacios vacíos.
9 Es la opción de ancho, el cual establece el ancho mínimo del número en 9 (incluido el punto decimal, la
coma y el signo de miles).
.3 Ese es el operador de precisión que define la precisión del número flotante dado a 3 lugares.
f Es la opción tipo que especifica que el número es un número float (página 42).
A continuación, un ejemplo de usar la función format() sobre escribiendo el método especial __format__()
de una clase (página 199), seria de la siguiente forma:
En el ejemplo anterior cuando se sobre escribe el método especial __format__() de la clase Persona. Ese
ahora acepta el argumento del método llamado edad el cual devuelve 23.
El método format() internamente ejecuta Persona().__format__("edad"), el cual devuelve el men-
saje 23. Si no hay formato especificado, el mensaje devuelto es Formato nulo.
index()
La función index() es como la función find() pero arroja una excepción ValueError (página 193) cuando la
sub-cadena no es encontrada.
intern()
La función intern() introduce la cadena en la tabla de cadenas internadas (si no está ya allí). Esto ingresa la
cadena en la tabla (global) de cadenas internas cuyo propósito es acelerar las búsquedas en el tipo diccionario.
Al utilizar la función intern(), se asegura de que nunca cree dos objetos de cadena de caracteres que tengan el
mismo valor: cuando solicita la creación de un segundo objeto de cadena de caracteres con el mismo valor que un
objeto de cadena existente, recibe una referencia al objeto de cadena preexistente. De esta manera, estás ahorrando
memoria. Además, la comparación de objetos de cadena de caracteres ahora es muy eficiente porque se lleva a
cabo comparando las direcciones de memoria de los dos objetos de cadena de caracteres en lugar de su contenido.
Esencialmente, la función intern() busca (o almacena si no está presente) la cadena de caracteres en una
colección de cadenas de caracteres internadas, por lo que todas las instancias internadas compartirán la misma
identidad. Cambia el costo único de buscar esta cadena de caracteres para realizar comparaciones más rápidas (la
comparación puede devolver True después de solo verificar la identidad, en lugar de tener que comparar cada
carácter), y reducir el uso de la memoria.
Sin embargo, Python internará automáticamente cadenas de caracteres que sean pequeñas o que parezcan identifi-
cadores, por lo que es posible que no obtengas ninguna mejora porque tus cadenas de caracteres ya están internadas
entre bastidores.
A continuación uno ejemplo de comparación de cadena de caracteres con operadores de relacionales:
A continuación uno ejemplo de comparación de cadena de caracteres con el operador is (página 84):
>>>
>>> cadena0 = intern('plone cms')
>>> cadena1 = 'plone cms'
>>> cadena0 is cadena1
False
>>> cadena1 = intern('plone cms')
>>> cadena0 is cadena1
True
isalnum()
La función isalnum() devuelve un valor booleano True o False si coincide que la cadena contenga caracte-
res alfanuméricos.
>>> '23456987'.isalnum()
True
>>> 'V-23456987'.isalnum()
False
isalpha()
La función isalpha() devuelve un valor booleano True o False si coincide que la cadena contenga caracte-
res alfabéticos.
>>> 'leonardo'.isalpha()
True
>>> 'leonardo caballero'.isalpha()
False
isdigit()
La función isdigit() devuelve un valor booleano True o False si coincide que la cadena contenga caracte-
res dígitos.
islower()
La función islower() devuelve un valor booleano True o False si coincide que la cadena contenga caracte-
res en MINÚSCULAS.
istitle()
La función istitle() devuelve un valor booleano True o False si coincide que la cadena de caracteres
(página 46) sean capitales en cada palabra.
isspace()
La función isspace() devuelve un valor booleano True o False si no es vacía, y todos sus caracteres son
espacios en blanco.
isupper()
La función isupper() devuelve un valor booleano True o False si coincide que la cadena de caracteres
(página 46) estén en MAYÚSCULAS en cada palabra.
lstrip()
La función lstrip() devuelve una copia de la cadena de caracteres (página 46) con el espacio en blanco inicial
eliminado. Si se dan la cadena de caracteres y no es None (página 210), elimina los caracteres en la cadena de
caracteres en su lugar. Si la cadena de caracteres son unicode, serán convertidas a unicode antes de eliminar.
lower()
La función lower() devuelve una cadenas de caracteres (página 46) con MINÚSCULAS en cada palabra.
ord()
La función ord() es el inverso de chr() (página 130) dada una cadena representando un carácter Unicode, de-
vuelve el entero del código correspondiente.
>>> ord('@')
64
>>> ord('$')
36
>>> ord('^')
94
>>> ord('~')
126
replace()
split()
La función split() devuelve una lista con la cadena de caracteres (página 46) separada por cada indice de la
lista.
splitlines()
La función splitlines() devuelve una lista con la cadena de caracteres (página 46) separada por cada salto
de linea en cada indice de la lista.
startswith()
La función startswith() devuelve un valor booleano True o False si coincide que la cadena inicie con el
criterio enviado por parámetros en la función.
str()
La función str() es el constructor del tipo de cadenas de caracteres (página 46), se usa crear una carácter o
cadenas de caracteres mediante la misma función str().
Puede convertir un número entero (página 41) a una cadena de caracteres, de la siguiente forma:
>>> str(2)
'2'
Puede convertir un número float (página 42) a una cadena de caracteres, de la siguiente forma:
>>> str(2.5)
'2.5'
>>> str(-2.5)
'-2.5'
Puede convertir un número complex (página 43) a una cadena de caracteres, de la siguiente forma:
>>> str(2.3+0j)
'(2.3+0j)'
Puede convertir un tipo booleano (página 44) a una cadena de caracteres, de la siguiente forma:
>>> str(True)
'True'
>>> str(False)
'False'
swapcase()
La función swapcase() devuelve una cadenas de caracteres (página 46) convertida al opuesto sea MAYÚS-
CULAS o MINÚSCULAS.
title()
La función title() devuelve una cadenas de caracteres (página 46) con capitales en cada palabra.
unichr()
La función unichr() devuelve una cadena de caracteres Unicode de un carácter con un numero entero.
>>> unichr(64)
u'@'
>>> unichr(36)
u'$'
>>> unichr(94)
u'^'
>>> unichr(126)
u'~'
upper()
La función upper() devuelve una cadenas de caracteres (página 46) con MAYÚSCULAS en cada palabra.
all()
La función all() toma un contenedor como un argumento. Esta devuelve las funciones integradas True si todo
los valores en el objeto iterable python tienen un valor de tipo booleano (página 44) igual a True. Un valor vacío
tiene un tipo booleano (página 44) igual a False.
any()
La función any() ese toma un argumento y devuelve True incluso si, un valor en el objeto iterable tiene un
valor de tipo booleano (página 44) igual a True.
>>> any((1,0,0))
True
>>> any((0,0,0))
False
>>> any(range(5))
True
>>> any(range(0))
False
coerce()
La función coerce() devuelve una tupla que consta de los dos argumentos numéricos convertidos en un tipo
común, utilizando las mismas reglas que las operaciones aritméticas. Si la coerción no es posible, levante una
excepción TypeError (página 193).
>>> coerce(3, 4)
(3, 4)
>>> coerce(3, 4.2)
(3.0, 4.2)
dict()
La función dict() es el constructor del tipo de diccionario (página 65), esta función se usa crear un diccionario:
>>> dict(python=2.7, zope=2.13, plone=5.1)
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
También puede crear un diccionario indicando a las claves usando comillas simples:
>>> {'python': 2.7, 'zope': 2.13, 'plone': 5.1}
{'python': 2.7, 'zope': 2, 'plone': 5.1}
>>> dict({'python': 2.7, 'zope': 2.13, 'plone': 5.1})
{{'python': 2.7, 'zope': 2.13, 'plone': 5.1}
Convertir desde un grupo de dos listas (página 58) de forma recursiva usando la función zip() (página 140) a tipo
diccionario:
>>> dict(zip(['python', 'zope', 'plone'], [2.7, 2.13, 5.1]))
{'python': 2.7, 'zope': 2.13, 'plone': 5.1}
Convertir desde un grupo de tuplas (página 63) respectivamente en una lista (página 58) a tipo diccionario:
>>> dict([('zope', 2.13), ('python', 2.7), ('plone', 5.1)])
{'plone': 5.1, 'zope': 2.13, 'python': 2.7}
frozenset()
La función frozenset() es el constructor del tipo de conjuntos (página 75), se usa crear un conjunto inmutable
mediante la misma función frozenset() de un objeto iterable lista (página 58):
>>> versiones = [6, 2.1, 2.5, 3.6, 4, 5, 6, 4, 2.5]
>>> print versiones, type(versiones)
[6, 2.1, 2.5, 3.6, 4, 5, 6, 4, 2.5] <type 'list'>
>>> versiones_plone = frozenset(versiones)
>>> print versiones_plone, type(versiones_plone)
frozenset([2.5, 4, 5, 6, 2.1, 3.6]) <type 'frozenset'>
iter()
La función iter() obtiene un iterador (página 92) de un objeto. En la primera forma, el argumento debe pro-
porcionar su propio iterador, o ser una secuencia.
>>> elemento = iter("Plone")
>>> elemento
<iterator object at 0x7eff6ce10250>
>>> elemento.next()
'P'
>>> elemento.next()
'l'
>>> elemento.next()
'o'
>>> elemento.next()
(continué en la próxima página)
En el ejemplo anterior, cuando se itera en la secuencia de tipo cadena de caracteres (página 46), al llegar al final
mediante el iterador llamado elemento se llama a la excepción StopIteration (página 192) y se causa el detener
la iteración.
list()
La función list() es el constructor del tipo de lista (página 58), se usa crear una lista mediante la misma función
list() de un iterable. Por ejemplo, una lista podría crearse mediante la función range(10) (página 120):
next()
En el ejemplo anterior, cuando se itera en la secuencia de tipo lista (página 58), al llegar al final mediante el
iterador llamado elemento se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
tuple()
La función tuple() es el constructor del tipo de tuplas (página 63), se usa crear una tupla mediante la misma
función tuple() de un iterable. Por ejemplo, una tupla podría crearse mediante la función range(10) (pági-
na 120):
set()
La función set() es el constructor del tipo de conjuntos (página 75), se usa crear un conjunto mutable mediante
la misma función set() de un objeto iterable lista (página 58):
sorted()
La función sorted() devuelve una lista ordenada de los elementos del tipo secuencia que recibe como argu-
mento (lista o cadena de caracteres). La secuencia original no es modificada.
La función sorted() siempre devuelve una lista, aunque reciba como argumento una cadena de caracteres
(página 46).
zip()
La función zip() devuelve una lista de tuplas (página 63), donde cada tupla contiene el elemento i-th desde cada
una de los tipos de secuencias de argumento. La lista devuelta es truncada en longitud a la longitud de la secuencia
de argumentos más corta.
delattr()
La función delattr() elimina un atributo con nombre en un objeto; delattr(x, 'y') es equivalente a
del x.y.
getattr()
hasattr()
La función hasattr() devuelve un tipo booleano cuando el objeto tiene un atributo con el nombre dado. (Esta
hecho llamando a la función getattr(instancia, atributo) y capturar excepciones.)
hash()
>>> type(Persona)
<type 'classobj'>
>>> type(macagua)
<type 'classobj'>
>>> hash(macagua)
8742669316448
>>> hash(Persona)
8742669316448
isinstance()
La función isinstance() le permite corroborar si un objeto es una instancia (página 201) de una clase.
isinstance(objeto, tipo)
Esta función devuelve True si el objeto especificado es del tipo especificado, de lo contrario False.
Los parámetros son:
objeto, es requerido. Un objeto.
tipo, un tipo o una clase, o una tupla de tipos y/o clases
Un ejemplo de uso con la clase Persona seria como lo siguiente:
Si el tipo de parámetro es una tupla, esta función devuelve True si le objeto es uno de los tipos en la tupla.
issubclass()
issubclass(subclase, clase)
Esta función devuelve True si la clase especificada es una subclase de la clase base, de lo contrario False.
Un ejemplo de uso con la subclase Supervisor que deriva de la clase Persona seria como lo siguiente:
Si el tipo de parámetro es una tupla, esta función devuelve True si le objeto es uno de los tipos en la tupla.
Aquí puede decir que sV1 es una subclase derivada de la clase Persona.
Las clases dan la posibilidad de crear estructuras de datos más complejas. En el ejemplo, una clase Persona que
realizará un seguimiento del cedula, nombre, apellido y sexo (que pasará como atributos).
setattr()
La función setattr() establecer un atributo con nombre en un objeto; setattr(x, 'y', v) es equiva-
lente a x.y = v.
Importante: La lista de todas las funciones disponibles en el lenguaje Python con la descripción correspondiente
se puede encontrar en la siguiente dirección URL:
https://docs.python.org/2/library/functions.html
En Python puede realizar depuración de programas por defecto usando el módulo pdb.
En esta lección se describen como hacer depuración a programas en el lenguaje Python, mostrando ejemplos
prácticos y útiles. A continuación el temario de esta lección:
En este tutorial se exploran herramientas que ayudan a entender tu código: depuración para encontrar y corregir
bugs (errores).
El depurador python, pdb: https://docs.python.org/2/library/pdb.html, te permite inspeccionar tu código de forma
interactiva.
Te permite:
Ver el código fuente.
Ir hacia arriba y hacia abajo del punto donde se ha producido un error.
Inspeccionar valores de variables.
Modificar valores de variables.
Establecer breakpoints (punto de parada del proceso).
Sí, las declaraciones print sirven como herramienta de depuración. Sin embargo, para inspeccionar en tiempo
de ejecución es más eficiente usar el depurador.
145
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Postmortem
/home/macagua/python/entrenamiento/index_error.py in index_error()
3 def index_error():
4 lst = list('foobar')
----> 5 print lst[len(lst)]
6
7 if __name__ == '__main__':
In [2]: %debug
> /home/macagua/python/entrenamiento/index_error.py(5)index_error()
4 lst = list('foobar')
----> 5 print lst[len(lst)]
6
ipdb> list
1 """Small snippet to raise an IndexError."""
2
3 def index_error():
4 lst = list('foobar')
----> 5 print lst[len(lst)]
6
7 if __name__ == '__main__':
8 index_error()
9
ipdb> len(lst)
6
ipdb> print lst[len(lst)-1]
r
ipdb> quit
In [3]:
En algunas situaciones no podrás usar IPython, por ejemplo para depurar un script que ha sido llamado desde la
línea de comandos. En este caso, puedes ejecutar el script de la siguiente forma python -m pdb script.
py:
Situación: Crees que existe un error en un módulo pero no estás seguro donde.
Por ejemplo, esta intentado depurar wiener_filtering.py. A pesar de que el código se ejecuta, observa que
el filtrado no se está haciendo correctamente.
Ejecuta el script en IPython con el depurador usando %run -d wiener_filtering.py:
In [1]: %run -d wiener_filtering.py
*** Blank or comment
*** Blank or comment
*** Blank or comment
Breakpoint 1 at /home/macagua/python/entrenamiento/wiener_filtering.py:4
NOTE: Enter 'c' at the ipdb> prompt to start your script.
> <string>(1)<module>()
ipdb> b 34
Breakpoint 2 at /home/macagua/python/entrenamiento/wiener_filtering.py:34
Da pasos hacia adelante y detrás del código con n(ext) y s(tep). next salta hasta la siguiente declara-
ción en el actual contexto de ejecución mientras que step se moverá entre los contextos en ejecución, i.e.
ipdb> n
> /home/macagua/python/entrenamiento/wiener_filtering.py(36)iterated_wiener()
35 denoised_img = local_mean(noisy_img, size=size)
---> 36 l_var = local_var(noisy_img, size=size)
37 for i in range(3):
Oh dear, solo ve entero y variación 0. Aquí está nuestro error, estamos haciendo aritmética con enteros.
Puede convertir estos avisos a excepciones, lo que le permitiría hacer una depuración post-mortem sobre ellos
y encontrar el problema de manera más rápida:
In [3]: np.seterr(all='raise')
Out[3]: {'divide': 'print', 'invalid': 'print', 'over': 'print', 'under': 'ignore
˓→'}
/home/macagua/python/entrenamiento/wiener_filtering.py in <module>()
55 pl.matshow(noisy_lena[cut], cmap=pl.cm.gray)
56
---> 57 denoised_lena = iterated_wiener(noisy_lena)
58 pl.matshow(denoised_lena[cut], cmap=pl.cm.gray)
59
/home/macagua/python/entrenamiento/wiener_filtering.py in
iterated_wiener(noisy_img, size)
148 38 Capítulo 6. Introspección a la depuración con pdb
res = noisy_img - denoised_img
39 noise = (res**2).sum()/res.size
---> 40 noise_level = (1 - noise/l_var )
41 noise_level[noise_level<0] = 0
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Advertencia: Cuandos e ejecutan nosetests, se captura la salida y parecerá que el depurador no está
funcionando. Para evitar esto simplemente ejecuta los nosetests con la etiqueta -s.
Quizá encuentres más conveniente usar un depurador gráfico como winpdb63 . para inspeccionar saltas a
través del código e inspeccionar las variables
De forma alternativa, pudb64 es un buen depurador semi-gráfico con una interfaz de texto en la consola.
También, estaría bien echarle un ojo al proyecto pydbgr65
62 https://pypi.org/project/ipdbplugin
63 https://pypi.org/project/winpdb/
64 https://pypi.org/project/pudb
65 https://code.google.com/archive/p/pydbgr
ipdb> help
Undocumented commands:
======================
retval rv
Importante: Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:
index_error.py y wiener_filtering.py. Adicional se incluye otro código de ejemplo muy simple
funcion_a_depurar.py usando la función set_trace() del paquete pdb.
leccion6/
index_error.py
wiener_filtering.py
funcion_a_depurar.py
Si tiene la estructura de archivo previa, entonces ejecute por separado cada comando:
python index_error.py
python wiener_filtering.py
python funcion_a_depurar.py
Ver también:
Consulte la sección de lecturas suplementarias (página 264) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python puede realizar operaciones de entrada y salida de datos, almacenar esos datos manipulando de archivos
usando métodos para leer y escribir archivos desde el sistema de archivos.
En esta lección se describen las operaciones de entrada y salida, manipulando de archivos del lenguaje Python,
mostrando ejemplos prácticos y útiles. A continuación el temario de esta lección:
Los programas serían de muy poca utilidad si no fueran capaces de interaccionar con el usuario.
Para pedir información al usuario, debe utilizar las funciones integradas en el interprete del lenguaje, así como los
argumentos de línea de comandos.
Ejemplo de la función raw_input:
La función raw_input() (página 123) siempre devuelve un valor de cadenas de caracteres:
151
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
En muchas practicas de este entrenamiento usted lo que ha hecho ha sido escribir código en el intérprete, y/o
escribir/ejecutar pequeños programas Python, pero los programas informáticos no funcionan así.
Se basan en escribir todas las instrucciones en archivos llamados scripts, que no es mas que guiones de instruc-
ciones. Luego se envía este archivo al intérprete como parámetro desde la terminal de comando (si es un lenguaje
interpretado como Python) y éste ejecutará todas las instrucciones en bloque.
A parte de ser la base del funcionamiento de los programas, la característica de los scripts es que pueden recibir
datos desde la propia terminal de comando en el momento de la ejecución, algo muy útil para agregar dinamismo
los scripts a través de parámetros personalizables.
A continuación, un ejemplo el cual simula a sala de chat del servicio LatinChat.com, validando datos de entradas
numérico y tipo cadena de caracteres e interactuá con el usuario y en base a condicionales muestra un mensaje.
print 'Ana: ¿Tiene WebCam?, ingrese "si" o "no", por favor!: '
tiene_WebCam = raw_input('Yo: ')
Truco: LatinChat.com, fue un servicio de Internet que ofrecía diversas salas de chat, muy popular en la década
de los 90 en latinoamericana.
Para poder enviar información a un script y manejarla, tenemos que utilizar la librería de sistema sys. En ella
encontraremos la lista argv que almacena los argumentos enviados al script.
Usted debe crear un script llamado entrada_argumentos.py con el siguiente contenido:
import sys
print sys.argv
python entrada_argumentos.py
['entrada_argumentos.py']
Al ejecutarlo puede ver que devuelve una lista con una cadena que contiene el nombre del script. Entonces, el
primer argumento de la lista sys.argv (es decir, sys.argv[0]) es el propio nombre del script.
Ahora si intenta ejecutar el script de nuevo pasando algunos valores como números y cadenas de caracteres entre
comillas dobles, todo separado por espacios:
Cada valor que enviamos al script durante la llamada se llama argumento e implica una forma de entrada de datos
alternativa sin usar las funciones input() (página 123) y raw_input() (página 123).
A continuación, un ejemplo el cual usa un script con la librería sys. El script recibe dos (02) argumentos: una
cadena de caracteres y un número entero. Lo que hace es imprimir la cadena de caracteres tantas veces como le
indique con el argumento de tipo número:
import sys
Si quiere comprobar la validación de cuantos argumentos deben enviarme al script, ejecute el siguiente comando:
Ahora si intenta ejecutar el script entrada_dos_argumentos.py con solo dos (2) argumentos, ejecutando
el siguiente comando:
La forma general de mostrar información por pantalla es mediante una consola de comando, generalmente pode-
mos mostrar texto y variables separándolos con comas, para este se usa la sentencia print (página 153).
Sentencia print
Sentencia print evalúa cada expresión, devuelve y escribe el objeto resultado a la salida estándar de la consola
de comando. Si un objeto no es un tipo cadena de caracteres (página 46), ese es primeramente convertido a un
tipo cadena de caracteres usando las reglas para las conversiones del tipo (página 136). La cadena de caracteres
(resultado o original) es entonces escrito.
Entonces para mostrar mensajes en pantalla, se utiliza el uso de la sentencia print.
Ejemplo del uso de la sentencia print:
En la sentencia print se pueden usar el formato de impresión alternando las cadenas de caracteres y variables:
Ver también:
Hay disponibles otras formas de aplicar formato de cadenas de caracteres:
Formateo % (página 53).
Clase formatter (página 53).
Nota: Una documentación completa del control de la salida de Python se encuentra en https://docs.python.org/2/
tutorial/inputoutput.html
Importante: Usted puede descargar los códigos usados en esta sección haciendo clic en los siguientes enlaces:
entrada_salida.py, entrada_argumentos.py y entrada_dos_argumentos.py.
leccion8/
entrada_argumentos.py
entrada_dos_argumentos.py
entrada_salida.py
python entrada_salida.py
python entrada_argumentos.py
python entrada_dos_argumentos.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
Para escribir o leer cadenas de caracteres para/desde archivos (otros tipos deben ser convertidas a cadenas de
caracteres). Para esto Python incorpora un tipo integrado llamado file (página 214), el cual es manipulado mediante
un objeto archivo el cual fue generado a través de una función integrada en Python, a continuación se describen
los procesos típicos y sus referencias a funciones propias del lenguaje:
La forma preferida para abrir un archivo es usando la función integrada open() (página 119).
La forma preferida para leer un archivo es usando algunas de los métodos del tipo objeto file (página 214) como
read() (página 216), readline() (página 217) y readlines() (página 217).
La forma preferida para escribir un archivo es usando el método del tipo objeto file (página 214) llamado write()
(página 219).
La forma preferida para cerrar un archivo es usando el método del tipo objeto file (página 214) llamado close()
(página 215).
El módulo os de Python le permite a usted realizar operaciones dependiente del Sistema Operativo como crear
una carpeta, listar contenidos de una carpeta, conocer acerca de un proceso, finalizar un proceso, etc. Este módulo
tiene métodos para ver variables de entornos del Sistema Operativo con las cuales Python esta trabajando en
mucho más. Aquí66 la documentación Python para el módulo os.
A continuación algunos útiles métodos del módulo os que pueden ayudar a manipular archivos y carpeta en su
programa Python:
Crear una nueva carpeta
>>> import os
>>> os.makedirs("Ana_Poleo")
>>> import os
>>> os.listdir("./")
['Ana_Poleo']
>>> import os
>>> os.getcwd()
'/home/usuario/python/'
>>> import os
>>> os.path.getsize("Ana_Poleo")
4096
>>> import os
>>> os.path.isfile("Ana_Poleo")
False
66 https://docs.python.org/2/library/os.html
>>> import os
>>> os.path.isdir("Ana_Poleo")
True
Cambiar directorio/carpeta
>>> import os
>>> os.chdir("Ana_Poleo")
>>> os.getcwd()
'/home/usuario/python/Ana_Poleo'
>>> os.listdir("./")
[]
>>> os.chdir("../")
>>> os.getcwd()
'/home/usuario/python'
Renombrar un archivo
>>> import os
>>> os.rename("Ana_Poleo","Ana_Carolina")
>>> os.listdir("./")
['Ana_Carolina']
Eliminar un archivo
>>> import os
>>> os.chdir("Ana_Carolina")
>>> archivo = open(os.getcwd()+'/datos.txt', 'w')
>>> archivo.write("Se Feliz!")
>>> archivo.close()
>>> os.getcwd()
'/home/usuario/python/Ana_Carolina'
>>> os.listdir("./")
['datos.txt']
>>> os.remove(os.getcwd()+"/datos.txt")
>>> os.listdir("./")
[]
>>> os.rmdir("Ana_Carolina")
>>> os.chdir("Ana_Carolina")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OSError: [Errno 2] No such file or directory: 'Ana_Carolina'
Lanza una excepción OSError (página 192) cuando intenta acceder al directorio que previamente elimino y este
no encuentra.
A continuación, se presentan algunos ejemplos del uso del tipo objeto file (página 214):
Ejemplo de iterar un archivo para leerlo
Usted puede iterar sobre un archivo como se muestra a continuación:
y otra prueba
>>> archivo.close()
import os
NOMBRE_ARCHIVO = 'datos.txt'
if NOMBRE_ARCHIVO in os.listdir("."):
print "\nArchivo creado en la ruta: \n\n\t{0}/{1}".format(
os.getcwd(), NOMBRE_ARCHIVO)
else:
print "El archivo no fue creado!!!\n"
os.remove(os.getcwd()+"/"+NOMBRE_ARCHIVO)
print "\nEliminado archivo desde la ruta: \n\n\t{0}/{1}".format(
os.getcwd(), NOMBRE_ARCHIVO)
Usted puede consultar toda la documentación disponible sobre los tipos objeto file (página 214) desde la consola
interactiva (página 15) de la siguiente forma:
>>> help(file)
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código archivo.py, abra una consola de comando, acceda al directorio donde se
encuentra el mismo, y ejecute el siguiente comando:
python archivo.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
En Python las diversas aplicaciones Python se encuentran dentro de módulos y paquetes los cuales los contienen
el sistema de ficheros.
En esta lección se describen como crear módulos y paquetes, luego se enseña a usar las practicas de scaffolding de
paquetes Python con mecanismo de instalación, mostrando ejemplos prácticos y útiles. A continuación el temario
de esta lección:
Un módulo le permite a usted organizar lógicamente su código Python. Agrupando código relacionado dentro
de un módulo hace el código mas fácil de entender y usar. Un módulo es un objeto de Python con atributos con
nombres arbitrarios que puede enlazar y hacer referencia.
Simplemente, un módulo es no es otra cosa sino un archivo con extensión .py. Un módulo puede definir funciones,
clases y variables, también puede incluir código ejecutable.
El código Python para un módulo nombrado funciones normalmente reside un archivo llamado
utilidades.py. A continuación un ejemplo de un simple módulo llamado utilidades.py:
def suma_total(monto=0):
""" Calcula la suma total """
calculo_suma = 20
calculo_suma += monto
return calculo_suma
La sentencia import se utiliza para importar un módulo. Usted puede usar cualquier archivo de código Python
como un módulo ejecutando esta sentencia en otro archivo de código Python. La sentencia import tiene la
siguiente sintaxis:
>>> import os
>>> import re, datetime
159
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Cuando el interprete encuentra una sentencia import, este importa el módulo si el mismo esta presente en la ruta
de búsqueda. Una ruta de búsqueda es una lista de directorios que el interprete busca antes de importar un módulo.
Por ejemplo, al importar el módulo utilidades.py, usted necesita colocar la siguiente sentencia al tope del
otro script Python. A continuación un ejemplo de un simple módulo, calculo_factura_pipo.py.
Un módulo se carga solo una vez, independientemente de la cantidad de veces que se importe. Esto evita que la
ejecución del módulo ocurra una y otra vez si se producen múltiples importaciones.
La primera vez que un módulo es importado en un script de Python, se ejecuta su código una vez. Si otro módulo
importa el mismo módulo este no se cargará nuevamente; los módulos son inicializados una sola vez.
Esto se debe al código objeto compilado que genera en el mismo directorio del módulo que cargo con la extensión
de archivo .pyc, ejecutando las siguientes sentencias:
De esta forma se comprueba que existe el archivo compilado de Python junto con el mismo módulo Python.
Cuando usted importa un módulo, el interprete Python busca por el módulo en la secuencia siguiente:
1. El directorio actual.
2. Si el módulo no es encontrado, Python entonces busca en cada directorio en la variable de entorno PYT-
HONPATH (página 161) del sistema operativo.
3. Si todas las anteriores fallan, Python busca la ruta predeterminada. En UNIX, la ruta predeterminada nor-
malmente esta /usr/local/lib/python/.
El ruta de búsqueda de módulo es almacenado en el módulo de system sys como la variable sys.path. La va-
riable sys.path contiene el directorio actual, PYTHONPATH, y las predeterminadas dependencia de instalación.
8.1.3 PYTHONPATH
Es una variable de entorno del sistema operativo, consistiendo de una lista de directorios. La sintaxis de
PYTHONPATH es la misma como la del shell de la variable PATH.
Así es una típica definición de PYTHONPATH desde un sistema Windows, ejecutando:
Las variables (página 26) son nombres (identificadores) que se asignan a objetos.
Un espacio de nombres o namespace, es un diccionario de nombres de variables (claves) y sus objetos (valores)
correspondientes.
Una sentencia de Python puede acceder a las variables en un espacio de nombres local y en el espacio de nombres
global. Si una variable local y una variable global tienen el mismo nombre, la variable local sombrea la variable
global.
Cada función (página 100) tiene su propio espacio de nombres local. Los métodos (página 198) de Clase siguen la
misma regla de alcance que las funciones ordinarias.
Python hace conjeturas educadas sobre si las variables son locales o globales. Se supone que cualquier variable
asignada a un valor en una función es local.
Por lo tanto, para asignar un valor a una variable global dentro de una función, primero debe usar la sentencia
global (página 31).
La sintaxis global nombre, le dice al interprete Python que la variable nombre es una variable global. Python
deja de buscar la variable en el espacio de nombres local.
Por ejemplo, defina una variable Money en el espacio de nombres global. Dentro de la función Money, asigna
un valor a Money, por lo tanto, Python asume que Money es una variable local. Sin embargo, accede al valor
de la variable local Money antes de configurarlo, por lo que el resultado es una excepción UnboundLocalError
(página 193). Si descomenta la sentencia global, se soluciona el problema.
Importante: Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:
utilidades.py y calculo_factura_pipo.py.
leccion8/
utilidades.py
calculo_factura_pipo.py
python calculo_factura_pipo.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
Los paquetes pueden contener módulos y otros paquetes. Son directorios. El único requisito es que contengan un
archivo llamado __init__.py. Este archivo puede estar vacío.
La sentencia from se utiliza en conjunto a la previa sentencia import (página 159) para importar un módulo.
Por ejemplo, cree un directorio llamado tostadas_pipo, que contiene los archivos llamados __init__.py,
principal.py (dentro del mismo directorio).
Archivo __init__.py, este archivo no tiene ningún contenido.
Archivo principal.py incluye el siguiente código:
Seguidamente dentro del directorio tostadas_pipo, cree otro directorio llamado utilidades, dentro de
este, cree los siguientes archivos:
Archivo __init__.py, este archivo no tiene ningún contenido.
Archivo calculos.py incluye el siguiente código:
def suma_total(monto=0):
""" Calcula la suma total """
calculo_suma = 20
calculo_suma += monto
return calculo_suma
def impuesto_iva12(monto=0):
""" Calcula el impuesto del IVA de 12 % """
total = ((monto * 12)/100)
return total
(continué en la próxima página)
def impuesto_iva14(monto=0):
""" Calcula el impuesto del IVA de 14 % """
total = ((monto * 14)/100)
return total
Al final tendrá la siguiente estructura del directorios del paquete Python llamado tostadas_pipo, como se
describe a continuación:
tostadas_pipo/
__init__.py
principal.py
utilidades/
calculos.py
impuestos.py
__init__.py
Entonces realizar importaciones desde una estructura de directorios mas completa se realiza de las siguientes
formas:
Importar todos los módulo el sub-paquete utilidades, ejecutando:
import tostadas_pipo.utilidades
from tostadas_pipo import utilidades
from tostadas_pipo.utilidades import *
Por ejemplo, cree un módulo llamado calculo_factura_pipo.py, que contiene las importaciones del pa-
quete tostadas_pipo:
Archivo calculo_factura_pipo.py incluye el siguiente código:
Importante: Usted puede descargar el código usado en esta sección, haciendo clic en el siguiente enlace:
paquetes.zip.
Truco: Para ejecutar el código incluido en el archivo paquetes.zip debe descomprimirlo, abra una consola
de comando, acceda al directorio donde se encuentra el archivo descomprimido, de la siguiente forma:
calculo_factura_pipo.py
tostadas_pipo/
__init__.py
principal.py
utilidades/
calculos.py
impuestos.py
__init__.py
python calculo_factura_pipo.py
python tostadas_pipo/principal.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
La distribución de código Python, le permite hacer portable de forma amigable usando herramienta de gestión de
paquetes Python como la herramienta pip. Esta labor se hace mediante el módulo distutils (página 164), y más
reciente incorporando el módulo setuptools (página 164).
Permite «empacar» el código de un proyecto de software para ser redistribuido en otros proyectos Python.
Cada paquete empaquetado se puede distribuir en su propia pagina de proyecto y al mismo tiempo puede optar
a publicar su proyecto en el Python Package Index (PyPI), con el cual si lo publica allí su proyecto estará a su
alcance y sino de muchos mas programadores, ya que es un repositorio de software publico, solo con ejecutar
el comando pip install <paquete> lo convierte en una herramienta tremendamente útil y probablemente
sea una de las razones del éxito de Python entre los que empiezan a programar.
El módulo setuptools, incorpora varias extensiones al módulo distutils para distribuciones de software
grandes o complejas.
Para poder empaquetar un proyecto necesita como mínimo la estructura de archivos siguiente:
DIRECTORIO-DEL-PROYECTO
LICENSE
MANIFEST.in
README.txt
setup.py
NOMBRE-DEL-PAQUETE
__init__.py
ARCHIVO1.py
ARCHIVO2.py
(continué en la próxima página)
License
=======
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston,
MA 02111-1307 USA.
MANIFEST.in: es el archivo donde se define los criterios de inclusión y exclusión de archivos a su distri-
bución de código fuente de su proyecto. Este archivo incluye la configuración del paquete como se indica a
continuación:
include LICENSE
include *.txt *.in
include *.py
recursive-include tostadas_pipo *
global-exclude *.pyc *.pyo *~
prune build
prune dist
README.txt: es el archivo donde se define la documentación general del paquete, este archivo es im-
portante debido a que no solo es usado localmente en un copia descargada, sino como información usada
el en sitio de PyPI. Entonces abra el archivo README.txt e ingrese el siguiente contenido. Usted puede
personalizarlo como quiera:
==================
NOMBRE-DEL-PAQUETE
==================
setup.py: es el archivo donde se define el paquete, el formato es el mismo para el módulo setuptools
(página 164) y para el módulo distutils (página 164). Lo puede ver a continuación. Este archivo incluye la
configuración del paquete como se indica a continuación:
"""Instalador para el paquete "tostadas_pipo"."""
long_description = (
open('README.txt').read()
+ '\n' +
open('LICENSE').read()
+ '\n')
setup(
name="tostadas_pipo",
version="0.1",
description="Sistema Administrativo de Tostadas Pipo C.A.",
long_description=long_description,
# Get more https://pypi.org/pypi?%3Aaction=list_classifiers
classifiers=[
# ¿Cuan maduro esta este proyecto? Valores comunes son
# 3 - Alpha
# 4 - Beta
# 5 - Production/Stable
"Development Status :: 3 - Alpha",
# Indique a quien va dirigido su proyecto
"Environment :: Console",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries",
# Indique licencia usada (debe coincidir con el "license")
"License :: OSI Approved :: GNU General Public License",
# Indique versiones soportas, Python 2, Python 3 o ambos.
"Programming Language :: Python",
"Programming Language :: Python :: 2.7",
"Operating System :: OS Independent",
],
keywords="ejemplo instalador paquete tostadas_pipo",
author="Leonardo J. Caballero G.",
author_email="[email protected]",
url="https://twitter/macagua",
download_url="https://github.com/macagua/tostadas_pipo",
license="GPL",
platforms="Unix",
packages=["tostadas_pipo", "tostadas_pipo/utilidades/"],
include_package_data=True,
)
Entonces debe cree la siguiente estructura de directorios, ya hecha para seguir adelante:
distribucion/
LICENSE
MANIFEST.in
README.txt
setup.py
tostadas_pipo
(continué en la próxima página)
Para construir cualquier cosas requeridas para instalar el paquete, ejecutando el siguiente comando:
De esta forma al terminar la ejecución del comando previo debe tener creado un directorio llamado build e
incluyendo el paquete tostadas_pipo construido con todo lo necesario para crear su distribución, como se
muestra a continuación:
build/
lib.linux-x86_64-2.7
tostadas_pipo
__init__.py
principal.py
utilidades
calculos.py
impuestos.py
__init__.py
De esta forma ya construyo el paquete tostadas_pipo y todas las cosas necesarias para crear su distribución
de código fuente o binaria para su proyecto.
Usted puede crear diversos tipos de formatos de instalación y distribución de sus paquetes Python, a continuación
se describen los mas usados:
Tanto el módulo setuptools (página 164) y distutils (página 164) le permiten crear una distribución de código
fuente o source distribution (sdist) de su paquete en formatos como tarball, archivo zip, etc. Para crear una
paquete sdist, ejecute el siguiente comando:
De esta forma al terminar la ejecución del comando previo debe tener creado un directorio llamado dist e
incluyendo el paquete en formato de archivo tarball comprimido en gztar, como se muestra a continuación:
dist/
tostadas_pipo-0.1.tar.gz
Por defecto, tanto el módulo setuptools (página 164) y distutils (página 164) creá el paquete en formato de archivo
tarball comprimido usando gztar.).
Usted puede cambiar el formato de paquete a crear de su distribución de código fuente de su paquete (en formato
archivo tarball, archivo zip, etc.), ejecute el siguiente comando:
python ./setup.py sdist --formats=zip,gztar,bztar
running sdist
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
writing entry points to tostadas_pipo.egg-info/entry_points.txt
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyc' found anywhere in
˓→distribution
Writing tostadas_pipo-0.1/setup.cfg
creating 'dist/tostadas_pipo-0.1.zip' and adding 'tostadas_pipo-0.1' to it
adding 'tostadas_pipo-0.1/MANIFEST.in'
adding 'tostadas_pipo-0.1/setup.cfg'
adding 'tostadas_pipo-0.1/PKG-INFO'
adding 'tostadas_pipo-0.1/LICENSE'
adding 'tostadas_pipo-0.1/README.txt'
adding 'tostadas_pipo-0.1/setup.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/principal.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/__init__.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/utilidades/impuestos.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/utilidades/__init__.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/utilidades/calculos.py'
(continué en la próxima página)
De esta forma al terminar la ejecución del comando previo debe tener creado un directorio llamado dist e
incluyendo los tres paquetes en formatos de archivos tarball comprimido en gzip/bzip2 y archivo comprimido en
zip.
dist/
tostadas_pipo-0.1.tar.bz2
tostadas_pipo-0.1.tar.gz
tostadas_pipo-0.1.zip
De esta forma ya creo el(los) paquete(s) en diversos formato de distribución de código fuente para su proyecto.
Distribución binaria
El módulo setuptools (página 164) y distutils (página 164) le permiten crear una distribución binaria construida o
built «binary» distribution (bdist) de su paquete en formato egg, wheel, rpm, etc. A continuación se describen
los mas usados:
Egg
Para crear una distribución bdist de su paquete en formato egg, ejecute el siguiente comando:
python ./setup.py bdist_egg
running bdist_egg
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
(continué en la próxima página)
creating build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/impuestos.py -> build/
˓→bdist.linux-x86_64/egg/tostadas_pipo/utilidades
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/principal.py to
˓→principal.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/impuestos.py
˓→to impuestos.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/__init__.py
˓→to __init__.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/calculos.py
˓→to calculos.pyc
creating build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/
˓→egg/EGG-INFO
De esta forma al terminar la ejecución del comando previo debe tener creado un directorio llamado dist e
incluyendo la distribución bdist en formato egg.
dist/
tostadas_pipo-0.1-py2.7.egg
De esta forma ya creo la distribución bdist del paquete en formato egg para su proyecto.
Wheel
Para crear una distribución bdist de su paquete en formato wheel, ejecute el siguiente comando:
creating build/bdist.linux-x86_64/wheel/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/impuestos.py -> build/
˓→bdist.linux-x86_64/wheel/tostadas_pipo/utilidades
running install_egg_info
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
writing entry points to tostadas_pipo.egg-info/entry_points.txt
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyc' found anywhere in
˓→distribution
running install_scripts
adding license file "LICENSE" (matched pattern "LICEN[CS]E*")
creating build/bdist.linux-x86_64/wheel/tostadas_pipo-0.1.dist-info/WHEEL
creating 'dist/tostadas_pipo-0.1-py2-none-any.whl' and adding 'build/bdist.linux-
˓→x86_64/wheel' to it
adding 'tostadas_pipo/__init__.py'
adding 'tostadas_pipo/principal.py'
adding 'tostadas_pipo/utilidades/__init__.py'
adding 'tostadas_pipo/utilidades/calculos.py'
adding 'tostadas_pipo/utilidades/impuestos.py'
adding 'tostadas_pipo-0.1.dist-info/LICENSE'
adding 'tostadas_pipo-0.1.dist-info/METADATA'
adding 'tostadas_pipo-0.1.dist-info/WHEEL'
adding 'tostadas_pipo-0.1.dist-info/entry_points.txt'
adding 'tostadas_pipo-0.1.dist-info/top_level.txt'
adding 'tostadas_pipo-0.1.dist-info/RECORD'
removing build/bdist.linux-x86_64/wheel
De esta forma al terminar la ejecución del comando previo debe tener creado un directorio llamado dist e
incluyendo la distribución bdist en formato whl.
dist/
tostadas_pipo-0.1-py2.7.egg
tostadas_pipo-0.1-py2-none-any.whl
De esta forma ya creo la distribución bdist del paquete en formato whl para su proyecto.
Para instalar el paquete de su proyecto, hay dos formas de instalación disponibles a continuación:
Para instalar una distribución código fuente de su paquete previamente creado, se realizar usando la herramienta
pip, ejecutando el siguiente comando:
pip install --user dist/tostadas_pipo-0.1.tar.gz
Esto es debido a que no tiene instalado dicha herramienta, así que debe ejecutar el siguiente comando:
sudo apt-get install -y python-pip
De esta forma tiene instalado una distribución código fuente en formato tarball de su paquete en el interprete
Python usando la herramienta pip.
Para instalar una distribución binaria de su paquete previamente creado, se realizar usando la herramienta pip,
ejecutando el siguiente comando:
pip install --user ./dist/tostadas_pipo-0.1-py2-none-any.whl
Processing ./dist/tostadas_pipo-0.1-py2-none-any.whl
Installing collected packages: tostadas-pipo
Successfully installed tostadas-pipo-0.1
De esta forma tiene instalado una distribución binaria en formato wheel de su paquete en el interprete Python
usando la herramienta pip.
67 https://pip.readthedocs.io/
creating build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/impuestos.py -> build/
˓→bdist.linux-x86_64/egg/tostadas_pipo/utilidades
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/principal.py to
˓→principal.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/impuestos.py
˓→to impuestos.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/__init__.py
˓→to __init__.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/calculos.py
˓→to calculos.pyc
creating build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/
˓→egg/EGG-INFO
adding 'tostadas_pipo/principal.py'
adding 'tostadas_pipo/principal.pyc'
adding 'tostadas_pipo/__init__.pyc'
adding 'tostadas_pipo/__init__.py'
adding 'tostadas_pipo/utilidades/impuestos.pyc'
adding 'tostadas_pipo/utilidades/calculos.pyc'
adding 'tostadas_pipo/utilidades/impuestos.py'
adding 'tostadas_pipo/utilidades/__init__.pyc'
adding 'tostadas_pipo/utilidades/__init__.py'
adding 'tostadas_pipo/utilidades/calculos.py'
adding 'EGG-INFO/zip-safe'
adding 'EGG-INFO/dependency_links.txt'
adding 'EGG-INFO/PKG-INFO'
adding 'EGG-INFO/SOURCES.txt'
adding 'EGG-INFO/top_level.txt'
removing 'build/bdist.linux-x86_64/egg' (and everything under it)
Processing tostadas_pipo-0.1-py2.7.egg
Copying tostadas_pipo-0.1-py2.7.egg to /home/leonardo/.local/lib/python2.7/site-
˓→packages
Installed /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1-py2.
˓→7.egg
De esta forma tiene instalado su paquete en su interprete Python usando el comando install disponible con el
script setup.py.
Comprobar la instalación
Usted puede comprobar luego de realizar la instalación de la distribución de código fuente o binaria de su paquete,
ejecute el siguiente comando:
pip list --user --format=freeze | grep "tostadas"
tostadas-pipo==0.1
De esta forma la herramienta de gestión de paquete indica que el tostadas-pipo en su versión 0.1 esta insta-
lado en su interprete Python.
Usar el paquete tostadas_pipo-0.1, recuerde que debe usarlo como una librería, entonces puede probar el
correcto funcionamiento del paquete, importando este, ejecutando el siguiente comando:
El comando previo muestra la docstring (página 50) de la función importada impuesto_iva14 sino muestra
ningún mensaje de error, el paquete tostadas_pipo-0.1 se instalo correctamente.
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/
˓→INSTALLER
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/
˓→METADATA
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/
˓→RECORD
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/
˓→WHEEL
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/
˓→metadata.json
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/
˓→top_level.txt
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/__init__.py
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/__init__.pyc
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/principal.py
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/principal.pyc
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/__
˓→init__.py
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/__
˓→init__.pyc
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/
˓→calculos.py
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/
˓→calculos.pyc
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/
˓→impuestos.py
/home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/
˓→impuestos.pyc
Proceed (y/n)? y
Successfully uninstalled tostadas-pipo-0.1
pip esta habilitado a desinstalar la mayoría de paquetes instalados. Las excepciones conocidas son:
Los paquetes basado en solamente en el módulo distutils (página 164) los cuales fueron instalados sin
la herramienta pip usando el comando python setup.py install desde el código del paquete
(página 174).
Instalándolo de esta forma, al momento de desintalarlo usando el comando pip uninstall
tostadas_pipo este comando removerá solo la metadata, no detrás dejando de la instalación metadata
para determinar que archivos fueron instalados.
Entonces para solventar este problema tiene que ir manualmente al directorio site-packages a eliminar
manualmente el paquete que instalo.
Usted puede consultar toda la ayuda comandos disponibles del módulo setuptools (página 164) y distutils (pági-
na 164), ejecute el comando siguiente:
Extra commands:
saveopts save supplied options to setup.cfg or other config file
testr Run unit tests using testr
compile_catalog compile message catalogs to binary MO files
develop install package in 'development mode'
upload_docs Upload documentation to PyPI
extract_messages extract localizable strings from the project code
init_catalog create a new catalog based on a POT file
test run unit tests after in-place build
update_catalog update message catalogs from a POT file
setopt set an option in setup.cfg or another config file
install_egg_info Install an .egg-info directory for the package
rotate delete older distributions, keeping N newest files
bdist_wheel create a wheel distribution
egg_info create a distribution's .egg-info directory
alias define a shortcut to invoke one or more commands
easy_install Find/get/install Python packages
bdist_egg create an "egg" distribution
Para consultar toda la ayuda del módulo setuptools (página 164) y distutils (página 164), ejecute el comando
siguiente:
Importante: Usted puede descargar el código usado en esta sección, haciendo clic en el siguiente enlace:
distribucion.zip.
Truco: Para poder definir un instalador y construirlo para así poder hacer que su proyecto se pueda distribuir de
forma más fácil debe crear la estructura de proyecto (página 164) usando el código descomprimido del archivo
distribucion.zip, siga los pasos para construir los archivos, crear el instalador y probar su instalación.
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
La estructura del paquete Egg Python es poco compleja. Por lo cual para empezar con su primer proyecto y
diversos módulos, puede usar el concepto Scaffolding para crear un esqueleto de código usando las plantillas
adecuadas para paquetes Python.
Este concepto scaffolding, es muy útil para del arranque de su desarrollo, ofreciendo una serie de colecciones de
plantillas esqueletos que permiten iniciar rápidamente proyectos, existente diversos esqueletos orientados a tipos
de desarrollos específicos.
Es una herramienta de linea de comando basada en plugins que le permiten crear estructuras de paquetes de
proyectos Python además sirve aplicaciones web, con configuraciones basadas en paste.deploy68 .
Instalación
Dentro de su entorno virtual69 activado debe instalar el paquete PasteScript70 , ejecutando el siguiente comando:
68 https://pypi.org/project/PasteDeploy
69 https://plone-spanish-docs.readthedocs.io/es/latest/python/creacion_entornos_virtuales.html
70 https://pypi.org/project/PasteScript
Nota: No olvidar que estos paquetes han sido instalados con el entorno virtual que previamente usted activo,
eso quiere decir que los paquetes previamente instalados con easy_install71 están instalados en el directorio ~/
virtualenv/python/lib/python2.x/site-packages/ en ves del directorio de su versión de Python
de sistema /usr/lib/python2.x/site-packages/
Al finalizar la instalación podrá opcionalmente consultar cuales plantillas tiene disponible para usa, ejecutando el
siguiente comando:
(python)$ paster create --list-templates
Available templates:
basic_package: A basic setuptools-enabled package
paste_deploy: A web application deployed through paste.deploy
Variables:
egg: mipaquetepython
package: mipaquetepython
project: mipaquetepython
Enter version (Version (like 0.1)) ['']: 0.1
Enter description (One-line description of the package) ['']: Mi Paquete Básico
Enter long_description (Multi-line description (in reST)) ['']: Mi Paquete
˓→Básico para demostrar el uso de PasteScript
Usted puede verificar el paquete previamente creado y observará como este paquete básico ha habilitado el Setup-
tools72 .
(python)$ tree mipaquetepython/
mipaquetepython/
|-- mipaquetepython
| `-- __init__.py
|-- mipaquetepython.egg-info
| |-- PKG-INFO
| |-- SOURCES.txt
| |-- dependency_links.txt
(continué en la próxima página)
71 https://plone-spanish-docs.readthedocs.io/es/latest/python/setuptools.html#que-es-easyinstall
72 https://plone-spanish-docs.readthedocs.io/es/latest/python/setuptools.html
(python)$ cd mipaquetepython/mipaquetepython/
(python)$ vim app.py
Guarde los cambios en el archivo app.py, luego importe su aplicación app.py en el archivo __init__.py
con el siguiente código fuente:
(python)$ python
Nota: Odoo75 , es un sistema ERP y CRM programado con Python, de propósito general.
• django-harness79 , es una aplicación destinada a simplificar las tareas típicas relacionadas con la crea-
ción de un sitio web hechos con Django, el mantenimiento de varias instalaciones (local, producción,
etc) y cuidando su instalación global y su estructura de «esqueleto» actualizado del sitio de manera
fácil.
• lfc-skel80 , Provee una plantilla para crear una aplicación django-lfc81 CMS.
Esqueletos de proyectos Pylons:
• Pylons83 , al instalarse usando la utilidad easy_install84 instala dos plantillas de proyectos Pylons.
• PylonsTemplates85 , le ofrece plantillas adicionales paster para aplicaciones Pylons, incluyendo im-
plementación de repoze.what.
• BlastOff86 , Una plantilla de aplicación Pylons87 que proporciona un esqueleto de entorno de
trabajo configurado con SQLAlchemy, mako, repoze.who, ToscaWidgets, TurboMail,
WebFlash y (opcionalmente) SchemaBot. La aplicación generada esta previamente configurada
con autenticación, inicio de sesión y formularios de registro, y (opcionalmente) confirmación de co-
rreo electrónico. BlastOff ayudar a acelerar el desarrollo de aplicaciones en Pylons por que genera
un proyecto con una serie de dependencias configuraciones previamente.
Esqueletos de proyectos CherryPy:
• TracLegosScript91 , TracLegos es un software diseñado para ofrecer plantillas para proyectos Trac y
asiste con la creación de proyecto trac.
• trac_project92 , Plantilla de proyecto Trac de software de código abierto.
8.4.3 Recomendaciones
Si desea trabajar con algún proyecto de desarrollo basado en esqueletos o plantillas paster y Buildout simple-
mente seleccione cual esqueleto va a utilizar para su desarrollo y proceso a instalarlo con easy_install93 o PIP94
(como se explico anteriormente) y siga sus respectivas instrucciones para lograr con éxito la tarea deseada.
79 https://pypi.org/project/django-harness
80 https://pypi.org/project/lfc-skel/
81 https://pypi.org/project/django-lfc
82 https://pypi.org/project/Pylons/
83 https://pypi.org/project/Pylons/
84 https://plone-spanish-docs.readthedocs.io/es/latest/python/setuptools.html#que-es-easyinstall
85 https://pypi.org/project/PylonsTemplates/
86 https://pypi.org/project/BlastOff/
87 https://pypi.org/project/Pylons/
88 https://pypi.org/project/CherryPy
89 https://pypi.org/project/CherryPaste
90 https://pypi.org/project/Trac
91 https://trac-hacks.org/wiki/TracLegosScript
92 https://trac-hacks.org/browser/traclegosscript/anyrelease/example/oss
93 https://plone-spanish-docs.readthedocs.io/es/latest/python/setuptools.html#que-es-easyinstall
94 https://plone-spanish-docs.readthedocs.io/es/latest/python/distribute_pip.html
8.4.4 Referencias
Gestión de proyectos con Buildout, instalando Zope/Plone con este mecanismo95 desde la comunidad de
Plone Venezuela.
95 https://coactivate.org/projects/ploneve/gestion-de-proyectos-con-buildout
En Python usted puede manejar de los errores de sus aplicaciones, además de poder escribir sus aplicaciones
usando el paradigma de la orientación a objetos (página 194).
En esta lección se describen el manejo de errores y la programación orientada a objetos con el lenguaje Python,
mostrando ejemplos prácticos y útiles. A continuación el temario de esta lección:
Hasta ahora los mensajes de error no habían sido más que mencionados, pero si probaste los ejemplos probable-
mente hayas visto algunos. Hay (al menos) dos tipos diferentes de errores: errores de sintaxis y excepciones.
Los errores de sintaxis, también conocidos como errores de interpretación, son quizás el tipo de queja más común
que tenés cuando todavía estás aprendiendo Python:
El intérprete repite la línea culpable y muestra una pequeña “flecha” que apunta al primer lugar donde se detectó
el error. Este es causado por (o al menos detectado en) el símbolo que precede a la flecha: en el ejemplo, el error
se detecta en la sentencia print, ya que faltan dos puntos (':') antes del mismo. Se muestran el nombre del
archivo y el número de línea para que sepas dónde mirar en caso de que la entrada venga de un programa.
9.1.2 Excepciones
Incluso si la sentencia o expresión es sintácticamente correcta, puede generar un error cuando se intenta ejecutarla.
Los errores detectados durante la ejecución se llaman excepciones, y no son incondicionalmente fatales: pronto
aprenderás cómo manejarlos en los programas en Python. Sin embargo, la mayoría de las excepciones no son
manejadas por los programas, y resultan en mensajes de error como los mostrados aquí:
183
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects
La última línea de los mensajes de error indica qué sucedió. Las excepciones vienen de distintos tipos, y el tipo
se imprime como parte del mensaje: los tipos en el ejemplo son: ZeroDivisionError (página 193), NameError
(página 192) y TypeError (página 193).
La cadena mostrada como tipo de la excepción es el nombre de la excepción predefinida que ocurrió. Esto es
verdad para todas las excepciones predefinidas del intérprete, pero no necesita ser verdad para excepciones defini-
das por el usuario (aunque es una convención útil). Los nombres de las excepciones estándar son identificadores
incorporados al intérprete (no son palabras clave reservadas).
El resto de la línea provee un detalle basado en el tipo de la excepción y qué la causó.
La parte anterior del mensaje de error muestra el contexto donde la excepción sucedió, en la forma de un trazado
del error listando líneas fuente; sin embargo, no mostrará líneas leídas desde la entrada estándar.
Excepciones integradas (página 190), es una lista las excepciones predefinidas y sus significados.
Es posible escribir programas que manejen determinadas excepciones. Mirá el siguiente ejemplo, que le pide al
usuario una entrada hasta que ingrese un entero válido, pero permite al usuario interrumpir el programa (usando
Control-C o lo que sea que el sistema operativo soporte); notá que una interrupción generada por el usuario se
señaliza generando la excepción KeyboardInterrupt (página 192).
El último except puede omitir nombrar qué excepción captura, para servir como comodín. Usá esto con extremo
cuidado, ya que de esta manera es fácil ocultar un error real de programación. También puede usarse para mostrar
un mensaje de error y luego re-generar la excepción (permitiéndole al que llama, manejar también la excepción):
import sys
try:
f = open('numeros.txt')
s = f.readline()
i = int(s.strip())
except IOError as (errno, strerror):
print "Error E/S ({0}): {1}".format(errno, strerror)
except ValueError:
print "No pude convertir el dato a un entero."
except:
print "Error inesperado:", sys.exc_info()[0]
raise
Las declaraciones try . . . except tienen un bloque else opcional, el cual, cuando está presente, debe seguir a
los except. Es útil para aquel código que debe ejecutarse si el bloque try no genera una excepción. Por ejemplo:
El uso de else es mejor que agregar código adicional en el try porque evita capturar accidentalmente una
excepción que no fue generada por el código que está protegido por la sentencia try . . . except.
Cuando ocurre una excepción, puede tener un valor asociado, también conocido como el argumento de la excep-
ción. La presencia y el tipo de argumento depende del tipo de excepción.
El except puede especificar una variable luego del nombre (o tupla) de excepción(es). La variable se vincula a
una instancia de excepción con los argumentos almacenados en instance.args. Por conveniencia, la instancia
de excepción define __str__() para que se pueda mostrar los argumentos directamente, sin necesidad de hacer
referencia a .args.
Uno también puede instanciar una excepción antes de generarla, y agregarle cualquier atributo que se desee:
>>> try:
... raise Exception('carne', 'huevos')
... except Exception as inst:
... print type(inst) # la instancia de excepción
... print inst.args # argumentos guardados en .args
... print inst # __str__ permite imprimir args directamente
... x, y = inst # __getitem__ permite usar args directamente
... print 'x =', x
... print 'y =', y
...
<type 'exceptions.Exception'>
('carne', 'huevos')
('carne', 'huevos')
x = carne
y = huevos
Si una excepción tiene un argumento, este se imprime como la última parte (el “detalle”) del mensaje para las
excepciones que no están manejadas.
Los manejadores de excepciones no manejan solamente las excepciones que ocurren en el bloque try, también
manejan las excepciones que ocurren dentro de las funciones que se llaman (inclusive indirectamente) dentro del
bloque try. Por ejemplo:
La sentencia raise permite al programador forzar a que ocurra una excepción específica. Por ejemplo:
El único argumento a raise indica la excepción a generarse. Tiene que ser o una instancia de excepción, o una
clase de excepción (una clase que hereda de Exception (página 190)).
Si necesitás determinar cuando una excepción fue lanzada pero no querés manejarla, una forma simplificada de la
sentencia raise te permite relanzarla:
>>> try:
... raise NameError('Hola')
... except NameError:
... print u'Ha sucedido una excepción!'
... raise
...
Ha sucedido una excepción!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: Hola
La sentencia assert es una vía conveniente para insertar afirmaciones de depuración dentro de un programa:
La forma simple, «assert expression», es equivalente a:
if __debug__:
if not expression: raise AssertionError
if __debug__:
if not expression1: raise AssertionError(expression2)
Estas equivalencias suponen que __debug__ y la excepción «AssertionError (página 191)» se refieren a las
variables incorporadas con esos nombres. En la corriente implementación, la variable incorporada __debug__
es True en circunstancias normales, False cuando se solicita la optimización (opción del línea de comando
-O). El generador de código actual no emite ningún código para una sentencia assert cuando se solicita la
optimización en tiempo de compilación. Nota que no es necesario incluir el código fuente de la expresión que
falló en el mensaje de error; se mostrará como parte del stack trace.
Asignaciones a __debug__ son ilegales. El valor para la variable integrada es determinada cuando el interprete
inicia.
Los programas pueden nombrar sus propias excepciones creando una nueva clase excepción (mirá el apartado
de Clases (página 194) para más información sobre las clases de Python). Las excepciones, típicamente, deberán
derivar de la clase Exception (página 190), directa o indirectamente. Por ejemplo:
En este ejemplo, el método __init__() de Exception (página 190) fue sobrescrito. El nuevo comportamiento
simplemente crea el atributo valor.
Esto reemplaza el comportamiento por defecto de crear el atributo args.
Las clases de Excepciones pueden ser definidas de la misma forma que cualquier otra clase, pero usualmente se
mantienen simples, a menudo solo ofreciendo un número de atributos con información sobre el error que leerán los
manejadores de la excepción. Al crear un módulo que puede lanzar varios errores distintos, una práctica común
es crear una clase base para excepciones definidas en ese módulo y extenderla para crear clases excepciones
específicas para distintas condiciones de error:
class Error(Exception):
"""Clase base para excepciones en el módulo."""
pass
class EntradaError(Error):
"""Exception lanzada por errores en las entradas.
Atributos:
expresion -- expresión de entrada en la que ocurre el error
mensaje -- explicación del error
"""
class TransicionError(Error):
"""Lanzada cuando una operación intenta una
transición de estado no permitida.
La mayoría de las excepciones son definidas con nombres que terminan en «Error», similares a los nombres de las
excepciones estándar.
Muchos módulos estándar definen sus propias excepciones para reportar errores que pueden ocurrir en funciones
propias. Se puede encontrar más información sobre clases en el capítulo Clases (página 194).
La sentencia try tiene otra sentencia opcional que intenta definir acciones de limpieza que deben ser ejecutadas
bajo ciertas circunstancias. Por ejemplo:
>>> try:
... raise KeyboardInterrupt
... finally:
... print 'Adiós, Mundo!'
...
Chau, Mundo!
KeyboardInterrupt
Traceback (most recent call last):
File "<stdin>", line 2, in ?
Una sentencia finally siempre es ejecutada antes de salir de la sentencia try, ya sea que una excepción haya
ocurrido o no. Cuando ocurre una excepción en la sentencia try y no fue manejada por una sentencia except
(o ocurrió en una sentencia except o else), es relanzada luego de que se ejecuta la sentencia finally. La
sentencia finally es también ejecutada «a la salida» cuando cualquier otra sentencia de la sentencia try es
dejada vía break, continue or return. Un ejemplo más complicado (sentencias except y finally en la
misma sentencia try):
Como puedes ver, la sentencia finally es ejecutada siempre. La excepción TypeError (página 193) lanzada al
dividir dos cadenas de caracteres no es manejado por la sentencia except y por lo tanto es relanzada luego de
que se ejecuta la sentencia finally.
En aplicaciones reales, la sentencia finally es útil para liberar recursos externos (como archivos o conexiones
de red), sin importar si el uso del recurso fue exitoso.
Algunos objetos definen acciones de limpieza estándar que llevar a cabo cuando el objeto no es más necesitado,
independientemente de que las operaciones sobre el objeto hayan sido exitosas o no. Mirá el siguiente ejemplo,
que intenta abrir un archivo (página 154) e imprimir su contenido en la pantalla.
El problema con este código es que deja el archivo abierto por un periodo de tiempo indeterminado luego de que
termine de ejecutarse. Esto no es un problema en scripts simples, pero puede ser un problema en aplicaciones más
grandes.
Sentencia with
La sentencia with permite que objetos como archivos sean usados de una forma que asegure que siempre se los
libera rápido y en forma correcta.
with open("numeros.txt") as f:
for linea in f:
print linea
Luego de que la sentencia sea ejecutada, el archivo f siempre es cerrado, incluso si se encuentra un problema al
procesar las líneas. Otros objetos que provean acciones de limpieza predefinidas lo indicarán en su documentación.
9.1.9 Traceback
El Traceback o trazado inverso, es un listado de las funciones en curso de ejecución, presentadas cuando sucede
un error en tiempo de ejecución. Es común que al trazado inverso también se le conozca como trazado de pila,
porque lista las funciones en el orden en el cual son almacenadas en la pila de llamadas96 .
El módulo integrado traceback97 incorpora el comportamiento de Traceback o trazado inverso ya que extrae,
formatea e imprime información acerca de trazado del stack de los errores y excepciones en Python.
Importante: Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:
excepciones_integradas.py, excepciones_propias.py y errores_propios.py.
leccion9/
excepciones_integradas.py
excepciones_propias.py
errores_propios.py
python excepciones_integradas.py
python errores_propios.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
Las excepciones pueden ser objetos de una clase u objetos cadena. Aunque la mayoría de las excepciones eran
objetos cadena en las anteriores versiones de Python, en Python 1.5 y versiones posteriores, todas las excepciones
estándar han sido convertidas en objetos de clase y se anima a los usuarios a que hagan lo propio. Las excepciones
están definidas en el módulo exceptions. Nunca es necesario importar este módulo explícitamente, pues las
excepciones vienen proporcionadas por el espacio nominal interno.
Dos objetos de cadena distintos con el mismo valor se consideran diferentes excepciones. Esto es así para forzar a
los programadores a usar nombres de excepción en lugar de su valor textual al especificar gestores de excepciones.
El valor de cadena de todas las excepciones internas es su nombre, pero no es un requisito para las excepciones
definidas por el usuario (página 187) u otras excepciones definidas por módulos de biblioteca.
En el caso de las clases de excepción, en una sentencia try con una sentencia except que mencione una clase
particular, esta sentencia también gestionará cualquier excepción derivada de dicha clase (pero no las clases de
excepción de las que deriva ella). Dos clases de excepción no emparentadas mediante sub-clasificación nunca son
equivalentes, aunque tengan el mismo nombre.
Las excepciones internas enumeradas a continuación pueden ser generadas por el intérprete o por funciones in-
ternas. Excepto en los casos mencionados, tienen un valor asociado indicando en detalle la causa del error.
Este valor puede ser una cadena o tupla de varios elementos informativos (es decir, un código de error y una
cadena que explica el código). El valor asociado es el segundo argumento a la sentencia raise. En las cadenas
de excepción, el propio valor asociado se almacenará en la variable nombrada como el segundo argumento de la
sentencia except (si la hay). En las clases de excepción, dicha variable recoge la instancia de la excepción. Si la
clase de excepción deriva de la clase raíz estándar Exception (página 190), el valor asociado está disponible en el
atributo args de la instancia de excepción y es probable que aparezca en otros atributos.
El código de usuario puede lanzar excepciones internas. Se puede usar para comprobar un gestor de excepciones
o para informar de una condición de error del mismo modo que el intérprete lanza la misma excepción. Hay que
ser precavido, pues nada incluye que el código de usuario lance una excepción inadecuada.
Las siguientes excepciones sólo se usan como clase base de otras excepciones.
BaseException La clase base de todas las comunes excepciones. Deriva de la clase raíz __builtin__.
object, es el tipo más básico.
Exception La clase base de todas las excepciones no existentes. Deriva de la clase raíz BaseException (pági-
na 190).
La clase base de las excepciones. Todas las excepciones internas derivan de esta clase. Todas las excepcio-
nes definidas por usuario deberían derivarse de esta clase, aunque no es obligatorio (todavía). La función
str(), aplicada a una instancia de una clase (o la mayoría de sus clases derivadas) devuelve un valor ca-
dena a partir de sus argumentos o una cadena vacía si no se proporcionaron argumentos al constructor. Si se
usa como secuencia, accede a los argumentos proporcionados al constructor (útil para compatibilidad con
código antiguo). Los argumentos también están disponibles en el atributo args de la instancia, como tupla.
StandardError La clase base para todas las excepciones internas excepto SystemExit (página 192). Deriva de
la clase raíz Exception (página 190).
ArithmeticError La clase base de las excepciones lanzadas por diversos errores aritméticos: OverflowError
(página 192), ZeroDivisionError (página 193) y FloatingPointError (página 191). Deriva de la clase raíz
StandardError (página 191).
LookupError La clase base de las excepciones lanzadas cuando una clave o índice utilizado en una correspon-
dencia (diccionario) o secuencia son incorrectos: IndexError (página 191), KeyError (página 192). Deriva
de la clase raíz StandardError (página 191).
EnvironmentError La clase base de las excepciones que pueden ocurrir fuera del sistema Python: IOError
(página 191), OSError (página 192). Cuando se crean excepciones de este tipo con una tupla de dos valores,
el primer elemento queda disponible en el atributo errno de la instancia (se supone que es un número de
error) y el segundo en el atributo strerror (suele ser el mensaje de error asociado). La propia tupla está
disponible en el atributo args. Cuando se instancia una excepción EnvironmentError con una tupla de
tres elementos, los primeros dos quedan disponibles como en el caso de dos elementos y el tercero queda en
el atributo filename. Sin embargo, por compatibilidad con sistemas anteriores, el atributo args contiene
sólo una tupla de dos elementos de los dos primeros argumentos del constructor. El atributo filename
es None (página 210) cuando se cree la excepción con una cantidad de argumentos diferente de 3. Los
atributos errno y strerror son también None cuando la instancia no se cree con 2 ó 3 argumentos. En
este último caso, args contiene los argumentos del constructor tal cual, en forma de tupla. Deriva de la
clase raíz StandardError (página 191).
Las siguientes excepciones son las realmente lanzadas.
AssertionError Se lanza cuando una sentencia assert es False. Deriva de la clase raíz StandardError
(página 191).
AttributeError Se lanza cuando una referencia o asignación a atributo fracasa (cuando un objeto no tenga
referencias o asignaciones a atributos en absoluto, se lanza, la excepción TypeError (página 193).) Deriva
de la clase raíz StandardError (página 191).
BufferError Se lanza cuando un error Buffer sucede. Deriva de la excepción StandardError (página 191).
EOFError Se lanza cuando las funciones internas (input() (página 123) o raw_input() (página 123)) alcanzan
un end of file EOF (final de archivo) sin leer datos. N.B.: Los métodos read() (página 216) y readline()
(página 217) de los objetos archivo devuelven una cadena vacía al alcanzar EOF. Deriva de la clase raíz
StandardError (página 191).
FloatingPointError Se lanza cuando falla una operación de coma flotante. Esta excepción siempre está
definida, pero sólo se puede lanzar cuando Python esta configurado con la opción --with-fpectl o
se ha definido el símbolo WANT_SIGFPE_HANDLER en el archivo config.h. Deriva de la clase raíz
ArithmeticError (página 191).
GeneratorExit Se lanza cuando la solicitud de salida de un generador Python sucede. Deriva de la excepción
BaseException (página 190).
IOError Se lanza cuando una operación de E/S (tal como una sentencia print (página 153), la función integrada
open() (página 119) o un método de un objeto archivo) fracasa por motivos relativos a E/S, por ejemplo, por
no encontrarse un archivo o llenarse el disco. Esta clase se deriva de EnvironmentError (página 191). En
la explicación anterior se proporciona información adicional sobre los atributos de instancias de excepción.
Deriva de la clase raíz EnvironmentError (página 191).
ImportError Se lanza cuando una sentencia import no encuentra la definición del módulo o cuando from
... import no encuentra un nombre a importar. Deriva de la clase raíz StandardError (página 191).
IndexError Se lanza cuando un sub-índice de una secuencia se sale del rango. Los índices de corte se truncan
silenciosamente al rango disponible. Si un índice no es un entero simple, se lanza TypeError (página 193).
Deriva de la clase raíz LookupError (página 191).
IndentationError Se lanza cuando una indentación incorrecta sucede. Deriva de la excepción SyntaxError
(página 192).
KeyError Se lanza cuando no se encuentra una clave de una correspondencia (diccionario) en el conjunto de
claves existentes. Deriva de la clase raíz LookupError (página 191).
KeyboardInterrupt Se lanza cuando el usuario pulsa la tecla de interrupción (normalmente con la combi-
nación de teclas Control-C o DEL2.7). A lo largo de la ejecución se comprueba si se ha interrumpido
regularmente. Las interrupciones ocurridas cuando una función input() (página 123) o raw_input() (pági-
na 123)) espera datos también lanzan esta excepción. Deriva de la clase raíz BaseException (página 190).
MemoryError Se lanza cuando una operación agota la memoria pero aún se puede salvar la situación (borrando
objetos). El valor asociado es una cadena que indica qué tipo de operación (interna) agotó la memoria.
Obsérvese que por la arquitectura de gestión de memoria subyacente (la función de C malloc()), puede
que el intérprete no siempre sea capaz de recuperarse completamente de esta situación. De cualquier modo,
se lanza una excepción para que se pueda imprimir una traza, por si la causa fue un programa desbocado.
Deriva de la clase raíz StandardError (página 191).
NameError Se lanza cuando no se encuentra un nombre local o global. Sólo se aplica a nombre no calificados.
El valor asociado es el nombre no encontrado. Deriva de la clase raíz StandardError (página 191).
NotImplementedError Esta excepción se deriva de RuntimeError (página 192). En clases base definidas por
el usuario, los métodos abstractos deberían lanzar esta excepción cuando se desea que las clases derivadas
redefinan este método. Deriva de la clase raíz RuntimeError (página 192).
OSError Esta clase se deriva de EnvironmentError (página 191) y se usa principalmente como excepción
os.error de os. En EnvironmentError (página 191) hay una descripción de los posibles valores asociados.
OverflowError Se lanza cuando el resultado de una operación aritmética es demasiado grande para repre-
sentarse (desbordamiento). Esto no es posible en los enteros largos (que antes que rendirse lanzarían Me-
moryError (página 192)). Por la falta de normalización de la gestión de excepciones de coma flotante en
C, la mayoría de las operaciones de coma flotante, tampoco se comprueban. En el caso de enteros norma-
les, se comprueban todas las operaciones que pueden desbordar excepto el desplazamiento a la izquierda,
en el que las aplicaciones típicas prefieren perder bits que lanzar una excepción. Deriva de la clase raíz
ArithmeticError (página 191).
RuntimeError Se lanza cuando se detecta un error que no cuadra en ninguna de las otras categorías. El valor
asociado es una cadena que indica qué fue mal concretamente. Esta excepción es mayormente una reliquia
de versiones anteriores del intérprete; ya casi no se usa. Deriva de la clase raíz StandardError (página 191).
StopIteration Se lanza cuando se indica el final desde iterator.next(). Deriva de la excepción Ex-
ception (página 190).
SyntaxError Se lanza cuando el analizador encuentra un error en la sintaxis. Esto puede ocurrir en una senten-
cia import, en una sentencia exec, en una llamada a la función interna eval() o input() (página 123), o
al leer el guion inicial o la entrada estándar (por ejemplo, la entrada interactiva). Si se usan excepciones de
clase, las instancias de esta clase tienen disponibles los atributos filename (nombre del archivo), lineno
(nº de línea), offset (nº de columna) y text (texto), que ofrecen un acceso más fácil a los detalles. En
las excepciones de cadena, el valor asociado suele ser una tupla de la forma (mensaje, (nombreFichero,
numLinea, columna, texto)). En las excepciones de clase, str() sólo devuelve el mensaje. Deriva de la
clase raíz StandardError (página 191).
SystemError Se lanza cuando el intérprete encuentra un error interno, pero la situación no parece tan grave
como para perder la esperanza. El valor asociado es una cadena que indica qué ha ido mal (en términos
de bajo nivel). Se debería dar parte de este error al autor o mantenedor del intérprete Python en cuestión.
Se debe incluir en el informe la cadena de versión del intérprete Python (sys.version, que también se
muestra al inicio de una sesión interactiva), la causa exacta del error y, si es posible, el código fuente del
programa que provocó el error. Deriva de la clase raíz StandardError (página 191).
SystemExit Lanzada por la función sys.exit(). Si no se captura, el intérprete de Python finaliza la eje-
cución sin presentar una pila de llamadas. Si el valor asociado es un entero normal, especifica el estado de
salida al sistema (se pasa a la función de C exit()), Si es None, el estado de salida es cero (que indica
una salida normal sin errores). En el caso de ser de otro tipo, se presenta el valor del objeto y el estado de
salida será 1. Las instancias tienen un atributo code cuyo valor se establece al estado de salida o mensaje
de error propuesto (inicialmente None). Además, esta excepción deriva directamente de Exception (pági-
na 190) y no de la excepción StandardError (página 191), ya que técnicamente no es un error. Una llamada a
sys.exit() se traduce a un error para que los gestores de limpieza final (las sentencias finally de las
sentencias try) se puedan ejecutar y para que un depurador pueda ejecutar un guion sin riesgo de perder el
control. Se puede usar la función os._exit() si es total y absolutamente necesario salir inmediatamente (por
ejemplo, tras un fork() en el proceso hijo). Deriva de la clase raíz BaseException (página 190).
ReferenceError Se lanza cuando se usó un proxy de referencia débil después de que el referente desapareció.
Deriva de la excepción StandardError (página 191).
TabError Se lanza cuando sucede una mezcla inadecuada de espacios y tabulaciones. Deriva de la excepción
IndentationError (página 191).
TypeError Se lanza cuando una operación o función interna se aplica a un objeto de tipo inadecuado. El valor
asociado es una cadena con detalles de la incoherencia de tipos. Deriva de la clase raíz StandardError
(página 191).
UnboundLocalError Se lanza cuando se hace referencia a una variable local en una función o método, pero
no se ha asignado un valor a dicha variable. Deriva de la excepción NameError (página 192).
UnicodeError Se lanza cuando se da un error relativo a codificación/descodificación Unicode. Deriva de la
excepción ValueError (página 193).
UnicodeDecodeError Se lanza cuando un error al decodificar Unicode sucede. Deriva de la excepción
UnicodeError (página 193).
UnicodeEncodeError Se lanza cuando un error al codificar Unicode sucede. Deriva de la excepción Uni-
codeError (página 193).
UnicodeTranslateError Se lanza cuando un error al traducir Unicode sucede. Deriva de la excepción
UnicodeError (página 193).
ValueError Se lanza cuando una operación o función interna recibe un argumento del tipo correcto, pero con
un valor inapropiado y no es posible describir la situación con una excepción más precisa, como IndexError
(página 191).
ZeroDivisionError Se lanza cuando el segundo argumento de una operación de división o módulo es cero.
El valor asociado es una cadena que indica el tipo de operandos y la operación. Deriva de la clase raíz
ArithmeticError (página 191).
Warning La clase base para las categorías de advertencias. Deriva de la excepción Exception (página 190).
BytesWarning La clase base para las advertencias acerca de problemas relacionados con bytes y buffer, mas
relacionado a la conversión desde str o comparando a str. Deriva de la excepción Warning (página 193).
DeprecationWarning La clase base para las advertencias acerca de características obsoletas. Deriva de la
excepción Warning (página 193).
FutureWarning La clase base para las advertencias acerca de constructores que pueden ser cambiado siste-
máticamente en el futuro. Deriva de la excepción Warning (página 193).
ImportWarning La clase base para las advertencias acerca de probables errores en importar módulos. Deriva
de la excepción Warning (página 193).
PendingDeprecationWarning La clase base para las advertencias acerca de características las cuales serán
obsoletas en el futuro. Deriva de la excepción Warning (página 193).
RuntimeWarning La clase base para las advertencias acerca de comportamiento del tiempo de ejecución du-
dosa. Deriva de la excepción Warning (página 193).
SyntaxWarning La clase base para las advertencias acerca de sintaxis dudosa. Deriva de la excepción Warning
(página 193).
UnicodeWarning La clase base para las advertencias acerca de problemas relacionado con Unicode, más
relacionado a problemas de conversión. Deriva de la excepción Warning (página 193).
UserWarning La clase base para las advertencias generadas por código de usuario. Deriva de la excepción
Warning (página 193).
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
La programación orientada a objetos (POO, u OOP según sus siglas en inglés) es un paradigma de programación
que viene a innovar la forma de obtener resultados. Los objetos manipulan los datos de entrada para la obtención
de datos de salida específicos, donde cada objeto ofrece una funcionalidad especial.
Muchos de los objetos prediseñados de los lenguajes de programación actuales permiten la agrupación en bibliote-
cas o librerías, sin embargo, muchos de estos lenguajes permiten al usuario la creación de sus propias bibliotecas.
98 https://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos
El mecanismo de clases de Python agrega clases al lenguaje con un mínimo de nuevas sintaxis y semánticas.
En Python las clases es una mezcla de los mecanismos de clase encontrados en C++ y Modula-3.
Como es cierto para los módulos, las clases en Python no ponen una barrera absoluta entre la definición y el
usuario, sino que más bien se apoya en la cortesía del usuario de no «forzar la definición».
Sin embargo, se mantiene el poder completo de las características más importantes de las clases: el mecanismo
de la herencia de clases permite múltiples clases base, una clase derivada puede sobrescribir cualquier método de
su(s) clase(s) base, y un método puede llamar al método de la clase base con el mismo nombre.
«Los objetos pueden tener una cantidad arbitraria de datos.»
En terminología de C++, todos los miembros de las clases (incluyendo los miembros de datos), son públicos, y
todas las funciones miembro son virtuales.
Como en Modula-3, no hay atajos para hacer referencia a los miembros del objeto desde sus métodos: la función
método se declara con un primer argumento explícito que representa al objeto, el cual se provee implícitamente
por la llamada.
Como en Smalltalk, las clases mismas son objetos. Esto provee una semántica para importar y renombrar.
A diferencia de C++ y Modula-3, los tipos de datos integrados pueden usarse como clases base para que el
usuario los extienda.
También, como en C++ pero a diferencia de Modula-3, la mayoría de los operadores integrados con sintaxis
especial (operadores aritméticos, de subíndice, etc.) pueden ser redefinidos por instancias de la clase.
(Sin haber una terminología universalmente aceptada sobre clases, haré uso ocasional de términos de Smalltalk
y C++. Usaría términos de Modula-3, ya que su semántica orientada a objetos es más cercana a Python que C++,
pero no espero que muchos lectores hayan escuchado hablar de él).
Algunas particularidades de POO en Python son las siguientes:
Todo es un objeto, incluyendo los tipos y clases.
Permite herencia múltiple.
No existen métodos ni atributos privados.
Los atributos pueden ser modificados directamente.
Permite «monkey patching».
Permite «duck typing».
Permite la sobrecarga de operadores.
Permite la creación de nuevos tipos de datos.
A continuación se procede a definir algunos conceptos necesarios para entender la POO:
9.3.2 Objetos
Los objetos son abstracción de Python para data. Toda la data en un programa Python es representado por objectos
o por relaciones entre objectos. (En cierto sentido, y en el código modelo de Von Neumann de una «computadora
almacenada del programa» también es un código representado por los objetos.)
Cada objeto tiene una identidad, un tipo y un valor. Una identidad de objecto nunca cambia una vez es creada;
usted puede pensar eso como la dirección de objeto en memoria. El operador in (página 84) compara la identidad
de dos objetos; la función id() (página 118) devuelve un número entero representando la identidad (actualmente
implementado como su dirección).
El tipo de un objeto también es inmutable. El tipo de un objeto determina las operaciones que admite el objeto
(por ejemplo, «¿tiene una longitud?») Y también define los valores posibles para los objetos de ese tipo. La
función «type() (página 122)» devuelve el tipo de un objeto (que es un objeto en sí mismo). El valor *de algunos
objetos puede cambiar. Se dice que los objetos cuyo valor puede cambiar son *mutables; los objetos cuyo valor
no se puede cambiar una vez que se crean se llaman immutable. (El valor de un objeto contenedor inmutable
que contiene una referencia a un objeto mutable puede cambiar cuando se cambia el valor de este último; sin
embargo, el contenedor todavía se considera inmutable, porque la colección de objetos que contiene no se puede
cambiar. Por lo tanto, la inmutabilidad no es estrictamente lo mismo que tener un valor incambiable, es más sutil.)
La mutabilidad de un objeto está determinada por su tipo; por ejemplo, los números, las cadenas y las tuplas son
inmutables, mientras que los diccionarios y las listas son mutables.
Los objetos son la clave para entender la POO (página 194). Si mira a nuestro alrededor encontrará un sin fin de
objetos de la vida real: perro, escritorio, televisor, bicicleta, etc. . .
En Python puede definir una clase con la palabra reservada class (página 200), de la siguiente forma:
class Persona:
pass
En el ejemplo anterior, el nombre de la clase es Persona y dentro del bloque de código usa la sentencia pass
(página 104). Aunque no es requerido por el intérprete, los nombres de las clases se escriben por convención
capitalizadas. Las clases pueden (y siempre deberían) tener comentarios.
Estado de un objeto
El conjunto de datos y objetos relacionados con un objeto en un momento dado, se le conoce como «estado».
Un objeto puede tener múltiples estados a lo largo de su existencia conforme se relaciona con su entorno y otros
objetos.
9.3.3 Atributos
Los atributos o propiedades de los objetos son las características que puede tener un objeto, como el color. Si el
objeto es Persona, los atributos podrían ser: cedula, nombre, apellido, sexo, etc. . .
Los atributos describen el estado de un objeto. Pueden ser de cualquier tipo de dato.
class Persona:
"""Clase que representa una Persona"""
cedula = "V-13458796"
nombre = "Leonardo"
(continué en la próxima página)
Usted puede probar el código anterior, si lo transcribe en el consola interactiva (página 15) Python como lo
siguiente:
Si el nombre de un atributo esta encerrado entre dobles guiones bajos son atributos especiales.
__name__, describe el nombre del objeto o del método.
>>> macagua.__name__
'Persona'
__doc__, contiene la documentación de un módulo, una clase, o método especifico, escrita en el formato
docstrings (página 50).
>>> macagua.__doc__
'Clase que representa una Persona'
Si el nombre de un atributo esta con dobles guiones bajos al principio son atributos «escondidos». A continuación
un pseudo código que ilustra un ejemplo:
>>> ms_windows.__privado
'True'
>>> ms_windows.codigo_fuente.__no_tocar
'True'
9.3.4 Métodos
Los métodos describen el comportamiento de los objetos de una clase. Estos representan las operaciones que se
pueden realizar con los objetos de la clase,
La ejecución de un método puede conducir a cambiar el estado del objeto.
Se definen de la misma forma que las funciones normales pero deben declararse dentro de la clase y su primer
argumento siempre referencia a la instancia que la llama, de esta forma se afirma que los métodos son funciones
(página 100), adjuntadas a objectos (página 195).
Nota: Usted puede encontrar ejemplos en las funciones de cadena de caracteres (página 46), listas (página 58),
diccionarios (página 65), etc.
Si el objeto es Persona, los métodos pueden ser: hablar, caminar, comer, dormir, etc.
class Persona:
"""Clase que representa una Persona"""
cedula = "V-13458796"
nombre = "Leonardo"
apellido = "Caballero"
sexo = "M"
La única diferencia sintáctica entre la definición de un método y la definición de una función es que el primer
parámetro del método por convención debe ser el nombre self.
Usted puede probar el código anterior, si lo transcribe en el consola interactiva (página 15) Python como lo
siguiente:
Si crea una instancia de objeto para la clase Persona e intenta llamar al método hablar() esto lanzara una
excepción TypeError (página 193), como sucede a continuación:
Los métodos cuentan con un espacio de nombres propio. En caso de no encontrar un nombre en su ámbito local,
buscará en el ámbito superior hasta encontrar alguna coincidencia.
Los métodos pueden acceder y crear atributos dentro del objeto al que pertenecen, anteponiendo la palabra self
y el operador de atributo «.» antes del nombre del atributo en cuestión.
Métodos especiales
Las clases en Python cuentan con múltiples métodos especiales, los cuales se encuentran entre dobles guiones
bajos __<metodo>__().
Los métodos especiales más utilizados son __init__() (página 201), __str__() (página 199) y __del__() (pági-
na 199).
__str__()
El método __str__() es un método especial, el cual se ejecuta al momento en el cual un objeto se manda
a mostrar, es decir es una cadena representativa de la clase, la cual puede incluir formatos personalizados de
presentación del mismo.
def __str__(self):
"""Devuelve una cadena representativa de Persona"""
return "%s: %s, %s %s, %s." % (
self.__doc__[25:34], str(self.cedula), self.nombre,
self.apellido, self.getGenero(self.sexo))
__del__()
El método __del__() es un método especial, el cual se ejecuta al momento en el cual un objeto es descartado
por el intérprete. El comportamiento de __del__() es muy similar a los «destructores» en otros lenguajes.
Métodos de clase
En ocasiones es necesario contar con métodos que interactúen con elementos de la clase de la cual el objeto es
instanciado. Python permite definir métodos de clase para esto.
Los métodos de clase son aquellos que están ligados directamente con los atributos definidos en la clase que los
contiene. Para definir un método de clase se utiliza el decorador @classmethod y por convención se utiliza
cls como argumento inicial en lugar de self.
Del mismo modo, los métodos de clase utilizan el prefijo cls para referirse a los atributos de la clase.
class <Clase>(object):
...
...
@classmethod
def <metodo>(cls, <argumentos>):
...
...
Métodos estáticos
Los métodos estáticos hacen referencia a las instancias y métodos de una clase. Para definir un método estático se
utiliza el decorador @staticmethod y no utiliza ningún argumento inicial.
Al no utilizar self, los métodos estáticos no pueden interactuar con los atributos y métodos de la instancia.
Para referirse a los elementos de la clase, se debe utilizar el nombre de la clase como prefijo.
class <Clase>(object):
...
...
@staticmethod
def <metodo>(<argumentos>):
...
...
Interfaces
La forma en que los métodos de un objeto pueden ser accedidos por otros objetos se conoce como «interfaz». Una
interfaz bien definida permite a objetos de distinta índole interactuar entre sí de forma modular. La interfaz define
el modo en que los objetos intercambian información.
Implementaciones
Una implementación corresponde al mecanismo interno que se desencadena en un método cuando éste es llamado.
Las implementaciones procesan las entradas proveniente de las interfaces y actúan en consecuencia ya sea:
Modificando el estado del objeto.
Transfiriendo la información resultante del proceso interno a través de la interfaces.
9.3.5 Clases
9.3.6 Instancias
Ya sabe que una clase es una estructura general del objeto. Por ejemplo, puede decir que la clase Persona
necesita tener una cedula, un nombre, un apellido y una sexo, pero no va a decir cual es cedula,
nombre, apellido y sexo, es aquí donde entran las instancias.
Una instancia es una copia específica de la clase con todo su contenido. Por ejemplo:
La excepción TypeError (página 193) indica que el método constructor no toma argumentos, esto se debe a que la
momento de definir la clase a cada atributo se le asigno un valor (tipo de dato).
Usted puede definir el metodo constructor de la clase usando el método __init__() (página 201).
Método __init__()
El método __init__() es un método especial, el cual se ejecuta al momento de instanciar un objeto. El com-
portamiento de __init__() es muy similar a los «constructores» en otros lenguajes. Los argumentos que se
utilizan en la definición de __init__() corresponden a los parámetros que se deben ingresar al instanciar un
objeto.
Función isinstance()
isinstance(), es una función integrada (página 113) la cual le permite corroborar si un objeto es instancia de
una clase.
Nota: Más información consulte la documentación detallada de la función isinstance() (página 142).
Importante: Usted puede descargar el código usado en esta sección haciendo clic aquí.
Truco: Para ejecutar el código poo.py, abra una consola de comando, acceda al directorio donde se encuentra
el mismo, y ejecute el siguiente comando:
python poo.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
9.4 Herencia
La herencia es una de las premisas y técnicas de la POO (página 194) la cual permite a los programadores crear
una clase general primero y luego más tarde crear clases más especializadas que re-utilicen código de la clase
general. La herencia también le permite escribir un código más limpio y legible.
Clase Base o también conocida como Clase abstracta le permite definir una clase que puede heredarse en otras
clases los atributos y comportamientos definido en esta.
Use el diagrama anterior para ilustrar el concepto de la herencia, vea el caso de dos clases que tiene algo en
común, ambas son personas, con atributos de datos personales y comportamiento típicos como hablar, comer,
caminar, entonces para eso se crea una clase base llamada Persona. A continuación un ejemplo de la clase
Persona con un método interno:
class Persona(object):
"""Clase que representa una Persona"""
def __str__(self):
"""Devuelve una cadena representativa de Persona"""
return "%s: %s, %s %s, %s." % (
self.__doc__[25:34], str(self.cedula), self.nombre,
self.apellido, self.getGenero(self.sexo))
En el ejemplo previo, es donde empieza a crear una clase (lo hace con la palabra class). La segunda palabra
Persona es el nombre de la clase. La tercera palabra que se encuentra dentro de los paréntesis este hace referencia
al objeto object (página 224), usando para indicar la clase de la cual precede.
La clase Persona tiene los métodos __init__, __str__, hablar y getGenero. Sus atributos son
cedula, nombre, apellido y sexo.
La instancia de dos nuevos objetos Persona seria de la siguiente forma:
El método constructor __init__ es un método especial el cual debe escribir como: MiClase(parámetros
iniciales si hay cualquiera).
Usted puede llamar esos métodos y atributos con la siguiente notación: claseinstancia.metodo o
claseinstancia.atributo.
El método __str__ es un método usando para imprimir la descripción de la instancia de objeto el cual debe
mostrar como:
En el anterior código se usan para cierto formato para imprimir la instancia de objeto usando la sentencia print,
concatenando el carácter \n para generar un salto de página y seguidamente convertir a formato cadena de carac-
teres usando la función str() a la instancia de objeto llamada persona2.
La herencia simple se apoya en el uso de clases base (página 202) para compartir sus atributos y comportamientos
con otros clases derivadas como los siguiente ejemplos el objeto Supervisor y el objeto Obrero.
El siguiente es un ejemplo de la clase Supervisor que derivada de la clase Persona con función interna:
class Supervisor(Persona):
"""Clase que representa a un Supervisor"""
# Nuevos atributos
self.rol = rol
self.tareas = ['10','11','12','13']
(continué en la próxima página)
def __str__(self):
"""Devuelve una cadena representativa al Supervisor"""
return "%s: %s %s, rol: '%s', sus tareas: %s." % (
self.__doc__[26:37], self.nombre, self.apellido,
self.rol, self.consulta_tareas())
def consulta_tareas(self):
"""Mostrar las tareas del Supervisor"""
return ', '.join(self.tareas)
Ahora, se creará una nueva clase Supervisor con los mismos métodos y atributos como la clase Persona,
pero con dos nuevos atributos rol y tareas. No se copia la clase previa, pero si se hereda de ella.
La instancia del nuevo objeto Supervisor seria de la siguiente forma:
Luego que generá la instancia del nuevo objeto Supervisor llamada supervisor1 se puede imprimir sus
detalles de la siguiente forma:
Como la instancia de objeto supervisor1 hereda los atributo(s) y método(s) de la clase Persona usted puede
reusarlo y llamarlo de la siguiente forma:
Si desea usar los atributo(s) y método(s) heredados de la clase Supervisor se puede imprimir de la siguiente
forma:
El uso de las clases y la programación orientada a objetos, le permite a usted que pueda organizar el código con
diferentes clases correspondientes a diferentes objetos que encontrará (una clase Persona, una clase Carro, una
clase Departamento, etc.), con sus propios métodos y atributos. Luego puede usar la herencia para considerar
las variaciones en torno a una clase base y reutilizar el código. Ej.: a partir de una clase base de Persona, usted
puede crear clases derivadas como Supervisor, JefeCuadrilla, Obrero, etc.
Función issubclass()
issubclass(), es una función integrada (página 113) la cual le permite corroborar si un objeto es instancia de
una clase.
Nota: Más información consulte la documentación detallada de la función issubclass() (página 142).
Importante: Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:
clases.py y herencia_simple.py.
Truco: Para ejecutar el código clases.py y herencia_simple.py, abra una consola de comando, acceda
al directorio donde se encuentra ambos programas:
leccion9/
clases.py
herencia_simple.py
python herencia_simple.py
A diferencia de lenguajes como Java y C#, el lenguaje Python permite la herencia múltiple, es decir, se puede
heredar de múltiples clases.
La herencia múltiple es la capacidad de una subclase de heredar de múltiples súper clases.
Esto conlleva un problema, y es que si varias súper clases tienen los mismos atributos o métodos, la subclase sólo
podrá heredar de una de ellas.
En estos casos Python dará prioridad a las clases más a la izquierda en el momento de la declaración de la subclase:
class Destreza(object):
"""Clase la cual representa la Destreza de la Persona"""
def __str__(self):
"""Devuelve una cadena representativa de la Destreza"""
return """Destreza en el área %s con la herramienta %s,
tiene %s años de experiencia.""" % (
str(self.area), self.experiencia, self.herramienta)
# Nuevos atributos
self.cuadrilla = cuadrilla
def __str__(self):
"""Devuelve cadena representativa al Jefe de Cuadrilla"""
jq = "{0}: {1} {2}, rol '{3}', tareas {4}, cuadrilla: {5}"
return jq.format(
self.__doc__[28:46], self.nombre, self.apellido,
self.rol, self.consulta_tareas(), self.cuadrilla)
Ese es el orden en el cual el método debe heredar en la presencia de herencia múltiple. Usted puede ver el MRO
usando el atributo __mro__.
>>> JefeCuadrilla.__mro__
(<class '__main__.JefeCuadrilla'>,
<class '__main__.Supervisor'>,
<class '__main__.Persona'>,
<class '__main__.Destreza'>,
<type 'object'>)
>>> Supervisor.__mro__
(<class '__main__.Supervisor'>,
<class '__main__.Persona'>,
<type 'object'>)
>>> Destreza.__mro__
(<class '__main__.Destreza'>,
<type 'object'>)
Importante: Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:
clases.py y herencia_multiple.py.
Truco: Para ejecutar el código clases.py y herencia_multiple.py, abra una consola de comando,
acceda al directorio donde se encuentra ambos programas:
leccion9/
clases.py
herencia_multiple.py
python herencia_multiple.py
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
9.5 Abstracción
9.5.1 Encapsulación
Métodos de soporte: Son métodos adicionales en un objeto que no definen un servicio utilizable por un cliente,
pero que ayudan a otros métodos en sus tareas.
La encapsulación es un mecanismo de control. El estado (el conjunto de propiedades, atributos ó datos) de un
objeto sólo debe ser modificado por medio de los métodos del propio objeto.
La técnica de encapsulación, es conocida como ocultación de datos, le permite que los atributos de un objeto
pueden ocultarse (superficialmente) para que no sean accedidos desde fuera de la definición de una clase. Para
ello, es necesario nombrar los atributos con un prefijo de doble subrayado: __atributo.
Python protege estos atributos cambiando su nombre internamente. A sus nombres agrega el nombre de la clase:
objeto._NombreClase__NombreAtributo
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
9.6 Polimorfismo
La técnica de polimorfismo de la POO (página 194) significa la capacidad de tomar más de una forma. Una
operación puede presentar diferentes comportamientos en diferentes instancias. El comportamiento depende de
los tipos de datos utilizados en la operación. El polimorfismo es ampliamente utilizado en la aplicación de la
herencia.
La sobrecarga de métodos es también es conocida por Overriding Methods, le permite sustituir un método pro-
veniente de la Clase Base, en la Clase Derivada debe definir un método con la misma forma (es decir, mismo
nombre de método y mismo número de parámetros que como está definido en la Clase Base).
>>> class Persona():
... def __init__(self):
... self.cedula = 13765890
... def mensaje(self):
... print("mensaje desde la clase Persona")
...
>>> class Obrero(Persona):
... def __init__(self):
... self.__especialista = 1
... def mensaje(self):
... print("mensaje desde la clase Obrero")
...
>>> obrero_planta = Obrero()
>>> obrero_planta.mensaje()
mensaje desde la clase Obrero
>>>
Lo que se logra definiendo el método mensaje() en la Clase Derivada (Obrero) se conoce como Método
Overriding (cuando se cree el objeto (en este caso obrero_planta y se llame al método mensaje(), este
será tomado de la propia clase y no de la Clase Base Persona). Si comenta o borra el método mensaje() de
la clase Obrero (Clase Derivada) y corre nuevamente el código, el método llamado será el mensaje() de la
Clase Base Persona.
La sobrecarga de operadores es también es conocida por Overloading Operators, trata básicamente de lo mismo
que la sobrecarga de métodos pero pertenece en esencia al ámbito de los operadores aritméticos, binarios, de
comparación y lógicos.
>>> class Punto:
... def __init__(self,x = 0,y = 0):
... self.x = x
... self.y = y
... def __add__(self,other):
... x = self.x + other.x
... y = self.y + other.y
... return x, y
...
>>> punto1 = Punto(4,6)
>>> punto2 = Punto(1,-2)
>>> print punto1 + punto2
(5, 4)
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
Existe otros tipos de datos integrados (página 25) en el interprete Python, que para muchos no son de uso frecuente,
los cuales se describen a continuación:
9.7.1 Ellipsis
Este tipo tiene un solo valor. Hay un solo objeto con este valor. Se accede a este objeto elipsis a través del
nombre incorporado «Ellipsis». Se utiliza para indicar la presencia de la sintaxis «...» en una porción o la
notación de corte extendida. Su valor de verdad es True.
>>> type(Ellipsis)
<type 'ellipsis'>
9.7.2 None
Este tipo tiene un solo valor. Hay un solo objeto con este valor. Se accede a este objeto a través del nombre
incorporado «None». Se utiliza para indicar la ausencia de un valor en muchas situaciones, por ejemplo, se
devuelve desde las funciones que no devuelven nada explícitamente. Su valor de verdad es False.
>>> type(None)
<type 'NoneType'>
9.7.3 NotImplemented
Este tipo tiene un solo valor. Hay un solo objeto con este valor. Se accede a este objeto a través del nombre
incorporado «NotImplemented». Los métodos numéricos y los métodos de comparación enriquecidos (como
__eq__(), __lt__() y amigos), para indicar que la comparación no se implementa con respecto al otro tipo, es
decir, pueden devolver este valor si no implementan la operación para los operandos proporcionados. (El intérprete
luego intentará la operación reflejada, o algún otro respaldo «fallback», dependiendo del operador). Su valor
de verdad es True.
>>> type(NotImplemented)
<type 'NotImplementedType'>
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
Python integra varias clases de tipos en el modulo __builtin__, a continuación se describen algunas clases:
buffer
El objeto de la clase buffer() crea un nuevo objeto de búfer que haga referencia al objeto dado. El búfer hará
referencia a una porción del objeto de destino desde el inicio del objeto (o en el desplazamiento especificado). La
división se extenderá hasta el final del objeto de destino (o con el tamaño especificado).
El búfer en este caso anterior es una sub-cadena, inicia en la posición 5 con un ancho de 5 caracteres y es no toma
espacio de almacenamiento extra - eso referencia a cortar una cadena de caracteres.
Este ejemplo anterior no es muy útil para cadenas de caracteres cortas como esta, pero eso puede ser necesario
cuando usa un gran numero de data. Este ejemplo puede usar un tipo mutable bytearray():
Esto puede ser muy útil si usted quiere tener más que una vista en la data y no quiere (o puede) contener múltiples
copias en memoria.
Note que el búfer ha sido remplazado por un mejor método llamado memoryview() (página 222) en Python 3,
aunque se puede usar en Python 2.7.
Note también que usted no puede implementar una interfaz búfer para sus propios objetos sin profundizando en la
API de C, ej. usted no puede hacer eso con puramente con código Python.
En general un slice tomará extra almacenamiento, entonces, si cadena[5:10] será una copia. Si usted define
cadena_buffer = cadena[5:10] y entonces del cadena, eso liberaría la memoria que fue tomada
por cadena, proveyendo que cadena_buffer fue copiada. (Para usar esto usted necesita una gran cadena
de caracteres, en este ejemplo cadena y rastrear el uso de la memoria de Python). Es sin embargo mucho más
eficiente que hacer la copia si no existe mucha data involucrada.
bytes
El objeto de la clase bytes es agregada en Python 2.6 como un sinónimo para el tipo str (página 46) y este
también soporta la notación b''.
El uso principal de bytes en Python 2.6 será escribir pruebas de tipo de objeto como isinstance(x, bytes).
Esto ayudará al convertidor 2to3, que no puede decir si el código 2.x pretende que las cadenas contengan ca-
racteres o bytes de 8 bits; ahora puede usar bytes o str para representar exactamente su intención, y el código
resultante también será correcto en Python 3.0.
quit
Es el método constructor de la clase Quitter incluida en el módulo site el cual le permite salir de la consola
interactiva Python:
>>> quit
Use quit() or Ctrl-D (i.e. EOF) to exit
>>> quit()
$
De esta forma puede salir de la consola interactiva Python y volviendo al interprete del Shell de comando.
slice
La clase slice crea un objecto slice, esto es usado por el extendido slicing por ejemplo:
>>> a = range(20)
>>> a[0:10:2]
[0, 2, 4, 6, 8]
La sintaxis es la siguiente:
>>> slice(stop)
>>> slice(start, stop[, step])
staticmethod
Los métodos estáticos en Python son extremadamente similar a los métodos de nivel clase en python, la diferencia
esta que un método estático es enlazado a una clase más bien que los objectos para esa clase.
Esto significa que un método estático puede ser llamado sin un objeto para esa clase. Esto también significa que
los métodos estáticos no pueden modificar el estado de un objeto como ellos no pueden enlazarse a ese.
Los métodos estáticos Python puede crearse en dos formas, usando el aprovechamiento staticmethod() o el
decorador @staticmethod:
La clase staticmethod() convierte una función a un método estático. Un método estático no recibe un primer
argumento implícito. La sintaxis es la siguiente:
En el ejemplo anterior usted puede notar que se llamo al método sumaNumeros sin crear un objeto. Se puede lla-
mar en la clase (por ejemplo, Clase.funcion()) o en una instancia (por ejemplo, Clase().funcion()).
La instancia se ignora a excepción de su clase.
Los métodos estáticos son similares a los métodos estáticos Java o C++. Para un concepto más avanzado, mire
la clase classmethod (página 221) integrada en el interprete.
La clase staticmethod introduce un cambio en la versión 2.4, agregando sintaxis de decorador (página 231)
de función. La sintaxis es la siguiente:
class Clase:
@staticmethod
def funcion(argumento1, argumento2, ...):
...
Este código fuente es enteramente idéntico al primer ejemplo (usando @staticmethod), solo que no usa la
agradable sintaxis de decorador (página 231).
Finalmente, se usa el método staticmethod() escasamente. Hay muchas situaciones donde los métodos es-
táticos son necesarios en Python.
enumerate
La clase enumerate devuelve un objeto enumerate. El iterable debe ser otro objeto que soporte iteradores
(página 92). El objeto enumerate produce pares que contiene una cuenta (desde donde inicia, el cual el valor por
defecto es cero) y un valor producido por el argumento iterable.
Cuando la iteración de la secuencia llega al final se llama a la excepción StopIteration (página 192) y se causa
el detener la iteración. El objeto enumerate es muy útil para obtener una lista indexada como: (0, seq[0]),
(1, seq[1]), (2, seq[2]), ....
En el ejemplo anterior usa una secuencia numérica de 3 elementos generada por la función integrada xrange()
(página 121).
A continuación se le pasa el parámetro de inicio con el valor 1 de la secuencia generada por la clase enumerate:
En el ejemplo anterior usa una secuencia numérica de 3 elementos generada con el valor inicial de 1 por la función
integrada xrange() (página 121).
reversed
La clase reversed devolver un iterador (página 92) inverso sobre los valores de la secuencia, cuando la iteración
de la secuencia llega al final se llama a la excepción StopIteration (página 192) y se causa el detener la iteración.
En el ejemplo anterior usa una secuencia numérica de 3 elementos generada por la función integrada xrange()
(página 121).
file()
El objeto file() se implementan con el paquete del lenguaje C stdio y se pueden crear con la función interna
open() (página 119). También son el resultado de otras funciones y métodos internos, por ejemplo, os.popen()
y os.fdopen() y el método makefile() de los objetos socket.
Cuando falla una operación de archivos por una cuestión de E/S, se lanza la excepción IOError (página 191). Esto
incluye situaciones donde la operación no esté definida por cualquier motivo, como usar seek() (página 217) en un
dispositivo tty o intentar escribir en un archivo abierto para lectura.
Métodos
close()
El método close() permite cerrar la manipulación del archivo. No es posible escribir ni leer en un archivo
cerrado. Cualquier operación que requiera que el archivo esté abierto lanzará IOError (página 191) si el archivo
se ha cerrado. Está permitido llamar a close() más de una vez.
Una vez que se terminó de usar el archivo es necesario cerrarlo, para liberar los recursos tomados por el manejo
del archivo. Eso se hace con la sentencia archivo.close():
Luego de lo cual no se puede acceder al archivo datos.txt, si intenta una llamada a la método archivo.read()
(página 216) devuelve una excepción ValueError (página 193), porque el archivo está cerrado:
>>> archivo.close()
>>> archivo.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file
flush()
El método flush() permite descargar el bufér interno, como la función de lenguaje C fflush() de la librería
stdio. Puede no tener efecto en ciertos objetos similares a los archivos.
Python automáticamente flushes los archivos cuando son cerrados. Pero usted podría to flush la data antes de cerrar
cualquier archivo.
isatty()
El método isatty() devuelve True si el archivo está conectado a un dispositivo tty (un terminal interactivo
de líneas de orden), en caso contrario, False.
Nota: Si un objeto similar a los archivos no está asociado a un archivo real, no debe implementar este método.
fileno()
El método fileno() devuelve el «descriptor de archivo» utilizado por la implementación subyacente para soli-
citar operaciones E/S del sistema operativo. Puede ser útil para interfaces de bajo nivel que utilicen descriptores
de archivos, por ejemplo, el módulo fcntl o os.read() y similares.
Nota: Si un objeto similar a los archivos no tiene un descriptor de archivo, no debe implementar este método.
next()
El método next() permite usar un iterador para tratar cada linea del archivo como el próximo valor, cuando
la iteración del archivo llega al final se llama a la excepción StopIteration (página 192) y se causa el detener la
iteración.
read()
El método read() permite leer el contenido del archivo. El argumento es opcional y si no se especifica (o es
-1) devuelve el contenido de todo el archivo. Una vez que se leyó todo el archivo, una nueva llamada a la función
devuelve una cadena vacía (“”).
Si desea recibir una salida formateada por consola leyendo un archivo, a continuación un ejemplo:
readline()
El método readline() permite leer una sola línea del archivo, devuelve al final de la línea el carácter de nueva
línea y solo se omite en la última línea del archivo (si no termina con el carácter de nueva línea). Esto hace que el
valor de retorno no sea ambiguo. Si devuelve una cadena de caracteres vacía se alcanzó el fin del archivo, mientras
que una línea en blanco se representa con un carácter de nueva línea.
>>>
readlines()
El método readlines() devuelve una lista que contiene todas las líneas del archivo.
seek()
El método seek() mueve la posición actual del cursos del archivo, como la función del lenguaje C fseek()
de la librería stdio. No devuelve ningún valor.
El método seek() lleva la siguiente nomenclatura:
A continuación, un ejemplo que escribir y leer el archivo datos.txt agregando una lista de lineas al principio
del archivo, como al final del archivo:
En el ejemplo anterior, puede ver que se escriben tres lineas y se pasa como argumento posicion_actual el
valor 8 el cual posiciona el curso de búsqueda en dicha posición de la primera linea con archivo.seek(8) y
muestra una parte de la linea.
El argumento punto_referencia es opcional, con un valor predeterminado de 0 (es el principio del archivo);
otros valores posibles son 1 (la posición actual del archivo) y 2 (el final del archivo). No hay valor de retorno.
>>> archivo = open('datos.txt', 'w')
>>> lista_de_lineas = ["Esta es la 1er linea", \
... "Esta es la 2da linea", "Esta es la 3era linea"]
>>> archivo.writelines("\n".join(lista_de_lineas))
>>> archivo.close()
>>> archivo = open('datos.txt', 'r')
>>> archivo.next()
'Esta es la 1er linea\n'
>>> archivo.seek(8)
>>> archivo.next()
'la 1er linea\n'
>>> archivo.close()
>>> archivo = open('datos.txt', 'rw+')
>>> nuevas_lineas = ["\nEsta es la 4ta linea", \
... "Esta es la 5ta linea"]
>>> # Escribe la secuencia de la lineas al final del archivo.
... archivo.seek(0, 2)
>>> archivo.writelines("\n".join(nuevas_lineas))
>>> # Ahora lea completamente el archivo desde el inicio.
... archivo.seek(0,0)
>>> for elemento in range(1, 6):
... linea = archivo.next()
... print "Linea No %d - %s" % (elemento, linea)
...
Linea No 1 - Esta es la 1er linea
En el ejemplo anterior se pudo usar el método seek() con el argumento punto_referencia al final del
archivo para agregar nuevas lineas y luego se uso de nuevo el argumento punto_referencia para ubicarse al
inicio del archivo para mostrar todo el contenido del archivo.
tell()
El método tell() devuelve la posición actual del archivo, como la función del lenguaje C ftell() de la
librería stdio.
>>> archivo = open('/etc/hostname')
>>> archivo.tell()
0
>>> linea = iter(archivo)
>>> linea.next()
'debacagua9\n'
>>> archivo.tell()
11
>>> len('debacagua9\n')
11
>>> linea.next()
Traceback (most recent call last):
(continué en la próxima página)
Cuando la iteración de la secuencia llega al final se llama a la excepción StopIteration (página 192) y se causa el
detener la iteración.
truncate()
El método truncate() trunca el archivo. Si se proporciona el argumento opcional, el archivo se trunca a (como
mucho) ese tamaño. El tamaño depende de la posición actual. La disponibilidad de esta función depende de la
versión del sistema operativo (por ejemplo, no todas las versiones de Unix dan soporte a esta operación).
write()
El método write() permite escribir el contenido de la cadena de texto al archivo, y devuelve la cantidad de
caracteres escritos.
Para escribir algo que no sea una cadena de caracteres, antes se debe convertir a cadena de caracteres.
writelines()
El método writelines() escribe una lista de cadenas al archivo. No se devuelve ningún valor. El nombre es
paralelo a readlines(), writelines() no añade separadores de línea.
Atributos
Los objetos archivo también ofrecen otros atributos interesantes. No son necesarios para los objetos de interfaz
tipo archivo, pero deberían implementarse si tienen sentido en un objeto particular.
closed
El atributo closed del objeto file (página 214) de tipo booleano (página 44) indica el estado actual. Es un atributo
de sólo lectura, que se cambia mediante el método close() (página 215). Puede no estar disponible en todos los
objetos con interfaz tipo archivo.
mode
El atributo mode del objeto file (página 214), es el modo de E/S del archivo. Si se creó el archivo con la función
integrada open() (página 119), será el valor del parámetro mode. Es un atributo de sólo lectura y puede no estar
disponible en todos los objetos con interfaz tipo archivo.
name
El atributo name del objeto file (página 214), es el nombre del archivo si se creó el objeto archivo mediante la
función integrada open() (página 119), el nombre del archivo. En caso contrario, alguna cadena que indique el
origen del archivo, de la forma «<. . . >». Es un atributo de sólo lectura y puede no estar disponible en todos los
objetos con interfaz tipo archivo.
encoding
El atributo encoding del objeto file (página 214), es el encoding del archivo.
softspace
El atributo softspace del objeto file (página 214) del tipo booleano (página 44) indica si se debe escribir un
espacio antes de escribir otro valor al usar la sentencia print (página 153). Las clases que intenten simular un
objeto archivo deberían tener un atributo escribible softspace, que debería inicializarse a cero.
Esto será automático en la mayoría de las clases implementadas en Python (se debe tener cuidado en las clases
que redefinan el acceso a los atributos). Los tipos implementados en el lenguaje C tendrán que proporcionar un
atributo softspace escribible.
Nota: Este atributo no se usa para controlar la sentencia print, sino para permitir que la implementación de
print lleve la cuenta de su estado interno.
>>>
>>> archivo = open('datos.txt', 'w')
>>> archivo.softspace
0
classmethod
La clase classmethod convierte una función para ser un método de clase. Un método de clase recibe la cla-
se como primer argumento implícito, al igual que un método de instancia recibe la instancia. La sintaxis es la
siguiente:
La clase classmethod introduce un cambio en la versión 2.4, agregando sintaxis de decorador (página 231) de
función. La sintaxis es la siguiente:
class Clase:
@classmethod
def funcion(cls, argumento1, argumento2, ...):
...
Se puede llamar en la clase (por ejemplo, Clase.funcion()) o en una instancia (por ejemplo, Clase().
funcion()). La instancia se ignora a excepción de su clase. Si se llama a un método de clase para una clase
derivada, el objeto de clase derivada se pasa como el primer argumento implícito.
Los métodos de clase son diferentes a los métodos estáticos C++ o Java. Si quieres eso, mira la clase staticmethod
(página 212) integrada en el interprete.
memoryview
>>> memoryview(objecto)
En el ejemplo anterior se crea una vista de memoria de un tipo bytearray mostrando los diversos atributos
disponibles.
Continuando el ejemplo anterior, se crea una vista de memoria de un tipo buffer (página 210) usando el objeto
cadena previamente creado:
En el ejemplo anterior se crea una vista de memoria de un tipo buffer (página 210) mostrando los diversos atributos
disponibles.
A continuación, otro ejemplo donde se crea una vista de memoria usando el objeto bytearray previamente
creado:
Continuando el ejemplo anterior, se puede crear una lista (página 58) desde una vista de memoria usando el objeto
vm previamente creado:
>>> list = []
>>> for item in range(3): list.append(vm[item])
...
>>> list
['A', 'B', 'C']
Continuando el ejemplo anterior, se puede crear cadena de caracteres (página 46) desde una vista de memoria
usando el objeto vm previamente creado:
Aquí, es creada un objeto vista de memoria llamado vm desde un objeto bytearray llamado randomBA.
Entonces, es accedido al índice 0 posición vm “A” y el valor es impreso. Luego, es accedido al índice 1 posición
vm “B” y el valor es impreso. También, es accedido al índice 2 posición vm “C” y el valor es impreso.
Finalmente, es accedido todos los índices del objeto vm y convertidos a una lista.
A continuación, otro ejemplo donde se modifica la data interna usando vista de memoria:
Aquí, se actualiza el indice 1 de la vista de memoria a un valor ASCII - 90 (Z) usando la función chr() (página 130).
Desde, el objeto de vista de memoria vm referencia al mismo búfer/memoria, actualiza el índice en el vm también
actualiza el randomBA.
Desde adentro internamente el tipo bytearray almacena valores ASCII para el alfabeto, es decir, cada posición
de la lista se debe indicar con su equivalente numérico en la tabla ASCII.
>>> chr(65)
'A'
>>> chr(66)
'B'
>>> chr(67)
'C'
>>> chr(90)
'Z'
Entonces se usa la función chr() (página 130) para indicar su equivalente en la tabla de valores ASCII.
object
El objeto de la clase object es el tipo más básico de objeto, es integrado en el módulo __builtin__. Este
objeto se usa como herencia (página 202) cuando se crea una nueva clase en Python.
Todo, incluyendo las clases y tipos de Python son instancias de object. Para corroborar si un objeto es instancia
de una clase se utiliza la función isinstance() (página 142).
>>> object
<type 'object'>
property
La clase property típicamente es usado para definir un atributo property. La sintaxis es la siguiente:
El parámetro fget es una función a ser usada para obtener un valor de un atributo, y igualmente el parámetro
fset es una función para definir el valor de un atributo, y el parámetro fdel es una función para eliminar un
atributo.
El método property() devuelve un atributo property donde es dado el método getter, setter y
deleter.
Si no hay argumentos son dados, el método property() devuelven un atributo base property que no con-
tienen ningún getter, setter o deleter. Si doc no es proveído, método property() toma el docstring
(página 50) de la función getter.
A continuación, un ejemplo sencillo:
>>> class Persona:
... def __init__(self, nombre):
... self._nombre = nombre
...
... def getNombre(self):
... print 'Obteniendo nombre'
... return self._nombre
...
... def setNombre(self, valor):
... print 'Definiendo nombre a ' + valor
... self._nombre = valor
...
... def delNombre(self):
... print 'Eliminando nombre'
... del self._nombre
...
... # Define la property para usar los métodos getNombre,
... # setNombre y delNombre
... nombre = property(getNombre, setNombre, delNombre, 'Atributo property
˓→nombre')
...
>>> persona1 = Persona('Leo')
>>> print persona1.nombre
Obteniendo nombre
Leo
>>> persona1.nombre = 'Leonardo'
>>> print persona1.nombre
Leonardo
>>> dir(persona1)
['__doc__', '__init__', '__module__', '_nombre', 'delNombre',
'getNombre', 'nombre', 'setNombre']
>>> persona1.delNombre()
Eliminando nombre
>>> dir(persona1)
['__doc__', '__init__', '__module__', 'delNombre', 'getNombre',
'nombre', 'setNombre']
>>> print persona1.nombre
Leonardo
>>> del persona1.nombre
>>> print persona1.nombre
Obteniendo nombre
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in getNombre
AttributeError: Persona instance has no attribute '_nombre'
Cuando se elimina persona1.delNombre() puede notar que _nombre ya no esta disponible y si se vuelve
a imprimir el valor de nombre print persona1.nombre aun muestra el valor inicializado con el método
setNombre, entonces al ejecutar del persona1.nombre se elimina por completo el valor en memoria,
luego si intenta mostrar el valor del atributo property nombre lanza AttributeError (página 191) por no encontró
_nombre el cual es usado como la variable privado para almacenar el nombre de una Persona.
Se definió lo siguiente:
Un método getter getNombre() para obtener el nombre de la persona,
Un método setter setNombre() para definir el nombre de la persona,
Un método deleter delNombre() para eliminar el nombre de la persona.
Ahora tiene definido un atributo property nombre llamando al método property().
Como se mostró en el código anterior, la referencia persona1.nombre internamente llama al método
getName() como getter, setName() como setter y delName() como deleter a través de las salidas im-
presas presente dentro de los métodos.
También se definió el docstring (página 50) del atributo con el valor “Atributo property nombre”.
Otra alternativa son los decoradores (página 231) facilitan la definición de nuevas propiedades o la modificación
de las existentes:
A continuación se creará un atributo property con métodos getter, setter y deleter usando el decorador
@property en vez de usar el método property(), usted puede usar el decorador Python @property para
asignar el método getter, setter y deleter:
Aquí, en vez de usar el método property(), es usado el decorador (página 231) @property.
Primero especifica que el método nombre() es un atributo de la clase Persona. Esto es hecho usando la sintaxis
@property antes el método getter como se muestra en el código anterior.
Seguidamente se usa el nombre del atributo nombre para especificar los métodos setter y deleter.
Esto es hecho usando la sintaxis @<nombre-de-atributo>.setter (@nombre.setter) para el método setter y
@<nombre-de-atributo>.deleter (@nombre.deleter) para el método deleter.
Note, es usando el mismo método nombre() con diferentes definiciones para definir los métodos getter,
setter y deleter.
Ahora, cada vez que se usa persona1.nombre, es internamente llama el apropiado método para getter,
setter y deleter como lo muestra la salida impresa presente dentro de cada método.
super
La clase super típicamente es usada al llamar un método de superclase cooperativo. Las sintaxis de como usarlo
son las siguientes:
>>> super(type)
class ClaseBase():
def metodo(self, argumento):
pass
class Clase(ClaseBase):
def metodo(self, argumento):
super(Clase, self).metodo(argumento)
Aquí, se llama el método __init__ de la clase Mamifero (desde la clase Perro) usando el có-
digo fuente super(Perro, self).__init__('Perro') en vez de del tradicional Mamifero.
__init__(self, 'Perro').
Como no necesitamos especificar el nombre de la clase base si usamos super(), podemos cambiar fácilmente
la clase base para el método Perro (si es necesario).
A continuación un ejemplo de cambiar la clase base a la clase RazaCanina:
El método integrado super() regresa un objeto proxy, un objeto substituto que tiene la habilidad de llamar al
método de la clase base vía delegación. Esto es llamado indirección (habilidad de referenciar objeto base con el
método super()).
Desde que la indirección es calculada en tiempo ejecución, usted puede usar para apuntar hacia una clase base
diferente en tiempo diferente (si usted lo necesita).
A continuación un ejemplo del uso super() con herencia múltiple (página 205) de la objetos:
>>> class Animal(object):
... def __init__(self, animal):
... print animal, 'es un animal.\n\n',
...
>>> class Mamifero(Animal):
... def __init__(self, mamifero):
... print mamifero, 'es un animal de sangre caliente.'
... super(Mamifero, self).__init__(mamifero)
...
>>> class MamiferoNoVolador(Mamifero):
... def __init__(self, mamifero):
... print mamifero, "no puede volar."
... super(MamiferoNoVolador, self).__init__(mamifero)
...
>>> class MamiferoNoAcuatico(Mamifero):
... def __init__(self, mamifero):
... print mamifero, "no puede nadar."
... super(MamiferoNoAcuatico, self).__init__(mamifero)
...
>>> class Perro(MamiferoNoAcuatico, MamiferoNoVolador):
... def __init__(self):
... print 'Perro tiene 4 piernas.\n',
... super(Perro, self).__init__('Perro')
...
>>> perro = Perro()
Perro tiene 4 piernas.
Perro no puede nadar.
Perro no puede volar.
Perro es un animal de sangre caliente.
Perro es un animal.
>>> Perro.__mro__
(<class '__main__.Perro'>,
<class '__main__.MamiferoNoAcuatico'>,
<class '__main__.MamiferoNoVolador'>,
<class '__main__.Mamifero'>,
<class '__main__.Animal'>,
<type 'object'>)
(continué en la próxima página)
>>> MamiferoNoAcuatico.__mro__
(<class '__main__.MamiferoNoAcuatico'>,
<class '__main__.Mamifero'>,
<class '__main__.Animal'>,
<type 'object'>)
El orden en resolver la herencia múltiple esta basado en el principio Method Resolution Order (MRO) (página 206).
El MRO es calculado en Python de la siguiente forma:
Un método en la llamada derivada es siempre llamada antes de método de la clase base. En nuestro ejemplo,
la clase Perro es llamada antes de las clases MamiferoNoAcuatico o MamiferoNoVolador. Esas dos
clases son llamada antes de la clase Mamifero el cual es llamada antes de la clase Animal y la clase Animal
es llamada antes de la clase object.
Si hay herencia múltiple como Perro(MamiferoNoAcuatico, MamiferoNoVolador), el método de
MamiferoNoAcuatico es invocado primero por que ese aparece primero.
9.8.5 type
Los objetos tipo (página 26) representan los diversos tipos de objeto. El tipo de un objeto es accesible mediante la
función integrada type() (página 122). No hay operaciones especiales sobre los tipos. El módulo estándar types
define nombres para todos los tipos internos estándar.
>>> type(type)
<type 'type'>
Ver también:
Consulte la sección de lecturas suplementarias (página 265) del entrenamiento para ampliar su conocimiento en
esta temática.
10.1 Decoradores
Un decorador es una función Python permite que agregar funcionalidad a otra función, pero sin modificarla.
También, esto es llamado meta-programación, por que parte del programa trata de modificar a otro al momento de
compilar.
Para llamar un decorador se utiliza el signo de arroba (@).
Los decoradores en Python son discutidos y definidos en el PEP-318. https://www.python.org/dev/peps/pep-0318/
La listas de comprensión, del inglés list comprehensions, es una funcionalidad que le permite crear listas avanzadas
en una misma línea de código.
La forma general de la definición de una lista por comprensión es:
expresion puede ser cualquier expresión computable en Python, generalmente involucrando un item del ite-
rable llamado iterable puede ser cualquier objeto iterable, como una secuencia (lista (página 58) o cadena de
caracteres (página 46)), la función la función range() (página 120), etc.
La salida siempre es un tipo de lista (página 58) Python.
231
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
10.2.1 Ejemplo 1
Si requiere crear una lista de 4 elementos y cada elemento calcularle la potencia de 2, usando el método tradicional,
eso seria así:
>>> lista = []
>>> for i in range(4):
... lista.append(i**2)
...
>>> print lista
[0, 1, 4, 9]
10.2.2 Ejemplo 2
A continuación se crear una lista con las letras de una palabra, usando el método tradicional, eso seria así:
>>> lista = []
>>> for letra in 'casa':
... lista.append(letra)
...
>>> print lista
['c', 'a', 's', 'a']
Como puede detallar en el ejemplo anterior, gracias a la listas de comprensión usted puede indicar directamente
cada elemento que va a formar la lista, en este caso cada letra, a la vez que definimos el bucle for (página 90),
entonces la lista está formada por cada letra que recorremos en el bucle for.
10.2.3 Ejemplo 3
A continuación se crear una lista con las potencias de 2 de los primeros 10 números, usando el método tradicional,
eso seria así:
>>> lista = []
>>> for numero in range(0,11):
... lista.append(numero**2)
...
>>> print lista
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
De este código anterior usted puede aprender que es posible modificar al vuelo los elementos los cuales van a
formar la lista.
10.2.4 Ejemplo 4
A continuación se crear una lista con los todos los múltiples de 2 entre 0 y 10, usando el método tradicional, eso
seria así:
>>> lista = []
>>> for numero in range(0,11):
... lista.append(numero**2)
...
>>> print lista
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
También, si añade al código anterior, los números del 0 al 10 cuando su módulo de 2 sea 0 usando el método
tradicional, eso seria así:
>>> lista = []
>>> for numero in range(0,11):
... if numero % 2 == 0:
... lista.append(numero)
...
>>> print lista
[0, 2, 4, 6, 8, 10]
Entonces el ejemplo anterior donde crear una lista con los todos los múltiples de 2 entre 0 y 10, usando listas de
comprensión, eso seria así:
Para el ejemplo anterior donde crear una lista con los todos los múltiples de 2 entre 0 y 10 cuando su módulo de 2
sea 0, usando listas de comprensión, eso seria así:
En este caso puede observar que incluso puede marcar una condición justo al final para añadir o no el elemento en
la lista.
10.2.5 Ejemplo 5
A continuación se crear una lista de pares a partir de otra lista creada con las potencias de 2 de los primeros 10
números, usando el método tradicional, eso seria así:
>>> lista = []
>>> for numero in range(0,11):
... lista.append(numero**2)
...
>>> pares = []
>>> for numero in lista:
... if numero % 2 == 0:
... pares.append(numero)
...
>>> print pares
[0, 4, 16, 36, 64, 100]
Crear listas a partir de listas anidadas le permite llevar la listas de comprensión al siguiente nivel y además no hay
un límite.
Ver también:
Consulte la sección de lecturas suplementarias (página 266) del entrenamiento para ampliar su conocimiento en
esta temática.
10.4 datetime
Fecha y hora
Advertencia: Tenga en cuenta que este documento no está completo sin la palabra hablada de un instructor
a pesar de que tratamos de incluir las partes más importantes de lo que enseñamos en la narrativa no puede
considerarse completa sin la palabra hablada.
Apéndices
Este entrenamiento toma 10 lecciones. Cada lección contiene material de lectura y ejercicios que usted tendrá que
escribir en el interprete Python. Cada lección aprendida están asociadas entre si mismas.
Descripción: Sensibilizar sobre la filosofía del lenguaje, su historia y evolución, casos de éxitos.
Práctica: Exponer los fundamentos sobre el lenguaje Python, comentar sobre usos e implementaciones exitosas a
nivel regional, nivel nacional y nivel mundial.
Descripción: Comprender la creación y asignación de tipos primitivos (variables numéricas, cadenas de texto con
sus operaciones; tipos compuestos (listas, tuplas, diccionarios).
Práctica: Ejemplos de creación y asignación de variables numéricas, cadenas de texto, listas, tuplas, diccionarios
y explorar el resultado desde el interprete Python.
Descripción: Comprender las estructuras de control como if (elif, else); for, while (else, break,
continue, pass); las funciones range() (página 120) y xrange() (página 121); ademas de los tipos iteradores()
(página 92).
237
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Práctica: Ejemplos de creación a estructuras condicionales, repetitivas y funciones propias y explorar el resultado
desde el interprete Python.
Descripción: Comprender el manejos de errores (try, except, else, finally, y raise) y el paradigma de
programación orientada a objetos (clases, herencia simple y múltiple, sobrecarga de métodos).
Práctica: Ejemplo de creación de clases, atributos, comportamientos, manipulación de errores en Python y explo-
rar el resultado en un paquete en el sistema de archivos.
Descripción: Comprender el uso de decoradores y los diversos módulos adicionales de la librería estándar de
Python.
Práctica: Ejemplo de uso de decoradores y módulos adicionales útiles de la biblioteca estándar explorando el
resultado en un paquete Python en el sistema de archivos.
Siempre aprender un nuevo lenguaje de programación tiene nuevos retos desde aprender sobre la filosofía del
lenguaje y hasta léxicos propios los cuales hacen característico el uso y expresión de sus programas con este nuevo
lenguaje, más esto requiere práctica y tiempo para lograr la fluidez en hablar y escribir programas en Python.
Hay más contenido complementario o detallada que el contenido del entrenamiento de las 10 lecciones cubiertas
en este entrenamiento. Al finalizar, yo he compilado una lista de lecturas relacionadas que soporta la información
que usted aprende en cada lección. Piensa que esto como materiales suplementarios. Usted puede leerlo en su
tiempo libre para ayudar a incrementar tanto la profundidad y amplitud en su conocimiento.
Las lecturas están organizada como las lecciones y sus temas.
Introducción a Python
Instalación
Descarga Python106 .
PyPI - the Python Package Index107 .
Ver la Figura 4.2 anexo sobre la instalación.
Su primer programa
Variables y constantes
Ver la Figura 4.5 anexo sobre los tipo booleanos y cadenas de caracteres.
Tipo listas
Tipo tuplas
Tipo diccionarios
Condicional if
Operadores lógicos
Ver la Figura 4.5 anexo sobre los tipo booleanos y cadenas de caracteres.
Bucle while
Bucle for
Programación estructurada
Manipulación de archivos
Módulos Python
Distribución de Software
Gestión de proyectos con Buildout, instalando Zope/Plone con este mecanismo145 desde la comunidad de
Plone Venezuela.
Errores y excepciones
Iteradores
Listas de comprensión
Figura 11.1: Vídeo Tutorial Python 1 - Introducción al Lenguaje de Programación153 , cortesía de CodigoFacili-
to.com154 .
147 https://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos
148 http://docs.python.org.ar/tutorial/2/classes.html
149 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/oop.html
150 https://www.youtube.com/watch?v=ALZmCy2u0jQ
151 https://stackoverflow.com/questions/1301346/what-is-the-meaning-of-a-single-and-a-double-underscore-before-an-object-name
152 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/control_flow.html#listas-por-comprension
153 https://www.youtube.com/watch?v=CjmzDHMHxwU
154 https://codigofacilito.com/
155 https://www.youtube.com/watch?v=VTykmP-a2KY
156 https://codigofacilito.com/
157 https://www.youtube.com/watch?v=OtJEj7N9T6k
158 https://codigofacilito.com/
159 https://www.youtube.com/watch?v=ssnkfbBbcuw
160 https://codigofacilito.com/
Figura 11.4: Vídeo Tutorial Python 4 - Enteros, reales y operadores aritméticos159 , cortesía de CodigoFacili-
to.com160 .
Figura 11.5: Vídeo Tutorial Python 5 - Booleanos, operadores lógicos y cadenas161 , cortesía de CodigoFacili-
to.com162 .
161 https://www.youtube.com/watch?v=ZrxcqbFYjiw
162 https://codigofacilito.com/
163 https://www.youtube.com/watch?v=hLqKvB7tGWk
164 https://codigofacilito.com/
165 https://www.youtube.com/watch?v=IyI2ZuOq_xQ
166 https://codigofacilito.com/
167 https://www.youtube.com/watch?v=_C7Uj7O5o_Q
168 https://codigofacilito.com/
169 https://www.youtube.com/watch?v=N4NtB4r28h0
170 https://www.youtube.com/watch?v=AzeUCuMvW6I
171 https://codigofacilito.com/
172 https://www.youtube.com/watch?v=B-JPXgxK3Oc
173 https://codigofacilito.com/
174 https://www.youtube.com/watch?v=VYXdpjCZojA
175 https://codigofacilito.com/
176 https://www.youtube.com/watch?v=87s8XQbUv1k
177 https://codigofacilito.com/
178 https://www.youtube.com/watch?v=tvHbC_OZV14
179 https://codigofacilito.com/
180 https://www.youtube.com/watch?v=TaIWx9paNIA
181 https://codigofacilito.com/
Figura 11.9: Vídeo Depurando um programa Python com pdb - Python Debugger169 , cortesía de Youtube.
Figura 11.10: Vídeo Tutorial Python 30 - Entrada Estándar rawInput170 , cortesía de CodigoFacilito.com171 .
Figura 11.11: Vídeo Tutorial Python 31 - Salida Estándar rawInput172 , cortesía de CodigoFacilito.com173 .
11.4 Operadores
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores de asignaciones (pági-
na 32).
- Resta
>>> 4 - 7
-3
- Negación
>>> -7
-7
* Multiplicación
>>> 2 * 6
12
** Exponente
>>> 2 ** 6
64
/ División
>>> 3.5 / 2
1.75
// División entera
>>> 3.5 // 2
1.0
% Módulo
>>> 7 % 2
1
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores aritméticos (página 35).
!= ¿son distintos a y b?
>>> 5 != 3
True
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores relacionales (pági-
na 38).
or ¿se cumple a o b?
>>> True or False
True
not No al valor
>>> not True
False
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores lógicos (página 86).
11.5 Glosario
local command Una clase Paste191 la cual provee funcionalidad adicional a una estructura de esqueleto de pro-
yecto que ha sido generada.
módulo Del Ingles module, es un archivo fuente Python; un archivo en el sistema de archivo que típicamente
finaliza con la extensión .py o .pyc. Los modules son parte de un paquete.
Nombre de puntos Python Es la representación Python del «camino» para un determinado objeto / módulo / fun-
ción, por ejemplo, Products.GenericSetup.tool.exportToolset. A menudo se utiliza como
referencia en configuraciones Paste y setuptools a cosas en Python.
paquete Ver Paquete Python.
Paquete bundle Este paquete consististe en un archivo comprimido con todos los módulos que son necesario
compilar o instalar en el PYTHONPATH de tu interprete Python.
paquete Egg Es una forma de empaquetar y distribuir paquetes Python. Cada Egg contiene un archivo setup.
py con metadata (como el nombre del autor y la correo electrónico y información sobre el licenciamiento),
como las dependencias del paquete.
La herramienta del setuptools <que_es_setuptools>, es la librería Python que permite usar el mecanismo
de paquetes egg, esta es capaz de encontrar y descargar automáticamente las dependencias de los paquetes
Egg que se instale.
Incluso es posible que dos paquetes Egg diferentes necesiten utilizar simultáneamente diferentes versiones
de la misma dependencia. El formato de paquetes Eggs también soportan una función llamada entry
points, una especie de mecanismo genérico de plug-in. Mucha más detalle sobre este tema se encuentra
disponible en el sitio web de PEAK192 .
Paquete Python Es un termino generalmente usando para describir un módulo Python. en el más básico nivel,
un paquete es un directorio que contiene un archivo __init__.py y algún código Python.
paquetes Egg Plural del termino paquete Egg.
Paquetes Python Plural del termino Paquete Python.
part En la herramienta buildout, es un conjunto opciones que le permite a usted construir una pieza de la aplica-
ción.
plantilla 1) Una clase Python la cual controla la generación de un esqueleto. Las plantillas contiene una lis-
ta de variables para obtener la respuesta de un usuario. Las plantillas son ejecutadas con el comando
templer suministrando el nombre de la plantilla como un argumento templer basic_namespace
my.package.
2) Los archivos y carpetas proveídas un paquete templer como contenido a ser generado. Las respues-
tas proporcionadas por un usuario en respuesta a las variables se utilizan para rellenar los marcadores de
posición en este contenido.
Producto Es una terminología usada por la comunidad Zope / Plone asociada a cualquier implementación de
módulos / complementos y agregados que amplíen la funcionalidad por defecto que ofrece Zope / Plone.
También son conocidos como «Productos de terceros» del Ingles Third-Party Products193 .
Producto Plone Es un tipo especial de paquete Zope usado para extender las funcionalidades de Plone. Se puede
decir que son productos que su ámbito de uso es solo en el desde la interfaz gráfica de Plone.
Producto Zope Es un tipo especial de paquete Python usado para extender Zope. En las antiguas versiones de
Zope, todos los productos eran carpetas que se ubican dentro de una carpeta especial llamada Products
de una instancia Zope; estos tendrían un nombre de módulo Python que empiezan por «Products.».
Por ejemplo, el núcleo de Plone es un producto llamado CMFPlone, conocido en Python como Pro-
ducts.CMFPlone194 .
Este tipo de productos esta disponibles desde la interfaz administrativa de Zope (ZMI)195 de su instalación196
191 https://paste.readthedocs.io/en/latest/
192 http://peak.telecommunity.com/DevCenter/setuptools
193 https://docs.plone.org/develop/addons/
194 https://pypi.org/project/Products.CMFPlone
195 https://plone-spanish-docs.readthedocs.io/es/latest/zope/zmi/index.html
196 http://localhost:8080/manage
donde deben acceder con las credenciales del usuario Administrador de Zope. Muchas veces el producto
simplemente no hay que instalarlo por que se agregar automáticamente.
Productos Plural del termino Producto.
Productos Plone Plural del termino Producto Plone.
Productos Zope Plural del termino Producto Zope.
profile Una configuración «predeterminada» de un sitio, que se define en el sistema de archivos o en un archivo
tar.
PyPI Siglas del termino en Ingles Python Package Index, es el servidor central de paquetes Egg Python ubicado
en la dirección https://pypi.org/.
Python Package Index Ver PyPI.
PYTHONPATH Una lista de nombre de directorios, que contiene librerías Python, con la misma sintaxis como
la declarativa PATH del shell del sistema operativo.
recipe En la herramienta buildout, es el software usado para crear partes de una instalación basada en sus opcio-
nes. Más información consulte el articulo Recipes Buildout197 .
setup.py El archivo setup.py es un módulo de Python, que por lo general indica que el módulo / paquete
que está a punto de instalar ha sido empacado y distribuidos con Distutils, que es el estándar para la
distribución de módulos de Python.
Con esto le permite instalar fácilmente paquetes de Python, a menudo es suficiente para escribir:
python setup.py install
mite la aplicación y la expedición enchufabilidad complejo basado en objetos que implementan una interfaz.
ZCatalog Ver Catalog.
ZCML Siglas del termino en Ingles Zope Configuration Mark-up Language.
ZCML-slug Los así llamados «ZCML-slugs», era configuraciones que estaban destinados a enlazar dentro
de un directorio una configuración especial en una instalación de Zope, por lo general se ven como
collective.foo-configure.zcml. Estas configuraciones ya no están más en uso, pueden ser eli-
minados agregando las configuraciones del paquete z3c.autoinclude201 .
Zope Configuration Mark-up Language Es un dialecto XML utilizado por Zope para las tareas de configura-
ción. ZCML es capaz de realizar diferentes tipos de declaración de configuración. Es utilizado para extender
y conectar a los sistemas basados en la Zope Component Architecture.
Zope 3 tiene la política de separar el código actual y moverlo a los archivos de configuración independien-
tes, típicamente un archivo configure.zcml en un buildout. Este archivo configura la instancia Zope.
El concepto “Configuración” podría ser un poco engañoso aquí y debe ser pensado o tomarse más cableado.
ZCML, el lenguaje de configuración basado en XML que se utiliza para esto, se adapta a hacer el registro
de componentes y declaraciones de seguridad, en su mayor parte. Al habilitar o deshabilitar ciertos com-
ponentes en ZCML, puede configurar ciertas políticas de la aplicación general. En Zope 2, habilitar y
deshabilitar componentes significa eliminar o remover un determinado producto Zope 2. Cuando está ahí,
se importa y se carga automáticamente. Este no es el caso en Zope 3 Si no habilita explícitamente, no va
a ser encontrado.
El grok proyecto ha adoptado un enfoque diferente para el mismo problema, y permite el registro de com-
ponentes, etc haciendo declarativa de código Python. Ambos enfoques son posibles en Plone.
11.6 Licenciamientos
Esta documentación se distribuye bajo los términos de la licencia Reconocimiento-CompartirIgual 3.0 Vene-
zuela de Creative Commons202 .
Esta documentación tiene las siguientes tareas pendientes por hacer para mejorar la calidad de la misma:
Búsqueda
search
257
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Este entrenamiento toma 10 lecciones. Cada lección contiene material de lectura y ejercicios que usted tendrá que
escribir en el interprete Python. Cada lección aprendida están asociadas entre si mismas.
Descripción: Sensibilizar sobre la filosofía del lenguaje, su historia y evolución, casos de éxitos.
Práctica: Exponer los fundamentos sobre el lenguaje Python, comentar sobre usos e implementaciones exitosas a
nivel regional, nivel nacional y nivel mundial.
Descripción: Comprender la creación y asignación de tipos primitivos (variables numéricas, cadenas de texto con
sus operaciones; tipos compuestos (listas, tuplas, diccionarios).
Práctica: Ejemplos de creación y asignación de variables numéricas, cadenas de texto, listas, tuplas, diccionarios
y explorar el resultado desde el interprete Python.
Descripción: Comprender las estructuras de control como if (elif, else); for, while (else, break,
continue, pass); las funciones range() (página 120) y xrange() (página 121); ademas de los tipos iteradores()
(página 92).
259
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Práctica: Ejemplos de creación a estructuras condicionales, repetitivas y funciones propias y explorar el resultado
desde el interprete Python.
Descripción: Comprender el manejos de errores (try, except, else, finally, y raise) y el paradigma de
programación orientada a objetos (clases, herencia simple y múltiple, sobrecarga de métodos).
Práctica: Ejemplo de creación de clases, atributos, comportamientos, manipulación de errores en Python y explo-
rar el resultado en un paquete en el sistema de archivos.
Descripción: Comprender el uso de decoradores y los diversos módulos adicionales de la librería estándar de
Python.
Práctica: Ejemplo de uso de decoradores y módulos adicionales útiles de la biblioteca estándar explorando el
resultado en un paquete Python en el sistema de archivos.
Siempre aprender un nuevo lenguaje de programación tiene nuevos retos desde aprender sobre la filosofía del
lenguaje y hasta léxicos propios los cuales hacen característico el uso y expresión de sus programas con este nuevo
lenguaje, más esto requiere práctica y tiempo para lograr la fluidez en hablar y escribir programas en Python.
Hay más contenido complementario o detallada que el contenido del entrenamiento de las 10 lecciones cubiertas
en este entrenamiento. Al finalizar, yo he compilado una lista de lecturas relacionadas que soporta la información
que usted aprende en cada lección. Piensa que esto como materiales suplementarios. Usted puede leerlo en su
tiempo libre para ayudar a incrementar tanto la profundidad y amplitud en su conocimiento.
Las lecturas están organizada como las lecciones y sus temas.
261
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
B.1.2 Instalación
Descarga Python210 .
PyPI - the Python Package Index211 .
Ver la Figura 4.2 anexo sobre la instalación.
Ver la Figura 4.5 anexo sobre los tipo booleanos y cadenas de caracteres.
B.4.1 Condicional if
Ver la Figura 4.5 anexo sobre los tipo booleanos y cadenas de caracteres.
222 https://www.eumus.edu.uy/eme/ensenanza/electivas/python/2014/CursoPython_clase01.html#orden-de-precedencia
223 https://www.eumus.edu.uy/eme/ensenanza/electivas/python/2014/CursoPython_clase01.html
224 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/control_flow.html#iterando-sobre-una-secuencia
225 https://www.eumus.edu.uy/eme/ensenanza/electivas/python/2014/CursoPython_clase03.html#Listas-I
226 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/control_flow.html#seguimiento-de-una-enumeracion
227 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/control_flow.html#bucle-sobre-un-diccionario
228 http://mundogeek.net/archivos/2008/01/17/python-tipos-basicos/
229 http://codigoprogramacion.com/cursos/tutoriales-python/operadores-basicos-de-python.html
230 http://docs.python.org.ar/tutorial/2/controlflow.html#la-sentencia-if
231 http://codigoprogramacion.com/cursos/tutoriales-python/condicionales-if-y-else-en-python.html
232 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/control_flow.html#expresiones-condicionales
Gestión de proyectos con Buildout, instalando Zope/Plone con este mecanismo249 desde la comunidad de
Plone Venezuela.
B.10.1 Iteradores
253 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/oop.html
254 https://www.youtube.com/watch?v=ALZmCy2u0jQ
255 https://stackoverflow.com/questions/1301346/what-is-the-meaning-of-a-single-and-a-double-underscore-before-an-object-name
256 https://claudiovz.github.io/scipy-lecture-notes-ES/intro/language/control_flow.html#listas-por-comprension
Operadores
267
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores de asignaciones (pági-
na 32).
- Resta
>>> 4 - 7
-3
- Negación
>>> -7
-7
* Multiplicación
>>> 2 * 6
12
** Exponente
>>> 2 ** 6
64
/ División
>>> 3.5 / 2
1.75
// División entera
>>> 3.5 // 2
1.0
% Módulo
>>> 7 % 2
1
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores aritméticos (página 35).
!= ¿son distintos a y b?
>>> 5 != 3
True
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores relacionales (pági-
na 38).
or ¿se cumple a o b?
>>> True or False
True
not No al valor
>>> not True
False
Ver también:
Usted puede consultar para más información la explicación de cada uno de los operadores lógicos (página 86).
Figura 4.1: Vídeo Tutorial Python 1 - Introducción al Lenguaje de Programación257 , cortesía de CodigoFacili-
to.com258 .
257 https://www.youtube.com/watch?v=CjmzDHMHxwU
258 https://codigofacilito.com/
259 https://www.youtube.com/watch?v=VTykmP-a2KY
260 https://codigofacilito.com/
261 https://www.youtube.com/watch?v=OtJEj7N9T6k
262 https://codigofacilito.com/
263 https://www.youtube.com/watch?v=ssnkfbBbcuw
264 https://codigofacilito.com/
271
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Figura 4.4: Vídeo Tutorial Python 4 - Enteros, reales y operadores aritméticos263 , cortesía de CodigoFacili-
to.com264 .
Figura 4.5: Vídeo Tutorial Python 5 - Booleanos, operadores lógicos y cadenas265 , cortesía de CodigoFacili-
to.com266 .
265 https://www.youtube.com/watch?v=ZrxcqbFYjiw
266 https://codigofacilito.com/
267 https://www.youtube.com/watch?v=hLqKvB7tGWk
268 https://codigofacilito.com/
269 https://www.youtube.com/watch?v=IyI2ZuOq_xQ
270 https://codigofacilito.com/
271 https://www.youtube.com/watch?v=_C7Uj7O5o_Q
272 https://codigofacilito.com/
273 https://www.youtube.com/watch?v=N4NtB4r28h0
274 https://www.youtube.com/watch?v=AzeUCuMvW6I
275 https://codigofacilito.com/
276 https://www.youtube.com/watch?v=B-JPXgxK3Oc
277 https://codigofacilito.com/
278 https://www.youtube.com/watch?v=VYXdpjCZojA
279 https://codigofacilito.com/
280 https://www.youtube.com/watch?v=87s8XQbUv1k
281 https://codigofacilito.com/
282 https://www.youtube.com/watch?v=tvHbC_OZV14
283 https://codigofacilito.com/
284 https://www.youtube.com/watch?v=TaIWx9paNIA
285 https://codigofacilito.com/
273
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Figura 4.9: Vídeo Depurando um programa Python com pdb - Python Debugger273 , cortesía de Youtube.
Figura 4.10: Vídeo Tutorial Python 30 - Entrada Estándar rawInput274 , cortesía de CodigoFacilito.com275 .
Figura 4.11: Vídeo Tutorial Python 31 - Salida Estándar rawInput276 , cortesía de CodigoFacilito.com277 .
275
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Glosario
277
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Declaración ZCML El uso concreto de una Directiva ZCML dentro de un archivo ZCML.
Directiva ZCML Una «etiqueta» ZCML como <include /> o <utility />.
Egg Ver paquetes Egg.
esqueleto Los archivos y carpetas recreados por un usuario el cual los genero ejecutando alguna plantilla
templer (PasteScript).
estructura 1) Una clase Python la cual controla la generación de un árbol de carpetas que contiene archivos.
2) Una unidad de carpetas y archivos proveídos por el sistema templer para ser usado en una plantilla
o plantillas. Las estructuras proporcionan recursos estáticos compartidos, que pueden ser utilizados por
cualquier paquete en el sistema de templer.
Las estructuras diferencian de las plantillas en que no proporcionan las vars.
filesystem Termino ingles File system, referido al sistema de archivo del sistema operativo.
Flujo de trabajo Es una forma muy poderosa de imitar los procesos de negocio de su organización, es también
la forma en se manejan la configuración de seguridad de Plone.
Flujo de trabajos Plural del termino Flujo de trabajo.
grok Ver la documentacion del proyecto grok294 .
Instalación de Zope El software propio del servidor de aplicaciones.
Instancia de Zope Un directorio específico que contiene una configuración completa del servidor Zope.
local command Una clase Paste295 la cual provee funcionalidad adicional a una estructura de esqueleto de pro-
yecto que ha sido generada.
módulo Del Ingles module, es un archivo fuente Python; un archivo en el sistema de archivo que típicamente
finaliza con la extensión .py o .pyc. Los modules son parte de un paquete.
Nombre de puntos Python Es la representación Python del «camino» para un determinado objeto / módulo / fun-
ción, por ejemplo, Products.GenericSetup.tool.exportToolset. A menudo se utiliza como
referencia en configuraciones Paste y setuptools a cosas en Python.
paquete Ver Paquete Python.
Paquete bundle Este paquete consististe en un archivo comprimido con todos los módulos que son necesario
compilar o instalar en el PYTHONPATH de tu interprete Python.
paquete Egg Es una forma de empaquetar y distribuir paquetes Python. Cada Egg contiene un archivo setup.
py con metadata (como el nombre del autor y la correo electrónico y información sobre el licenciamiento),
como las dependencias del paquete.
La herramienta del setuptools <que_es_setuptools>, es la librería Python que permite usar el mecanismo
de paquetes egg, esta es capaz de encontrar y descargar automáticamente las dependencias de los paquetes
Egg que se instale.
Incluso es posible que dos paquetes Egg diferentes necesiten utilizar simultáneamente diferentes versiones
de la misma dependencia. El formato de paquetes Eggs también soportan una función llamada entry
points, una especie de mecanismo genérico de plug-in. Mucha más detalle sobre este tema se encuentra
disponible en el sitio web de PEAK296 .
Paquete Python Es un termino generalmente usando para describir un módulo Python. en el más básico nivel,
un paquete es un directorio que contiene un archivo __init__.py y algún código Python.
paquetes Egg Plural del termino paquete Egg.
Paquetes Python Plural del termino Paquete Python.
part En la herramienta buildout, es un conjunto opciones que le permite a usted construir una pieza de la aplica-
ción.
294 https://grok-community-docs.readthedocs.io/en/latest/
295 https://paste.readthedocs.io/en/latest/
296 http://peak.telecommunity.com/DevCenter/setuptools
plantilla 1) Una clase Python la cual controla la generación de un esqueleto. Las plantillas contiene una lis-
ta de variables para obtener la respuesta de un usuario. Las plantillas son ejecutadas con el comando
templer suministrando el nombre de la plantilla como un argumento templer basic_namespace
my.package.
2) Los archivos y carpetas proveídas un paquete templer como contenido a ser generado. Las respues-
tas proporcionadas por un usuario en respuesta a las variables se utilizan para rellenar los marcadores de
posición en este contenido.
Producto Es una terminología usada por la comunidad Zope / Plone asociada a cualquier implementación de
módulos / complementos y agregados que amplíen la funcionalidad por defecto que ofrece Zope / Plone.
También son conocidos como «Productos de terceros» del Ingles Third-Party Products297 .
Producto Plone Es un tipo especial de paquete Zope usado para extender las funcionalidades de Plone. Se puede
decir que son productos que su ámbito de uso es solo en el desde la interfaz gráfica de Plone.
Producto Zope Es un tipo especial de paquete Python usado para extender Zope. En las antiguas versiones de
Zope, todos los productos eran carpetas que se ubican dentro de una carpeta especial llamada Products
de una instancia Zope; estos tendrían un nombre de módulo Python que empiezan por «Products.».
Por ejemplo, el núcleo de Plone es un producto llamado CMFPlone, conocido en Python como Pro-
ducts.CMFPlone298 .
Este tipo de productos esta disponibles desde la interfaz administrativa de Zope (ZMI)299 de su instalación300
donde deben acceder con las credenciales del usuario Administrador de Zope. Muchas veces el producto
simplemente no hay que instalarlo por que se agregar automáticamente.
Productos Plural del termino Producto.
Productos Plone Plural del termino Producto Plone.
Productos Zope Plural del termino Producto Zope.
profile Una configuración «predeterminada» de un sitio, que se define en el sistema de archivos o en un archivo
tar.
PyPI Siglas del termino en Ingles Python Package Index, es el servidor central de paquetes Egg Python ubicado
en la dirección https://pypi.org/.
Python Package Index Ver PyPI.
PYTHONPATH Una lista de nombre de directorios, que contiene librerías Python, con la misma sintaxis como
la declarativa PATH del shell del sistema operativo.
recipe En la herramienta buildout, es el software usado para crear partes de una instalación basada en sus opcio-
nes. Más información consulte el articulo Recipes Buildout301 .
setup.py El archivo setup.py es un módulo de Python, que por lo general indica que el módulo / paquete
que está a punto de instalar ha sido empacado y distribuidos con Distutils, que es el estándar para la
distribución de módulos de Python.
Con esto le permite instalar fácilmente paquetes de Python, a menudo es suficiente para escribir:
279
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
Temas / Apariencias Por lo general si un producto de Tema esta bien diseñado y implementado debe aplicarse de
una ves al momento de instalarlo. En caso que no se aplique de una puede acceder a la sección Configuración
de Temas302 y cambiar el Tema predeterminado por el de su gusto.
Tipos de contenidos Los tipos de contenidos son productos que extienden la funcionalidad de Agregar elemento
que permite agregar nuevos tipos de registros (Contenidos) a tu sitio. Esto quiere decir que si instala un tipo
de contenido exitosamente debería poder acceder a usarlo desde el menú de Agregar elemento en el sitio
Plone. Opcionalmente algunos productos instalan un panel de control del producto que puede acceder a este
en la sección Configuración de Productos Adicionales303 .
var Diminutivo en singular del termino variable.
variable 1) Una pregunta que debe ser respondida por el usuario cuando esta generando una estructura de esque-
leto de proyecto usando el sistema de plantilla templer. En este caso una variable (var) es una descripción
de la información requerida, texto de ayuda y reglas de validación para garantizar la entrada de usuario
correcta.
2) Una declarativa cuyo valor puede ser variable o constante dentro de un programa Python o en el sistema
operativo.
variables Plural del termino variable.
vars Diminutivo en plural del termino variable.
Workflow Ver Flujo de trabajo.
ZCA
Zope Component Architecture La arquitectura de componentes de Zope (alias ZCA)304 , es un sistema que per-
mite la aplicación y la expedición enchufabilidad complejo basado en objetos que implementan una interfaz.
ZCatalog Ver Catalog.
ZCML Siglas del termino en Ingles Zope Configuration Mark-up Language.
ZCML-slug Los así llamados «ZCML-slugs», era configuraciones que estaban destinados a enlazar dentro
de un directorio una configuración especial en una instalación de Zope, por lo general se ven como
collective.foo-configure.zcml. Estas configuraciones ya no están más en uso, pueden ser eli-
minados agregando las configuraciones del paquete z3c.autoinclude305 .
Zope Configuration Mark-up Language Es un dialecto XML utilizado por Zope para las tareas de configura-
ción. ZCML es capaz de realizar diferentes tipos de declaración de configuración. Es utilizado para extender
y conectar a los sistemas basados en la Zope Component Architecture.
Zope 3 tiene la política de separar el código actual y moverlo a los archivos de configuración independien-
tes, típicamente un archivo configure.zcml en un buildout. Este archivo configura la instancia Zope.
El concepto “Configuración” podría ser un poco engañoso aquí y debe ser pensado o tomarse más cableado.
ZCML, el lenguaje de configuración basado en XML que se utiliza para esto, se adapta a hacer el registro
de componentes y declaraciones de seguridad, en su mayor parte. Al habilitar o deshabilitar ciertos com-
ponentes en ZCML, puede configurar ciertas políticas de la aplicación general. En Zope 2, habilitar y
deshabilitar componentes significa eliminar o remover un determinado producto Zope 2. Cuando está ahí,
se importa y se carga automáticamente. Este no es el caso en Zope 3 Si no habilita explícitamente, no va
a ser encontrado.
El grok proyecto ha adoptado un enfoque diferente para el mismo problema, y permite el registro de com-
ponentes, etc haciendo declarativa de código Python. Ambos enfoques son posibles en Plone.
302 http://localhost:8080/Plone/@@skins-controlpanel
303 http://localhost:8080/Plone/prefs_install_products_form
304 https://plone-spanish-docs.readthedocs.io/es/latest/programacion/zca/zca-es.html
305 https://pypi.org/project/z3c.autoinclude
Licenciamientos
Esta documentación se distribuye bajo los términos de la licencia Reconocimiento-CompartirIgual 3.0 Vene-
zuela de Creative Commons306 .
306 https://creativecommons.org/licenses/by-sa/3.0/ve/
281
Materiales del entrenamiento de programación en Python - Nivel básico, Versión 0.2
283