Módulo 6 Python

Python

0
Módulo 6 Python

Contenido
1 Introducción.............................................................................................................................. 2
2 Instalación ................................................................................................................................. 3
3 Estructura Python ..................................................................................................................... 5
3.1 Comentarios ..................................................................................................................... 5

3.2 Print.................................................................................................................................... 6
3.3 Variables ............................................................................................................................ 6

3.4 Numéricas ......................................................................................................................... 7

3.5 Texto .................................................................................................................................. 7

3.6 Print y variables ................................................................................................................ 8

4 Estructuras de control ............................................................................................................. 9
4.1 Identacion (sangría) ......................................................................................................... 9
4.2 If ......................................................................................................................................... 9
4.3 Condiciones .................................................................................................................... 10
4.4 While ................................................................................................................................ 11
4.5 For .................................................................................................................................... 11
5 Funciones ................................................................................................................................ 13
6 Diccionarios y listas................................................................................................................ 14

6.1 Listas ................................................................................................................................ 14

6.2 Operaciones con listas .................................................................................................. 15

6.3 Diccionarios .................................................................................................................... 15

6.4 Operaciones con diccionarios ...................................................................................... 16

7 Entrada / Salida de archivos ................................................................................................. 17

7.1 Métodos de los objetos archivo .................................................................................. 18

1
Módulo 6 Python

1 Introducción

Podrías escribir un script en el intérprete de comandos o un archivo por lotes de Windows

para algunas de estas tareas, pero los scripts se lucen para mover archivos de un lado a
otro y para modificar datos de texto, no para aplicaciones con interfaz de usuario o
juegos. Podrías escribir un programa en C/C++/Java, pero puede tomar mucho tiempo de
desarrollo obtener al menos un primer borrador del programa. Python es más fácil de
usar, está disponible para sistemas operativos Windows, Mac OS X y Unix, y te ayudará a
realizar tu tarea más velozmente.

Python te permite separar tu programa en módulos que pueden reusarse en otros

programas en Python. Viene con una gran colección de módulos estándar que puedes
usar como base de tus programas, o como ejemplos para empezar a aprender a
programar en Python. Algunos de estos módulos proveen cosas como entrada/salida a
archivos, llamadas al sistema, sockets, e incluso interfaces a sistemas de interfaz gráfica de
usuario como Tk.

Python es un lenguaje interpretado, lo cual puede ahorrarte mucho tiempo durante el

desarrollo ya que no es necesario compilar ni enlazar. El intérprete puede usarse
interactivamente, lo que facilita experimentar con características del lenguaje, escribir
programas descartables, o probar funciones cuando se hace desarrollo de programas de
abajo hacia arriba. Es también una calculadora de escritorio práctica.

2
Módulo 6 Python

2 Instalación

Python es un lenguaje de programación, y por lo tanto nos permite escribir a una

computadora qué es lo que queremos que haga. Python funciona, entre otros, en
Windows, MacOS e incluso Linux.

Los archivos de Python tienen la extensión .py. Son archivos de texto que son
interpretados por el compilador. Para poder ejecutar programas en Python, necesitamos
en primer lugar el intérprete de Python, y en segundo lugar el código que queremos
ejecutar.

Python es “case sensitive”, lo que quiere decir que diferencia mayúscula de minúsculas, y
por lo tanto python y Python, no son lo mismo. La última versión de Python es la 3, pero
tiene el problema de que no es compatible del todo con los programas escritos para la
versión 2.

La versión 2.7 fue la última de la familia 2.x, y se considera obsoleta. A pesar de que la
versión 3 existe desde hace bastantes años, la 2 todavía se usa bastante ya que algunas
librerías externas (como por ejemplo Mechanize) no han sido adaptadas para funcionar
con la versión 3.

Vamos a usar una distribución de Python gratuita llamada Anaconda. Aunque está
disponible sólo en inglés, esta distribución incluye multitud de utilidades que nos
facilitarán el trabajo y es ideal para empezar. Para instalarla, sólo tienes que descargar la

3
Módulo 6 Python

