Introducción a la programación en GAE con Python

Tema 1: Introducción a Python

Contenido
Tema 1: Introducción a Python..................................................................................................................1
1 Introducción........................................................................................................................................2
2 Trabajo básico con Python.................................................................................................................2
3 Consola...............................................................................................................................................4
4 Tipos de datos.....................................................................................................................................4
4.1 Números......................................................................................................................................5
4.2 Cadenas.......................................................................................................................................6
5 Decisión............................................................................................................................................10
6 Problemas de indentación.................................................................................................................11
7 Repetición.........................................................................................................................................11
8 Funciones..........................................................................................................................................14
8.1 Paso de parámetros...................................................................................................................15
8.2 Devolución de más de un elemento..........................................................................................16
8.3 Funciones dentro de funciones.................................................................................................17
8.4 Documentación.........................................................................................................................17
9 Referencias.......................................................................................................................................20
10 Ejercicios resueltos.........................................................................................................................20
11 Ejercicios........................................................................................................................................22

Introducción-1
Introducción a la programación en GAE con Python

1 Introducción
Python es un lenguaje de programación de concepción muy reciente, 1991. Ha tenido un desarrollo en
el tiempo similar al de Java, aunque sin contar con las agresivas campañas publicitarias de este. Su
fama, por tanto, ha sido más reducida en un principio, para ir ganando adeptos con el paso del tiempo,
incluyendo hoy en día grandes firmas de prestigio que son anunciados en la web del lenguaje,
Python.org1. Para darse cuenta del prestigio que tiene Python, sólo es necesario comentar que entre
estas firmas están Google, NASA, Industrial Light & Magic, Youtube, EVE online...
Este lenguaje de programación basa su éxito en su extrema flexibilidad, derivada del hecho de
ser dinámico. Como tal, no existen tipos, y los errores se descubren en el momento de ejecutar la
aplicación, si bien también es posible ejecutar un detector de errores opcional.
Otros lenguajes han seguido la estela de Python, como Ruby, que ha tomado la inspiración en su
dinamicidad, o Boo, con el que está intimamente ligado, pues Boo respeta toda la sintaxis de Python,
añadiendo verificación de errores de tipos en tiempo de compilación.
El lenguaje tiene una máquina virtual, de manera que la primera vez que un programa es
ejecutado se compila, y se ejecuta, y a partir de ahí, si no ha habido cambios en el programa fuente,
sólo se ejecuta.
Python está en proceso de cambiar de versión en el momento de escribir este documento: la
versión 3 ha alcanzado la revisión 3.4, mientras que el equivalente antiguo, Python 2.7, no volverá a a
ser actualizado. Python 3 incorpora cambios que no son compatibles con Python 2. Sin embargo,
existen numerosas aplicaciones y librerías que aún dependen de Python 2. Así, a lo largo de este texto
se tratará de ofrecer los conceptos según la versión Python 3, diferenciando donde sea necesario la
forma de obtener el mismo comportamiento en Python 2.

2 Trabajo básico con Python

Python se distribuye como un compilador/máquina virtual/entorno de consola, así como con un entorno
gráfico llamado IDLE.
En cuanto al primero, si en una consola del sistema operativo se teclea 2 simplemente 'python',
entonces entra en un entorno que permite ejecutar expresiones y sentencias individualmente. En este
modo, llamando a quit() es posible volver al sistema operativo.

1 http://www.python.org/
2 En muchos sistemas (especialmente Linux y otros derivados de UNIX), es posible seleccionar la versión de Python
tecleando 'python2' o 'python3'.

Introducción-2
Introducción a la programación en GAE con Python

$ python
Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (In
tel)] on win32
Type "help", "copyright", "credits" or "license" for more information.

>>> print("¡hola, mundo!")

¡hola, mundo!
>>> quit()

Por supuesto, es perfectamente posible crear un programa Python (un archivo con extensión
.py), e indicarle a Python que lo ejecute.
$ echo print('Hola!')>hola.py
$ python hola.py
Hola!

En el ejemplo anterior, se crea un archivo hola.py mediante el comando echo (que simplemente
repite lo que aparezca a su derecha), redireccionando la salida hacia un archivo mediante el operador >.
A continuación, se le indica a Python que ejecute el archivo, con lo que se muestra Hola! por pantalla.
En cuanto a IDLE, se trata del mismo entorno interactivo descrito más arriba, pero en un
entorno gráfico, lo que puede hacer el trabajo con él más cómodo.

