2015-2016

Bloque 3 - Tema 8
APLICACIONES WEB. DESARROLLO FRONT-END Y
EN SERVIDOR, MULTIPLATAFORMA Y
MULTIDISPOSITIVO. LENGUAJES: HTML, XML Y
SUS DERIVACIONES. NAVEGADORES Y LENGUAJES
DE PROGRAMACIÓN WEB. LENGUAJES DE SCRIPT

PYTHON

PREPARACIÓN OPOSICIONES
TÉCNICOS AUXILIARES DE INFORMÁTICA
B3T8 APLICACIONES WEB - PYTHON TAI

ÍNDICE
ÍNDICE ............................................................................................................................................................ 2
1. INTRODUCCIÓN......................................................................................................................................... 3
1. Tipos de ejecución ................................................................................................................................ 3
2. Ventajas ............................................................................................................................................... 3
2. SINTAXIS BÁSICA ....................................................................................................................................... 5
1. Tipos de datos ...................................................................................................................................... 5
2. Operadores ......................................................................................................................................... 12
3. Variables ............................................................................................................................................ 13
4. Estructuras de control ........................................................................................................................ 13
5. Entrada y salida.................................................................................................................................. 15
6. Funciones ........................................................................................................................................... 16
7. Módulos ............................................................................................................................................. 17
8. Clases ................................................................................................................................................. 18
9. Librerías .............................................................................................................................................. 20
3. FRAMEWORKS ........................................................................................................................................ 21
1. Django ................................................................................................................................................ 21
2. Web2py .............................................................................................................................................. 21
3. Flask ................................................................................................................................................... 21
4. Pyramid .............................................................................................................................................. 21

PABLO ARELLANO [Link] Página 2

B3T8 APLICACIONES WEB - PYTHON TAI

1. INTRODUCCIÓN
Python, creado por Guido van Rossum, es un lenguaje de programación de alto nivel
multiparadigma (imperativo, orientado a objetos, funcional y reflexivo).

Es un lenguaje interpretado, de código abierto bajo licencia Python Software Foundation,

integrable, con una curva de aprendizaje baja.

La versión más reciente de Python es la 3.

1. Tipos de ejecución
- Interpretado en la consola de Python: se ejecuta cada instrucción que introduce el usuario
de manera interactiva.
> python
>>> name = "gente"
>>> print("Hola ", name)

- Interpretado en fichero: se leen y se ejecutan una a una todas las instrucciones del fichero.
> python [Link]

- Compilado a bytecodes: Python "compila" (no es una compilación en sentido estricto ya

que no se genera un código binario) el código fuente de Python a bytecode, y en ese
momento interpreta ese bytecode, ejecutándolo sobre la marcha. Implementaciones:
o CPython: implementación oficial en C.
o Jython: implementación en Java.
o IronPython: implementación para .NET escrita en C#.
o PyPy: implementación en RPython.

- Compilado a ejecutables del sistema: hay distintos paquetes que permiten compilar a un
ejecutable del sistema operativo usado (por ejemplo, pyinstaller).

2. Ventajas
El lenguaje también cuenta con las siguientes ventajas:
- Python no necesita caracteres delimitadores (como las llaves), ya que la estructura de los
bloques se define automáticamente mediante la indentación, que se usa para darle
estructura.

- Si una línea solo cuenta con una instrucción, no se requiere un punto y coma al final de la
línea.

PABLO ARELLANO [Link] Página 3

B3T8 APLICACIONES WEB - PYTHON TAI

- Python no necesita declaraciones de variables.

- Python también ofrece una biblioteca estándar muy amplia.

- Gracias a un intérprete portátil, el lenguaje está disponible en diversas plataformas.

- El desarrollo continuo (gracias a la gran comunidad) está asegurado.

PABLO ARELLANO [Link] Página 4

B3T8 APLICACIONES WEB - PYTHON TAI

2. SINTAXIS BÁSICA
Podemos insertar comentarios dentro de Python de 2 formas:
- ''' ''': comentario multilínea.

- #: comentario de una sola línea (estilo consola).