versión de Anaconda para tu sistema operativo desde su página web (te pedirá
tu dirección de email).
Una vez instalado, encontraremos un nuevo folder llamado Anaconda, y varias utilidades
ahí dentro. Jupyter Notebook o IPhyton son las que podemos usar.

Jupyter es un Python “interactivo” que nos va a facilitar mucho el aprendizaje. Vemos que
Anaconda ha instalado dos “sabores” de Jupyter diferentes. Vamos a ejecutar Jupyter
Notebook , y se abrirá una ventana nueva en el navegador de internet.

Haciendo click en New–>Python3 o New–>Python2, veremos la siguiente pantalla, donde

ya podemos empezar a programar.

IPhyton es la consola de Python donde podemos ir probando nuestro código.

4
Módulo 6 Python

3 Estructura Python

3.1 Comentarios

Los comentarios en Python, al igual que sucede en otros lenguajes de programación,

sirven para explicar a las personas que puedan leer el programa en el futuro, qué es lo
que hace el programa, así como explicar algunas partes del código. Estos comentarios
son ignorados por las computadoras cuando ejecutan el código.

Escribir comentarios en Python, aunque requiere un esfuerzo, es una buena práctica y

compensará con creces ese esfuerzo en el futuro.

En Python los comentarios se pueden poner de dos formas:

 Escribiendo el símbolo gato antes de la línea de texto donde está el

