INÍCIATE EN PYTHON

ÍNDICE DE CONTENIDO

Unidad 1. Primeros pasos en Python _______________________ 5

1.1 Objetivos ______________________________________________ 5

1.2 Introducción ____________________________________________ 5

1.3 Alcance del lenguaje _____________________________________ 5

1.4 Entorno de desarrollo integrado (IDE) en línea _________________ 6

1.5 Tipos de datos en Python ________________________________ 12

1.6 Resumen _____________________________________________ 14

Unidad 2. Operaciones y expresiones _____________________ 15

2.1 Objetivos _____________________________________________ 15

2.2 Introducción ___________________________________________ 15

2.3 Operadores aritméticos __________________________________ 15

2.4 Operadores relacionales _________________________________ 16

2.5 Operadores de asignación ________________________________ 17

2.6 Operadores lógicos _____________________________________ 18

2.6.1 Operador and __________________________________________ 18

2.6.2 Operador or ____________________________________________ 19
2.6.3 Operador not ___________________________________________ 20
2.7 Expresiones ___________________________________________ 21

2.7.1 Expresiones relacionales _________________________________ 22

2.7.2 Expresiones lógicas _____________________________________ 22
2.7.3 Expresiones anidadas ____________________________________ 23
2.8 Resumen _____________________________________________ 24

Unidad 3. Sentencias de control de flujo____________________ 32

3.1 Objetivos _____________________________________________ 32

3.2 Introducción ___________________________________________ 32

3.3 Sentencias de control de flujo condicionales __________________ 33

1
 3.3.1 Sentencia if ____________________________________________ 33
3.3.2 Sentencia else __________________________________________ 34
3.3.3 Sentencia elif ___________________________________________ 34
3.4 Sentencias de control de flujo repetitivas o bucles _____________ 35

3.4.1 Sentencia for ___________________________________________ 35

3.4.2 Sentencia while _________________________________________ 36
3.5 Función range() ________________________________________ 38

3.6 Resumen _____________________________________________ 40

Unidad 4. Colecciones de datos __________________________ 42

4.1 Objetivos _____________________________________________ 42

4.2 Introducción ___________________________________________ 42

4.3 Tuplas _______________________________________________ 42

4.4 Listas ________________________________________________ 44

4.5 Conjuntos _____________________________________________ 51

4.6 Diccionarios ___________________________________________ 52

4.7 Resumen _____________________________________________ 56

Unidad 5. Entradas y salidas de información ________________ 58

5.1 Objetivos _____________________________________________ 58

5.2 Introducción ___________________________________________ 58

5.3 Formatos de entrada de información ________________________ 58

5.4 Formatos de información _________________________________ 61

5.5 Resumen _____________________________________________ 66

Unidad 6. Funciones ___________________________________ 67

6.1 Objetivos _____________________________________________ 67

6.2 Introducción ___________________________________________ 67

6.3 Argumentos y parámetros ________________________________ 69

6.3.1 Por posición ____________________________________________ 69

6.3.2 Por nombre ____________________________________________ 69

2
 6.3.3 Llamada sin parámetros __________________________________ 70
6.3.4 Parámetros con valores por defecto _________________________ 71
6.4 Argumentos indeterminados ______________________________ 71

6.4.1 Argumentos indeterminados por nombre _____________________ 72

6.4.2 Argumentos indeterminados por nombre (clave, valor) __________ 72
6.4.3 Argumentos indeterminados por nombre y por nombre: clave, valor 73
6.5 Resumen _____________________________________________ 73

Unidad 7. Manejo de errores en Python ____________________ 75

7.1 Objetivos _____________________________________________ 75

7.2 Introducción ___________________________________________ 75

7.3 Tipos de errores ________________________________________ 76

7.4 Captura de eroores _____________________________________ 77

7.5 Cláusula finally _________________________________________ 78

7.6 Resumen _____________________________________________ 78

Unidad 8. Métodos de análisis y transformación de cadenas ____ 80

8.1 Objetivos _____________________________________________ 80

8.2 Introducción ___________________________________________ 80

8.2.1 Método capitalize _______________________________________ 82

8.2.2 Método lower ___________________________________________ 82
8.2.3 Método upper __________________________________________ 83
8.2.4 Método swapcase _______________________________________ 83
8.2.5 Método title ____________________________________________ 83
8.2.6 Método center() _________________________________________ 84
8.2.7 Método ljust() ___________________________________________ 84
8.2.8 Método rjust() __________________________________________ 85
8.2.9 Método zfill(longitud) _____________________________________ 85
8.2.10 Método count() _________________________________________ 86
8.2.11 Método find() ___________________________________________ 86
8.2.12 Método startwith() _______________________________________ 87
8.2.13 Método endswith() _______________________________________ 87
8.2.14 Método isalnum() ________________________________________ 88
8.2.15 Método isalpha() ________________________________________ 88

3
 8.2.16 Método isnumeric() ______________________________________ 89
8.2.17 Método isdecimal() ______________________________________ 89
8.2.18 Método isdigit() _________________________________________ 89
8.2.19 Método isspace() ________________________________________ 90
8.2.20 Método istitle() __________________________________________ 90
8.2.21 Método replace() ________________________________________ 91
8.2.22 Método strip() __________________________________________ 91
8.2.23 Método join() ___________________________________________ 92
8.2.24 Método partition() _______________________________________ 92
8.2.25 Método split() ___________________________________________ 93
8.2.26 Método splitlines() _______________________________________ 93
8.2.27 Método ord() ___________________________________________ 93
8.2.28 Operador > < == != en las cadenas _________________________ 94
8.2.29 Método index(argumento) _________________________________ 94
8.2.30 Método slice(argumento)__________________________________ 95
8.3 Resumen _____________________________________________ 97

Unidad 9. Entorno de desarrollo Anaconda y Jupyter __________ 99

4
UNIDAD 1. PRIMEROS PASOS EN PYTHON

1.1 OBJETIVOS

El objetivo de este tema es entender la plataforma de ejecución del lenguaje

Python, la naturaleza del lenguaje e introducir los conceptos fundamentales para
los que nación este lenguaje, así como la historia de su nacimiento.

1.2 INTRODUCCIÓN

Python es un lenguaje de programación creado por Guido Van Rossum, el cual

inició su implementación en diciembre de 1989. Es un lenguaje interpretado de
tipado dinámico, su filosofía se basa en una sintaxis sencilla que favorezca un
aprendizaje fácil y rápido, lo cual lo convierte en un lenguaje de programación
ideal para quienes quieren aprender a empezar a programar.

Python es un lenguaje de código abierto, lo que ha permitido generar una

comunidad muy grande a su alrededor, desarrollando una gran cantidad de
librerías, manipulación de bases de datos, motores de búsqueda, criptografía,
entre otras.

1.3 ALCANCE DEL LENGUAJE

En sus orígenes Python fue ideado como un lenguaje de uso para la comunidad
científica (fundamentalmente para el área de las matemáticas), por lo que
permite hacer cálculos que no son posibles de realizar con otros lenguajes de
programación.

5
Python puede utilizarse para programar casi cualquier cosa, sus características
han hecho que aplicaciones de gran alcance a nivel mundial como Instagram,
Uber, Netflix, Lyft y Spotify lo utilicen como parte de sus lenguajes de desarrollo.

Con el crecimiento del volumen de datos que se viene generando por el uso
masificado del internet, Python ha visto crecer también su uso al permitir la
manipulación de datos a gran escala, siendo común su uso en las áreas del Big
Data, inteligencia artificial y el análisis de datos.

1.4 ENTORNO DE DESARROLLO INTEGRADO (IDE) EN

LÍNEA

Existen distintos entornos de desarrollo integrado1 donde se pueden llevar a

cabo proyectos de Python, tales como Jupyter o Spider, entre otros. En este caso
se hará a través de un entorno de desarrollo en línea, al cual accedemos a través
del navegador de internet del ordenador escribiendo la siguiente dirección
https//:repl.it o pulsando sobre el enlace anterior.Para empezar a escribir el

1 Es un programa informático compuesto por un conjunto de herramientas de programación.

Puede dedicarse en exclusiva a un solo lenguaje de programación o bien puede utilizarse para
varios. (Entorno de programación).

6
código y ensayar el lenguaje, solo debemos ir a la parte superior derecha de la
pantalla y pulsar sobre el icono “<>Start coding” como se muestra en la siguiente
imagen.

Al avanzar, el entorno pedirá elegir el lenguaje en el cual se quiere programar.

Elegimos Python y luego pulsamos sobre “create repl”.

Ya tenemos el archivo en donde se puede empezar a escribir código en Python.

Para probarlo, se puede escribir una cadena que se llame “Hola Mundo”, tal
como aparece en la siguiente imagen.

7
Para ejecutar el código debemos pulsar sobre el botón “Run” que se encuentra
en la parte superior de la pantalla y el resultado del código ejecutado se verá en
la pantalla de color negro ubicada a la derecha de este.

Para poder guardar los archivos del código se debe dar de alta como usuario,
permitiéndonos acceder posteriormente a los archivos que se han creado. Para
darse de alta, presionamos el botón azul “Sign up” situado en la parte superior
derecha de la página y rellenamos los datos de usuario.

8
Al darse de alta ya podremos guardar los archivos que iremos desarrollando
dentro de este entorno en línea.

Para acceder al archivo que se ha creado por defecto para la ejecución de la

cadena de texto “Hola Mundo”, pulsamos el botón que se encuentra en la parte
superior izquierda de la página compuesto por tres líneas horizontales,
desplegando así un menú.

9
Pulsa el botón “My Repls” para poder acceder al archivo que se creó por defecto.

Importante

Al archivo también se le asigna un nombre por defecto, sin embargo, lo más

importante es saber que cada vez que se cree un nuevo archivo que se quiera
trabajar, se hace pulsando el botón “My Repls”

10
Al pulsar el botón accederemos a la pantalla de crear archivos, crearemos tantos
como queramos para almacenar los ejercicios de cada tema que veremos en
este manual.

Para crear una carpeta donde almacenar los ejercicios de Python, pulsamos en
el botón de “New Folder” y la titulamos “ejercicios”. Dentro de esta creamos un
nuevo archivo Python pulsando sobre el botón “New Repl”. Al hacerlo hay que
elegir el programa en el que se ejecutará ese archivo, elegimos Python, ponemos
un nombre al archivo y pulsamos el botón “Create repl”. El archivo ya se ha
creado y el entorno de trabajo está listo para empezar a programar, tal como se
muestra en la siguiente imagen.

11
Para llevar a cabo los ejercicios que se verán más adelante, se recomienda crear
una carpeta para cada tema. Por ejemplo, para el tema sentencias de control de
flujo creamos una carpeta y dentro de ella creamos un archivo para cada
subtema. Por ejemplo, se crea un archivo para la sentencia “if”, otro archivo para
la sentencia “for” y así sucesivamente.