Ejemplo:
'''
Comentario multilinea en Python
'''
print ("Prueba") # Comentario de una sola linea

1. Tipos de datos
(1) Tipos de datos primitivos SIMPLES
- Números: int y float.
>>> 2+3
5
>>> 5*-2
-10
>>> 5/2
2.5
>>>
5//2
2
>>> (2+3)**2
25

- Boolean: bool. valores lógicos True y False.

>>> 3==3
True
>>> 3.1<=3
False
>>> -1!=1
True

- Cadenas de caracteres: str. El entrecomillado puede ser simple o doble. Es posible

acceder a los caracteres de forma individual con un índice encerrado entre corchetes. Si
se recorre de principio a fin el índice varía entre 0 y longitud-1. Si se recorre de final a
principio el último elemento el índice comienza en -1, decrementándose en una unidad
para sucesivos elementos.

PABLO ARELLANO [Link] Página 5

B3T8 APLICACIONES WEB - PYTHON TAI

0 1 2 3 4 5 6 7

A P R O B A D O
-8 -7 -6 -5 -4 -3 -2 -1

Ejemplo:
'Python'
"123"
'True'
# Cadena vacía
''
# Cadena con un espacio en blanco
' '
# Cambio de línea
'\n'
# Tabulador
'\t'
>>> 'Python'[0]
'P'
>>> 'Python'[1]
'y'
>>> 'Python'[-1]
'n'
# Error
>>> 'Python'[6]

Operaciones:
o c[i:j:k]: subcadena, desde el elemento con índice i hasta el elemento anterior al
índice j, tomando elementos cada k.
o c1 + c2: concatena las cadenas.
o c * n: n copias de la cadena c.
o c1 in c2: True si c1 es una subcadena de c2, False en caso contrario.
o c1 not in c2: operación inversa a la anterior.
>>> 'Me gusta ' + 'Python'
'Me gusta Python'
>>> 'Python' * 3
'PythonPythonPython'
>>> 'y' in 'Python'
True
>>> 'tho' in 'Python'
True
>>> 'to' not in 'Python'
True

Funciones:
o len(c): número de caracteres de c.

PABLO ARELLANO [Link] Página 6

B3T8 APLICACIONES WEB - PYTHON TAI

o min(c): el carácter menor de c.

o max(c): el carácter mayor de c.
o [Link](): cadena c en mayúsculas.
o [Link](): cadena c en minúsculas.
o [Link](): convierte el primer carácter de cada palabra de c a mayúscula.
o [Link](delimitador): lista de subcadenas de c delimitadas por delimitador.
>>> len('Python')
6
>>> min('Python')
'P'
>>> max('Python')
'y'
>>> 'Python'.upper()
'PYTHON'
>>> 'A,B,C'.split(',')
['A', 'B', 'C']
>>> 'I love Python'.split()
['I', 'love', 'Python']

o [Link](valores): cadena c tras sustituir los valores de la secuencia valores en los

marcadores de posición de c. Los marcadores de posición se indican mediante llaves
{} en la cadena c, y el reemplazo de los valores se puede realizar por posición,
indicando en número de orden del valor dentro de las llaves, o por nombre, indicando
el nombre del valor, siempre y cuando los valores se pasen con el formato
nombre=valor.
>>> 'Un {} vale {} {}'.format('€', 1.17, '$')
'Un € vale 1.17 $'
>>> 'Un {2} vale {1} {0}'.format('€', 1.17, '$')
'Un $ vale 1.17 €'
>>> 'Un {moneda1} vale {cambio} {moneda2}'.format(moneda1 = '€', cambio =
1.17, moneda2 = '$')
'Un € vale 1.17 $'

Los marcadores de posición, además de indicar la posición de los valores de reemplazo,