comentario (#)
 Escribiendo triple comilla doble (“””) al principio y al final del comentario (que
puede ocupar más de una línea).

Ejemplo

# Esto es un comentario

# Esto también es un comentario de

# dos líneas

5
Módulo 6 Python

# El siguiente comentario es un comentario mixtilíneas

""" Este es un comentario multilinea. La
siguiente parte realiza una serie
de acciones """

3.2 Print

El comando print es de gran utilidad para que el programa pueda comunicarse con
nosotros. Como veremos más adelante, este comando muestra el texto que
pongamos, o incluso el valor que hay dentro de una variable.

3.3 Variables

Una variable es un sitio donde guardamos una determinada información. En función

del tipo de información que guardemos (texto, números, booleanas, etc.), la variable
será de uno u otro tipo.

Cada variable tiene que tener un nombre con el que referirnos a ella. Python tiene en
cuenta si escribimos en mayúsculas o minúsculas la variable (lo que se conoce como
case sensitive). No es lo mismo una variable que se llame e1 que una que se llame E1.

6
Módulo 6 Python

Como es lógico y, para evitar confusiones, el nombre de la variable no puede coincidir

con los nombres de los “comandos” de Python (if, for, etc.). Tampoco podremos usar
nombres de variables con tildes o con ñ.
¿Y por qué hay que decir lo que se mete en cada variable? Porque en función de lo
que haya dentro de ella, se podrán hacer una u otras cosas, como por ejemplo sumar
dos números.

3.4 Numéricas

Hay dos tipos principales, los números enteros (llamados int) y los reales (llamados
float). El separador decimal que tenemos que usar es el punto.

Aunque si no decimos el tipo de número que va a contener, Python intentará decidir

por sí mismo cuál es el más apropiado, esto en ocasiones produce errores.

3.5 Texto

Las variables que almacenan texto se denominan strings (str). Tienen que estar entre
comillas sencillas(‘) o dobles (“), o si el texto ocupa varias líneas, entre triples comillas.

7
Módulo 6 Python

Al igual que sucedía con los números, Python supone que lo que introducimos es un
texto al estar entre comillas, aunque siempre podemos forzarle a interpretarlo como
texto usando el comando str.

3.6 Print y variables

Como hemos visto, el comando print es de gran utilidad para que el programa pueda
comunicarse con nosotros. Este comando muestra el texto que pongamos, o incluso el
valor que hay dentro de una variable. En el caso de que juntemos texto y números,
debemos tomar la precaución de convertir los números en texto, ya que, si no, Python
no sabe cómo se hace la suma de un texto y un número.

8
Módulo 6 Python

4 Estructuras de control

4.1 Identacion (sangría)

Esta es una de las principales señas de identidad de Python y es fuente de una gran
parte de los errores que se producen. En Python, las líneas de código que están dentro
de un mismo.

Deben estar agrupadas, teniendo el mismo número de espacios a la izquierda de cada

línea, al igual que sucedería en la vida real.

En Python, se recomienda usar siempre bloques de cuatro espacios, aunque si se usan

otro número de espacios, también funcionaría. También se pueden usar tabuladores,
aunque se recomienda no usarlos.

4.2 If

En todo programa que se precie, llega el momento en el que se llega a una bifurcación
y que, en función de una determinada condición, hay que realizar una serie de cosas u
otra.

9
Módulo 6 Python

Esto se hace con el comando if (condición principal), con los opcionales elif

(condiciones adicionales, se pueden poner tantas como se quiera) y else (si no se ha

cumplido ninguna de las anteriores, sólo se puede poner una vez y al final).

A modo de ejemplo:

4.3 Condiciones

Las condiciones que se suelen usar con más frecuencia son:

 a == b –> Indica si a es igual a b

 a<b
 a>b
 not –> NO: niega la condición que le sigue.
 and –> Y: junta dos condiciones que tienen que cumplirse las dos
 or –> O: junta dos condiciones y tienen que cumplirse alguna de las dos.

10
Módulo 6 Python

4.4 While

En ocasiones, tenemos que repetir varias veces una determinada tarea hasta conseguir
nuestro objetivo. En Python esto se realiza con el comando while. A modo de ejemplo
while en Python se usa así:

Con los while, hay que tener la precaución de no realizar un “bucle infinito”, que
consiste en un bucle que nunca termina por un error en la programación. En el caso
anterior, esto ocurriría si no hubiéramos puesto la línea vuelta=vuelta+1.

4.5 For

En ocasiones, tenemos que repetir varias veces una determinada tarea hasta conseguir
nuestro objetivo. En Python esto se realiza con el comando for. A modo de ejemplo
for en Python se usa así:

11
Módulo 6 Python

12
Módulo 6 Python

5 Funciones

La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la
función 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 con sangría.

La primera sentencia del cuerpo de la función puede ser opcionalmente una cadena de
texto literal; esta es la cadena de texto de documentación de la función, o docstring.
Hay herramientas que usan las docstrings para producir automáticamente
documentación en línea o imprimible, 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.

Ahora veamos el mismo ejemplo, pero retornando el valor en vez de imprimirlo en la

consola.

13
Módulo 6 Python

6 Diccionarios y listas

6.1 Listas

Son listados de datos en los que hay un orden, por lo que tiene en cuenta la posición
en la que está el elemento. Recuerda que el primer elemento es el número 0, y no el
número 1. En las listas se pueden modificar sus elementos, y puede haber elementos
duplicados. Se crean poniendo sus elementos entre corchetes [a, b, c, >>>].

Las listas tienen una flexibilidad total en los elementos que pueden tener, por lo que
pueden contener no sólo texto, si no también números o cualquier otro tipo de
variables.

14
Módulo 6 Python

6.2 Operaciones con listas

Las operaciones más habituales que se realizan en Python son las siguientes:

 lista[i]: Devuelve el elemento que está en la posición i de la lista.

 lista.pop(i): Devuelve el elemento en la posición i de una lista y luego lo borra.
 lista.append(elemento): Añade elemento al final de la lista.
 lista.insert(i, elemento): Inserta elemento en la posición i.
 lista.extend(lista2): Fusiona lista con lista2.
 lista.remove(elemento): Elimina la primera vez que aparece elemento.

Es importante mencionar que los índices empiezan desde el 0.

6.3 Diccionarios

Como sucede con un diccionario convencional, un diccionario en Python es una

palabra que tiene asociado algo. Al contrario de lo que sucedía en las listas, los
diccionarios no tienen orden.

Se crean poniendo sus elementos entre llaves {“a”:”Alemania”, “b”:”Bermudas”,>>>}. Se

denominan keys a las “palabras” y values a las “definiciones”. Lógicamente, no puede
haber dos keys iguales, aunque sí dos values iguales.

15
Módulo 6 Python

6.4 Operaciones con diccionarios

Es similar a las listas, con el matiz de que, dado que los diccionarios no tienen orden, no
tienen funciones en las que se tenga en cuenta la posición.

 diccionario.get(‘key’): Devuelve el valor que corresponde con la key introducida.

 diccionario.pop(‘key’): Devuelve el valor que corresponde con la key introducida, y
luego borra la key y el valor.
 “key” in diccionario: Devuelve verdadero (True) o falso (False) si la key (no los
valores) existe en el diccionario.
 “definicion” in diccionario.values(): Devuelve verdadero (True) o falso (False) si
definición existe en el diccionario (no como key).

16
Módulo 6 Python

7 Entrada / Salida de archivos

La función open() devuelve un objeto archivo, y es normalmente usado con dos

argumentos: open(nombre_de_archivo, modo).

El primer argumento es una cadena conteniendo el nombre de archivo. El segundo

argumento es otra cadena conteniendo unos pocos caracteres que describen la forma en
que el archivo será usado. El modo puede ser 'r' cuando el archivo será solamente leído,
'w' para sólo escribirlo (un archivo existente con el mismo nombre será borrado), y 'a' abre
el archivo para agregarle información; cualquier dato escrito al archivo será
automáticamente agregado al final. 'r+' abre el archivo tanto para leerlo como para
escribirlo. El argumento modo es opcional; si se omite se asume 'r'.

En Windows, agregando 'b' al modo abre al archivo en modo binario, por lo que también
hay modos como 'rb', 'wb', y 'r+b'. Python en Windows hace una distinción entre archivos
binarios y de texto; los caracteres de fin de línea en los archivos de texto son
automáticamente alterados levemente cuando los datos son leídos o escritos. Esta
modificación en bambalinas para guardar datos está bien con archivos de texto ASCII,
pero corromperá datos binarios como en archivos JPEG o EXE. Sé muy cuidadoso en usar
el modo binario al leer y escribir tales archivos. En Unix, no hay problema en agregarle una
'b' al modo, por lo que podrás usarlo independientemente de la plataforma para todos los
archivos binarios.

17
Módulo 6 Python

7.1 Métodos de los objetos archivo

El resto de los ejemplos en esta sección asumirán que ya se creó un objeto archivo
llamado f.
Para leer el contenido de una archivo llama a f.read(cantidad), el cual lee alguna
cantidad de datos y los devuelve como una cadena. cantidad es un argumento
numérico opcional. Cuando se omite cantidad o es negativo, el contenido entero del
archivo será leído y devuelto; es tu problema si el archivo es el doble de grande que la
memoria de tu máquina. De otra manera, a lo sumo una cantidad de bytes son leídos y
devueltos. Si se alcanzó el fin del archivo, f.read() devolverá una cadena vacía ("").
f.readline() lee una sola línea del archivo; el carácter de fin de línea (\n) se deja al final
de la cadena, y sólo se omite en la última línea del archivo si el mismo no termina en
un fin de línea. Esto hace que el valor de retorno no sea ambiguo; si f.readline()
devuelve una cadena vacía, es que se alcanzó el fin del archivo, mientras que una línea
en blanco es representada por '\n', una cadena conteniendo sólo un único fin de línea.

f.readlines() devuelve una lista conteniendo todas las líneas de datos en el archivo. Si
se da un parámetro opcional size, lee esa cantidad de bytes del archivo y lo
suficientemente más como para completar una línea, y devuelve las líneas de eso. Esto
se usa frecuentemente para permitir una lectura por líneas de forma eficiente en
archivos grandes, sin tener que cargar el archivo entero en memoria. Sólo líneas
completas serán devueltas.

El enfoque alternativo es mucho más simple pero no permite un control fino. Como
los dos enfoques manejan diferente el buffer de líneas, no deberían mezclarse.

18
Módulo 6 Python

f.write(cadena) escribe el contenido de la cadena al archivo, devolviendo None.

Cuando hayas terminado con un archivo, llama a f.close() para cerrarlo y liberar
cualquier recurso del sistema tomado por el archivo abierto. Luego de llamar f.close(),
los intentos de usar el objeto archivo fallarán automáticamente.

19
Módulo 6 Python

20