1.5 TIPOS DE DATOS EN PYTHON

Existen cinco tipos de datos básicos en Python:

 Cadenas o string representadas por cualquier carácter que esté dentro de

comillas simples o dobles.
 Números enteros o int, representados por los números del 0 al 9 y no están
dentro de comillas simples o dobles.
 Números con decimales o float.
 Booleanos o boolean, representados por dos palabras reservadas en
Python (True y False).

12
  Tipo de ninguno o None, un tipo de dato nuevo que se utiliza para crear
variables sin asignarle ningún valor.

Para asegurarnos que tipo de dato estamos utilizando (no es necesario casi
nunca) utilizamos el método type (dato), que recibe como argumento la variable
de la que queremos conocer qué tipo de dato es, tal como se ilustra a
continuación.

Las sentencias para saber el tipo de dato de las variables cadena y numero, se
encuentran en la parte izquierda de la imagen en las líneas 14 y 19
respectivamente. El resultado de estas sentencias se consigue en la parte
derecha de la imagen, donde la información está entre un símbolo menor que (<)
y mayor que (>). Se puede ver que el primer resultado es para la variable que se
ha definido con el nombre de cadena. Debajo de la frase “Hola Mundo, ya es
2020” se puede observar <class ‘str’> lo que indica que es de tipo string aun
cuando dentro de la cadena existan números, esto es porque cualquier variable
que se defina como se ha hecho con la variable cadena, es decir, dentro de
comillas dobles, automáticamente se convierte en un dato de tipo string.

Luego se ha definido una variable llamada número a la cual se le ha asignado el

valor 2020 sin comillas. Esto convierte a esa variable en un dato de tipo entero
que se puede verificar en la parte derecha de la imagen debajo del 2020 donde
se lee <class ‘int’>.

13
Para el caso del tipo de dato flotante, booleano y None, se puede constatar esas
condiciones a través de los ejemplos en las siguientes imágenes.

1.6 RESUMEN

Python es un lenguaje de programación interpretado cuya sencilla sintaxis y su

código abierto permiten un aprendizaje fácil y rápido. Hoy en día, Python cuenta
con una gran comunidad de usuarios, una vasta cantidad de librerías, entre otras
ventajas. Gracias a estas características, Python se utiliza en la actualidad en
áreas como el Big Data, la inteligencia artificial y el análisis de datos.

Para programar con Python, contamos con diferentes entornos de desarrollo

integral: Django, Jupyter, Spider, etc. Repl.it, utilizado en este capítulo como
ejemplo, es un entorno en línea que permite guardar archivos de código a los
que se puede acceder posteriormente con tan solo darse de alta como usuario.

En dicho ejemplo, se explican los cinco tipos de datos existentes en Python, tales
como: cadenas, números enteros, números con decimales, booleanos y None.
Este concepto clave es lo que permitirá un mejor manejo y comprensión de
Python.

14
UNIDAD 2. OPERACIONES Y EXPRESIONES

2.1 OBJETIVOS

El objetivo de este tema es dar un vistazo a todos los elementos del lenguaje
Python a nivel sintaxis elementos que nos ayudan a construir un programa básico
tales como operadores, expresiones, etc…

A través de estos elementos podremos construir más adelante todas las

estructuras de programación.

2.2 INTRODUCCIÓN

El objetivo de este tema es dar un vistazo a todos los elementos del lenguaje
Python a nivel sintaxis, elementos que nos ayudan a construir un programa
básico tales como operadores, expresiones, etc…

A través de estos elementos podremos construir más adelante todas las

estructuras de programación.

2.3 OPERADORES ARITMÉTICOS

Los operadores aritméticos realizan funciones matemáticas con las que se está
ya familiarizado, sin embargo, algunos de estos operadores son utilizados de
forma distinta en Python para realizar operaciones con resultados diferentes,
como en el caso de la división, la cual se explica en la siguiente tabla.

15
 Operador Descripción Ejemplo Resultado

+ Suma 5+7 12

- Resta 8-3 5

+ Negación -7 -7

* Multiplicación 3*9 27

** Exponente 5**2 25

/ División 8.4/2 4.2

// División entera 4.6//2 2.0

% Módulo 7%2 1

Para ver el funcionamiento de estos operadores en Python, se puede ejecutar

cada uno de los ejemplos en el entorno de trabajo repl.it y ver los resultados.

2.4 OPERADORES RELACIONALES

Los operadores relacionales se caracterizan por preguntar la condición de un

operando respecto a otro operando, el resultado siempre tendrá dos
posibilidades: True o False.

Operador Descripción Ejemplo Resultado

== ¿Son iguales a y b? 9==7 False

!= ¿Son distintos a y b? 12!=4 True

< ¿Es a menor que b? 12<9 False

> ¿Es a mayor que b? 12>9 False

<= ¿Es a menor o igual que b? 12<=12 False

16
 >= ¿Es a mayor o igual que b? 12>=12 False

2.5 OPERADORES DE ASIGNACIÓN

Los operadores de asignación tienen la función de asignar un valor a una

variable. El caso más conocido es el del operador igual (=). En Python, así como
en otros lenguajes de programación, el operador igual (=) se utiliza para abreviar
operaciones de asignación. Por ejemplo, tenemos una variable x cuyo valor es
5, pero luego queremos agregarle otro valor para que el valor final de x sea 15,
la operación que se tiene que hacer, sería la siguiente:

La forma de abreviar esa operación anterior, donde entran en función los

operadores de asignación, sería de la siguiente forma:

El resultado es el mismo, pero de forma abreviada, lo cual es de mucha utilidad

en programación cuando se necesitan hacer operaciones repetitivas. Prueba a
hacer otros ejercicios con otros operadores de asignación distintos al del ejercicio
que se ha hecho que verifiquen cómo funcionan cada uno de los operadores.

17
 Operador Descripción Ejemplo Resultado

= Asigna un valor a la variable X=5 X vale 5

=+ Suma el valor a la variable X+=10 15

-= Resta el valor de la variable X-=2 3

*= Multiplica el valor de la variable X*=7 35

/= Divide el valor de la variable X/=2 2.5

Calcula el exponente del valor de la

**= X**=3 75
variable

Calcula la división entera al valor de la

//= X//=2 2
variable

Devuelve el resto de la división del valor

%= X%=2 1
de la variable

2.6 OPERADORES LÓGICOS

Los operadores lógicos preguntan si se cumple una condición dentro de una

expresión. El resultado de estas expresiones solo tiene dos posibilidades: True
o False.

2.6.1 Operador and

En el caso del operador and, se pregunta si se cumplen dos o más condiciones

dentro de una expresión. Imagínese que está preguntando si la edad es mayor
a 18 y si tiene pasaporte, pues ambos son requisitos para viajar al extranjero. Si
la persona tiene más de 18 años, el resultado de esta primera pregunta sería
true. Luego la siguiente pregunta es sobre el pasaporte, en caso de tenerlo, el
resultado sería también true. En este ejemplo, ambas condiciones se cumplen,

18
por lo cual el resultado final es true y la persona puede viajar al extranjero. Pero
si el resultado de una sola de las preguntas fuera false, el resultado final sería
false y la persona no podría viajar al extranjero. En la siguiente imagen se
muestra cómo actúa el operador and en sus dos casos posibles.

2.6.2 Operador or

El operador or verifica que al menos una de las condiciones se cumpla. Volvamos

al ejemplo del viajero, en esta ocasión, el viajero se desplazará a otra ciudad
dentro de su país. Para poder subir al avión, debe presentar una identificación
y el aeropuerto tiene dos formas de identificar al pasajero: verificando su
documento de identidad nacional o verificando su carnet de conducir. Si el viajero
presenta su documento de identidad nacional la respuesta será true, pero si
presenta su carnet de conducir la respuesta también será true, ya que al menos
una de las dos condiciones se ha cumplido. Si el pasajero no hubiese presentado
ninguna de las dos identificaciones, la respuesta hubiese sido false y no podría
tomar el vuelo.

19
2.6.3 Operador not

El operador not constata que la condición no se cumpla, devuelve true si la

condición efectivamente no se cumple y false si la condición se cumple. Tenemos
nuevamente al viajero. Las medidas de seguridad de los vuelos indican que está
prohibido viajar con armas. La aerolínea pregunta al pasajero si no lleva algún
arma con él. Si el viajero responde no, la condición not se cumpliría y el resultado
sería true. En caso que el viajero responda que sí lleva un arma con él, el not no
se cumpliría, el resultado sería false y el viajero no podría tomar el vuelo.

A continuación, se muestra dentro de una tabla un resumen de cada uno de los

operadores lógicos.

20
 Operadores lógicos

Operador Descripción Ejemplo Resultado

And ¿Se cumple a y b? True and False False

Or ¿Se cumple a o b? True or False True

not No al valor Not True False

2.7 EXPRESIONES

Las expresiones en programación pueden ser de dos tipos según los operandos.
Tenemos dos operandos, el primero es el número 5 y el segundo es el número
10. Ambos valores representan un valor literal y si hacemos una suma entre
ellos, es decir, 5+10, esta expresión pertenecería al tipo de expresión
aritmética porque estas expresiones se caracterizan por estar compuestas de
valores que se representan a sí mismos.

Importante

Otro tipo de expresión es el conocido como expresión algebraica. En este tipo

de expresión al menos uno de los operandos es una variable numérica. Si
creamos una variable llamada promedio, la cual es igual al resultado de sumar
los valores de 10+15/2, la variable promedio no tiene un valor predefinido, por
lo que, al no representar un valor literal, y representar otro valor, se convierte
en un operando variable haciendo que la expresión explicada sea de tipo
algebraica.

21
2.7.1 Expresiones relacionales

Son expresiones donde los operadores son del tipo relacional. Un ejemplo de
una expresión relacional puede ser el siguiente: 8 > 9. Vemos un ejemplo de
cada una de estas expresiones.

2.7.2 Expresiones lógicas

Son expresiones donde los operadores son del tipo lógico. En la siguiente tabla
podemos tener una mejor visión de cómo funcionan los operadores lógicos y
como son las expresiones lógicas.

Operador Ejemplo Explicación Resultado

and 5==7 and 7<12 False and False False

and 9<12 and 12>7 True and True True

and 9<12 and 12>5 True and False False

22
 Or 12==12 or 15<7 True or False True

Or 7>5 or 9<12 True or True True

Not not 5>10 Not False True

not not 5<10 Not True False

2.7.3 Expresiones anidadas

Son expresiones que pueden ser aritméticas o algebraicas. La diferencia es que