Python es un lenguaje de programación dinámico. Entre otras cosas, esto quiere decir que no se
realizan apenas comprobaciones en el momento de compilar, sino que los errores salen a relucir en el
momento de la ejecución.
Otro aspecto importante es que, mientras la mayoría de los lenguajes de programación tienen un
punto de entrada (una función que suele llamarse main()), en Python el punto de entrada es la primera
instrucción que no está dentro de una función o método de un objeto. Así, las variables que se crean son
inmediatamente globales.

Introducción-3
Introducción a la programación en GAE con Python

3 Consola
La salida por consola se obtiene mediante la función print(). La entrada por consola la realiza la
función input().

# Lectura de un número por teclado

x = input("Introduzca numero: ")
num = float(x)
print("El numero es {0:.2f}, y su doble es {1:.2f}".format(num, num * 2))

El carácter '#' indica que la línea es un comentario, y se descarta. Además... ¡no se usan puntos y
coma (';') para indicar el fin de línea! El cambio de línea es el indicador de fin de sentencia, excepto
cuando se trata de una expresión encerrada entre parántesis.
El valor devuelto por input() es, obviamente, una cadena, que habrá que convertir a número si
se desea operar con él. Nótese que si la cadena no contiene un número, se producirá una excepción en
tiempo de ejecución.
Cada par de llaves '{}' encierra una argumento. El número dentro de las llaves es opcional, pero
si existe, debe indexar alguno de los argumentos del método format(). Si se desea, tras dos puntos, se
pueden poner delimitadores de campos, y escritores de tipos, nombrados como los de C: d entero, f
flotante...
En el caso de Python 2, print no es una función, sino un operador (no precisa paréntesis) y el
equivalente para obtener la entrada es raw_input(). Además, para formatear una cadena se emplea un
proceso más arcaico, claramente inspirado en el lenguaje de programación C. Lo siguiente es el código
que aparece más arriba, en su versión para Python 2.

x = raw_input("Introduzca numero: ")

num = float(x)
print("El numero es %.2f, y su doble es %.2f" % (num, num * 2))

4 Tipos de datos
Como tal, ya se ha indicado que en Python no existen los tipos, si no que cada variable adopta en cada
momento el tipo al que pertenece el valor que referencia. Evidentemente, hay varios tipos de valores,
que en caso de Python se reducen a tres en cuanto a los básicos: números, cadenas y listas. Nótese que
el lenguaje evita distinguir entre enteros pequeños (short int), o largos (long int), y otros,
consideraciones de lenguajes de programación de más bajo nivel como C o C++.

Introducción-4
Introducción a la programación en GAE con Python

4.1 Números
Los tipos de números soportados son entero y real, aunque debe tenerse en cuenta que en Python no
existen los tipos como tal, así que una variable puede contener un valor entero en un momento, y otro
real al siguiente.

i = 5
print(i)

i = 7.8
print(i)

i, j = 4, 5.8
print(i, j)

La última asignación demuestra una forma curiosa de trabajar en cuanto a la evaluación de

expresiones en Python: las expresiones a la derecha del igual, separadas por comas, se evalúan de
izquierda a derecha, para entonces asignar los valores a las variables respectivas en el lado izquierdo
del igual.
Los operadores aplicables a números en Python son los habituales en los lenguajes de
programación actuales.

Operador Significado Ejemplo

= Asignación x = 5 # x pasa a tener valor 5

== Comparación 6 == 7 # False

+ Suma 6 + 7 # 13

- Resta 7 – 5 # 2

* Multiplicación 2 * 4 # 8

/ División3 4 / 2 # 2

% Resto 8 % 3 # 2

** Potencia 8 ** 2 # 64

+= Incrementa45 x += 1 # x == 6 # x se incrementa

Introducción-5
Introducción a la programación en GAE con Python

La función str() convierte un número a cadena. Existen muchas otras funciones generalistas,
como por ejemplo, abs(), que devuelve el valor absoluto.
La salida del ejemplo es:

6
7.8
4 5.8

4.2 Cadenas
Las cadenas se pueden enmarcar con comillas simples o dobles, indicando con '\' que una cadena va
más allá de la línea actual. Admite también, al igual que en C, los códigos de escape como '\n'. Python
no se quejará en ningún caso. Cuando las comillas simples o dobles se utilizan de forma triple,
entonces el contenido se toma de manera exacta, incluyendo los cambios de línea como si fueran saltos
de línea dentro de la cadena. Así, por ejemplo:

str1 = “Esto es una\n\

prueba.”
print(str1)

Y el código
str1 = """Esto es una
prueba"""
print(str1)

Provocan la misma salida:

Esto es una
prueba

El operador más ('+') se utiliza para concatenar cadenas. El operador de multiplicación ('*') crea
copias de una cadena. Nótese que ninguna de las cadenas que intervienen en la operación de
concatenación se ve modificada, sino que se crea una nueva cadena.

3 En Python 2, las divisiones no devuelven un número real, sino que se truncan al número entero más próximo. En
Python 3, las divisiones devuelven un número real. Para obtener un número entero, es necesario utilizar '//'.
4 Es importante tener en cuenta que los operadores ++ o – NO existen. En su lugar, se puede emplear n += 1.
5 De la misma forma que existe +=, también se puede emplear -=, *=, y /=, con el mismo efecto.

Introducción-6
Introducción a la programación en GAE con Python

word = 'Help' + 'A'

print(word)
print(len(word))

word = '<' + word * 5 + '>'

print(word)

La salida sería:
5
'HelpA'
'<HelpAHelpAHelpAHelpAHelpA>'

Es posible acceder a los elementos individuales de una cadena utilizando las mismas técnicas
que en una lista6, es decir, indicando el índice de comienzo y el de final separados por dos puntos, entre
corchetes. La función len() devuelve el tamaño de la cadena.

print(word[4])
print(word[0:2])
print(word[2:4])

Provocaría la siguiente salida:

A
He
lp

Las funciones para pasar de cadena a número son int(), float(); mientras que de número a
cadena se emplea str(). A continuación se muestran varios ejemplos:

6 Las listas se verán en detalle en el siguiente tema. Esta forma de tomar un trozo de una cadena o lista se denomina
slicing.

Introducción-7
Introducción a la programación en GAE con Python

nombre = "Baltasar"
print(nombre + ":" + nombre[0:3])

i = 6
strI = str(i)
print(strI + " " + nombre)

j = int("78")
print(j + i)

La salida es la siguiente:

Baltasar:Bal
6 Baltasar
84

Las cadenas son objetos7 y tienen otros muchos métodos, como por ejemplo, upper(), lower(),
capitalize()...

str = “PyTHon”

print(str.upper())
print(str.lower())
print(str.capitalize())

La salida es la siguiente:

PYTHON
python
Python

7 La orientación de objetos de Python todavía no se ha estudiado. Por el momento, baste saber que dada una cadena,
puede llamar a una función embebida en ella, colocando un punto, y a continuación, el nombre de esa función y sus
argumentos.

Introducción-8
Introducción a la programación en GAE con Python

5 Decisión
En lenguajes basados en la sintaxis de C, la condición que involucra una sentencia de decisión se
encierra entre paréntesis. En Python, esto no es necesario.
Sintaxis
if <condición>:
sentencia1
sentencia2
…
sentenciaN
else:
sentencia1
sentencia2
…
sentenciaN

Por primera vez, aparece la peculiar manera de Python de especificar un bloque de código:
mediante la indentación de las sentencias que lo componen hacia la derecha, precedido por dos puntos
(':'). No se utiliza ningún delimitador al margen de la indentación. Colocar el código de nuevo hacia la
izquierda, es la manera de indicar el final del bloque.
Ejemplo
if n % 2 == 0:
print(“El número es par.”)
else:
print(“El número es par.”)

Es también posible encadenar varios if. Debido a la necesaria indentación con else, unos pocos
if's encadenados llevarían el código enseguida demasiado a la derecha. Para ello, se puede utilizar una
palabra clave combinación de ambas: elif.
n = 6

if n < 10:
print("Menor que 10")
elif n < 50:
print("Menor que 50")
elif n < 100:
print("Menor que 100")

Introducción-9
Introducción a la programación en GAE con Python

6 Problemas de indentación
El uso por parte de Python de la indentación como indicativo de bloque de código, involucra ciertos
problemas. Por ejemplo, este código no funciona:
n = 6

if n < 10:
print("Menor que 10")
elif n < 50:
print("Menor que 50")
elif n < 100:
print("Menor que 100")