pueden indicar también el formato de estos. Sintaxis:
§ {:n}: alinea el valor a la izquierda rellenando con espacios por la derecha hasta los
n caracteres.
§ {:>n}: alinea el valor a la derecha rellenando con espacios por la izquierda hasta
los n caracteres.
§ {:^n}: alinea el valor en el centro rellenando con espacios por la izquierda y por la
derecha hasta los n caracteres.
§ {:nd}: formatea el valor como un número entero con n caracteres rellenando con
espacios blancos por la izquierda.
§ {:[Link]}: formatea el valor como un número real con un tamaño de n caracteres
(incluido el separador de decimales) y m cifras decimales, rellenando con espacios
blancos por la izquierda.

PABLO ARELLANO [Link] Página 7

B3T8 APLICACIONES WEB - PYTHON TAI

>>> 'Hoy es {:^10}, mañana {:10} y pasado {:>10}'.format('lunes',

'martes', 'miércoles')
'Hoy es lunes , mañana martes y pasado miércoles'
>>> 'Cantidad {:5d}'.format(12)'
'Cantidad 12'
>>> 'Pi vale {:8.4f}'.format(3.141592)
'Pi vale 3.1416'

(2) Tipos de datos primitivos COMPUESTOS (contenedores)

- Listas: list. Secuencias ordenadas de objetos de distintos tipos. Se representan con
corchetes y los elementos se separan por comas. Las listas son mutables, es decir, su valor
puede modificarse durante la ejecución del programa. Es posible acceder a los caracteres
de forma individual con un índice encerrado entre corchetes. Se recorre de principio a fin
y el índice varía entre 0 y longitud-1.
# Lista vacía
>>> type([])
<class 'list'>
# Lista con elementos de distintos tipos
>>> [1, "dos", True]
# Listas anidadas
>>> [1, [2, 3], 4]

Operaciones:
o l[i:j:k]: sublista, desde el elemento con índice i hasta el elemento anterior al índice
j, tomando elementos cada k.
o l1 + l2: concatena las listas.
o dato in l: True si dato está en la lista y False en caso contrario.

Funciones:
o list(c): crea una lista c.
o len(l): número de elementos.
o min(l): mínimo elemento de la lista (si los datos son comparables).
o max(l): máximo elemento de la lista (si los datos son comparables).
o sum(l): suma de los elementos de la lista (si los datos se pueden sumar).
o [Link](dato): posición en la lista del primero elemento con valor dato.
o [Link](dato): número de veces que el valor dato aparece en la lista.
o [Link](dato): añade dato al final de la lista.
o [Link](indice,dato): inserta dato en la posición índice y desplaza el resto de
elementos a partir de esa posición.
o [Link](dato): elimina el primer elemento con valor dato y desplaza el resto de
elementos hacia la izquierda.
o [Link](indice): devuelve el dato situado en la posición índice y lo elimina de la lista,
desplazando el resto de elementos hacia la izquierda.

PABLO ARELLANO [Link] Página 8

B3T8 APLICACIONES WEB - PYTHON TAI

o [Link](): ordena los elementos de la lista.

o [Link](): invierte el orden de los elementos de la lista.
o all(l): True si todos los elementos de la lista son True y False en caso contrario.
o any(l): True si algún elemento de la lista es True y False en caso contrario.
>>> list()
[]
>>> list(1, 2, 3)
[1, 2, 3]
>>> list("Python")
['P', 'y', 't', 'h', 'o', 'n']
>>> a = ['P', 'y', 't', 'h', 'o', 'n']
>>> a[0]
'P'
>>> a[5]
'n'
>>> a[-1]
'n'
>>> a = ['P', 'y', 't', 'h', 'o', 'n']
>>> a[1:4]
['y', 't', 'h']
>>> a[1:1]
[]
>>> a[:-3]
['P', 'y', 't']
>>> a[:]
['P', 'y', 't', 'h', 'o', 'n']
>>> a[0:6:2]
['P', 't', 'o']
>>> a = [1, 2, 2, 3]
>>> len(a)
4
>>> min(a)
1
>>> max(a)
3
>>> sum(a)
8
>>> 3 in a
True
>>> [Link](2)
1
>>> [Link](2)
2
>>> all(a)
True
>>> any([0, False, 3<2])
False
>>> a = [1, 3]
>>> b = [2 , 4, 6]
>>> [Link](5)
>>> a
[1, 3, 5]
>>> [Link](3)
>>> a
[1, 5]
>>> [Link](1, 3)