son expresiones más complejas, siendo necesario aplicar reglas para poder
resolverlas.

Las reglas con las que se resuelven estas expresiones proceden del mundo de
las matemáticas. Un ejemplo de este tipo de expresión puede ser el siguiente:

a=10

b=5

a*b – 2**b >= 20 and not (a%b) !=0

El cómo solucionar esta expresión, obedece a las siguientes reglas:

 Primero, se resuelven las expresiones que se encuentran entre los

paréntesis ya que indican prioridad
 Segundo, se resuelven las expresiones aritméticas siguiendo sus propias
reglas.
 En tercer lugar, se resuelven las expresiones relacionales.
 Por último, se resuelven las expresiones lógicas.

23
2.8 RESUMEN

Un operador es un símbolo que representa de forma visual los diferentes cálculos

que se lleva en la vida diaria, para dar un ejemplo sería la siguiente:

Operador ( representado de
Vida Diaria
forma visual )

Sumar, restar, multiplicar, dividir [ + ], [ - ], [ x ], [ ÷ ]

Es igual,
[ = ], [ ≠ ], [ < ], [ > ]
es distinto, menor que, mayor que

Una expresión en programación es la utilización de 2 operando (a los extremos)

y un operador (en el centro) la formula básica sería la siguiente:

Vida Diaria [Operando] [operador] [Operando2]

Sumar 5 + 2

Restar 78 - 5

Es igual Hola = Hola

Es distinto mundo ≠ mañana

En Python, existen cuatro tipos de operadores: operadores aritméticos,

relacionales, lógicos y de asignación.

Operadores aritméticos

Tanto Python como muchos otros tipos de lenguajes utilizan los operadores
matemáticos, estos tienen los siguientes símbolos.

24
 Operador Descripción Ejemplo Resultado

+ Suma 5+7 12

- Resta 8-3 5

* Multiplicación 3*9 27

Potencia: Para que un número ( a ) este

** elevado a la potencia ( b ) en matemáticas 5**2 25
sería (ab) Python utiliza el doble asterisco

/ División 8.4/2 4.2

División entera: El resultado devolverá decimal, 4.6//2 2.0

si divides con decimales, si divides entre
//
números enteros, el resultado devolverá la
parte entera de un decimal 5//2 2

Módulo: El resultado devolverá el RESTO de

% 7%2 1
una división

Operaciones Relacionales

Los operadores relacionales se caracterizan por preguntar la condición de un

operando respecto a otro operando, en donde el resultado siempre tendrá dos
posibilidades: True o False.

Operador Descripción Ejemplo Resultado

== ¿Son iguales a y b? 9==7 False

!= ¿Son distintos a y b? 12!=4 True

< ¿Es a menor que b? 12<9 False

> ¿Es a mayor que b? 12>9 True

25
 <= ¿Es a menor o igual que b? 12<=12 True

>= ¿Es a mayor o igual que b? 12>=12 True

Operadores lógicos

Python utiliza las siguientes palabras reservadas AND, OR, NOT. Siguiendo el
punto número 1. Operadores y expresiones en la tabla [operando1] [operador]
[operando2] Los operadores Lógicos cumplen las siguientes funciones.

AND

El resultado dará False si uno de los operandos tiene como valor FALSE, caso
contrario si los 2 operando tienen valor TRUE, el resultado dará True

[Operando] [Operador] [Operando2] Resultado

False and True False

True and False False

False and False False

True and True True

OR

El resultado dará True si uno de los operando tiene como valor TRUE, caso
contrario si los 2 operando tiene valor FALSE, el resultado dará False

[Operando1] [Operador] [Operando2] Resultado

False or True True

True or False True

False or False False

26
 True or True True

NOT

Único operador lógico que se utiliza con un solo operando, este negará el
resultado y convertirá la contraparte del resultado (el resultado es devuelto como
booleano)

[Operador][Operando] Resultado

not True False

not False True

Operadores de Asignación

Tienen la función de asignar un valor a una variable. El caso más conocido es el

del operador igual ( = ). En Python, así como en otros lenguajes de programación
como lo son JavaScript, C#, Visual Basic, etc, etc.

Operador Descripción Ejemplo Resultado

Todo valor que esté en el lado

= derecho del símbolo se x = 5x ß 5 x tiene valor 5
guardará en el lado izquierdo

Con el paso del tiempo, la programación ha ido evolucionando

exponencialmente, Python como muchos otros tipos de lenguajes se pueden
abreviar líneas de código como el siguiente ejemplo.

En el ejemplo anterior cuando ‘x’ tiene valor 5 utilizaremos este ejemplo.

27
 Código Código
Operador Descripción Resultado
original abreviado
Si x tiene valor ‘x + 10’
teniendo en cuenta antes
que x su valor es 5, la
+= x = x + 10 suma pasa implícitamente x += 10 15
donde esta ‘x =’ y el
resultado se guardará en
x por la asignación del ‘ = ‘
Si x tiene valor ‘x -2’
teniendo en cuenta antes
que x su valor es 5, la
-= x=x–2 resta pasa implícitamente x -= 2 3
donde esta ‘x =’ y el
resultado se guardará en
x por la asignación del ‘ = ‘
Si x tiene valor ‘x *7’
teniendo en cuenta antes
que x su valor es 5, la
multiplicación pasa
*= x=x*7 x *= 7 35
implícitamente donde esta
‘x =’ y el resultado se
guardará en x por la
asignación del ‘ = ‘
Si x tiene valor ‘x / 2’
teniendo en cuenta antes
x /= 2
que x su valor es 5, la
división pasa
/= x=x/2 2.5
implícitamente donde esta 5 2
‘x =’ y el resultado se
guardará en x por la 1 2.5
asignación del ‘ = ‘
Si x tiene valor ‘x ** 3’
**= x = x ** 3 x **= 3 75
teniendo en cuenta antes

28
 que x su valor es 5, la
potencia pasa
implícitamente donde esta
‘x =’ y el resultado se
guardará en x por la
asignación del ‘ = ‘
Si x tiene valor ‘x // 2’
teniendo en cuenta antes
x //= 2
que x su valor es 5, la
división entera pasa
//= x = x // 2 2
implícitamente donde esta 5 2
‘x =’ y el resultado se
guardará en x por la 1 2.5
asignación del ‘ = ‘
Si x tiene valor ‘x % 2’
teniendo en cuenta antes
que x su valor es 5, la
x %= 2
división resto o módulo
%= x=x%2 1
pasa implícitamente
donde esta ‘x =’ y el 5 2
resultado se guardará en
x por la asignación del ‘ = ‘

Expresiones relacionales

Siguiendo con el punto número 1. Operadores y expresiones sabemos que una

expresión en programación utiliza 2 operando y el operador para tener nuestra
expresión, en matemáticas podemos considerar una expresión aritmética (el
operador puedes ser +, -, x, ÷)

29
 Expresiones
Aritméticas

8/9

[7 x 5] o [7 * 5]

4+9

6-9

Expresiones lógicas

Sabemos que las expresiones llevan la regla de

[operando1][operador][operando2] vamos a dar unos ejemplos con los
operadores lógicos para poder tener nuestras expresiones lógicas.

Expresión
Expresión Lógica resultado
Relacional

9 == 3 and 43 9==3 9 == 3 and 43

And False
> 25 False > 25

3 != 5 or 2 ==
3 != 5 or5 2 == 0 True
0
True False

not(4 > 4) not(6 < 0)

not(4>4) and
and True
not(6<0) not(False) not(False)
True True

No hay mucho que decir, primero como prioridad las expresiones relacionales
(Si llevase paréntesis, tiene mayor prioridad) una vez resulto tendremos valores
booleanos: True y False, para obtener las expresiones lógicas, dentro de las

30
expresiones lógicas se pueden anidar más de una expresión lógica. Anidamos
en el ejemplo anterior para ver qué resultado podemos obtener.

Expresión
Expresión Lógica Resultado
Relacional

9 == 3 and 43 2 ==
9==3 and 43 > 25True Or True
> 25 or 2==2 2True
False

3 != 5 or 2 == 0 3 <=
3 != 5True Or 3 != 5True Or True
or 3 <=2 2False