En Python2, Es posible utilizar dos caracteres para realizar indentación (el tabulador ('\t', ASCII
#9), así como el espacio (' ', ASCII #32)), siempre y cuando no aparezcan mezclados; mientras que
Python3 solamente acepta el espacio. Es decir, es posible configurar un editor avanzado como Geany o
Notepad++ para que emplee cuatro espacios al pulsar la tecla de tabulación, y mientras se emplee de
manera consistente no supondrá ningún problema. Sin embargo, si ese código se edita posteriormente
en un editor de textos sencillo como Notepad o Leafpad, que no aceptan ese tipo de sofisticaciones,
colocarán verdaderos caracteres de tabulación cuando se pulse la tela TAB, con lo que el mismo código
incorporará un uso inconsistente de tabulaciones. Python no acepta esta situación, y en ese tipo de
casos lanza una excepción IndentationError, negándose a continuar. En estos casos es necesario
examinar cuidadosamente el código para encontrar, primero, el sistema de indentación mayoritario, y a
continuación, aquellas líneas que rompen ese sistema de indentación.

7 Repetición
En Python existen disponibles los bucles while() y for(). No existen, sin embargo, do... while() o
repeat... until(). En cuanto al primer bucle, las sentencias se ejecutan de arriba a abajo mientras se
cumpla condición. Es decir, cada vez que se completa la ejecución del bloque de sentencias, se reevalúa
la condición, en caso de devolver True, se vuelve a ejecutar el bloque de sentencias, y así
sucesivamente.
Sintaxis
while <condición>:
sentencia1
sentencia2
…
sentenciaN
else:
sentencia1
sentencia2
…
sentenciaN

Introducción-10
Introducción a la programación en GAE con Python

La parte else se ejecuta en cuanto la condición del bucle no se cumple.

Ejemplo
n = 0
while n < 10:
print(n + 1)
n += 1 # n++ no funciona... y no provoca un error.

Salida
1
2
3
4
5
6
7
8
9
10

Sintaxis
for i in range(<limite>):
sentencia1
sentencia2
…
sentenciaN
else:
sentencia1
sentencia2
…
sentenciaN

for i in range(<inicio>, <limite>, <salto>):

sentencia1
sentencia2
…
sentenciaN
else:
sentencia1
sentencia2
…

Introducción-11
Introducción a la programación en GAE con Python

sentenciaN
De nuevo, la parte else se ejecuta en cuanto i se encuentra fuera del rango dado por la función
range()8.

Ejemplo
for i in range(10):
print(n + 1)

Salida
1
2
3
4
5
6
7
8
9
10

Ejemplo
for i in range(0, 10, 2):
print(i + 1)

Salida
1
3
5
7
9

8 La función range() devuelve una lista. Las listas se tratan en el siguiente tema.

Introducción-12
Introducción a la programación en GAE con Python

8 Funciones
Las funciones permiten agrupar más de una sentencia en un bloque de código, al que además, se le
pueden pasar parámetros. La palabra clave que se emplea para crear funciones es def. A continuación,
el nombre de la función, y entre paréntesis, la lista de parámetros. Entonces, dos puntos (':') y el bloque
de código.

Sintaxis
def <nombre>(<parametro1, parametro2,... parametroN>):
sentencia1
sentencia2
…
sentenciaN

Ejemplo
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n – 1)

factorial(6)

Salida

720

Es importante hacer notar que las funciones siempre devuelven un valor, incluso cuando aparentemente
no devuelven nada. Este valor es None, que tiene su equivalente en otros lenguajes de programación
como NULL o null.

Introducción-13
Introducción a la programación en GAE con Python

Ejemplo
def show(n):
print(n)

print(show(5))
5
None

8.1 Paso de parámetros

Los parámetros se pasan de una forma u otra según el tipo de valor. Cuando se trata de un valor
inmutable, como una cadena, número o tupla, se pasa por valor. En cambio, cuando se pasa un
parámetro del tipo lista, objeto o diccionario, se pasa por referencia.
En realidad, Python siempre pasa los parámetros por referencia, pero cuando se trata de asignar
cualquiera de ellos, realiza la asignación sobre una copia de ellos, produciéndose en la práctica un paso
por copia. Por otra parte, intentar llamar a un método de un objeto, lista o diccionario no provoca
ninguna copia.

X = 5

def inc(n):
n += 1

inc(x)
print(x)
5

s = "hola"
def concatMundo(cad):
cad += ", mundo"

print(s)
hola

Introducción-14
Introducción a la programación en GAE con Python

8.2 Devolución de más de un elemento

En Python, es posible devolver más de un elemento. En ese caso, la devolución se realiza con un return
que tiene como parámetros varios valores separados por comas.

Sintaxis
def <nombre>(<parametro1, parametro2,... parametroN>):
sentencia1
sentencia2
…
sentenciaN
return valor1, valor2,... valorN

Ejemplo
def pide_datos_persona():
nombre = input(“Dame tu nombre: “)
apellidos = input(“Dame tus apellidos: “)
edad = int(input(“Dame tu edad: “))
return nombre, apellidos, edad

nombre, apellidos, edad = pideDatos()

print(“{1}, {0}: {2}”, nombre, apellidos, edad)

Introducción-15
Introducción a la programación en GAE con Python

8.3 Funciones dentro de funciones

Una capacidad interesante de Python es la posibilidad de crear funciones privadas, funciones auxiliares
para una principal, de tal forma que estas funciones auxiliares sean inaccesibles desde el exterior.

Ejemplo
def pide_datos_persona():

def input_int(msg):
return int(input(msg))

nombre = input(“Dame tu nombre: “)

apellidos = input(“Dame tus apellidos: “)
edad = input_int(“Dame tu edad: “)
return nombre, apellidos, edad

nombre, apellidos, edad = pideDatos()

print(“{1}, {0}: {2}”, nombre, apellidos, edad)

8.4 Documentación
Python soporta las llamadas docstrings, que son cadenas especificadas mediante las triples comillas, y
contienen información sobre una entidad del código, en este caso, una función. En cualquier caso,
siempre se sitúa antes de la primera sentencia. Esta documentación está disponible posteriormente
mediante la función help().

Sintaxis
def <función>(<lista_parámetros>):
”””<Información en la docstring.>”””
sentencia1
sentencia2
…
sentenciaN

Introducción-16
Introducción a la programación en GAE con Python

Ejemplo
def pide_datos_persona():
”””Devuelve el nombre, apellidos y edad.”””
nombre = input(“Dame tu nombre: “)
apellidos = input(“Dame tus apellidos: “)
edad = int(input(“Dame tu edad: “))
return nombre, apellidos, edad

help(pide_datos_persona)

Salida
Help on function pide_datos_persona in module __main__:

pide_datos_persona()
Devuelve el nombre, apellidos y edad.

Las docstring son informaciones de las que se espera que se sigan varios criterios a la hora de
crearlas:

1. Deben empezar por mayúscula y terminar en un punto.

2. Siempre se utilizan las triples comillas.
3. Nunca se repite el nombre de la función, ni se repite una especie de firma de la misma.
4. No hay líneas en blanco ni antes ni después de la docstring.
5. Los parámetros llevan como prefijo: “:param <nombre>:”
6. Los valores de retorno se prefijan como “:return:”

Por supuesto, sería extraño que fuese siempre suficiente con una sola línea de explicaciones. En
el caso de necesitar más de una línea, se deja una línea en blanco entre lo que pasa a ser el resumen, y
la explicación más elaborada. Las triples comillas de cierre siempre se colocan en su propia línea.

Introducción-17
Introducción a la programación en GAE con Python

Ejemplo
def pide_datos_persona():
"""Devuelve el nombre, apellidos y edad, tras pedirlos por teclado.

:return: lo siguiente, en el mismo orden:

nombre -- el nombre de la persona, como cadena
apellidos -- los apellidos de la persona, como cadena
edad -- la edad de la persona, como entero.
"""

nombre = input("Dame tu nombre: ")

apellidos = input("Dame tus apellidos: ")
edad = int(input("Dame tu edad: "))
return nombre, apellidos, edad

help(pide_datos_persona)

Salida
Help on function pide_datos_persona in module __main__:

pide_datos_persona()
Devuelve el nombre, apellidos y edad, tras pedirlos por teclado.

:return: lo siguiente, en el mismo orden:

nombre -- el nombre de la persona, como cadena
apellidos -- los apellidos de la persona, como cadena
edad -- la edad de la persona, como entero.

Introducción-18
Introducción a la programación en GAE con Python

9 Referencias
• Documentación de Python 3: http://docs.python.org/3/ (accedido en 02/2015)
• Tutorial de Python 3: http://docs.python.org/3/tutorial/ (accedido en 02/2015)
• PEP 8 – Style guide for Python code: http://www.python.org/dev/peps/pep-0008/ (accedido en
02/2015)
• PEP 257 - Docstring Conventions: http://www.python.org/dev/peps/pep-0257/ (accedido en
02/2015).