PABLO ARELLANO [Link] Página 9

B3T8 APLICACIONES WEB - PYTHON TAI

>>> a
[1, 3, 5]
>>> [Link]()
6
>>> c = a + b
>>> c
[1, 3, 5, 2, 4]
>>> [Link]()
>>> c
[1, 2, 3, 4, 5]
>>> [Link]()
>>> c
[5, 4, 3, 2, 1]

- Tuplas: tuple. Secuencias ordenadas de objetos de distintos tipos. A diferencia de las listas
son inmutables, es decir, que no cambian durante la ejecución. Se representan mediante
paréntesis y los elementos se separan por comas.

Funciones:
o tuple(c): crea una tupla.
>>> tuple(1, 2, 3)
(1, 2, 3)
>>> tuple("Python")
('P', 'y', 't', 'h', 'o', 'n')
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> a = (1, 2, 3)
>>> a[1]
2
>>> len(a)
3
>>> [Link](3)
2
>>> 0 in a
False
>>> b = ((1, 2, 3), (4, 5, 6))
>>> b[1]
(4, 5, 6)
>>> b[1][2]
6

Las funciones y operaciones son las mismas que para listas (teniendo en cuenta que no se
pueden variar los datos).

- Diccionarios: dict. Colección de pares formados por una clave y un valor asociado a la
clave. Se representan con llaves, los pares separados por comas y cada par contiene una
clave y un objeto asociado separados por dos puntos. Estos objetos son mutables. Como
restricción las claves han de ser únicas, no pudiéndose repetir en un mismo diccionario.
# Diccionario con elementos de distintos tipos
{'nombre':'Pablo', 'aula': 23, 'email':'pablo@[Link]'}
# Diccionarios anidados
{'nombre_completo':{'nombre': 'Pablo', 'Apellidos': 'Arellano'}}

PABLO ARELLANO [Link] Página 10

B3T8 APLICACIONES WEB - PYTHON TAI

Operaciones:
o d[clave]: devuelve el valor asociado a la clave clave. Si no existe devuelve error.
o d[clave]=valor: añade al diccionario el par (clave,valor).
o clave in d: True si clave pertenece al diccionario, False en caso contrario.
o del d[clave]: elimina del diccionario el par con clave clave.
>>> a = {'nombre':'Pablo', 'aula': 23, 'email':'pablo@[Link]'}
>>> a['nombre']
'Pablo'
>>> a['dia'] = 'jueves'
>>> a
{'nombre':'Pablo', 'aula': 23, 'email':'pablo@[Link]', 'dia':'jueves'}
>>> 'email' in a
True
>>> del a['email']

Funciones:
o len(d): número de elementos del diccionario.
o min(d): mínima clave del diccionario.
o max(d): máxima clave del diccionario.
o sum(d): suma las claves del diccionario, siempre que se puedan sumar.
o [Link](clave): devuelve el valor asociado a la clave, en caso contrario None.
o [Link](): iterador sobre las claves de un diccionario.
o [Link](): iterador sobre los valores de un diccionario.
o [Link](): iterador sobre los pares (clave,valor) de un diccionario.
o [Link](): devuelve el último par (clave,valor) añadido.
o [Link](): elimina todos los pares del diccionario.
>>> a = {'nombre':Pablo, 'aula': 23, 'email':'pablo@[Link]'}
>>> len(a)
3
>>> min(a)
'aula'
>>> [Link]('email')
pablo@[Link]
>>> [Link]('email','pablo@[Link]')
pablo@[Link]
>>> [Link]()
dict_keys(['nombre', 'aula', 'email'])
>>> [Link]()
dict_values(['Pablo', 23, 'pablo@[Link]'])
>>> [Link]()
dict_items([('nombre', 'Pablo'), ('aula', 23), ('email',
'pablo@[Link]')])
>>> [Link]()
>>> a
{}

PABLO ARELLANO [Link] Página 11