not(4>4) and not(6 < 0

3 // 2
not(6<0) and 3 not(4 > 4) And And False
== 0
not(FalseTrue not(False)
// 2 == 0
False
True

31
UNIDAD 3. SENTENCIAS DE CONTROL DE FLUJO

3.1 OBJETIVOS

El objetivo de este tema es revisar las estructuras de control de flujo del lenguaje
Python que realmente son las mismas que en cualquier otro lenguaje, pero algo
más reducidas, ya que no contamos con las estructuras switch y do while.

Haremos ejemplos con las estructuras alternativas y repetitivas para saber

cuándo utilizar unas y otras.

3.2 INTRODUCCIÓN

Las sentencias de control de flujo se utilizan en programación para evaluar

condiciones, y según el resultado, ejecutar otras funciones. En Python existen
dos tipos de sentencias de control de flujo: condicionales, entre las que se
encuentran las sentencias if, elif y else, y luego las sentencias de control de flujo
iterativas, en donde se encuentran las sentencias for y while.

En las sentencias de control de flujo es importante conocer un aspecto

relacionado con el formato de la programación en Python, algo que se conoce
como identación, que es el equivalente a la sangría en los textos normales, sólo
que en Python si no se identa, el programa no se ejecutará. Revise la siguiente
imagen para luego poder explicar a qué se refiere la identación.

32
En la imagen anterior, se puede ver que debajo de la sentencia while, cada línea
tiene una identación, la cual se hace de forma automática si se posiciona al
extremo derecho en la línea 4 y pulsamos el botón enter en el ordenador. Esa
identación significa que todas las líneas de código ubicadas bajo el while son
instrucciones que se ejecutan en caso de que se cumpla la condición que está
preguntando la sentencia while.

De igual forma pasa con la sentencia else que se encuentra más abajo en la
línea 7, lo cual indica que esa sentencia es complementaria del while que ha sido
escrito en la línea 4. Si la sentencia else estuviera identada con la línea 6, Python
nos indicaría que hay un error de identación, lo cual también ocurriría si por
ejemplo el print que se encuentra en la línea 5 estuviera alienado con la
sentencia while que se encuentra en la línea 4.

3.3 SENTENCIAS DE CONTROL DE FLUJO

CONDICIONALES

Las sentencias de control de flujo condicionales verifican que una condición se

cumpla. Si se cumple, se ejecuta la función que buscamos dentro del programa,
de lo contrario, no se ejecuta el programa a no ser que le indiquemos que el
programa ejecute una función en caso de que la condición no sea cierta, lo cual
también se puede hacer. Lo veremos a continuación.

3.3.1 Sentencia if

La sentencia if es la sentencia condicional más sencilla, se encarga de preguntar

si una condición es verdadera o falsa. Si la condición es verdadera, ejecuta una
función determinada por el programador. Si la condición no se cumple, la función
no se ejecuta y termina el programa. Un ejemplo de ello se puede ver en la
siguiente imagen, donde la condición sí se cumple y el programa se ejecuta.

33
3.3.2 Sentencia else

Opcionalmente a la sentencia if podemos agregarle otra sentencia en la que

entra el programa en caso de que la condición que estamos evaluando no se
cumpla. La sentencia else es el equivalente al no cumplimiento de la condición
que se encuentra en el if. Esto se refleja en el siguiente ejemplo.

3.3.3 Sentencia elif

Dentro de las sentencias de control de flujo condicionales también existe la

sentencia elif. Si la sentencia if pregunta sobre una condición, la sentencia elif
sería la forma de cómo podemos preguntar otras condiciones que queremos
conocer. En el ejemplo reflejado en la imagen anterior, la sentencia if pregunta
si -a es menor que -b. Pero ¿cómo se hace si queremos preguntar no solo si -a
es menor que -b, sino que también queremos preguntar si otras variables son
menores que -b? La sentencia elif nos ayuda a resolver este problema como se
ve a continuación.

34
La sentencia elif tiene como objetivo preguntar sobre condiciones que se buscan
para ejecutar un programa. En el ejemplo de la imagen, el objetivo es preguntar
si existe una variable que sea menor a otra variable, como el resultado refleja, al
conseguir una condición verdadera el programa ejecuta la función imprimir y
termina la sentencia de control de flujo, lo cual es muy importante saber.

3.4 SENTENCIAS DE CONTROL DE FLUJO

REPETITIVAS O BUCLES

Si las sentencias de control de flujo condicionales preguntaban una condición

para ejecutar o no un programa, en el caso de las sentencias de control de flujo
repetitivas o bucles (como se le conoce en programación), también preguntan
sobre una condición solo que pueden hacerlo más de una vez. La cantidad
dependerá de la sentencia que utilicemos, las cuales pueden ser la sentencia for
o while.

3.4.1 Sentencia for

En Python, la sentencia for está compuesta por una lista de elementos sobre los
cuales queremos ejecutar un programa y una variable que almacenará cada

35
elemento de la lista definida dentro del bucle for. El siguiente ejemplo ilustra un
bucle for.

Como se puede ver, la variable nombre almacena cada nombre por cada uno
que consigue dentro de la tupla. En otras palabras, la sentencia diría lo siguiente:
por cada nombre que consigas dentro de la variable nombres, muéstralo en
pantalla. Este sería el ejemplo de una operación sencilla, pero se pueden hacer
operaciones mucho más complejas que pueden incluir operaciones
matemáticas, como en el siguiente ejemplo.

Como se puede observar, el programa tiene la instrucción de sumar 2 a cada

número que consigue en la tupla y luego imprimirlo en pantalla. También se
pueden hacer muchas otras operaciones, inténtalo probar con otros datos y
operadores para ver el funcionamiento de la sentencia for.

3.4.2 Sentencia while

En la sentencia for se ha visto desde un inicio cuántas veces se va a ejecutar la

sentencia y que esta se ejecutará al menos una vez. En cambio, en la sentencia
while podría incluso no entrar a ejecutar el programa, ya que en esta sentencia
primero se verifica la condición que, en caso de no cumplirse, finaliza el

36
programa. El siguiente ejemplo ilustra cómo se ejecuta la sentencia while
mientras la condición que preguntamos es verdadera.

Como se puede ver en el ejemplo, lo primero que se pregunta es si la variable

manzanas es menor a 5, al ser verdadera esta condición, entra en el programa,
imprime el valor de manzanas y luego suma 1 a la variable manzana, entrando
en bucle hasta que la variable manzana supere el valor de 5. Si no se sumara 1
cada vez que se verifica la condición, el programa se ejecutaría de forma infinita
pues el valor de manzanas siempre sería 0.

Cuando la condición no se cumple el programa finaliza, pero también se puede

capturar el no cumplimiento de la condición a través de la sentencia else, como
se puede ver en la siguiente imagen.

En otros casos se necesitará verificar la condición sobre la que se quiere

preguntar, pero desde dentro de la sentencia while. Para ello, agregamos a la
sentencia la palabra reservada True, con lo cual la ejecución del programa da
por verdadero la condición del while e ingresa para ejecutar las siguientes líneas
de código. Revise la siguiente imagen para ver cómo funciona.

37
En la imagen se refleja la forma de entrar en un bucle while dando por cierta una
condición. También se puede ver que se está haciendo uso de la palabra
reservada break, la cual se utiliza para finalizar el programa cuando la condición
se cumple. Es necesaria en este caso pues al tener predefinido el while como
True, si no se inserta el break el programa se ejecutará de forma indefinida e
imprimiría “Ya había 5 manzanas” infinitamente.

3.5 FUNCIÓN RANGE()

En Phyton la función range() nos permite crear un rango de números de un inicio

a un final. Esta función recibe tres parámetros, aunque funciona también con uno
solo. Cuando se le pasa a la función un solo parámetro, crea una lista de
números que empiezan en cero y termina un número antes del número que se
le ha pasado como parámetro, como se muestra a continuación.

Como se puede ver, se ha creado una lista (list), un conjunto (set) y una tupla
(tuple) con distintos parámetros dentro de la función range(). Se puede

38
comprobar como el número final de cada una de ellas es el parámetro menos
uno, es decir, en el caso de la lista se le ha pasado el 10 como parámetro y al
imprimir el resultado, ha impreso los números del 0 al 9.

La función range() puede iniciar en el número que se le indique y finalizar en otro

número que también se le indique, siempre teniendo en cuenta que el último
número va a ser uno menos que el que se le pasa como parámetro, como se
muestra en el siguiente ejercicio.

También se le puede indicar a la función un parámetro para que el rango de

número se cree de forma ascendente o descendente, de dos en dos, de tres en
tres o de la cifra en que se quiera construir el rango. Si se quiere construir un
rango de números del 10 al 20 pero de dos en dos, el tercer parámetro que se
debe indicar es el número dos, al igual que para construir un rango de números
en forma descendente desde el 20 al 10 de dos en dos, reflejado de la siguiente
forma.

39
La función range() también crea rangos de números negativos, como se puede
ver en el siguiente ejemplo.

También se pueden utilizar las longitudes de una cadena len(cadena) o cualquier

dato numérico y pasarlo como argumento a la función range() para crear rangos,
como se verá a continuación.

3.6 RESUMEN

Sentencias de control de flujo

En Python existen dos tipos de sentencias de control de flujo: condicionales,

entre las que se encuentran: las sentencias if, elif y else, y luego las sentencias
de control de flujo iterativas, en donde se encuentran: las sentencias for y while.

40
Sentencias de control de flujo condicionales:

 Sentencia if: Se encarga de preguntar si una condición es verdadera o

falsa. Si la condición es verdadera, ejecuta una función determinada. Si la
condición es falsa, la función no se ejecuta y termina el programa.

 Sentencia else: Podemos agregarla en caso de que la condición que se

encuentra en el if no se cumpla. Si la condición if es falsa, se ejecuta la
función dentro del else.

41
UNIDAD 4. COLECCIONES DE DATOS

4.1 OBJETIVOS

El objetivo de este tema es estudiar las estructuras de datos más avanzadas que
nos ofrece el lenguaje Python. A través de estas estructuras podemos manipular
y almacenar de distintas formas los diferentes tipos de datos en Python en
función de las necesidades del programa matemático, de gestión, etc...

4.2 INTRODUCCIÓN

Las colecciones de datos en Python, son conjuntos de datos que almacenan

valores o variables casi de cualquier tipo: cadenas, números, entre otros. En
total, son cuatro los tipos de colecciones que existen en Python: tuplas, listas,
conjuntos y diccionarios. Se verá a continuación de que se trata cada uno.

4.3 TUPLAS

Una tupla es un conjunto de datos que pueden ser del mismo tipo (sólo números)
o de varios (una cadena, un número, incluso otra tupla). Las tuplas pueden
escribirse (o no) dentro de un paréntesis y pueden estar formadas por un solo
dato. Para hacer saber a Python que este único dato es una tupla, este debe ir
seguido de una coma. En el caso de tener varios datos, cada uno debe ir
separado por una coma. Las tuplas son inmutables, por lo que una vez se define
un valor dentro de la tupla, no se puede alterar; tampoco se pueden agregar más
elementos a la tupla ni eliminarlos una vez creada. Las tuplas además se pueden
concatenar con otras tuplas y así formar una tupla de tuplas. Revisa las
imágenes a continuación para ver cómo funciona y también practícalo en tu
ordenador.

42
Se puede acceder a cada elemento de la tupla haciendo referencia al índice en
el que se encuentra, teniendo en cuenta que siempre el primer elemento de la
tupla va a ser el índice cero, de la siguiente forma.

Si se quisiera hacer referencia al segundo dato, entonces se escribiría el uno

entre los corchetes y así sucesivamente. También se puede acceder a varios
elementos de la tupla siguiendo el formato tupla[inicio:fin] teniendo cuenta que el
fin será un índice inferior en la tupla, por lo que si queremos obtener los datos
dos, tres y cuatro, haríamos lo indicado en la siguiente imagen.

Como se puede ver en la imagen anterior, el primer elemento que se imprime es

el que se encuentra en el índice uno, “pedro”, pero el último elemento que se
imprime es “ana”, el cual se encuentra en el índice 3 de la tupla, es decir, un
índice menos del que se encuentra dentro del corchete.

Si se quisiera cambiar alguno de los nombres dentro de la tupla, como hemos

mencionado antes, no se podría ya que las tuplas son inmutables por lo que
Python devolvería un error, explicando que los elementos no pueden ser
reasignados.

43
También se puede conocer el tamaño de la tupla a través de la palabra reservada
len. Se hace como se muestra en la imagen y el resultado es 6, ya que la tupla
contiene 6 elementos.

Como se mencionó anteriormente, las tuplas se pueden concatenar, por lo que

una tupla puede ser la suma de varias tuplas. En el siguiente ejemplo también
se puede ver cómo se puede definir una tupla sin la necesidad de utilizar el
paréntesis.

4.4 LISTAS

Las listas son colecciones de valores ordenados. Con “ordenados” se refiere a

que se puede acceder a cada elemento dentro de la lista a través de su índice.

44
Las listas a diferencia de las tuplas, son mutables. Es decir, se pueden reasignar
valores a los elementos que se encuentran dentro de ella, así como aumentar o
disminuir la cantidad de elementos de la lista. Pueden almacenar cualquier tipo
de dato y una lista también puede estar formada por otras listas, es decir, una
lista de listas. Las listas se declaran entre corchetes y se separa cada elemento
dentro de ella por una coma.

En el ejemplo anterior se puede ver cómo la lista almacena una cadena, un

número, una variable de tipo cadena, una lista, un valor booleano e incluso la
palabra reservada None. Para acceder a un valor dentro de la lista, se hace de
la misma forma que con las tuplas. Para reasignar el valor de un elemento dentro
de la lista, se escribe el nombre de la lista junto el índice del elemento a sustituir
entre corchetes seguido de un operador igual (=) con el valor que queremos
asignar. En la siguiente imagen se puede apreciar cómo se lleva a cabo.

En el ejemplo anterior se puede ver cómo la lista almacena una cadena, un

número, una variable de tipo cadena, una lista, un valor booleano e incluso la
palabra reservada None. Para acceder a un valor dentro de la lista, se hace de

45
la misma forma que con las tuplas. Para reasignar el valor de un elemento dentro
de la lista, se escribe el nombre de la lista junto el índice del elemento a sustituir
entre corchetes seguido de un operador igual (=) con el valor que queremos
asignar. En la siguiente imagen se puede apreciar cómo se lleva a cabo.

Se puede agregar un elemento a la lista a través del método append(), el cual

inserta el valor al final de la lista.

Agregar un elemento en un índice específico se puede hacer a través del método

insert(index, object), el cual recibe como primer argumento el índice en el que se
quiere insertar el nuevo elemento y como segundo argumento el elemento que
se quiere insertar.

46
Para remover un elemento, se puede hacer a través del método remove(object)
el cual recibe como argumento el valor que se quiere remover, como se refleja
en la siguiente imagen.

Para conocer el tamaño de la lista al igual que en con las tuplas, se puede invocar
el método len(nombre_lista). Para saber en qué índice se encuentra un
elemento, se utiliza el método index(elemento) que devuelve el índice donde se
encuentra el elemento que se ha pasado como argumento al método y devuelve
error si este no se encuentra dentro de la lista.

A través del método count(object), se puede saber la cantidad de veces que un

elemento se encuentra repetido.

47
Se puede eliminar el último elemento de la lista a través del método pop(), el cual
también se puede guardar en otra variable.

Con el método reverse(), se puede ordenar la lista de forma inversa.

Con el método sort() se puede ordenar una lista de forma ascendente, como se
puede apreciar en la siguiente imagen.

48
Para acceder a cada uno de los elementos de una lista, se hace a través del
índice que poseen. El índice de una lista siempre empieza en cero y en esa
posición se encuentra el primer elemento de la lista (de izquierda a derecha). En
el siguiente ejemplo se muestra cómo funciona.

Como se puede ver, al pasar el cero entre corchetes, se ha impreso el primer

elemento de la cadena, es decir la “a” que se encuentra en el índice cero.
También se puede acceder a varios valores de la cadena si después del primer
argumento escribimos dos puntos y pasamos un segundo argumento, tal como
se ve a continuación.

También podemos acceder a los valores de una lista de forma discontinua

pasando un tercer argumento, el cual indica los saltos entre índices, como se
refleja en el siguiente ejemplo.

49
Cuando se pasan más de dos argumentos, los valores por defecto de esos
argumentos son, en el primer argumento, el índice cero de la lista y el valor por
defecto del segundo argumento, el último índice de la lista, como se muestra a
continuación.

Las listas además poseen un índice negativo a través del cual se puede acceder
a sus elementos. En este caso, el -1 representa el último elemento de la lista y
funciona como se muestra a continuación.

50
4.5 CONJUNTOS

Un conjunto es una colección de elementos sin repeticiones y sin un orden de

inserción. El objetivo de los conjuntos es agrupar datos sin dar importancia al
orden en el que se agrupan, ofreciendo una mayor velocidad para saber si un
dato se encuentra o no dentro del conjunto.

Los conjuntos se definen de forma similar a la lista, pero en vez de corchetes, se

utilizan llaves. Los conjuntos no admiten repeticiones, por lo que, si se inserta
dentro del conjunto un mismo valor dos o más veces, al imprimir el conjunto,
eliminaría los valores repetidos.

Python ordena los datos dentro de los conjuntos de forma arbitraria, si se quisiera
utilizar un bucle for por ejemplo para imprimir cada uno de los elementos que se
encuentran dentro del conjunto, lo haría, pero sin respetar un orden, es decir, los
imprimiría en un orden arbitrario y no ordenado. En la siguiente imagen se
muestra cómo funciona un conjunto.

51
4.6 DICCIONARIOS

Los diccionarios son conjuntos de datos no ordenados donde cada dato está
formado por una clave que Python llama key y un valor llamado values. Cada
key debe ser único y no puede repetirse, aunque los values si pueden hacerlo.
El key siempre será el primer valor y el value será el segundo en cada par. Los
diccionarios se definen con un nombre seguido del operador igual y una apertura
y cierre de llaves.

Cada dato, tanto los keys como los values están entre comillas simples,
separados por dos puntos. Si el key o el value es un entero, entonces solo se
coloca la cifra sin las comillas. Para separar cada par se utiliza una coma, como
se puede apreciar en la siguiente imagen.

Para acceder a un value dentro de un diccionario, se hace de la siguiente forma:

52
También podemos acceder al value de un key a través del método get(key) el
cual recibe como argumento el key y devuelve como resultado el value
correspondiente a ese key, como se puede ver a continuación.

En el caso de querer acceder sólo a los keys de un diccionario, se hace de forma

similar a la utilizada para acceder a los values, como se refleja en la siguiente
imagen.

Para obtener todos los values del diccionario, se hace de igual forma que para
obtener los keys, pero utilizando la palabra values.

53
La cantidad de elementos que contiene un diccionario se puede obtener también
utilizando el método len(diccionario), el cual recibe como argumento el
diccionario del cual se desea saber su tamaño.

También se pueden insertar nuevos elementos al diccionario y hay dos formas

de hacerlo. Pasando el key y el value, o pasando el key y como value asignar
None, en el caso que no se quiera asignar ningún value.

54
Si se quiere eliminar un elemento del diccionario, se utiliza el método
pop(‘key’,’values’), el cual recibe como primer argumento el nombre del key y
como segundo argumento el value correspondiente al key que queremos
eliminar.

El método ítems() devuelve una lista formada por tuplas, donde cada una de
estas se conforma por el key y el value de cada elemento del diccionario.

55
Se puede eliminar el último elemento del diccionario a través del método
popitem(), el cual también se puede capturar en una variable, como se muestra
en la siguiente imagen.

4.7 RESUMEN

Colección: una forma de almacenar un conjunto de valores o variables de casi

cualquier tipo.

Hay cuatro tipos:

1.Tuplas (tuple): se escriben con paréntesis, pero pueden no llevarlos. Son

inmutables, acepta repetidos y es ordenada por lo que se puede acceder a
sus elementos mediante el índice. Se pueden concatenar.
2.Listas (list): se escriben con []. Son ordenadas (se puede acceder por el
índice), acepta repetidos y son mutables (se pueden cambiar, añadir o
eliminar sus elementos).

56
3.Conjuntos (set): se escriben con {}. No admiten datos repetidos y no están
ordenados. Sirven para saber si un dato está en él más rápidamente.
4.Diccionarios (dict): conjuntos de datos agrupados de dos en dos en los
que el primer dato es la clave y el segundo el valor, de esta manera
{dato:valor}. No están ordenados, pero sí son mutables. Para trabajar con
ellos se puede acceder solo a las claves, solo a los valores o a ambos.

57
UNIDAD 5. ENTRADAS Y SALIDAS DE
INFORMACIÓN

5.1 OBJETIVOS

El objetivo de este tema es utilizar las funciones de entrada y salida de datos,

así como dar formato a las salidas. En la programación es fundamental la fase
de lectura de datos bien por teclado o por otro tipo de interfaz para después sean
procesados y finalmente obtener una salida formateada de los datos procesados.

5.2 INTRODUCCIÓN

En Python, así como en otros lenguajes de programación, siempre existe la

necesidad de pedir al usuario de una aplicación que ingrese algún tipo de dato
que se requiere bien sea para comprobar su identidad, para darse del alta como
usuario, entre otros. Para ello, Python proporciona métodos, tanto para recoger
información del usuario, como para mostrarle información, lo cual se verá con
detalle a continuación.

5.3 FORMATOS DE ENTRADA DE INFORMACIÓN

Uno de los principales métodos que se utilizan en Python para recabar

información es el input(), que recoge información suministrada por el usuario a
través del teclado. El siguiente es un ejemplo sencillo.

58
El método input() una vez ejecutado, espera a que el usuario ingrese, en este
caso, el nombre el cual debe escribirse en el teclado y luego pulsar la tecla enter.
Si el usuario no pulsa la tecla enter el programa no se ejecutará. Además, la
información suministrada por el usuario a través del teclado se puede almacenar
en una variable, que por defecto es de tipo cadena.

Si se quisiera llevar a cabo una operación matemática con los datos que el
usuario ingresa por pantalla, lo único que habría que hacer es transformar el dato
que se recibe a entero mediante la palabra reservada que indica que es un
entero, int(), colocando entre sus paréntesis el input.

Si se quisiera recibir por parte del usuario cifras con decimales habría que hacer
la misma transformación pero en lugar de int() se escribiría float(). En la siguiente
imagen se ve cómo se lleva a cabo esta transformación.

En consecuencia, el método input() está preparado para recibir cualquier dato y

almacenarlo como tipo string. Sin embargo, cuando se emplea un método para

59
transformar el dato que se reciba entero, si el usuario ingresa letras, Python
devolverá un error como el que se muestra a continuación.

Igual pasará si se espera recibir un entero y el usuario ingresa un número flotante

o decimal. Por contra, cuando se espera un flotante y el usuario envía un entero,
por ejemplo, el número 15, Python lo acepta y lo entiende como 15.0, tal como
se puede observar en la siguiente imagen.

60
5.4 FORMATOS DE INFORMACIÓN

Los formatos de salida de información tienen que ver con la forma de cómo se
organizan los datos para que, cuando existe un gran volumen de información,
hacerlo de forma más eficiente.

La forma básica de mostrar la salida de un dato es a través del método print() el

cual se ha utilizado en cada uno de los ejemplos que se han mostrado
anteriormente. El método principal para dar formato a los datos que se quieren
mostrar es el format(), el cual recibe como parámetros una serie de argumentos
que se irán explicando más adelante.

La forma más sencilla del método ‘cadena’.format() es representar dentro de una

cadena un valor a través de una apertura y cierre de llaves {} El lugar que ocupan
las llaves dentro de la cadena, será el lugar que ocupe el valor que se ha pasado
como argumento al método format(), tal como se ilustra a continuación.

Si se quisiera mostrar primero el apellido pero además agregar la edad, se

tendría que escribir como primer valor dentro del format() el apellido ‘López’,
seguido del nombre. Para la edad se debe agregar un par de llaves más y definir
en qué lugar se desea ver este último valor. La siguiente imagen refleja la forma
de hacerlo.

61
Dentro del método format() cada valor posee un índice (empezando por cero,
correspondiendo al primer valor por la izquierda). En el caso del ejemplo, el valor
del índice cero dentro del format() corresponde a ‘López’, el valor del índice uno
corresponde a ‘Juan’ y así sucesivamente. Este índice se pasa como argumento
dentro del par de llaves y de esta forma se indica dónde se desea mostrar dentro
de la cadena el valor que se tiene dentro del índice del format(), tal como se
refleja a continuación:

Como se puede ver en la imagen anterior, el orden de los valores dentro del
format() no ha cambiado, es decir, se mantiene en el índice cero ‘López’, en el
índice uno ‘Juan’ y en el índice dos el valor 27. Sin embargo sí se ha cambiado
la forma mostrar la información y se reflejan los números de los índices de los
valores que se encuentran dentro del format() dentro de cada una de las llaves
de donde se quiere mostrar la información.

Otra forma de ingresar valores dentro del método format() es a través de

variables, como se verá a continuación.

La opción de insertar variables dentro del método format() da la posibilidad de

poder repetir una variables cuantas veces queramos, como se demuestra a
continuación.

62
Al texto también se le puede incorporar por ejemplo una cantidad de espacios
dentro del cual debe aparecer. Por ejemplo, para el nombre “Juan”, se le puede
decir a Python que aparezca dentro de un espacio de diez caracteres. Por lo cual
“Juan” al tener sólo cuatro caracteres, dejará seis espacios. Esos espacios
vacíos se pueden rellenar con una línea, un asterisco o el símbolo que se desee.
El método format() también puede alinear el texto a la izquierda, al centro o a la
derecha. Revisa en la siguiente imagen cómo funciona.

Como se puede ver en la imagen anterior, la alineación se hace sobre cada texto
que se quiere mostrar en pantalla. Para hacerlo, después del número de índice
se colocan dos puntos. Si después de los dos puntos colocamos un símbolo
“menor que” <, se indicará a Python que se quiere alinear el texto a la izquierda,
el símbolo ^ alineará el texto en el centro, y el símbolo > lo alineará a la derecha,
tal como se observa en la imagen Los espacios vacíos al alinear el texto pueden
ser rellenados con caracteres y para hacerlo, se debe colocar el carácter con el
que queremos rellenar los espacios vacíos a la izquierda del símbolo que se
ingrese para centrar.

63
El método format() ofrece la posibilidad de construir una tabla utilizando para ello
la cantidad de espacios en los que se quiere mostrar la información y ajustar la
alineación del texto como se ha explicado anteriormente. Para indicar a Python
qué tipo de dato se está alineando, después de la cantidad de espacios, se
escribe la letra “d” para indicar que son dígitos o la letra “s” para indicar que son
letras, como se observa a continuación.

Si lo que se busca es darle formato a valores flotantes, el número

correspondiente a la cantidad de espacios entre los cuales queremos que
aparezca la cifra debe ir seguido de un punto y luego un número con la cantidad
de decimales que se quiere en la cifra, seguido de una “f” para hacer referencia
a que es un dato flotante. Si la cifra contiene menos decimales y dentro de las
llaves se ha indicado que se desea tener más, el método format() incorporará
ceros por cada decimal que no tenga la cifra, en el caso contrario, truncará la
cantidad de decimales redondeando el último valor decimal hacia arriba o hacia
abajo, según las dos últimas cifras de los decimales como se observa en la
siguiente imagen.

64
La posibilidad de mostrar solo una parte de un texto almacenado en una variable
se puede realizar colocando dentro de las llaves, tras del índice del valor y de los
dos puntos, un punto seguido de la cantidad de caracteres que se quieren
mostrar del texto, es decir, si se tiene el nombre “Juan” y solo se quieren mostrar
las dos primeras letras del nombre, se haría de la siguiente forma {0:.2} o como
se ve en la siguiente imagen.

65
5.5 RESUMEN

Existen formas de ingresar datos en Python, uno de estos formatos de entrada

de información, es el método input(), que recoge la información introducida por
teclado. En el caso de introducir un número es importante indicarlo o con la
palabra int(), para número entero o float() para número decimal. Ya que si no lo
recoge como string.

Para salida de información se usa el método print() y para además dar formato
a los datos el método format(), con el cual indicamos dentro de los paréntesis los
valores que queremos introducir en una cadena y en esta se ponen las llaves {}
donde se introducirán los valores de forma ordenada. Aunque también se pueden
introducir los valores por índice. (Ejemplo: “Hola{0}”). O usar variables, en vez de
introducir directamente los valores en los paréntesis del método format(), de esta
forma se pueden repetir una variable las veces que queramos.

66
UNIDAD 6. FUNCIONES

6.1 OBJETIVOS

El objetivo de este tema es introducir el concepto de función en programación.

Ver las partes de que consta una función en Python, como se define
(implementación), como se le llama(ejecuta) y cómo se gestiona el paso de
parámetros a la misma, así como las diferentes técnicas de paso de parámetros
valor, posición, etc…).

6.2 INTRODUCCIÓN

Una función es un bloque varias líneas de código al cual el programador le asigna

un nombre de forma arbitraria, la cual puede recibir uno, varios o ningún
argumento de entrada. Las funciones ejecutan una secuencia de sentencias a
través de las cuales realizan las operaciones que el programador desea, y la
función puede ser llamada cuando se necesite, de lo contrario, la función no se
ejecuta, es decir, aun cuando una función haya sido incluida dentro del archivo
del código, si no se llama a la función, esta no se ejecuta.

Las funciones permiten modularizar un programa complejo en un conjunto de

partes más simples y además permite su reutilización en cada parte del
programa en donde se necesite ejecutar sin necesidad de volver a escribir más
líneas de código, tan sólo llamando a la función.

Para declarar una función en Python, se utiliza la palabra reservada def seguido
del nombre de la función, por ejemplo “suma” y luego entre paréntesis puede ir
el argumento que la función recibe como parámetro en caso de que lo tenga, y
luego se escriben dos puntos y se pulsa la tecla “enter”, lo cual hará que la
función se idente y allí es donde se incluirán las líneas de código que se buscan
ejecutar a través de la función. A continuación, se verá cómo se escribe una

67
función cuyo objetivo es sumar los valores que el programador le pasa como
argumento y al mismo tiempo, obtener de la función un resultado, que es lo que
se quiere obtener de la función.

Como se puede ver, dentro del nombre de la función, es decir, “suma”, se ha

nombrado dos parámetros: “a” y “b”, aunque también hubiesen podido ser “x”,”y”,
o cualquier otro nombre que el programador le hubiese querido asignar. Luego
en la siguiente línea de código se ha escrito la palabra reservada return que se
utiliza para indicar el resultado que devolverá la función, seguido de la operación
que se busca realizar a través de la función. Luego, se ha llamado a la función
“suma” en la siguiente línea, pero como se puede observar, no está alineada con
el return, pues de lo contrario estaríamos llamando a la función dentro de la
propia función lo que ocasiona que la función no se ejecute. Dentro de los
paréntesis se han incluido los valores 17 y 15, los cuales al llamar a la función
pasarán a convertirse en “a” y “b”, y que, al mismo tiempo, serán los valores
sobre los cuales se realice la operación que se ha definido dentro de la función
“suma”. Si se quisiera ver el resultado que ha devuelto la función, sería llamando
la función dentro de un print(). Esto funciona como se muestra en la siguiente
imagen.

68
6.3 ARGUMENTOS Y PARÁMETROS

A nivel conceptual, es importante establecer la diferencia entre qué es un

parámetro y qué es un argumento. Siguiendo la imagen anterior, los parámetros
son “a, “b”, y los argumentos son los valores que se envían a la función, es decir,
los valores 11 y 13. Los parámetros y argumentos pueden manejarse de distintas
formas dentro de una función, como se explicará a continuación.

6.3.1 Por posición

A nivel conceptual, es importante establecer la diferencia entre qué es un

parámetro y qué es un argumento. Siguiendo la imagen anterior, los parámetros
son “a”, “b”, y los argumentos son los valores que se envían a la función, es decir,
los valores 11 y 13. Los parámetros y argumentos pueden manejarse de distintas
formas dentro de una función, como se explicará a continuación.

6.3.2 Por nombre

En este caso, al llamar a la función, se asignan a cada parámetro los valores de

los argumentos que se envían para ejecutar la función.

69
6.3.3 Llamada sin parámetros

Se puede definir una función sin parámetros, por lo cual al momento de llamarla
no se enviará ningún argumento, pero aun así la función ejecutará las
operaciones que se encuentren dentro de ella, como se muestra a continuación:

Si en una función se han establecido parámetros, tratar de ejecutarla sin

asignarle argumentos, provocará el error que se puede ver en el siguiente
ejemplo.

70
6.3.4 Parámetros con valores por defecto

Una forma de evitar que una función devuelva error cuando se han establecido
parámetros y no se envían argumentos al momento de ejecutarla, es asignando
valores por defecto a los parámetros y de esta forma, decirle al programa que
siga una determinada instrucción si no se reciben argumentos, como se puede
ver a continuación.

6.4 ARGUMENTOS INDETERMINADOS

Una función puede establecer que va a recibir parámetros, pero el programador

no sabe qué argumentos ni cuántos va a enviar al llamar a la función.

71
6.4.1 Argumentos indeterminados por nombre

Para ello, Python establece una forma sencilla de hacerlo, colocando un

asterisco dentro de los paréntesis donde deben ir los parámetros seguido de una
palabra elegida de forma arbitraria por el programador, de la siguiente forma:

6.4.2 Argumentos indeterminados por nombre (clave, valor)

Funciona igual que en el ejemplo anterior de argumentos indeterminados por

nombres, pero agregando un valor a cada nombre y agregando un asterisco
adicional dentro de los paréntesis entre los que debe ir el parámetro, como se
muestra a continuación:

72
6.4.3 Argumentos indeterminados por nombre y por nombre
(clave, valor)

Es una función que recibe tanto argumentos indeterminados por nombres, como
argumentos indeterminados por clave y valor, como se verá en la siguiente
imagen.

6.5 RESUMEN

Las funciones son trozos de código que se pueden ejecutar múltiples veces, la
cual pueden recibir y devolver información para comunicarse con el proceso
principal. Para ser declarada posee la sentencia def usada para crear objetos de
funciones determinadas por el usuario. En ellas se pueden pasar valores que se
denominan (parámetros) y en la llamada los denominamos (argumentos).

Es importante resaltar que los argumentos que reciben una función pueden ser
por posición y por nombre.

Ejemplo:

Función por Posición Función por Nombre

>>> def multiplicacion(a, >>> def multiplicacion(a,

b):return a*b b):return a*b

73
>>> multiplicacion(2, 5)10 >>> multiplicacion(2, 5)10

74
UNIDAD 7. MANEJO DE ERRORES EN PYTHON

7.1 OBJETIVOS

El objetivo de este tema es poder controlar los diferentes tipos de errores en

tiempo de ejecución que se pueden producir en Python a la hora de interpretar
un programa. De este modo podremos hacer que nuestro programa no se
detenga ante un error en tiempo de ejecución y también poder controlarlo
realizando las acciones oportunas.

7.2 INTRODUCCIÓN

Los errores en Python están relacionados con la ejecución no correcta de un

programa debido a que una de las secuencias en las líneas de código contiene
algún tipo de error. Un ejemplo claro de esto sería una función que debe recibir
como parámetro dos argumentos y es llamada sin que se le pase ningún
argumento. Como se pudo observar anteriormente, Python devuelve un error,
que se puede ver a continuación.

75
7.3 TIPOS DE ERRORES

Los errores en Python no siempre son iguales. En el ejemplo anterior, el nombre

del error que devuelve es TypeError y esto se puede verificar en la cuarta línea
de la pantalla derecha de la imagen. Si se intenta pasar como argumentos a la
misma función dos variables a las que no se les ha agregado valor, el error que
nos devuelve es de tipo NameError como se muestra en la siguiente imagen.

Si se intenta dividir un valor entre cero (operación que no se puede realizar), el

error que se obtendría sería ZeroDivisionError, se puede ver en la función
división que se ha creado en el ejercicio siguiente.

Y así existen una gran cantidad de errores que pueden ocurrir en Python, que se
pueden conocer en la medida que se vayan ejecutando distintos programas. La
consecuencia de un error es la paralización del programa que se intenta ejecutar.

76
7.4 CAPTURA DE EROORES

Sin embargo, los errores pueden ser manejados y en caso de que un programa
entre en uno, se le puede indicar que ejecute una instrucción para de esta forma
no paralizar el programa, sino darle una vía de continuidad para su ejecución.
Para ello se utiliza un bloque de manejo de excepciones que utiliza las palabras
reservadas try y except. Para implementarlo, las instrucciones que se quieren
ejecutar se colocan dentro del try y en el caso de que llegara a ocurrir un error,
se inserta lo que se quiere ejecutar dentro del except como se muestra a
continuación.

Como se puede observar en la imagen anterior, la función ha intentado realizar

la operación, al no poder resolver el try, se ha ido dentro del except y ha
ejecutado la instrucción que allí se indica. El except es la forma general de
manejar cualquier tipo de error. Si se quisiera ejecutar una instrucción por cada
tipo error, primero se debería conocer el tipo de error para incluirlo dentro del
bloque. A continuación, se muestra en la imagen como se realiza.

77
Como se puede observar en la imagen anterior, se han incluido dos bloques
distintos para manejar dos errores distintos los cuales tienen su origen en lugares
distintos. ¿Por qué se hace de esta forma? Si se analiza bien, el error del tipo
ZeroDivisionError proviene de la línea de código return: a/b cuando se intenta
hacer la división. Por otro lado, si se intenta llamar a la función solo con un
argumento (cuando en realidad requiere dos), esto arroja el error TypeError y,
en consecuencia, el bloque try-except debe envolver el llamado a la función
porque es allí donde se origina el error y no en otro lugar, lo cual es exactamente
lo que ha ocurrido

7.5 CLÁUSULA FINALLY

Dentro del manejo de errores, adicional al “try-except”, también se tiene el bloque

“finally”, el cual es una instrucción que se ejecuta independientemente de lo que
ocurra, es decir, si entra o no en el error. En el siguiente ejemplo, la función entra
en el error, sin embargo, el bloque “finally” se ejecuta igualmente.

7.6 RESUMEN

Errores de sintaxis (SyntaxError)

Son los que podemos apreciar repasando el código, por ejemplo, al dejarnos de
cerrar un paréntesis:

78
Errores de nombre (NameError)

Se producen cuando el sistema interpreta que debe ejecutar alguna función,

método, pero no lo encuentra definido

Los errores semánticos

Son muy difíciles de identificar, ya que van ligados al sentido del funcionamiento
y dependen de la situación. Algunas veces pueden ocurrir y otras no.

Cuanta más experiencia como programador tengas, y más te hayas equivocado,

más aprenderás a avanzarte a los errores semánticos.

Las excepciones

Son bloques de código excepcionales que nos permiten continuar con la

ejecución de un programa pese a que ocurra un error.

Creando la excepción - Bloques try y except

Para prevenir el error, debemos poner el código propenso a error un bloque try
y luego encadenaremos un bloque except para tratar la excepción.

Bloque else en excepciones

Es posible encadenar un bloque else después del except para comprobar el caso
en que todo funcione correctamente (no se ejecuta la excepción).

El bloque else es un buen momento para romper la iteración con break si todo
funciona correctamente.

Bloque finally en excepciones

Por último, es posible utilizar un bloque finally que se ejecute al final del código,
ocurra o no ocurra un error.

79
UNIDAD 8. MÉTODOS DE ANÁLISIS Y
TRANSFORMACIÓN DE CADENAS

8.1 OBJETIVOS

El objetivo de este tema es ir viendo todas las funciones de las cadenas (clase
str) muy útiles en cualquier lenguaje de programación. Veremos cómo manipular,
analizar y procesar las cadenas de textos a través de todas las funciones que
nos ofrece la clase str (string).

8.2 INTRODUCCIÓN

Las cadenas poseen una serie de métodos que permiten analizarlas y también
transformarlas. A continuación, se mostrará con ejemplos cada uno de estos
métodos.

Para acceder a un elemento de la cadena, se utiliza el índice de la cadena, el

cual se inicia en cero. En el siguiente ejemplo se refleja cómo hacerlo.

Como se puede ver, se han impreso la letra “a” que corresponde al índice cero,
y la letra “b” que corresponde al índice uno. Pero también podemos mostrar un
segmento de la cadena, para hacerlo, luego del primer argumento, se colocan
dos puntos y se pasa el siguiente argumento, el cual indica hasta donde se quiere
obtener los valores de la cadena menos uno, es decir, si queremos obtener los

80
valores desde el índice cero hasta el índice 4, el segundo argumento que se debe
pasar es el número cinco, tal como se puede ver a continuación.

También existe una forma de obtener los valores de una cadena iniciando desde
el último índice, para ello, la cadena tiene un índice negativo, y si se quiere
obtener el último valor de la cadena, se le pasa entre corchetes el -1, como se
ve en el siguiente ejemplo.

Igualmente, se pueden obtener un segmento de la cadena utilizando un segundo

argumento de índice negativo como se muestra en la siguiente imagen.

Cuando se pasa más de un argumento, es decir, cuando se utilizan los dos

puntos, si no se escribe el argumento antes de los dos puntos, el argumento por
defecto será el índice cero de la cadena, o si no se pasa el segundo argumento
luego de los dos puntos, el argumento por defecto será el último índice de la
cadena, como se muestra en la siguiente imagen.

81
8.2.1 Método capitalize

Este método convierte la primera letra de la cadena en mayúscula. Si todas las

letras están en mayúscula, devuelve la cadena con la primera letra en mayúscula
y las siguientes en minúsculas. Si consigue en el primer elemento un espacio o
un carácter especial, devuelve la cadena a su estado original.

8.2.2 Método lower

Este método retorna una copia de la cadena en minúscula.

82
8.2.3 Método upper

Este método, al contrario de lower (), devuelve una copia de la cadena en letras
mayúsculas.

8.2.4 Método swapcase

Este método convierte las minúsculas a mayúsculas y viceversa.

8.2.5 Método title

Este método convierte la primera letra de cada palabra en mayúscula siempre y

cuando la letra sea minúscula, de lo contrario la deja igual.

83
8.2.6 Método center()

Este método centra una cadena dentro de una cantidad de espacios que recibe
como argumentos. Si la longitud de la cadena es más pequeña que la cantidad
de espacios que le damos como argumento, por defecto, los espacios restantes
estarán vacíos, pero si le pasamos un carácter como segundo argumento, llena
los espacios restantes con ese argumento. El segundo argumento no funciona
si no lo pasamos entre comillas o si le pasamos dos caracteres como argumento.

8.2.7 Método ljust()

Este método realiza una copia de la cadena y la alinea a la izquierda, funciona

igual que el método center() pero los espacios sobrantes los deja a la derecha
de la cadena.

84
8.2.8 Método rjust()

Este método realiza una copia de la cadena y la alinea a la derecha, funciona

igual que el método center() pero los espacios sobrantes los deja a la izquierda
de la cadena.

8.2.9 Método zfill(longitud)

Este método realiza el relleno con ceros a la izquierda hasta alcanzar la longitud
final indicada. Si hay 4 números y como argumento pasamos el 5, solo insertará
un cero a la izquierda.

85
8.2.10 Método count()

Este método retorna un entero con la cantidad de veces que aparece el

argumento que le damos, si no encuentra una coincidencia retorna 0. También
puede recibir dos argumentos más: desde qué parte de la cadena queremos
aplicar el método y dónde queremos que culmine. Este método distingue entre
mayúsculas, minúsculas y el índice de la ubicación dentro de la cadena inicia en
el 0.

8.2.11 Método find()

Este método retorna un entero indicando la posición del índice en el que se inicia
la subcadena, si no encuentra una coincidencia retorna -1. Además, puede
recibir dos argumentos más: desde qué parte de la cadena queremos aplicar el
método y dónde queremos que culmine. Este método distingue entre
mayúsculas, minúsculas y el índice de la ubicación dentro de la cadena inicia en
el 0. Este método inicia su búsqueda de izquierda a derecha y retorna la posición
en la que se encuentra la primera coincidencia. El argumento donde se inicia la
búsqueda toma en cuenta el carácter que se encuentra desde el índice que le
pasamos, pero el segundo argumento debe superar en al menos un índice la
subcadena que estamos buscando.

86
8.2.12 Método startwith()

Este método busca saber si una cadena empieza por una subcadena
determinada retornando True si encuentra la subcadena o False si no lo hace.
El argumento donde se inicia la búsqueda debe coincidir exactamente con el
índice en el cual inicia la subcadena y el segundo argumento debe superar en al
menos un índice la subcadena que estamos buscando. Distingue entre
mayúsculas y minúsculas.

8.2.13 Método endswith()

Este método busca saber si una cadena termina por una subcadena determinada
retornando True si encuentra la subcadena o False si no lo hace.

87
8.2.14 Método isalnum()

Este método evalúa si un carácter es alfabético o numérico. Devuelve True si la

cadena o el carácter contiene solo números y letras, de lo contrario devuelve
False.

8.2.15 Método isalpha()

Este método evalúa si un carácter es alfabético, devuelve True si la cadena o el

carácter son letras de lo contrario devuelve False. Este método incluye los
caracteres de otros alfabetos, como el ruso, chino, árabe, etc.

88
8.2.16 Método isnumeric()

Este método evalúa si un carácter es numérico, devuelve True si la cadena es

completamente numérica o el carácter es un número, de lo contrario devuelve
False. Este método admite números en otras codificaciones (como por ejemplo
en UTF-8 o en lenguajes orientales como por ejemplo chino tradicional) y
también fracciones, como por ejemplo ½ y potencias.

8.2.17 Método isdecimal()

Este método evalúa si un carácter se encuentra entre el 0 y el 9, devuelve True

si la cadena es completamente numérica o el carácter es un número entero
decimal, de lo contrario devuelve False.

8.2.18 Método isdigit()

Este método es completamente igual al método isnumeric(), excepto que no

admite números en otros idiomas (como el oriental) ni tampoco fracciones.

89
8.2.19 Método isspace()

Este método evalúa si el índice la cadena contiene solo espacios en blanco,

devuelve True si la cadena solo tiene espacios en blanco, de lo contrario
devuelve False. También lo podemos utilizar para evaluar un índice dentro de la
cadena.

8.2.20 Método istitle()

Este método evalúa si una cadena tiene formato de título, devuelve True si la
cadena tiene este formato, de lo contrario devuelve False. El formato de título
consiste en que la cadena debe empezar con una letra mayúscula. Admite un
punto y espacios.

90
8.2.21 Método replace()

Este método sustituye la cadena de una variable por la cadena de otra variable.
La cadena que queremos sustituir se debe insertar de forma literal al igual que
la cadena nueva que queremos incluir.

8.2.22 Método strip()

Este método elimina los espacios en blanco que se encuentran a la izquierda y

a la derecha de una cadena y devuelve la cadena sin estos espacios.

91
8.2.23 Método join()

Este método inserta una cadena dentro de otra tantas veces como queramos.
Para hacerlo, se llama a la variable con el valor que queremos insertar seguida
del punto y el método join(argumento), en el argumento pasamos la variable en
la que queremos insertar el valor. Para esta función es necesario incluir comas
dentro de la cadena que recibe el argumento que serán los lugares en donde se
incluirá el elemento que queremos agregar. Este método solo recibe strings, por
lo que si intentamos insertar un entero nos devolverá un error de atributo.

8.2.24 Método partition()

Este método convierte una cadena en una tupla de tres elementos. La forma en
como los divide es: un elemento que es todo lo que se encuentra antes del
argumento (subcadena que le pasamos como argumento), un segundo elemento
que es la propia subcadena que le pasamos y un tercer elemento que es todo lo
que se encuentra después del argumento. Evalúa la cadena de izquierda a
derecha y si el argumento existe varias veces, toma el primero que se consigue.
Si después del argumento no hay más elementos, como último elemento
devuelve una cadena vacía.

92
8.2.25 Método split()

Este método convierte una cadena en una lista con todas las subcadenas que
se encuentran en la cadena. Un segundo argumento indica la cantidad de índices
que queremos en la lista, lo cual limita la cantidad de elementos en los que se
dividirá la cadena

8.2.26 Método splitlines()

Crea una lista de elementos a partir de una cadena. El método divide la cadena
en un elemento para la nueva lista tomando en cuenta los caracteres de salto de
línea.

8.2.27 Método ord()

Este método nos permite conocer el código Unicode del carácter que se le pasa
como argumento. Acepta sólo un carácter como argumento y devuelve un entero,

93
lo que permite comparar si una letra es mayor que otra. Devuelve un error si se
le pasan dos caracteres o ninguno.

8.2.28 Operador > < == != en las cadenas

Permite comparar los códigos Unicode de cada cadena y devuelve un valor

booleano.

8.2.29 Método index(argumento)

Recibe un argumento y nos devuelve el índice en el que se encuentra o inicia. Si

no lo encuentra, devuelve un ValueError.

94
8.2.30 Método slice(argumento)

Este método permite obtener una o varias secciones de una cadena y lo hace
recibiendo argumentos. Para utilizar este método, se crea una variable a la que
se la pasa el método y los argumentos, como se muestra a continuación.

Como se puede ver, el método slice ha sido almacenado en una variable y para
aplicarlo luego se ha pasado entre corchetes, antecedido de la cadena a la que
se le ha aplicado el método. El número que se le ha pasado al método slice hace
referencia a los índices que se quieren obtener de la cadena menos uno, por eso
el método ha devuelto “fran” y no “franc”, por defecto empieza en el índice cero.

También se le puede indicar al método empezar de un número de índice distinto

de cero, para lo cual se le pasarán dos argumentos, como se muestra en el
siguiente ejemplo.

95
Este método también permite obtener un segmento de la cadena de forma
escalonada, se hace pasando un tercer argumento a través del cual el método
hace saltos entre índices de la cadena, como se ve a continuación.

El número que se ha pasado como tercer argumento al método ha hecho que

luego de tomar el carácter del primer índice, la “a”, cuente hasta tres para volver
a tomar el siguiente carácter, el cual ha sido el “d” y así sucesivamente. Una
forma abreviada de utilizar el método y tener los mismos resultados sería como
se refleja en la siguiente imagen.

96
8.3 RESUMEN

CADENAS

Podemos acceder a un elemento de una cadena utilizando el índice, el cual se

inicia en 0 y para acceder desde el final de la cadena se inicia en -1.

Para poder acceder a un trozo de la cadena o a elementos concretos, escribimos

el nombre de la cadena acompañada de corchetes, donde ponemos desde
donde hasta donde queremos acceder de la cadena (nombreCadena [a:b],
siendo a el primer índice (se incluye) y b el ultimo índice (no se incluye)).

Si se deja el índice ‘a’ en blanco se tomaría como un 0, mientras que si se deja

el índice ‘b’ en blanco se tomaría como el último índice de la cadena (imprimiendo
desde el primer índice hasta el final de la cadena)

Estos índices pueden ser tanto positivos como negativos, con la única regla que
el índice ‘a’ este más a la derecha en la cadena que el índice ‘b’.

Por ejemplo:

nombreCadena [-5:-1] à Es válido porque comienza desde el -5 (+ a la derecha

que el -1)

nombreCadena [-2:-5] à No es válido porque comienza desde el -2 (+ a la

izquierda que el -5)

En las cadenas encontramos métodos, los cuales nos permiten modificarlas y

analizarlas.

NombreCadena.metodo(argumento)

1. Método capitalize(): Convierte la primera letra de la cadena en

mayúsculas y las demás en minúsculas.
2. Método lower(): Convierte la cadena en minúscula
3. Método upper(): Convierte la cadena en mayúscula.

97
4. Método swapcase(): Lo que está en mayúscula lo convierte en minúscula
y viceversa.
5. Método title(): Convierte la primera letra de cada palabra en mayúscula.
6. Método center(): Centra la cadena dentro de una cantidad de caracteres
o espacios, consta de dos argumentos pero solo el primero es
indispensable.
7. Método ljust(): Igual que el center() pero alineándolo a la izqda.
8. Método rjust():Igual que el center() pero alineándolo a la drcha.
9. Método zfill(longitud): Rellena con 0 a la izq. hasta alcanzar la longitud
indicada
10. Método count(): Nos dice la cantidad de veces que aparece el argumento
11. Método find(): Nos indica la posición del argumento.
12. Método starswith(): Nos indica si una cadena empieza por una
subcadena determinada.
13. Método endswith(): Nos indica si una cadena termina por una subcadena
determinada.
14. Método isalnum(): Nos indica si un carácter es alfabético o numérico.
15. Método isalpha(): Nos indica si un carácter es alfabético.
16. Método isnumeric():Nos indica si un carácter es numérico.
17. Método isdecimal(): Nos indica si un carácter se encuentra entre el 0 y
el 9.
18. Método isdigit():
19. Método isspace()

98
UNIDAD 9. ENTORNO DE DESARROLLO ANACONDA
Y JUPYTER

Para programar en Phyton se ha venido utilizando el entorno de desarrollo en

línea repl.it, sin embargo, también existen otros entornos de desarrollo que
permiten crear y desarrollar proyectos en Python. Tal es el caso de Anaconda,
una suite orientada a la ciencia de datos de código abierto en la que a través de
los entornos Jupyter o Spider, se pueden desarrollar proyectos en Phyton al igual
que se ha venido haciendo en repl.it. En este caso, sólo nos enfocaremos en la
instalación de la suite Anaconda y de cómo usar Jupyter.

Para empezar la instalación de Anaconda, entramos en la dirección

https://www.anaconda.com/ y pulsamos el botón download para descargar la
última versión de la suite. Una vez se tenga descargado, se ejecuta.

99
100
101
La primera casilla no hace falta marcarla en la nueva versión de Python así que
se puede dejar desmarcada.

102
Accedemos desde inicio en Windows escribiendo la palabra anaconda en el
buscador, pulsamos en Anaconda Navigator que es el entorno que vamos a
manejar.

Luego se elige Jupyter Notebook y ya se podrá acceder al entorno de desarrollo.

103
Clicamos en launch y se abrirá en el navegador la interfaz de Jupyter en el puerto
8888

104
Esta estructura arranca desde la ubicación donde se encuentra la carpeta de
usuario dentro de Windows.

Se abre el Jupyter Notebook y se crea un nuevo bloc de notas, cada bloc de

notas está organizado en celdas.

105
En la barra de herramientas podremos seleccionar desde un desplegable el tipo
de programa dentro de cada celda, estas pueden mostrar código o simple
información.

Si se elige Mark Down el contenido será un lenguaje de marcado al estilo HTML

que servirá para poder poner comentarios formateados dentro del código, por
ejemplo, para poner un título.

106
Para confirmar la celda siempre se pulsan las teclas Shift + Intro. A continuación,
se muestran ejemplos de mark down:

Hay dos botones muy interesantes en la barra de herramientas:

107
Cada bloc de notas es una sesión independiente del intérprete de Python, es
decir, un archivo independiente en el cual se pueden guardar los proyectos que
se desarrollen.

108
 SIGUE LA ACTUALIDAD DE
ANDALUCÍA COMPROMISO DIGITAL
www.andaluciacompromisodigital.org

CONTACTA CON NOSOTROS

andalucia.compromisodigital@juntadeandalucia.es