10 Ejercicios resueltos

1. Escribe un programa que calcule la conversión de grados farenheit a celsius. Escribe el

algoritmo de la conversión en una función, y llámala desde el programa.

def grados_farenheit_celsius(g):
"""Calcula el equivalente a grados Farenheit en Celsius.

:param g: Grados Farenheit

:return: Los grados Celsius, como num. real.
"""

return (g - 32) / 1.8

grados_farenheit = float(input("Introduce los grados Farenheit: "))

grados_celsius = grados_farenheit_celsius(grados_farenheit)

print("En grados Celsius: {0:5.2f}".format(grados_celsius))

Introducción-19
Introducción a la programación en GAE con Python

2. Escribe un programa que calcule el área y el perímetro de una circunferencia. Escribe los
algoritmos correspondientes en funciones que sean llamadas desde tu programa.

def superficie_circulo(r):
"""Calcula la superficie de la circunferencia.

:param r: El radio de la circunferencia.

:return: La superficie, como un num. real.
"""

return 3.1416 * r * r

def perimetro_circulo(r):
"""Calcula la longitud de la circunferencia.

:param r: El radio de la circunferencia

:return: La longitud, como un num. real.
"""

return 2 * r * 3.1416;

radio = float(input("Introduce el radio de la circunferencia: "))