B3T8 APLICACIONES WEB - PYTHON TAI

Para conocer la clase de un dato se utiliza el comando type().

>>> type(1)
<class 'int'>
>>> type(-2)
<class 'int'>
>>> type(2.3)
<class 'float'>
>>> type("Hola")
<class 'str'>
>>> type([1, "dos", [3, 4], True])
<class 'list'>
>>>type({'pi':3.1416, 'e':2.718})
<class 'dict'>
>>>type((1, 'dos', 3))
<class 'tuple'>

2. Operadores
OPERADOR DESCRIPCIÓN
** Exponenciación
+ Suma
- Cambio de signo. Admite un operador
* Multiplicación
/ División
// División entera
% Módulo
== Igual que
!= Distinto de
< Menor que
<= Menor o igual que
> Mayor que
>= Mayor o igual que
not Negación
and Conjunción
or Disyunción

PABLO ARELLANO [Link] Página 12

B3T8 APLICACIONES WEB - PYTHON TAI

3. Variables
Una variable es un identificador ligado a algún valor (Python es case sensitive). Las reglas para
nombrarlas son:
- Comienzan siempre por una letra o guion bajo, seguido de otras letras, números o guiones
bajos.
- No se pueden utilizarse palabras reservadas del lenguaje.

A diferencia de otros lenguajes no tienen asociado un tipo y no es necesario declararlas antes

de usarlas (tipado dinámico).

Para asignar un valor a una variable se utiliza el operador = y para borrar una variable se utiliza
la instrucción del.
lenguaje = 'Python'
x = 3.14
y = 3 + 2
# Asignación múltiple
a1, a2 = 1, 2
# Intercambio de valores
a, b = b, a
# Incremento (equivale a x = x + 2)
x += 2
# Decremento (equivale a x = x - 1)
x -= 1
# Valor no definido
x = None
del x

4. Estructuras de control
- Condicionales (if): evalúa la expresión lógica condición1 y ejecuta el primer bloque de
código si es True; si no, evalúa las siguientes condiciones hasta llegar a la primera que es
True y ejecuta el bloque de código asociado. Si ninguna condición es True ejecuta el bloque
de código después de else:. Pueden aparecer varios bloques elif pero solo uno else al
final. Sintaxis:
if condición1: _bloque código_ `elif` condición2: _bloque código_
... `else`: _bloque código_

>>> edad = 14
>>> if edad <= 18 :
... print('Menor')
... elif edad > 65:
... print('Jubilado')
... else:
... print('Activo')
...
Menor
>>> age = 20
>>> if edad <= 18 :
... print('Menor')

PABLO ARELLANO [Link] Página 13

B3T8 APLICACIONES WEB - PYTHON TAI

... elif edad > 65:

... print('Jubilado')
... else:
... print('Activo')
...
Activo

- Bucles condicionales (while): repite la ejecución del bloque de código mientras la

expresión lógica condición sea cierta. Se puede interrumpir en cualquier momento la
ejecución del bloque de código con la instrucción break. Sintaxis:
while condición:
bloque código

>>> # Pregunta al usuario por un número hasta que introduce 0.

>>> num = None
>>> while num != 0:
... num = int(input('Introduce un número: '))
...
Introduce un número: 2
Introduce un número: 1
Introduce un número: 0
>>>

- Bucles iterativos (for): repite la ejecución del bloque de código para cada elemento de la
secuencia secuencia, asignando dicho elemento a i en cada repetición. Se puede
interrumpir en cualquier momento la ejecución del bloque de código con la instrucción
break o saltar la ejecución para un determinado elemento de la secuencia con la
instrucción continue. Sintaxis:
for i in secuencia:
bloque código

>>> palabra = 'Python'

>>> for letra in palabra:
... print(letra)

La función range() permite iterar sobre una secuencia de números:

>>> for i in range(5):
... print(i)

range(start, stop, step). Argumentos:

o start: inicio (valor por defecto 0).

o stop: fin (parámetro obligatorio). El valor stop queda fuera de la secuencia.

o step: salto (valor por defecto 1).

>>> list(range(5, 10))

[5, 6, 7, 8, 9]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(-10, -100, -30))
[-10, -40, -70]

PABLO ARELLANO [Link] Página 14

B3T8 APLICACIONES WEB - PYTHON TAI

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

>>> for i in range(len(a)):
... print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

5. Entrada y salida
- input(mensaje): muestra la cadena mensaje por la salida estándar y devuelve una cadena
con la entrada del usuario.
>>> language = input('¿Cuál es tu lenguaje favorito? ')
¿Cuál es tu lenguaje favorito? Python
>>> language
'Python'
>>> age = input('¿Cuál es tu edad? ')
¿Cuál es tu edad? 20
>>> age
'20'

- print(dato1, ..., sep=' ', end='\n', file=[Link]): muestra datos por la salida
estándar. Argumentos:
o dato1, ... son los datos a imprimir y pueden indicarse tantos como se quieran
separados por comas.
o sep establece el separador entre los datos Por defecto es un espacio en blanco ' '.
o end indica la cadena final de la impresión, que por defecto es un cambio de línea \n.
o file indica la dirección del flujo de salida, que por defecto es la salida estándar
[Link].
>>> print('Hola')
Hola
>>> name = 'Pablo'
>>> print('Hola', name)
Hola Pablo
>>> print('El valor de pi es', 3.1415)
El valor de pi es 3.1415
>>> print('Hola', name, sep='')
HolaAlf
>>> print('Hola', name, end='!\n')
Hola Pablo!
>>> print("Java"*4 + "Linux" )
JavaJavaJavaJavaLinux

PABLO ARELLANO [Link] Página 15

B3T8 APLICACIONES WEB - PYTHON TAI

6. Funciones
Una función es un bloque de código que tiene asociado un nombre, de manera que cada vez
que se quiera ejecutar el bloque de código basta con invocar el nombre de la función. Para
declarar una función se utiliza la siguiente sintaxis:
def <nombre-funcion> (<parámetros>):
bloque código
return <objeto>

>>> def bienvenida():

... print('¡Bienvenido a Python!')
... return
...
>>> type(bienvenida)
<class 'function'>
>>> bienvenida()
¡Bienvenido a Python!

Respecto a los parámetros de la función, se pueden indicar los argumentos en la llamada a la

función de dos maneras:
- Argumentos posicionales: se asocian a los parámetros de la función en el mismo orden
que aparecen en la definición de la función.
- Argumentos por nombre: se indica explícitamente el nombre del parámetro al que se
asocia un argumento de la forma parametro=argumento.

>>> def bienvenida(nombre, apellido):

... print('¡Bienvenido a Python', nombre, apellido + '!')
... return
...
>>> bienvenida('Pablo', 'Arellano')
¡Bienvenido a Python Pablo Arellano!
>>> bienvenida(apellido = 'Arellano', nombre = 'Pablo')
¡Bienvenido a Python Pablo Arellano!

En Python el paso de argumentos a una función es siempre por referencia, es decir, se pasa
una referencia al objeto del argumento, de manera que cualquier cambio que se haga dentro
de la función mediante el parámetro asociado afectará al objeto original, siempre y cuando
este sea mutable.
>>> primer_curso = ['Matemáticas', 'Física']
>>> def añade_asignatura(curso, asignatura):
... [Link](asignatura)
... return
...
>>> añade_asignatura(primer_curso, 'Química')
>>> print(primer_curso)
['Matemáticas', 'Física', 'Química']

En la definición de una función se puede asignar a cada parámetro un argumento por defecto,
de manera que, si se invoca la función sin proporcionar ningún argumento para ese
parámetro, se utiliza el argumento por defecto.

PABLO ARELLANO [Link] Página 16

B3T8 APLICACIONES WEB - PYTHON TAI

>>> def bienvenida(nombre, lenguaje = 'Python'):

... print('¡Bienvenido a', lenguaje, nombre + '!')
... return
...
>>> bienvenida('Pablo')
¡Bienvenido a Python Pablo!
>>> bienvenida('Pablo', 'PHP')
¡Bienvenido a PHP Pablo!