superficie = superficie_circulo(radio)
longitud = perimetro_circulo(radio)

print("Superficie: {0:5.2f}, longitud: {1:5.2f}".

format(superficie, longitud))

Introducción-20
Introducción a la programación en GAE con Python

11 Ejercicios

1. Escribe el programa ¡Hola, mundo!. El programa escribirá la famosa frase por pantalla.

2. Escribe un programa en Python que visualice el mensaje “Dime tu nombre”, y que acepte el
nombre del usuario almacenándolo como texto. Entonces visualizará "Hola," y el nombre
introducido.

3. Esta es una buena ocasión para practicar con las opciones de formateo de Python 3. Recuerda
que cualquier cadena tiene el método format(), por ejemplo "{0:03d}".format(5) devuelve el
cinco convirtiéndolo previamente a número y precediéndolo con dos ceros. Reescribe el
programa anterior para que también pida la edad, y muestre toda la información mediante el
método format().

4. Escribe un programa que tiene una función a la que se le pasan dos parámetros numéricos, y
devuelve una cadena con los parámetros entre paréntesis y separados por una coma. La función
se llama formatea_coordenadas(), y consumirá dos números introducidos por teclado. Es
posible utilizar las funciones de conversión entre tipos (en este caso str()), o el método de las
cadenas format(). Experimenta implementando la función de ambas formas.

5. Divide los programas anteriores en funciones: una función para pedir los datos, y otra, para
visualizarlos, pasándose por parámetro. Añade el código necesario para arrancar la aplicación,
es decir, llamar a las funciones.

6. Escribe un programa que acepte tres parámetros: dos números y un carácter. Si el carácter es '+'
los números se suman, con '-' se restan, con '*' se multiplican, con '/' se dividen, y con '^' se
eleva el primero al segundo. Crea una función que acepte estos tres datos y devuelva el
resultado del cálculo. Crea otra función que pida los datos necesarios. Recuerda convertir las
cadenas que tienen números con int() y float().
7. Un formateador de números de teléfono básicamente agrupa los dígitos en grupos de tres, e
ignora cualquier carácter que no sea un dígito. Por ejemplo, (988) 387001 se convertiría en 988
387 001. Además, el número puede estar precedido o no por el código de páis (dos dígitos),
mediante el formato ‘+’ o ‘00’: +34 (988) 387001 o 0034 (988) 387001 deben convertirse en
+34 988 387 001. Finalmente, pueden encontrarse letras de la a a la z en el número, que deben
traducirse a dígitos siguiendo la convención: 2: a, b, c; 3: d, e, f; 4: g, h, i; 5: j, k, l; 6: m, n, o; 7:
p, q, r, s; 8: t, u, v; y 9: w, y, z. Así, 900 ESI NFO sería 900 374 636.

Introducción-21