Los parámetros y las variables declaradas dentro de una función son de ámbito local, mientras
que las definidas fuera de ella son de ámbito ámbito global.

Una función puede devolver un objeto de cualquier tipo tras su invocación. Para ello el objeto
a devolver debe escribirse detrás de la palabra reservada return. Si no se indica ningún objeto,
la función no devolverá nada.
>>> def area_triangulo(base, altura):
... return base * altura / 2
...
>>> area_triangulo(2, 3)
3
>>> area_triangulo(4, 5)
10

7. Módulos
El código de un programa en Python puede reutilizarse en otro importándolo. Cualquier
fichero con código de Python reutilizable se conoce como módulo.

Los módulos suelen contener funciones reutilizables, pero también pueden definir variables
con datos simples o compuestos (listas, diccionarios, etc), o cualquier otro código válido en
Python.

Python permite importar un módulo completo o sólo algunas partes de él. Cuando se importa
un módulo completo, el intérprete de Python ejecuta todo el código que contiene el módulo,
mientras que si solo se importan algunas partes del módulo, solo se ejecutarán esas partes.

Para importar un módulo completo, import M. Ejecuta el código que contiene M y crea una
referencia a él, de manera que pueden invocarse un objeto o función f definida en él mediante
la sintaxis M.f.
>>> import calendar
>>> print([Link](2020, 6))
June 2020
Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30

PABLO ARELLANO [Link] Página 17

B3T8 APLICACIONES WEB - PYTHON TAI

Para importar parcialmente un módulo tenemos dos opciones. Con from M import * se crea
referencia a todos los objetos públicos (aquellos que no comienzan por _) de M y con from M
import f, g,... crea referencias a los objetos enumerados f, g, …
>>> from math import *
>>> cos(pi)
-1.0

Módulos predefinidos
Son aquellos que no necesitan importación explícita por parte del programador. Podemos
destacar:
- sys: funciones y parámetros específicos del sistema operativo.

- os: Interfaz con el sistema operativo.

- [Link]: funciones de acceso a las rutas del sistema.

- io: funciones para manejo de flujos de datos y ficheros.

- string: funciones con cadenas de caracteres.

- datetime: funciones para fechas y horas.

- math: funciones y constantes matemáticas.

- statistics: funciones estadísticas.

- random: generación de números pseudoaleatorios.

8. Clases
Para declarar una clase se utiliza la palabra clave class seguida del nombre de la clase y dos
puntos, de acuerdo a la siguiente sintaxis:
class <nombre-clase>:
<atributos>
<métodos>

Los atributos se definen igual que las variables mientras que los métodos se definen igual que
las funciones. La única diferencia es que su primer parámetro es especial y se denomina self.
Este parámetro hace siempre referencia al objeto desde donde se llama el método, de manera
que para acceder a los atributos o métodos de una clase en su propia definición se puede
utilizar la sintaxis [Link] o self.método.

En la definición de una clase suele haber un método llamado __init__ que se conoce como
inicializador. Este método es un método especial que se llama cada vez que se instancia una
clase y sirve para inicializar el objeto que se crea.
class Tarjeta:
... def __init__(self, id, cantidad = 0): # Inicializador
[Link] = id # Creación atributo id
... [Link] = cantidad # Creación atributo saldo
... return

PABLO ARELLANO [Link] Página 18

B3T8 APLICACIONES WEB - PYTHON TAI

... def mostrar_saldo(self):

... print('El saldo es', [Link], '€')
... return
>>> t = Tarjeta('1111111111', 1000) # Creación objeto con argumentos
>>> t.muestra_saldo()
El saldo es 1000 €

Los atributos que se crean dentro del método __init__ se conocen como atributos del objeto,
mientras que los que se crean fuera de él se conocen como atributos de la clase.
>>> class Circulo:
... pi = 3.14159 # Atributo de clase
... def __init__(self, radio):
... [Link] = radio # Atributo de instancia
... def area(self):
... return [Link] * [Link] ** 2
...
>>> c1 = Circulo(2)
>>> c2 = Circulo(3)
>>> print([Link]())
12.56636
>>> print([Link]())
28.27431
>>> print([Link])
3.14159
>>> print([Link])
3.14159

Para implementar herencia se pone detrás del nombre de la subclase entre paréntesis los
nombres de las clases de las que hereda.
>>> class Tarjeta:
... def __init__(self, id, cantidad = 0):
... [Link] = id
... [Link] = cantidad
... return
... def mostrar_saldo(self): # Método clase Tarjeta que hereda de
Tarjeta_descuento
... print('El saldo es', [Link], '€.')
... return
...
>>> class Tarjeta_descuento(Tarjeta):
... def __init__(self, id, descuento, cantidad = 0):
... [Link] = id
... [Link] = descuento
... [Link] = cantidad
... return
... def mostrar_descuento(self): # Método exclusivo de la clase
Tarjeta_descuento
... print('Descuento de', [Link], '% en los pagos.')
... return
...
>>> t = Tarjeta_descuento('0123456789', 2, 1000)
>>> t.mostrar_saldo()
El saldo es 1000 €.
>>> t.mostrar_descuento()
Descuento de 2 % en los pagos.

PABLO ARELLANO [Link] Página 19

B3T8 APLICACIONES WEB - PYTHON TAI

9. Librerías
Se citan las librerías/bibliotecas más relevantes:
- Keras: librería que permite construir y entrenar modelos de aprendizaje automático
(Machine Learning).

- Matplotlib: librería para la generación de visualizaciones estáticas, animadas e

interactivas a partir de datos contenidos en listas o arrays en el lenguaje de programación
Python y su extensión matemática NumPy. Seaborn, Bokeh y Plotly son otras librerías de
visualización de datos.

- NLTK (Natural Lenguage ToolKit): librería para el procesamiento del lenguaje natural.

- NumPy: especializada en el cálculo matemático y en el análisis de grandes volúmenes de

datos. Permite trabajar con arrays que permiten representar colecciones de datos de un
mismo tipo en varias dimensiones, además de funciones muy eficientes para su
manipulación.

- Pandas: una de las librerías más utilizadas para el tratamiento de datos en Python. Esta
herramienta de análisis y manipulación de datos se caracteriza, entre otros aspectos, por
definir nuevas funcionalidades de datos basadas en los arrays de la librería NumPy.
Permite leer y escribir fácilmente ficheros en formato CSV, Excel y especificar consultas a
bases de datos SQL.

- Pillow: librería para el manejo de imágenes.

- PyTorch: librería de aprendizaje automático.

- SciPy: presenta una colección de algoritmos matemáticos y funciones construidas sobre

la extensión de NumPy. Incluye módulos de extensión para Python sobre estadística,
optimización, integración, álgebra lineal o procesamiento de imágenes, entre otros.

- Scikit-Learn: librería que implementa una gran cantidad de algoritmos de Machine

Learning para tareas de clasificación, regresión, clustering y reducción de
dimensionalidad.

- TensorFlow: librería permite construir y entrenar modelos de aprendizaje automático.

PABLO ARELLANO [Link] Página 20

B3T8 APLICACIONES WEB - PYTHON TAI

3. FRAMEWORKS

1. Django
Framework de código abierto bajo licencia BSD para desarrollo web siguiendo el patrón MVC.
Como características destacables están la extensibilidad, la reutilización de componentes, la
escalabilidad y la seguridad. La última versión estable es la 5.

2. Web2py
Framework de código abierto, bajo licencia LGPL v3, para el desarrollo ágil de aplicaciones
web seguras conectadas a servicios de bases de datos, conteniendo todos los componentes
necesarios para crear aplicaciones web totalmente funcionales. Usa el patrón MVC.

3. Flask
Considerado un microframework dirigido al desarrollo de aplicaciones web de forma rápida.

4. Pyramid
Framework sencillo, rápido y flexible. Utilizado en desarrollos web grandes o para diseño de
prototipos.

PABLO ARELLANO [Link] Página 21