Manual Sobre Python

2022
Python
Python es un lenguaje de alto nivel de programación interpretado cuya filosofía hace hincapié en la legibilidad
de su código, se utiliza para desarrollar aplicaciones de todo tipo, ejemplos: Instagram, Netflix, Spotify, Panda
3D, entre otros
Autor: Alejandro Enrique Ispache García

01 de octubre del 2022
5
INDICE
Introducción a la programación...................................................................................................3
Introducción a Python..................................................................................................................4
¿Qué es Python?..................................................................................................................4
Principales ventajas de Python.............................................................................................4
Tipos de ejecución........................................................................................................................4
Interpretado en fichero........................................................................................................4
Compilado a bytecode..........................................................................................................5
Compilado a ejecutable del sistema.....................................................................................5
Tipos de Datos Primitivos Simples..............................................................................................5
Tipos de datos primitivos simples........................................................................................5
Tipos de datos primitivos compuestos (contenedores)........................................................6
Clase de un dato (type..............................................................................................................6
Números (clases int y float)......................................................................................................6
Operadores aritméticos...........................................................................................................7
Operadores lógicos con números.............................................................................................7
Cadenas (clase str)................................................................................................................8
Subcadenas..............................................................................................................................9
Operaciones con cadenas.........................................................................................................9
Operaciones de comparación de cadenas................................................................................9
Utilizan el orden establecido en el código ASCII.......................................................................10
Funciones de cadenas........................................................................................................10
len(c) : Devuelve el número ...............................................................................................10
Cadenas formateadas (format(()).......................................................................................11
Datos lógicos o booleanos (clase bool)...............................................................................11
Tabla de verdad......................................................................................................................12
Conversión de datos primitivos simples.............................................................................12
Variables....................................................................................................................................13
Entrada y Salida por Terminal....................................................................................................13
Entrada por terminal (input(())...........................................................................................13
Salida por terminal (print(())...............................................................................................14
Condicionales.............................................................................................................................14
Bucles.........................................................................................................................................15
Bucles condicionales (while................................................................................................15
Alternativa:.........................................................................................................................16
5
Bucles iterativos (for).........................................................................................................16

Listas..........................................................................................................................................16
Creación de listas mediante la función list ()......................................................................17
Acceso a los elementos de una lista...................................................................................17
Sublistas.............................................................................................................................18
Operaciones que no modifican una lista............................................................................18
Operaciones que modifican una lista.................................................................................19
Copia de listas....................................................................................................................19
Tuplas.........................................................................................................................................20
Creación de Tuplas mediante la función tuples ()..............................................................20
Operaciones con Tuplas.....................................................................................................21
Diccionarios................................................................................................................................21
Acceso a los elementos de un diccionario..........................................................................22
Operaciones que no modifican un diccionario...................................................................22
Operaciones que modifican un diccionario........................................................................23
Copia de diccionarios.........................................................................................................23
Variables - Curso de Python desde cero.....................................................................................25
Como ejecutar un programa de Python.....................................................................................26
Cómo funcionan las variables.....................................................................................................26
https://youtu.be/dZq2SinHOg8..................................................................................................27
Cómo concatenar - Strings 2......................................................................................................27
Introducción a Python........................................................................................................29
Cómo instalar Python.................................................................................................................33
Cómo ejecutar programas en Python.........................................................................................33
Python 2 vs Python 3..............................................................................................................45
Básicos en Python......................................................................................................................46
Variables en Python...............................................................................................................46
Expresiones y declaraciones en Python.........................................................................47
Comentar..........................................................................................................................47
Indentación en Python....................................................................................................48
Tipos de datos en Python...........................................................................................................48
Operadores en Python...............................................................................................................50
Operador de asignación en Python....................................................................................51
Operadores aritméticos en Python....................................................................................51
Operadores de comparación en Python.......................................................................52
5
Operadores booleanos en Python.................................................................................52

Operadores bit a bit en Python......................................................................................53
is e in en Python...........................................................................................................54
El operador ternario en Python..................................................................................................54
Cadenas en Python.....................................................................................................................55
Booleanos en Python.................................................................................................................58
Python Intermedio.....................................................................................................................60
Introducción...............................................................................................................................60
Colecciones............................................................................................................................61
12.1. defaultdict.....................................................................................................................61
12.2. OrderedDict ............................................................................................................62
12.3. counter..........................................................................................................................63
12.4. deque ..............................................................................................................................63
12.5. namedtuple ...................................................................................................................64
12.6. enum.Enum (Python 3.4+)...............................................................................................66
Enumerados...........................................................................................................................67
introspección de objetos............................................................................................................68
14.1. dir ..............................................................................................................................68
14.2. type y id .................................................................................................................68
14.3. Módulo inspect .......................................................................................................69
Comprensión........................................................................................................................69
15.1. Comprensión de list .........................................................................................70
15.2. dict comprehensions........................................................................................70
15.3. set comprehensions..........................................................................................71
15.4. generator comprehensions.............................................................................71
Excepciones..............................................................................................................................71
16.1. Manejando múltiples excepciones:...........................................................................72
16.1.1. Uso de finally ..................................................................................................72
16.1.2. Uso de try/else ...............................................................................................73
Clases........................................................................................................................................73
17.1. 1. Variables de instancia y clase.................................................................................74
17.2. 2. Nuevo estilo de clases............................................................................................75
5
17.3. 3. Métodos mágicos....................................................................................................76

Funciones Lambda......................................................................................................................78
Ejemplos en 1 línea..................................................................................................................78
for/else ................................................................................................................................81
20.1. Uso del else .............................................................................................................82
Conclusión:.................................................................................................................................83
5
Introducció
n a la
programaci
ón que la programación es realizar una serie de órdenes a unos
Podemos decir
dispositivos que tradicionalmente ha sido órdenes o computadoras,
controles numéricos e inclusivo robot, para que realicen todo un
determinado número de acciones.
En la actualidad las cosas tecnológicas son una de la cosas más importante

que tenemos aprende a utilizar es una de las ramas que más usamos hoy en
la actualidad es una de las cosas que tiene hoy en fecha muchos más trabajo
que podemos encontrar por eso la programación y todo lo que sea
tecnológico es una de la cosas más importantes que nosotros debemos saber
por qué es una de las cosas que podemos encontrar más trabajo en la vida
actual.
Por eso en este manual vamos a enseñar el programa de python que es muy
importante que debemos de aprender en este manual se va a enseñar de la
manera más básica hasta la mas avanzada que es python.
5
Introducción a Python
¿Qué es Python?
Python es un lenguaje de programación de alto nivel multiparadigma que permite:
 Programación imperativa
 Programación funcional
 Programación orientada a objetos
Fue creado por Guido van Rossum en 1990 aunque actualmente es desarrollado y mantenido por
la Python Software Fundación.
Principales ventajas de Python
 Es de código abierto (certificado por la OSI).

 Es interpretable y comparable.
 Es fácil de aprender gracias a que su sintaxis es bastante legible para los humanos.
 Es un lenguaje maduro (29 años).
 Es fácilmente extensible e integrable en otros lenguajes (C, java).
 Esta mantenido por una gran comunidad de desarrolladores y hay multitud de recursos
para su aprendizaje.
Tipos de ejecución
Interpretado en la consola de Python
Se ejecuta cada instrucción que introduce el usuario de manera interactiva.
> python
>>> name = "Alf"
>>> print("Hola ", name)
Hola Alf
5
Interpretado en fichero
Se leen y se ejecutan una a una todas las instrucciones del fichero.

# Fichero hola.py
name = "Alf"
print("Hola ", name)
> python hola.py
Hola Alf
También se puede hacer el fichero ejecutable indicando en la primera línea la ruta hasta el
intérprete de Python.
#!/usr/bin/python3
name = "Alf"
print("Hola", name)
> chmod +x hola.py
> ./hola.py
Hola Alf
Compilado a bytecode
# Fichero hola.py
name = "Alf"
print("Hola " + name)
> python -O -m py_compile hola.py
> python __pycache__/hola.cpython-37.pyc
Hola Alf
Compilado a ejecutable del sistema
Hay distintos paquetes que permiten compilar a un ejecutable del sistema operativo usado, por
ejemplo pyinstaller.
> conda install pyinstaller
> pyinstaller hola.py
> ./dist/hola/hola
Hola Alf
Tipos de Datos Primitivos Simples

5
Tipos de datos primitivos simples
 Números (numbers): Secuencia de dígitos (pueden incluir el - para negativos y el . para

decimales) que representan números.
Ejemplo. 0, -1, 3.1415.
 Cadenas (strings): Secuencia de caracteres alfanuméricos que representan texto. Se

escriben entre comillas simples o dobles.
Ejemplo. ‘Hola’, “Adiós”.
Booleanos (boolean): Contiene únicamente dos elementos True y False que representan

los valores lógicos verdadero y falso respectivamente.
Estos datos son inmutables, es decir, su valor es constante y no puede cambia
Tipos de datos primitivos compuestos (contenedores)
 Listas (lists): Colecciones de objetos que representan secuencias ordenadas de objetos

de distintos tipos. Se representan con corchetes y los elementos se separan por comas.
Ejemplo. [1, “dos”, [3, 4], True].
 Tuplas (tuples). Colecciones de objetos que representan secuencias ordenadas de

objetos de distintos tipos. A diferencia de las listas son inmutables, es decir, que no
cambian durante la ejecución. Se representan mediante paréntesis y los elementos se
separan por comas.
Ejemplo. (1, ‘dos’, 3)
 Diccionarios (dictionaries): Colecciones de objetos con una clave asociada. Se

representan con llaves, los pares separados por comas y cada par contiene una clave y
un objeto asociado separados por dos puntos.
Ejemplo. {‘pi’:3.1416, ’e’:2.718}.
Clase de un dato (type)

La clase a la que pertenece un dato se obtiene con el comando type()
>>> type(1)
<class 'int'>
>>> type("Hola")
<class 'str'>
>>> type([1, "dos", [3, 4], True])
<class 'list'>
>>>type({'pi':3.1416, 'e':2.718})
<class 'dict'>
5
>>>type((1, 'dos', 3))

<class 'tuple'>
Números (clases int y float)
Secuencia de dígitos (pueden incluir el - para negativos y el. para decimales) que representan
números. Pueden ser enteros (int) o reales (float).
>>> type(1)
<class 'int'>
>>> type(-2)
<class 'int'>
>>> type(2.3)
<class 'float'>
Operadores aritméticos
Operadores aritméticos: + (suma), - (resta), * (producto), / (cociente), // (cociente división
entera), % (resto división entera), ** (potencia).
Orden de prioridad de evaluación:

1 Funciones predefinidas
2 Potencias
3 Productos y cocientes
4 Sumas y restas
Se puede saltar el orden de evaluación utilizando paréntesis ( ).
>>> 2+3
5
>>> 5*-2
-10
>>> 5/2
2.5
>>> 5//2
2
>>> (2+3)**2
25
Operadores lógicos con números

Devuelven un valor lógico o booleano.
5
Operadores lógicos: == (igual que), > (mayor que), < (menor que), >= (mayor o igual

que), <= (menor o igual que), != (distinto de).
>>> 3==3
True
>>> 3.1<=3
False
>>> -1!=1
True
Cadenas (clase str)
Secuencia de caracteres alfanuméricos que representan texto. Se escriben entre comillas
sencillas’ o dobles “.
'Python'
"123"
'True'
# Cadena vacía
''
# Cadena con un espacio en blanco
' '
# Cambio de línea
'\n'
# Tabulador
'\t'
Acceso a los elementos de una cadena

Cada carácter tiene asociado un índice que permite acceder a él.
Cadena P y t h o n
Índice positivo 0 1 2 3 4 5
Índice negativo -6 -5 -4 -3 -2 -1
C[i] devuelve el carácter de la cadena c con el índice i.

El índice del primer carácter de la cadena es 0.
También se pueden utilizar índices negativos para recorrer la cadena del final al principio.
El índice del último carácter de la cadena es -1.
5
>>> 'Python'[0]
'P'
>>> 'Python'[1]
'y'
>>> 'Python'[-1]
'n'
>>> 'Python'[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
Subcadenas
c[i:j:k] : Devuelve la subcadena de c desde el carácter con el índice i hasta el carácter anterior al
índice j, tomando caracteres cada k.
>>> 'Python'[1:4]
'yth'
>>> 'Python'[1:1]
''
>>> 'Python'[2:]
'thon'
>>> 'Python'[:-2]
'Pyth'
>>> 'Python'[:]
'Python'
>>> 'Python'[0:6:2]
'Pto'
Operaciones con cadenas
 c1 + c2 : Devuelve la cadena resultado de concatenar las cadenas c1 y c2.

 c * n : Devuelve la cadena resultado de concatenar n copias de la cadena c.
 c1 in c2 : Devuelve True si c1 es una cadena concernida en c2 y False en caso contrario.
 c1 not in c2 : Devuelve True si c1 es una cadena no concernida en c2 y False en caso
contrario.
>>> 'Me gusta ' + 'Python'

'Me gusta Python'
>>> 'Python' * 3
'PythonPythonPython'
>>> 'y' in 'Python'
True
>>> 'tho' in 'Python'
True
>>> 'to' not in 'Python'
True
5
Operaciones de comparación de cadenas
 c1 == c2 : Devuelve True si la cadena c1 es igual que la cadena c2 y False en caso

contrario.
 c1 > c2 : Devuelve True si la cadena c1 sucede a la cadena c2 y False en caso contrario.
 c1 < c2 : Devuelve True si la cadena c1 antecede a la cadena c2 y False en caso
contrario.
 c1 >= c2 : Devuelve True si la cadena c1 sucede o es igual a la cadena c2 y False en
caso contrario.
 c1 <= c2 : Devuelve True si la cadena c1 antecede o es igual a la cadena c2 y False en
caso contrario.
 c1 != c2 : Devuelve True si la cadena c1 es distinta de la cadena c2 y False en caso
contrario.
Utilizan el orden establecido en el código

ASCII.
>>> 'Python' == 'python'

False
>>> 'Python' < 'python'
True
>>> 'a' > 'Z'
True
>>> 'A' >= 'Z'
False
>>> '' < 'Python'
True
Funciones de cadenas
len(c) : Devuelve el número .
 min(c) : Devuelve el carácter menor de la cadena c.

 Max(c) : Devuelve el carácter mayor de la cadena c.
 c.upper() : Devuelve la cadena con los mismos caracteres que la cadena c pero
en mayúsculas.
 c.lower() : Devuelve la cadena con los mismos caracteres que la cadena c pero
en minúsculas.
 c.title() : Devuelve la cadena con los mismos caracteres que la cadena c con el
primer carácter en mayúsculas y el resto en minúsculas.
 c.split(delimitador) : Devuelve la lista formada por las Subcadenas que resultan
de partir la cadena c usando como delimitador la cadena delimitador. Si no se
especifica el delimitador utiliza por defecto el espacio en blanco.
5
>>> len('Python')
6
>>> min('Python')
'P'
>>> max('Python')
'y'
>>> 'Python'.upper()
'PYTHON'
>>> 'A,B,C'.split(',')
['A', 'B', 'C']
>>> 'I love Python'.split()
['I', 'love', 'Python']
Cadenas formateadas (format(())
 c.format(valores): Devuelve la cadena c tras sustituir los valores de la

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

'Un € vale 1.12 $'
>>> 'Un {2} vale {1} {0}'.format('€', 1.12, '$')
'Un $ vale 1.12 €'
>>> 'Un {moneda1} vale {cambio} {moneda2}'.format(moneda1 = '€',
cambio = 1.12, moneda2 = '$')
'Un € vale 1.12 $'
Los marcadores de posición, aparte de indicar la posición de los valores de reemplazo, pueden
indicar también el formato de estos. Para ello se utiliza la siguiente sintaxis:
 {:n} : Alinea el valor a la izquierda rellenando con espacios por la derecha hasta
los n caracteres.
 {:>n} : Alinea el valor a la derecha rellenando con espacios por la izquierda hasta
los n caracteres.
 {:^n} : Alinea el valor en el centro rellenando con espacios por la izquierda y por la
derecha hasta los n caracteres.
 {:nd} : Formatea el valor como un número entero con n caracteres rellenando con
espacios blancos por la izquierda.
 {:n.mf} : Formatea el valor como un número real con un tamaño de n caracteres
(incluido el separador de decimales) y m cifras decimales, rellenando con espacios
blancos por la izquierda.
>>> 'Hoy es {:^10}, mañana {:10} y pasado {:>10}'.format('lunes',
'martes', 'miércoles')
'Hoy es lunes , mañana martes y pasado miércoles'
>>> 'Cantidad {:5d}'.format(12)'
'Cantidad 12'
>>> 'Pi vale {:8.4f}'.format(3.141592)
'Pi vale 3.1416'
5
Datos lógicos o booleanos (clase bool)
Contiene únicamente dos elementos True y False que representan los valores lógicos

verdadero y falso respectivamente.
False tiene asociado el valor 0 y True tiene asociado el valor 1.
Operaciones con valores lógicos
 Operadores lógicos: == (igual
que), > (mayor), < (menor), >= (mayor o igual
que), <= (menor o igual que), != (distinto de).
 not b (negación) : Devuelve True si el dato
booleano b es False , y False en caso contrario.
 b1 and b2 : Devuelve True si los datos
booleanos b1 y b2 son True, y False en caso
contrario.
 b1 or b2 : Devuelve True si alguno de los datos
booleanos b1 o b2 son True, y False en caso
contrario.
Tabla de verdad
x y not x x and y x or y
False False True False False
False True True False True
True False False False True
True True False True True

>>> not True
False
>>> False or True
True
>>> True and False
False
>>> True and True
True
Conversión de datos primitivos simples
Las siguientes funciones convierten un dato de un tipo en otro, siempre y cuando la conversión
sea posible.
5
 int () convierte a entero.

Ejemplo. int('12') 12
int(True) 1
int('c') Error
 float () convierte a real.
Ejemplo. float('3.14') 3.14
float(True) 1.0
float('III') Error
 str () convierte a cadena.
Ejemplo. str(3.14) '3.14'
str(True) 'True'
 bool () convierte a lógico.
Ejemplo. bool('0') False
bool('3.14') True
bool('') False
bool('Hola') True
Variables
Una variable es un identificador ligado a algún valor.
Reglas para nombrarlas:
 Comienzan siempre por una letra, seguida de otras letras o números.
 No se pueden utilizarse palabras reservadas del lenguaje.
A diferencia de otros lenguajes no tienen asociado un tipo y no es necesario declararlas antes de
usarlas (tipado dinámico).
Para asignar un valor a una variable se utiliza el operador = y para borrar una variable se utiliza
la instrucción del.
lenguaje = 'Python'
x = 3.14
y = 3 + 2
# Asignación múltiple
a1, a2 = 1, 2
# Intercambio de valores
a, b = b, a
# Incremento (equivale a x = x + 2)
x += 2
# Decremento (equivale a x = x - 1)
x -= 1
# Valor no definido
x = None
del x
Entrada y Salida por Terminal

5
Entrada por terminal (input(())
Para asignar a una variable un valor introducido por el usuario en la consola se utiliza la
instrucción
Input (mensaje) : Muestra la cadena mensaje por la terminal y devuelve una cadena con la
entrada del usuario.
El valor devuelto siempre es una cadena, incluso si el usuario introduce un dato numérico.
>>> language = input('¿Cuál es tu lenguaje favorito? ')

¿Cuál es tu lenguaje favorito? Python
>>> language
'Python'
>>> age = input('¿Cuál es tu edad? ')
¿Cuál es tu edad? 20
>>> age
'20'
Salida por terminal (print(())
Para mostrar un dato por la terminal se utiliza la instrucción

Print (dato1,..., sep.=' ', end='\n', file=sys.stdout)
Donde
 dato1,... son los datos a imprimir y pueden indicarse tantos como se quieran separados
por comas.
 sep. establece el separador entre los datos, que por defecto es un espacio en blanco ' '.
 end indica la cadena final de la impresión, que por defecto es un cambio de línea \n.
 file indica la dirección del flujo de salida, que por defecto es la salida
estándar sys.stdout.
>>> print('Hola')
Hola
>>> name = 'Alf'
>>> print('Hola', name)
Hola Alf
>>> print('El valor de pi es', 3.1415)
El valor de pi es 3.1415
>>> print('Hola', name, sep='')
HolaAlf
>>> print('Hola', name, end='!\n')
Hola Alf!
Condicionales
Condicionales (if)
5
If condición1:
bloque código
elif condición2:
bloque código
…
else:
bloque código
Evalúa la expresión lógica condición1 y ejecuta el primer bloque de código si es True; si no,

evalúa las siguientes condiciones hasta llegar a la primera que es True y ejecuta el bloque de
código asociado. Si ninguna condición es True ejecuta el bloque de código después de else:.
Pueden aparecer varios bloques elif pero solo uno else al final.
Los bloques de código deben estar indentados por 4 espacios.
La instrucción condicional permite evaluar el estado del programa y tomar decisiones sobre qué
código ejecutar en función del mismo.
>>> edad = 14
>>> if edad <= 18 :
... print('Menor')
... elif edad > 65:
... print('Jubilado')
... else:
... print('Activo')
...
Menor
>>> age = 20
>>> if edad <= 18 :
... print('Menor')
... elif edad > 65:
... print('Jubilado')
... else:
... print('Activo')
...
Activo
Bucles
Bucles condicionales (while)
Hile condición:
bloque código
Repite la ejecución del bloque de código mientras la expresión lógica condición sea cierta.
Se puede interrumpir en cualquier momento la ejecución del bloque de código con la
instrucción break.
El bloque de código debe estar indentados por 4 espacios.

>>> # Pregunta al usuario por un número hasta que introduce 0.
>>> num = None
>>> while num != 0:
5
... num = int(input('Introduce un número: '))

...
Introduce un número: 2
>>>
Alternativa:
>>> # Pregunta al usuario por un número hasta que introduce 0.
>>> while True:
... num = int(input('Introduce un número: '))
... if num == 0:
... break
...
>>>
Bucles iterativos (for)
For i in secuencia:
bloque código
Repite la ejecución del bloque de código para cada elemento de la secuencia secuencia,
asignado dicho elemento a i en cada repetición.
Se puede interrumpir en cualquier momento la ejecución del bloque de código con la
instrucción break o saltar la ejecución para un determinado elemento de la secuencia
con la instrucción continúe.
El bloque de código debe estar indentado por 4 espacios.
Se utiliza fundamentalmente para recorrer colecciones de objetos como cadenas, listas, Tuplas o
diccionarios.
A menudo se usan con la instrucción range:
 range (fin): Genera una secuencia de números enteros desde 0 hasta fin-1.
 range (inicio, fin, salto): Genera una secuencia de números enteros
desde inicio hasta fin-1 con un incremento de salto.
>>> palabra = 'Python'
>>> for letra in palabra:
... print(letra)
...
P
y
t
h
o
n
>>> for i in range(1, 10, 2):
... print(i, end=", ")
...
5
1, 3, 5, 7, 9, >>>
Listas
Listas
Una lista es unas secuencias ordenadas de objetos de distintos tipos.
Se construyen poniendo los elementos entre corchetes [ ] separados por comas.
Se caracterizan por:
 Tienen orden.
 Pueden contener elementos de distintos tipos.
 Son mutables, es decir, pueden alterarse durante la ejecución de un programa.
# Lista vacía
>>> type([])
<class 'list'>
# Lista con elementos de distintos tipos
>>> [1, "dos", True]
# Listas anidadas
>>> [1, [2, 3], 4]
Creación de listas mediante la función list ()
Otra forma de crear listas es mediante la función list ().

List(c): Crea una lista con los elementos de la secuencia o colección c.
Se pueden indicar los elementos separados por comas, mediante una cadena, o mediante una
colección de elementos iterable.
>>> list()
[]
>>> list(1, 2, 3)
[1, 2, 3]
>>> list("Python")
['P', 'y', 't', 'h', 'o', 'n']
Acceso a los elementos de una lista
Se utilizan los mismos operadores de acceso que para cadenas de caracteres.

 l[i] : Devuelve el elemento de la lista l con el índice i.
5
El índice del primer elemento de la lista es 0.

>>> a = ['P', 'y', 't', 'h', 'o', 'n']
>>> a[0]
'P'
>>> a[5]
'n'
>>> a[6]
IndexError: list index out of range
>>> a[-1]
'n'
Sublistas
 l[i:j:k] : Devuelve la sublista desde el elemento de l con el índice i hasta el elemento

anterior al índice j, tomando elementos cada k.
>>> a = ['P', 'y', 't', 'h', 'o', 'n']
>>> a[1:4]
['y', 't', 'h']
>>> a[1:1]
[]
>>> a[:-3]
['y', 't', 'h']
>>> a[:]
['P', 'y', 't', 'h', 'o', 'n']
>>> a[0:6:2]
['P', 't', 'o']
Operaciones que no modifican una lista
 len (l): Devuelve el número de elementos de la lista l.

 min (l): Devuelve el mínimo elemento de la lista l siempre que los datos sean
comparables.
 max(l) : Devuelve el máximo elemento de la lista l siempre que los datos sean
comparables.
 sum (l): Devuelve la suma de los elementos de la lista l, siempre que los datos se
puedan sumar.
 dato in l: Devuelve True si el dato dato pertenece a la lista l y False en caso contrario.
 l.index (dato): Devuelve la posición que ocupa en la lista l el primer elemento con
valor dato.
 l.count (dato): Devuelve el número de veces que el valor dato está contenido en la
lista l.
 all (l): Devuelve True si todos los elementos de la lista l son True y False en caso
contrario.
 any (l) : Devuelve True si algún elemento de la lista l es True y False en caso contrario.
>>> a = [1, 2, 2, 3]
5
>>> len(a)
4
>>> min(a)
1
>>> max(a)
3
>>> sum(a)
8
>>> 3 in a
True
>>> a.index(2)
1
>>> a.count(2)
2
>>> all(a)
True
>>> any([0, False, 3<2])
False
Operaciones que modifican una lista
 l1 + l2: Crea una nueva lista concatenan los elementos de la listas l1 y l2.

 l.append (dato): Añade dato al final de la lista l.
 l.extend (sequencia): Añade los datos de sequencia al final de la lista l.
 l.insert (índice, dato): Inserta dato en la posición índice de la lista l y desplaza los
elementos una posición a partir de la posición índice.
 l.remove (dato): Elimina el primer elemento con valor dato en la lista l y desplaza los
que están por detrás de él una posición hacia delante.
 l.pop ([índice]): Devuelve el dato en la posición índice y lo elimina de la lista l,
desplazando los elementos por detrás de él una posición hacia delante.
 l.sort (): Ordena los elementos de la lista l de acuerdo al orden predefinido, siempre que
los elementos sean comparables.
 l.reverse (): invierte el orden de los elementos de la lista l.
>>> a = [1, 3]
>>> b = [2 , 4, 6]
>>> a.append(5)
>>> a
[1, 3, 5]
>>> a.remove(3)
>>> a
[1, 5]
>>> a.insert(1, 3)
>>> a
[1, 3, 5]
>>> b.pop()
6
>>> c = a + b
>>> c
[1, 3, 5, 2, 4]
>>> c.sort()
>>> c
[1, 2, 3, 4, 5]
>>> c.reverse()
>>> c
[5, 4, 3, 2, 1]
5
Copia de listas
Existen dos formas de copiar listas:

 Copia por referencia l1 = l2: Asocia a la variable l1 la misma lista que tiene asociada la
variable l2, es decir, ambas variables apuntan a la misma dirección de memoria.
Cualquier cambio que hagamos a través de l1 o l2 afectará a la misma lista.
 Copia por valor l1 = list (l2): Crea una copia de la lista asociada a l2 en una dirección de
memoria diferente y se la asocia a l1. Las variables apuntan a direcciones de memoria
diferentes que contienen los mismos datos. Cualquier cambio que hagamos a través
de l1 no afectará a la lista de l2 y viceversa.
>>> a = [1, 2, 3]
>>> # copia por referencia
>>> b = a
>>> b
[1, 2, 3]
>>> b.remove(2)
>>> b
[1, 3]
>>> a
[1, 3]
>>> a = [1, 2, 3]
>>> b = list(a)
>>> b
[1, 2, 3]
>>> b.remove(2)
>>> b
[1, 3]
>>> a
[1, 2, 3]
Tuplas
Tuplas
Una tulpa es unas secuencias ordenadas de objetos de distintos tipos.
Se construyen poniendo los elementos entre corchetes ( ) separados por comas.
 Tienen orden.
 Son inmutables, es decir, no pueden alterarse durante la ejecución de un programa.
Se usan habitualmente para representar colecciones de datos una determinada estructura

semántica, como por ejemplo un vector o una matriz.
# Tupla vacía
type(())
<class 'tuple'>
5
# Tupla con elementos de distintos tipos

(1, "dos", True)
# Vector
(1, 2, 3)
# Matriz
((1, 2, 3), (4, 5, 6))
Creación de Tuplas mediante la función tuples ()
Otra forma de crear Tuplas es mediante la función tuples ().

 tuples(c): Crea una tupla con los elementos de la secuencia o colección c.
Se pueden indicar los elementos separados por comas, mediante una cadena, o mediante una
colección de elementos iterable.
>>> tuple()
()
>>> tuple(1, 2, 3)
(1, 2, 3)
>>> tuple("Python")
('P', 'y', 't', 'h', 'o', 'n')
>>> tuple([1, 2, 3])
(1, 2, 3)
Operaciones con Tuplas
El acceso a los elementos de una tupla se realiza del mismo modo que en las listas.
También se pueden obtener subtuplas de la misma manera que las Sublistas.
Las operaciones de listas que no modifican la lista también son aplicables a las Tuplas.
>>> a = (1, 2, 3)
>>> a[1]
2
>>> len(a)
3
>>> a.index(3)
2
>>> 0 in a
False
>>> b = ((1, 2, 3), (4, 5, 6))
>>> b[1]
(4, 5, 6)
>>> b[1][2]
6
Diccionarios
Diccionarios
Un diccionario es una colección de pares formados por una clave y un valor asociado a la clave.
5
Se construyen poniendo los pares entre llaves { } separados por comas, y separando la clave del
valor con dos puntos:
 No tienen orden.
 Son mutables, es decir, pueden alterarse durante la ejecución de un programa.
 Las claves son únicas, es decir, no pueden repetirse en un mismo diccionario, y pueden
ser de cualquier tipo de datos inmutable.
# Diccionario vacío
type({})
<class 'dict'>
# Diccionario con elementos de distintos tipos
{'nombre':'Alfredo', 'despacho': 218, 'email':'asalber@ceu.es'}
# Diccionarios anidados
{'nombre_completo':{'nombre': 'Alfredo', 'Apellidos': 'Sánchez
Alberca'}}
Acceso a los elementos de un diccionario
 d[clave] devuelve el valor del diccionario d asociado a la clave clave. Si en el

diccionario no existe esa clave devuelve un error.
 d.get(clave, valor) devuelve el valor del diccionario d asociado a la clave clave. Si en el
diccionario no existe esa clave devuelve valor, y si no se especifica un valor por defecto
devuelve None.
>>> a = {'nombre':'Alfredo', 'despacho': 218,
'email':'asalber@ceu.es'}
>>> a['nombre']
'Alfredo'
>>> a['despacho'] = 210
>>> a
{'nombre':'Alfredo', 'despacho': 218, 'email':'asalber@ceu.es'}
>>> a.get('email')
'asalber@ceu.es'
>>> a.get('universidad', 'CEU')
'CEU'
Operaciones que no modifican un diccionario
 len (d): Devuelve el número de elementos del diccionario d.

 min (d): Devuelve la mínima clave del diccionario d siempre que las claves sean
comparables.
 Max (d): Devuelve la máxima clave del diccionario d siempre que las claves sean
comparables.
 sum (d): Devuelve la suma de las claves del diccionario d, siempre que las claves se
puedan sumar.
 clave in d : Devuelve True si la clave clave pertenece al diccionario d y False en caso
contrario.
 d.keys() : Devuelve un iterador sobre las claves de un diccionario.
 d.values() : Devuelve un iterador sobre los valores de un diccionario.
 d.items() : Devuelve un iterador sobre los pares clave-valor de un diccionario.
5

>>> len(a)
3
>>> min(a)
'despacho'
>>> 'email' in a
True
>>> a.keys()
dict_keys(['nombre', 'despacho', 'email'])
>>> a.values()
dict_values(['Alfredo', 218, 'asalber@ceu.es'])
>>> a.items()
dict_items([('nombre', 'Alfredo'), ('despacho', 218), ('email',
'asalber@ceu.es')])
Operaciones que modifican un diccionario
 d[clave] = valor : Añade al diccionario d el par formado por la clave clave y el

valor valor.
 d.update (d2). Añade los pares del diccionario d2 al diccionario d.
 d.pop (clave, alternativo): Devuelve del valor asociado a la clave clave del
diccionario d y lo elimina del diccionario. Si la clave no está devuelve el
valor alternativo.
 d.popitem (): Devuelve la tupla formada por la clave y el valor del último par añadido al
diccionario d y lo elimina del diccionario.
 del d[clave] : Elimina del diccionario d el par con la clave clave.
 d.clear (): Elimina todos los pares del diccionario d de manera que se queda vacío.
>>> a['universidad'] = 'CEU'
>>> a
{'nombre': 'Alfredo', 'despacho': 218, 'email': 'asalber@ceu.es',
'universidad': 'CEU'}
>>> a.pop('despacho')
218
>>> a
{'nombre': 'Alfredo', 'email': 'asalber@ceu.es', 'universidad': 'CEU'}
>>> a.popitem()
('universidad', 'CEU')
>>> a
{'nombre': 'Alfredo', 'email': 'asalber@ceu.es'}
>>> del a['email']
>>> a
{'nombre': 'Alfredo'}
>>> a.clear()
>>> a
{}
Copia de diccionarios
Existen dos formas de copiar diccionarios:

 Copia por referencia d1 = d2: Asocia la la variable d1 el mismo diccionario que tiene
asociado la variable d2, es decir, ambas variables apuntan a la misma dirección de
5
memoria. Cualquier cambio que hagamos a través de l1 o l2 afectará al mismo

diccionario.
 Copia por valor d1 = list(d2): Crea una copia del diccionario asociado a d2 en una
dirección de memoria diferente y se la asocia a d1. Las variables apuntan a direcciones
de memoria diferentes que contienen los mismos datos. Cualquier cambio que hagamos
a través de l1 no afectará al diccionario de l2 y viceversa.
>>> a = {1:'A', 2:'B', 3:'C'}
>>> b = a
>>> b
{1:'A', 2:'B', 3:'C'}
>>> b.pop(2)
>>> b
{1:'A', 3:'C'}
>>> a
{1:'A', 3:'C'}
>>> a = {1:'A', 2:'B', 3:'C'}
>>> b = dict(a)
>>> b
{1:'A', 2:'B', 3:'C'}
>>> b.pop(2)
>>> b
{1:'A', 3:'C'}
>>> a
{1:'A', 2:'B', 3:'C'}
Referencias
Referencias
Webs
 Python Sitio web de Python.
 Repl.it Entorno de desarrollo web para varios lenguajes, incluido Python.
 Python tutor Sitio web que permite visualizar la ejecución el código Python.
Libros y manuales
 Tutorial de Python Tutorial rápido de python.
 Python para todos Libro de introducción a Python con muchos ejemplos. Es de licencia
libre.
 Python para principiantes Libro de introducción Python que abarca orientación a
objetos. Es de licencia libre.
 Python cash course Libro de introducción a Python gratuito.
 Think python 2e. Libro de introducción a Python que abarca también algoritmos,
estructuras de datos y gráficos. Es de licencia libre.
 Learning Python Libro de introducción a Python con enfoque de programación
orientada a objetos.
Vídeos
 Curso “Python para todos”.
5
Videos de sobre cómo empezar a utilizar Python desde cero:
Curso Python 3 desde cero - Curso de programación profesional - YouTube
Introducción a Programación en Python - YouTube
Que es Python video:
¿Qué es PYTHON y para qué SIRVE? - YouTube
Variables - Curso de Python desde cero

Para empezar a programar deberás abrir un IDE o un editor de texto, en mi
caso, utilizaré Visual Studio Community como te dije en el capítulo anterior.
5
Si no sabes como crear un archivo donde empezar a escribir código, te

recomiendo que veas el vídeo.
Para escribir una variable, no necesitas ninguna palabra reservada,

simplemente dale un nombre y un valor.
 Código Python 
mensaje = "Bienvenidos al curso de Python"
Python
COPIAR
Si has programado en otros lenguajes de programación, puede que eches

en falta algo. ¿Un punto y coma quizás?
No, no falta nada, así es Python, da por terminada la línea donde acaba su
último caracter.
A lo largo de este curso, vas a ver lo simplificada que está la sintaxis
de Python y lo fácil que es aprenderlo.
Como ejecutar un programa de Python

Vamos al grano, que nuestro primer programa haga algo. Por ejemplo,
imprimir en la consola el valor de nuestra primera variable.
Cuando hablo de imprimir, me refiero a mostrar. Para imprimir el valor de
la variable mensaje, lo deberemos hacer con la función
predefinida print() y entre sus paréntesis escribe el nombre de la variable
que quieres mostrar.
Con esto tan fácil, ya has creado tu primer programa. Simple, pero
funciona:
print(mensaje)
Python
COPIAR
terminal Resultado en la consola terminal

Bienvenidos al curso de Python
Plain text
COPIAR
Cómo funcionan las variables

Las variables, varían. Vaya cosas, así que las variables pueden variar...
De eso se trata, las variables son susceptibles a cambios, por lo que en un
5
momento dado de tu programa, una variable puede tener un valor

de "Bienvenidos al curso de Python" y en otro momento que cambie o
varíe a cualquier otra cosa, como por ejemplo un número.
Vamos a poner lo que estoy diciendo en práctica. En Python, cambiar de
valor y de tipo de dato una variable es la cosa más sencilla del mundo, solo
tienes que decirle lo que quieres y Python lo hará por tí.
mensaje = 10
print(mensaje)
Python
COPIAR
En este ejemplo, estoy redeclarando la variable mensaje y no solo la cambio

de valor, si no que también le especifico otro tipo de dato como puede ser
un número.
El resultado es que se sustituye el valor primero por el segundo:
10
Plain text
COPIAR
El flujo de ejecución normal de Python es de arriba a abajo , por lo tanto,

primero lee la primera línea, después la segunda, hasta la última.
Quizás ahora no lo veas, pero cuando aprendas más, lo verás claro. Las
posibilidades de las variables son infinitas.
Un ejemplo real, es la variable salud que le podrías dar a un personaje de
un videojuego. Esta variable inicialmente valdría 100, por ejemplo. Con
diversos factores como un enemigo atacando, podemos hacer que el valor
de la variable salud vaya disminuyendo con los ataques y que cuando gane
algo de salud vaya aumentando, cuando se quede a 0 el jugador pierda, etc.
https://youtu.be/dZq2SinHOg8
Cómo concatenar - Strings 2

En este capítulo vamos a ver que es concatenar y cómo hacerlo.
Concatenar es sinónimo de unir, por lo tanto, cuando hablamos
de concatenar nos referimos a unir dos trozos de código o más.
Para concatenar en Python, hay que utilizar el operador + que también es
utilizado para sumar.
5
Mira este ejemplo, en las dos primeras variables (palabra_1 y palabra_2), hay

un string con una palabra. En la tercera variable (nombre_completo), utilizo
la concatenación para unir esos dos strings en uno solo:
palabra_1 = 'Programación'
palabra_2 = 'fácil'
nombre_completo = palabra_1 + palabra_2
print(nombre_completo)
Python
COPIAR

¡Vaya! La concatenación ha funcionado, no obstante, las palabras salen en la
consola juntas, sin un espacio.
Programaciónfácil
Plain text
COPIAR
¿Cómo arreglamos esto? Muy fácil, le puedes concatenar un espacio extra

dónde mejor te venga, mira unos ejemplos:
nombre_completo = palabra_1 + ' ' + palabra_2
Python
COPIAR

Programación fácil
Plain text
COPIAR
palabra_1 = 'Programación '
Python
COPIAR

Plain text
COPIAR
5
palabra_2 = ' fácil'
Python
COPIAR

Plain text
COPIAR
Son tres ejemplos ligeramente distintos con un mismo resultado, la

cuestión es que lleve el espacio donde toca.
Debes saber, que si intentas concatenar números, estos se van a sumar:

num1 = 10
num2 = 15
suma = num1 + num2
print(suma)
Python
COPIAR

25
Plain text
COPIAR
En cambio, si quieres juntar números literalmente (que quede así: 1015),

deberás envolver estos valores numéricos entre comillas simples '' o
dobles "", convirtiéndolos así en tipo de dato string:
num1 = '10'
num2 = '15'
suma = num1 + num2
print(suma)
Python
COPIAR

1015
Plain text
COPIAR
5
Dejo el capítulo aquí, en el siguiente, veremos cosas un poco más

avanzadas, algunos métodos para strings.
Introducción a Python
Python literalmente se está comiendo el mundo de la

programación. Está creciendo en popularidad y uso de
formas que no tienen precedentes en la historia de las
computadoras.
Python sobresale en una amplia variedad de

escenarios: las secuencias de comandos Shell, la
automatización de tareas y el desarrollo web son solo
algunos ejemplos básicos.
Python es el lenguaje preferido para data analysis y
machine learning, pero también puede adaptarse para
crear juegos y trabajar con dispositivos integrados.
Más importante aún, es el idioma elegido para las
carreras de ciencias de computación en universidades de
todo el mundo.
Muchos estudiantes aprenden Python como su primer
lenguaje de programación. Muchos lo están aprendiendo
ahora mismo y muchos más lo aprenderán en el futuro. Y
para muchos de ellos, Python será el único lenguaje de
programación que necesitarán.
Gracias a esta posición única, es probable que Python

crezca aún más en el futuro.
El lenguaje es simple, expresivo y bastante sencillo.
El ecosistema es enorme. Parece haber una biblioteca

para todo lo que puedas imaginar.
Python es un lenguaje de programación de alto nivel

adecuado para principiantes gracias a su sintaxis
intuitiva, su enorme comunidad y su ecosistema vibrante.
5
También es apreciado por profesionales de muchos

campos diferentes.
Técnicamente hablando, Python es un lenguaje

interpretado que no tiene una fase de compilación
intermedia como un lenguaje compilado, por ejemplo C o
Java.
Y como muchos lenguajes interpretados, se escribe

dinámicamente. Esto significa que no tienes que indicar
los tipos de variables que usas y las variables no están
vinculadas a un tipo específico.
Esto tiene pros y contras. En particular, escribes

programas más rápido, pero por otro lado tienes menos
ayuda de las herramientas para prevenir posibles errores.
Esto significa que conocerás ciertos problemas solo
ejecutando el programa en tiempo de ejecución.
Python admite una amplia variedad de paradigmas de

programación diferentes, incluida la programación
procedimental, la programación orientada a objetos y la
programación funcional. Es lo suficientemente flexible
como para adaptarse a muchas necesidades diferentes.
Creado en 1991 por Guido van Rossum, su popularidad

ha ido aumentando, especialmente en los últimos 5 años,
como muestra esta infografía de Tendencias de Google:
5
Lenguaje de
programación Python en Google Trends 2004 - Actualidad(Abr,2021)
Comenzar con Python es muy fácil. Todo lo que

necesitas es instalar el paquete oficial de python.org, para
Windows, macOS o Linux, y estarás listo para comenzar.
Si eres nuevo en la programación, en las siguientes
publicaciones te guiaremos para pasar de cero a
convertirte en programador Python.
E incluso si actualmente eres un programador que se

especializa en otro idioma, Python es un lenguaje que
vale la pena conocer porque creemos que solo seguirá
creciendo a partir de aquí.
Los lenguajes de nivel inferior como C++ y Rust pueden

ser excelentes para programadores expertos, pero son
desalentadores para empezar y requieren mucho tiempo
para dominarlos.
5
Python, por otro lado, es un lenguaje de programación

para todos: estudiantes, personas que hacen su trabajo
diario con Excel, científicos y más.
Es el idioma que todos los interesados en programar

deberían aprender primero.
Cómo instalar Python

Ve a https://www.python.org, elije el menú Downloads
(descargas), elije tu sistema operativo y aparecerá un
panel con un enlace para descargar el paquete oficial:
Asegúrate de seguir las instrucciones específicas para tu

sistema operativo. En macOS puedes encontrar una guía
detallada(inglés) en https://flaviocopes.com/python-
installation-macos/.
Cómo ejecutar programas en Python

Hay algunas formas diferentes de ejecutar programas
Python.
5
En particular, hay una distinción entre el uso de mensajes

interactivos, donde se escribe código Python y se ejecuta
inmediatamente; y guardar un programa Python en un
archivo y ejecutarlo.
Comencemos con indicaciones interactivas.
Si abres la terminal y escribes python, verás una pantalla

parecida a esta:
Este es el Python REPL(Read-Evaluate-Print-Loop).
REPL es un entorno de programación computacional simple

e interactivo que toma las entradas individuales del
usuario, las evalúa y devuelve el resultado al usuario; un
programa escrito en un entorno REPL es ejecutado por
partes.
Observa el símbolo >>> y el cursor después de eso.
Puedes escribir cualquier código Python ahí y presionar
la tecla enter para ejecutarlo.
Por ejemplo, intenta definir una nueva variable usando
nombre = "Flavio"
y luego imprime su valor, usando print():
print(nombre)
5
Nota: en el REPL, también puedes escribir el nombre,

presionar la tecla enter y obtendrás el valor de vuelta.
Pero en un programa, no verás ningún resultado si lo
haces; deberás usar print() en su lugar.
Cualquier línea de Python que escribas ahí se ejecutará
inmediatamente.
Escribe quit() para salir de este REPL de Python.

Puedes acceder al mismo mensaje interactivo utilizando
la aplicación IDLE que Python instala automáticamente:
Esto te podría ser más conveniente porque con el mouse

puedes moverte y copiar/pegar más fácilmente que con el
terminal.
5
Esos son los básicos que vienen con Python de forma

predeterminada. Sin embargo, recomiendo que
instales IPython, probablemente la mejor aplicación REPL
de línea de comandos que puedas encontrar.
Instálalo con
pip install ipython

Asegúrate de que los binarios pip estén en tu path(ruta), y
ejecuta ipython:
ipython es otra interfaz que te permite trabajar con un

REPL de Python y proporciona algunas características
interesantes como resaltado de sintaxis, finalización de
código y mucho más.
La segunda forma de ejecutar un programa Python es
escribir el código de tu programa Python en un archivo,
por ejemplo program.py:
5
y luego ejecútalo con python program.py:
Ten en cuenta que guardamos los programas de Python

con la extensión .py, eso es una convención.
En este caso, el programa se ejecuta como un todo, no
una línea a la vez. Y así es como normalmente
ejecutamos los programas.
Usamos REPL para la creación rápida de prototipos y

para el aprendizaje.
En Linux y macOS, un programa Python también se

puede transformar en un script de shell, anteponiendo
todo su contenido con una línea especial que indica qué
ejecutable usar para ejecutarlo.
En mi sistema, el ejecutable de Python se encuentra

en /usr/bin/python3, así que
escribo #!/usr/bin/python3 en la primera línea:
5
Entonces puedo establecer el permiso de ejecución en el

archivo:
chmod u+x program.py

y puedo ejecutar el programa con
./program.py
Esto es especialmente útil cuando escribes scripts que

interactúan con el terminal.
Tenemos muchas otras formas de ejecutar programas

Python.
Una de ellas es usando VS Code, y en particular la

extensión oficial de Python de Microsoft:
5
Después de instalar esta extensión, tendrás

autocompletado de código Python y verificación de
errores, formateo automático y verificación de código
con pylint, y algunos comandos especiales, que
incluyen:
Python: start REPL para ejecutar REPL en la terminal
integrada:
5
Python: Run Python File in Terminal para ejecutar el

archivo actual en la terminal:
Python: Run Current File in Python Interactive

Window (Ejecutar archivo actual en Ventana Interactiva
Python)
5
y muchos más. Simplemente abre la paleta de comandos

(View -> Command palette, o Cmd/Ctrl+Shift+P ) y
escribe python para ver todos los comandos relacionados
con Python:
Otra forma de ejecutar fácilmente el código Python es
usar repl.it, un sitio web muy agradable que proporciona
un entorno de programación en el que puedes crear y
ejecutar tus aplicaciones, en cualquier lenguaje, incluido
Python:
5
Regístrate (es gratis), luego, en create a repl, haz clic en

Python:
5
e inmediatamente se mostrará un editor con un

archivo main.py, listo para ser llenado con una gran
cantidad de código Python:
5
Una vez que tengas algo de código, haz clic en Run para

ejecutarlo en el lado derecho de la ventana:
5
Creemos que repl.it es útil porque:

 puedes compartir código fácilmente con solo compartir el
enlace
 varias personas pueden trabajar en el mismo código
 puede albergar grandes programas de ejecución
 puedes instalar paquetes
 proporciona una base de datos de clave-valor para aplicaciones
más complejas
Python 2 vs Python 3
Un tema clave que debemos abordar, desde el principio,
es la discusión de Python 2 vs Python 3.
Python 3 se introdujo en 2008 y ha estado en desarrollo

como la versión principal de Python, mientras que Python
5
2 se mantuvo con correcciones de errores y parches de

seguridad hasta principios de 2020.
En esa fecha, se descontinuó el soporte a Python 2.
Muchos programas todavía se escriben con Python 2, y

las organizaciones aún trabajan activamente en ellos,
porque la migración a Python 3 no es trivial y requeriría
mucho trabajo actualizar esos programas. Y las
migraciones grandes e importantes siempre introducen
nuevos errores.
Pero el código nuevo, a menos que tengas que cumplir

con las reglas establecidas por tu organización que
obliguen a usar Python 2, siempre debe escribirse en
Python 3.
Este libro se enfoca en Python 3.
Básicos en Python
Variables en Python
Podemos crear una nueva variable de Python asignando
un valor a una etiqueta, usando el operador de
asignación =.
En este ejemplo asignamos una cadena con el valor
"Roger" a nombre:
nombre = "Roger"
Aquí tienes un ejemplo con un número:
edad = 8
Un nombre de variable puede estar compuesto por
caracteres, números y el carácter de subrayado _. No
puede empezar con un número. Todos estos son
nombres de variables válidos:
nombre1
5
EDAD
eDAD
a11111
mi_nombre
_nombre
Estos son nombres de variables inválidos:
123
prueba!
nombre%
Aparte de eso, cualquier cosa es válida a menos que sea
una palabra clave de Python. Hay algunas palabras clave
como for, if, while, import y más.
No es necesario memorizarlos, ya que Python te alertará
si usas uno de ellos como variable, y los reconocerás
gradualmente como parte de la sintaxis del lenguaje de
programación Python.
Expresiones y declaraciones en Python

Podemos expresar cualquier tipo de código que devuelva
un valor. Por ejemplo
1 + 1
"Roger"
Una declaración, por otro lado, es una operación sobre
un valor. Por ejemplo, estas son 2 declaraciones:
nombre = "Roger"
print(nombre)
Un programa está formado por una serie de
declaraciones. Cada declaración se coloca en su propia
línea, pero puedes usar un punto y coma para tener más
de una declaración en una sola línea:
nombre = "Roger"; print(nombre)
Comentar
En un programa de Python, todo lo que aparece después
de una marca # se ignora y se considera un comentario.
#esto es una linea comentada
5
nombre = "Roger" #esto es un comentario en-linea
Indentación en Python
La indentación en Python es significativa.
No puede indentar aleatoriamente así:
nombre = "Flavio"
print(nombre)
Algunos otros lenguajes no tienen espacios en blanco
significativos, pero en Python, el indentado es importante.
En este caso, si intentas ejecutar este programa,

obtendrás un error IndentationError: unexpected indent,
porque el indentado tiene un significado especial.
Todo lo indentado pertenece a un bloque, como una
declaración de control o un bloque condicional, o una
función o cuerpo de clase. Veremos más sobre ellos más
adelante.
Tipos de datos en Python

Python tiene varios tipos integrados.
Si creas la variable nombre asignándole el valor "Roger",

automáticamente esta variable ahora representa un tipo
de datos String(cadena)
nombre = "Roger"
Puedes verificar el tipo de una variable usando la
función type(), pasando la variable como un argumento y
luego comparando el resultado con str
nombre = "Roger"
type(nombre) == str #True
O usando isinstance():
nombre = "Roger"
isinstance(nombre, str) #True
5
Ten en cuenta que para ver el valor True (verdadero) en

Python, fuera de un REPL, debes envolver este código
dentro de print(), pero para mayor claridad, evitamos
usarlo
Usamos la clase str aquí, pero lo mismo funciona para
otros tipos de datos.
Primero, tenemos números. Los números enteros se
representan mediante la clase int. Los números
flotantes,decimales o fracciones, son de tipo float:
edad = 1
type(edad) == int #True
fraccion = 0.1
type(fraccion) == float #True
Viste cómo crear un tipo a partir de un valor literal, como
este:
nombre = "Flavio"
edad = 20
Python detecta automáticamente el tipo a partir del tipo
de valor.
También puedes crear una variable de un tipo específico

utilizando el constructor de clase, pasando un valor literal
o un nombre de variable:
nombre = str("Flavio")
otroNombre = str(nombre)
También puedes convertir de un tipo a otro utilizando el
constructor de clases. Python intentará determinar el
valor correcto, por ejemplo, extrayendo un número de una
cadena:
edad = int("20")
print(edad) #20
fraccion = 0.1
5
fraccionEntera = int(fraccion)
print(fraccionEntera) #0
A esto se le llama casting. Por supuesto, es posible que
esta conversión no siempre funcione según el valor
pasado. Si escribes prueba en lugar de 20 en la cadena
anterior, obtendrás unValueError: invalid literal for
int() with base 10: 'prueba'.
Esos son solo los conceptos básicos de los tipos.
Tenemos muchos más tipos en Python:
 complex para números complejos
 bool para booleanos(verdadero/falso)
 list para listas
 tuple para tuplas
 range para rangos
 dict para diccionarios
 set para conjuntos(sets)
¡y más!
Los exploraremos todos pronto.
Operadores en Python
Los operadores de Python son símbolos que usamos
para ejecutar operaciones sobre valores y variables.
Podemos dividir los operadores en función del tipo de

operación que realizan:
 Operador de asignación
 Operadores aritméticos
 Operadores de comparación
 Operadores lógicos
 Operadores bit a bit
además de algunos interesantes como is e in.
5
Operador de asignación en Python
El operador de asignación se utiliza para asignar un valor

a una variable:
edad = 8
O para asignar un valor de variable a otra variable:
edad = 8
otraVariable = edad
Desde Python 3.8, el operador walrus(morsa) := se usa
para asignar un valor a una variable como parte de otra
operación. Por ejemplo, dentro de un if o en la parte
condicional de un bucle. Más sobre eso luego.
Operadores aritméticos en Python
Python tiene varios operadores

aritméticos: +,-, , / (división), %(resto), **(exponenciación)
y // (división de piso):
1 + 1 #2
2 - 1 #1
2 * 2 #4
4 / 2 #2
4 % 3 #1
4 ** 2 #16
4 // 2 #2
Ten en cuenta que no necesitas un espacio entre los
operandos, pero es bueno para la legibilidad.
- también funciona como un operador unario negativo:
print(-4) #-4
+ también se usa para concatenar valores de cadena:
"Roger" + " es un buen perro"
#Roger es un buen perro
Podemos combinar el operador de asignación con
operadores aritméticos:
 +=
5
 -=
 *=
 /=
 %=
 ...y así
Ejemplo:
edad = 8
edad += 1
#edad es ahora 9
Operadores de comparación en Python

Python define algunos operadores de comparación:
 ==
 !=
 >
 <
 >=
 <=
Puedes usar esos operadores para obtener un valor
booleano (True o False) según el resultado:
a = 1
b = 2
a == b #False
a != b #True
a > b #False
a <= b #True
Operadores booleanos en Python

Python nos da los siguientes operadores booleanos:
 not
 and
 or
5
Cuando se trabaja con atributos True o False, estos

funcionan como "Y", "O" y "NO" lógicos, y a menudo se
usan en la evaluación de la expresión condicional if:
condicion1 = True
condicion2 = False
not condicion1 #False

condicion1 and condicion2 #False
condicion1 or condicion2 #True
De lo contrario, presta atención a una posible fuente de
confusión:
or usado en una expresión devuelve el valor del primer

operando que no es un valor falso (False, 0, '', []...). De
lo contrario, devuelve el último operando.
print(0 or 1) ## 1
print(False or 'hey') ## 'hey'
print('hola' or 'hey') ## 'hola'
print([] or False) ## 'False'
print(False or []) ## '[]'
Los documentos de Python lo describen como :
si "x" es falso, entonces "y", si no "x".

and solo evalúa el segundo argumento si el primero es
verdadero. Entonces, si el primer argumento es falso
(False, 0, '', []...), devuelve ese argumento. De lo
contrario, evalúa el segundo argumento:
print(0 and 1) ## 0
print(1 and 0) ## 0
print(False and 'hey') ## False
print('hola' and 'hey') ## 'hey'
print([] and False ) ## []
print(False and [] ) ## False
Los documentos de Python lo describen como:
si "x" es falso, entonces "x", si no "y"
Operadores bit a bit en Python
5
Algunos operadores se utilizan para trabajar con bits y

números binarios:
 & realiza el binario AND

 | realiza el binario OR
 ^ realiza una operación binaria XOR
 ~ realiza una operación binaria NOT
 << operación shift left
 >> operación shift right
Los operadores bit a bit se utilizan raramente, solo en
situaciones muy específicas, pero vale la pena
mencionarlos.
is e in en Python
is se llama el operador de identidad. Se utiliza para
comparar dos objetos y devuelve verdadero si ambos son
el mismo objeto. Más sobre objetos luego.
in se llama el operador de membresía. Se utiliza para
saber si un valor está contenido en una lista o en otra
secuencia. Más sobre listas y otras secuencias luego.
El operador ternario en Python

El operador ternario en Python permite definir
rápidamente un condicional.
Digamos que tienes una función que compara una

variable de edad con el valor 18 y
devuelve True o False según el resultado.
En lugar de escribir:
def es_adulto(edad):
if edad > 18:
return True
else:
return False
5
Puedes implementarlo con el operador ternario de esta

manera:
def es_adulto(edad):
return True if edad > 18 else False
Primero defines el resultado si la condición es verdadera,
luego evalúas la condición, luego defines el resultado si la
condición es falsa:
<resultado_si_es_verdadero> if <condicion> else <resultado_si_es_falso>
Cadenas en Python
Una cadena en Python es una serie de caracteres entre
comillas o comillas dobles:
"Roger"
'Roger'
Puedes asignar un valor de cadena a una variable:
nombre = "Roger"
Puedes concatenar dos cadenas usando el operador +:
frase = "Roger" + " es un buen perro"
Puedes agregar a una cadena usando +=:
nombre = "Roger"
nombre += " es un buen perro"
print(nombre) #Roger es un buen perro

Puedes convertir un número en una cadena usando el
constructor de clase str:
str(8) #"8"
Esto es esencial para concatenar un número a una
cadena:
print("Roger tiene " + str(8) + " a_os de edad")

#Roger tiene 8 a_os de edad
5
Una cadena puede ser de varias líneas cuando se define

con una sintaxis especial, encerrando la cadena en un
conjunto de 3 comillas:
print("""Roger tiene
a_os de edad
""")
#comillas dobles o simples
print('''
Roger tiene
a_os de edad
''')
Una cadena tiene un conjunto de métodos integrados,
como:
 isalpha() para comprobar si una cadena contiene solo

caracteres y no está vacía
 isalnum() para comprobar si una cadena contiene caracteres o
dígitos y no está vacía
 isdecimal() para comprobar si una cadena contiene dígitos y
no está vacía
 lower() para obtener una versión en minúsculas de una cadena
 islower() para comprobar si una cadena está en minúsculas
 upper() para obtener una versión en mayúsculas de una cadena
 isupper() para comprobar si una cadena está en mayúsculas
 title() para obtener una versión capitalizada de una cadena
 startsswith() para comprobar si la cadena comienza con una
subcadena específica
5
 endswith() para comprobar si la cadena termina con una

subcadena específica
 replace() para reemplazar una parte de una cadena
 split() para dividir una cadena en un separador de caracteres
específico
 strip() para recortar el espacio en blanco de una cadena
 join() para agregar nuevas letras a una cadena
 find() para encontrar la posición de una subcadena
Y muchas mas.
Ninguno de esos métodos altera la cadena original. En su

lugar, devuelven una cadena nueva y modificada. Por
ejemplo:
nombre = "Roger"
print(nombre.lower()) #"roger"
print(nombre) #"Roger"
También puedes usar algunas funciones globales para
trabajar con cadenas.
En particular, pienso en len(), que te da la longitud de

una cadena:
nombre = "Roger"
print(len(nombre)) #5
El operador in te permite verificar si una cadena contiene
una subcadena:
nombre = "Roger"
print("ger" in nombre) #True
Escapar es una forma de agregar caracteres especiales a
una cadena.
Por ejemplo, ¿cómo agregas una comilla doble en una

cadena que está envuelta en comillas dobles?
nombre = "Roger"
"Ro"Ger" nofuncionará, ya que Python pensará que la
cadena termina en "Ro".
5
El camino a seguir es hacer escapar a a las comillas

dobles dentro de la cadena, con el carácter \ (barra
invertida):
nombre = "Ro\"ger"
#"Ro"ger"
Esto también se aplica a las comillas simples \' y a los
caracteres de formateo especial como \t para
tabulación, \n para nueva línea y \\ para la barra
invertida.
Dada una cadena, puedes obtener sus caracteres usando
corchetes cuadrados para obtener un elemento
específico, dado su índice, comenzando desde cero [0]:
nombre = "Roger"
nombre[0] #'R'
nombre[1] #'o'
nombre[2] #'g'
El uso de un número negativo comenzará a contar desde
el final:
nombre = "Roger"
nombre[-1] #"r"
También puedes usar un rango, usando lo que
llamamos rebanar(slicing):
nombre = "Roger"
nombre[0:2] #"Ro"
nombre[:2] #"Ro"
nombre[2:] #"ger"
Booleanos en Python
Python proporciona el tipo bool , que puede tener dos
valores: True (Verdadero) y False (Falso) (capitalizado).
hecho = False
hecho = True
Los booleanos son especialmente útiles con estructuras
de control condicionales como declaraciones if :
hecho = True
5
if hecho:
# Ejecuta algun codigo
else:
# Ejecuta algun otro codigo
Al evaluar un valor para True o False, si el valor no es
un bool , tenemos algunas reglas dependiendo del tipo
que estemos verificando:
 los números son siempre True excepto el número 0,
 las cadenas son False solo cuando están vacías '',
 las listas, tuplas, conjuntos y diccionarios son False solo
cuando están vacíos.
Puedes verificar si un valor es booleano de esta manera:
hecho = True
type(hecho) == bool #True
O usando isinstance(), pasando 2 argumentos: la
variable y la clase bool :
hecho = True
isinstance(hecho, bool) #True
La función global any() también es muy útil cuando se
trabaja con valores booleanos, ya que
devuelve True si alguno de los valores del iterable (lista,
por ejemplo) pasado como argumento es True :
libro_1_leido = True
libro_2_leido = False
algun_libro_leido = any([libro_1_leido, libro_2_leido])

#True
La función global all() es la misma, pero
devuelve True si todos los valores que se le pasan
son True:
ingredientes_comprados = True
comida_preparada = False
list_para_servir = all([ingredientes_comprados, comida_preparada])

#False
5
Python Intermedio
Introducción
Python es un lenguaje de programación increíble con una comunidad de
programadores de las más fuertes, y es cada vez más usado en gran cantidad
de ámbitos e industrias. Sin embargo, muchas veces es difícil encontrar
documentación, y sobre todo en Español. En ellibrodepython.com estamos
comprometidos con la enseñanza en Python, y colaboramos tanto con
contenido propio como con traducciones. Es una pena que siendo el Español
un idioma tan hablado, sea tan complicado encontrar documentación de
calidad. No todo el mundo entiende Inglés perfectamente, y aunque ese sea el
caso, ¿no resulta más fácil de leer el contenido escrito en tu lengua materna?
El idioma nunca puede ser una barrera en la educación.
Este libro recopila diferentes conceptos de Python de un nivel intermedio, por lo

que para poder leerlo fácilmente es necesario tener unas bases del lenguaje de
programación. El libro no pretende ser una referencia, sino un complemento a
la documentación oficial, que muchas veces resulta difícil de leer y poco
didáctica, sobre todo para gente que está empezando.
Aún así, estoy seguro de que sea cual sea tu nivel, habrá algo para ti en este
libro. Tanto si eres un principiante como si tu nivel es intermedio, verás nuevos
conceptos que pronto podrás empezar a utilizar en tu día a día. Por otro lado si
eres un experto, estoy seguro de que tal vez encuentres alguna forma de
colaborar, por lo que estaríamos encantados de escucharte.
Este libro está en continua evolución, por lo que asegúrate de que tienes la
última, y si tienes cualquier sugerencia estamos abiertos a ellas a través del
repositorio de GitHub.
5
Colecciones
Python viene con un modulo que contiene varios contenedores de datos
llamados colecciones o collections en Inglés. Hablaremos de algunos de ellos
y de sus usos.
En concreto, hablaremos de los siguientes:
 defaultdict
 OrderedDict
 counter
 deque
 namedtuple
 enum.Enum (fuera del módulo; Python 3.4+)
12.1. defaultdict
Personalmente uso defaultdict bastante. A diferencia
de dict con defaultdict no tienes que verificar que una llave o key este
presente. Es decir, puedes hacer lo siguiente:
from collections import defaultdict
colours = (
('Asturias', 'Oviedo'),
('Galicia', 'Ourense'),
('Extremadura', 'Cáceres'),
('Galicia', 'Pontevedra'),
('Asturias', 'Gijón'),
('Cataluña', 'Barcelona'),
)
ciudades = defaultdict(list)
for name, colour in colours:

ciudades[name].append(colour)
print(ciudades)
# Salida
# defaultdict(<type 'list'>,
# {'Extremadura': ['Cáceres'],
# 'Asturias': ['Oviedo', 'Gijón'],
# 'Cataluña': ['Silver'],
# 'Galicia': ['Ourense', 'Pontevedra']
# })
5
Una de las ocasiones en las que son más útiles, es si quieres añadir elementos
a listas anidadas dentro e un diccionario. Si la llave o key no está ya presente
en el diccionario, tendrás un error tipo KeyError . El uso de defaultdict permite
evitar este problema. Antes de nada, vamos a ver un ejemplo con dict que
daría un error KeyError como hemos mencionado, y después veremos la
solución usando defaultdict .
Problema:
some_dict = {}
some_dict['region']['ciudad'] = "Oviedo"
# Raises KeyError: 'region'
Solución:
from collections import defaultdict

tree = lambda: defaultdict(tree)
some_dict = tree()
some_dict['region']['ciudad'] = "Oviedo"
# ¡Funciona!
Ahora podrías imprimir también el diccionario some_dict usando json.dumps .
Aquí tienes un ejemplo:
import json
print(json.dumps(some_dict))
# Output: {"region": {"ciudad": "Oviedo"}}
12.2. OrderedDict
OrderedDict es un diccionario que mantiene ordenadas sus entradas según van
siendo añadidas. Es importante saber también que sobreescribir un valor
existente no cambia la posición de la llave o key. Sin embargo, eliminar y
reinsertar una entrar mueve la llave al final del diccionario.
Problema:
colours = {"Rojo" : 198, "Verde" : 170, "Azul" : 160}

for key, value in colours.items():
print(key, value)
# Salida:
# Verde 170
# Azul 160
# Rojo 198
# Las entradas son recuperadas en un orden no predecible.
Solución:
from collections import OrderedDict
colours = OrderedDict([("Rojo", 198), ("Verde", 170), ("Azul", 160)])

for key, value in colours.items():
5
print(key, value)
# Output:
# Rojo 198
# Verde 170
# Azul 160
# El orden de inserción se mantiene.
12.3. counter
El uso de counter nos permite contar el número de elementos que una llave
tiene. Por ejemplo, puede ser usado para contar el número de colores favoritos
de diferentes personas.
from collections import Counter
colours = (
('Covadonga', 'Amarillo'),
('Pelayo', 'Azul'),
('Xavier', 'Verde'),
('Pelayo', 'Negro'),
('Covadonga', 'Rojo'),
('Amaya', 'Plata'),
)
favs = Counter(name for name, colour in colours)

print(favs)
# Salida: Counter({
# 'Covadonga': 2,
# 'Pelayo': 2,
# 'Xavier': 1,
# 'Amaya': 1
# })
También podemos contar las líneas más comunes de un fichero, como por
ejemplo:
with open('nombre_fichero', 'rb') as f:

line_count = Counter(f)
print(line_count)
12.4. deque
deque proporciona una cola con dos lados, lo que significa que puedes añadir y
eliminar elementos de cualquiera de los lados de la cola. Primero debes
importar el módulo de la librería de colecciones o collections:
from collections import deque

Una vez importado ya podemos crear el objeto:
d = deque()
Tienen un comportamiento relativamente similar a las conocidas listas de
Python, y sus métodos son también similares. Puedes hacer lo siguiente:
5
d = deque()
d.append('1')
d.append('2')
d.append('3')
print(len(d))
# Salida: 3
print(d[0])
# Salida: '1'
print(d[-1])
# Salida: '3'
También puedes tomar elementos de los dos lados de la cola, una
funcionalidad conocida como pop. Es importante notar que pop devuelve el
elemento eliminado.
d = deque(range(5))
print(len(d))
# Salida: 5
d.popleft()
# Salida: 0
d.pop()
# Salida: 4
print(d)
# Salida: deque([1, 2, 3])
También podemos limitar la cantidad de elementos que la cola deque puede
almacenar. Al hacer esto, simplemente quitará elementos del otro lado de la
cola si el límite es superado. Se ve mejor con un ejemplo como se muestra a
continuación:
d = deque([0, 1, 2, 3, 5], maxlen=5)

print(d)
# Salida: deque([0, 1, 2, 3, 5], maxlen=5)
d.extend([6])
print(d)
#Salida: deque([1, 2, 3, 5, 6], maxlen=5)
Ahora cuando insertamos valores después del 5, la parte más a la izquierda
será eliminada de la lista. También puedes expandir la lista en cualquier
dirección con valores nuevos.
d = deque([1,2,3,4,5])
d.extendleft([0])
d.extend([6,7,8])
print(d)
# Salida: deque([0, 1, 2, 3, 4, 5, 6, 7, 8])
12.5. namedtuple
5
Tal vez conozcas ya las tupas, que son listas inmutables que permiten
almacenar una secuencia de valores separados por coma. Son simplemente
como las listas pero con algunas diferencias importantes. La principal es que a
diferencia de las listas no puedes reasignar el valor de un elemento una vez
inicializada. Para acceder a un índice de la tupla se hace de la siguiente
manera:
man = ('Pelayo', 30)

print(man[0])
# Output: Pelayo
Sabido esto, ¿qué son las namedtuples ?. Se trata de un tipo que convierte las
tuplas en contenedores bastante útiles para tareas simples. Con ellas, no
necesitas usar índices enteros para acceder a los miembros de la misma.
Puedes pensar en ellas como si fuesen diccionarios, con la salvedad de que
son inmutables. Veamos un ejemplo.
from collections import namedtuple
Animal = namedtuple('Animal', 'nombre edad tipo')

perry = Animal(nombre="perry", edad=31, tipo="cat")
print(perry)
# Salida: Animal(nombre='perry', edad=31, tipo='cat')
print(perry.nombre)
# Salida: 'perry'
Puedes ver como es posible acceder a los elementos a través de su nombre,
simplemente haciendo uso de . . Vamos a verlo con más detalle.
Una namedtuple requiere de dos argumentos. Estos son, el nombre de la tupla y
los campos de la misma. En el ejemplo anterior hemos visto como el nombre
de la tupla era “Animal” y tenía tres atributos: “nombre”, “edad” y “tipo”.
Las namedtuple son muy útiles ya que hacen que las tuplas tengan una especie
de documentación propia, y apenas sea necesaria una explicación de como
usarlas, ya que puedes verlo con un simple vistazo al código. Además, dado
que no es necesario usar índices, hace que sea más fácil de mantener.
Otra de las ventajas es que son bastante ligeras, y no necesitan mas memoria
que las tuplas normales. Esto hace que sean mas rápidas que los diccionarios.
Sin embargo, recuerda que los atributos de las tuplas son inmutables, por lo
que no pueden ser modificados. El siguiente ejemplo no funcionaría:

5

perry.edad = 42
# Salida: Traceback (most recent call last):

# File "", line 1, in
# AttributeError: can't set attribute
Deberías usar las namedtuple si quieres que tu código sea autodocumentado. Lo
mejor de todo es que ofrecen compatibilidad con las tuplas, por lo que puedes
indexarlas como si de una tupla normal se tratase. Veamos un ejemplo:

print(perry[0])
# Salida: perry
Por último, aunque no por ello menos importante, puedes convertir una
namedtuple en un diccionario. Se puede hacer de la siguiente manera:

perry = Animal(nombre="Perry", edad=31, tipo="cat")
print(perry._asdict())
# Salida: OrderedDict([('nombre', 'Perry'), ('edad', 31), ...
12.6. enum.Enum (Python 3.4+)

Otra de las colecciones más útiles de Python es el tipo enum, que se
encuentra disponible en el módulo enum desde Python 3.4 en adelante (también
está disponible como backport en PyPI bajo el nombre enum32 ). Los enums
(enumerated type) son básicamente una forma de organizar aquellos nombres
que puedan tomar un determinado número de estados limitados y claramente
definidos.
Vamos a considerar el ejemplo anterior en namedtuples del Animal. Si

recuerdas, había un campo denominado tipo . El problema de este tipo es que
era una cadena. ¿Qué pasaría si escribimos Gato o GATO ?
El uso de enum nos puede ayudar a resolver este problema, evitando por lo
tanto usar cadenas. Veamos el siguiente ejemplo:

from enum import Enum
class Especies(Enum):
gato = 1
perro = 2
5
caballo = 3
lobo = 4
mariposa = 5
buho = 6
# ¡Y muchos más!
# Se pueden usar también alias

gatito = 1
perrito = 2
Animal = namedtuple('Animal', 'name age type')

perry = Animal(name="Perry", age=31, type=Especies.gato)
caballo = Animal(name="HorseLuis", age=4, type=Especies.caballo)
tom = Animal(name="Tom", age=75, type=Especies.lobo)
luna = Animal(name="Luna", age=35, type=Especies.gatito)
# Y un ejemplo
>>> perry.type == luna.type
True
>>> luna.type
<Especies.gato: 1>
Un código así es mucho menos propenso a tener fallos. Si necesitamos ser
específicos, deberíamos usar sólo los tipos enumerados.
Por último, existen tres formas de acceder a los enum. Sigamos con el ejemplo
anterior de las especies. Vamos a acceder a gato:
Especies(1)
Especies['cat']
Especies.cat
Con esto finalizamos una breve introducción al módulo de collections de
Python. Si quieres saber más, te recomendamos que leas la documentación
oficial de Python, que aunque pueda ser un poco más técnica y menos
didáctica, con esta introducción ya deberías estar list@ para entenderla
Enumerados
Python viene con un tipo por defecto denominado Enumerate. Permite asignar
índices a elementos de, por ejemplo una lista. Veamos un ejemplo:
for contador, valor in enumerate(lista):

print(contador, valor)
También acepta un parametro opcional que que lo hace aún más útil.
mi_lista = ['Ibias', 'Pesoz', 'Tineo', 'Boal']

for c, valor in enumerate(mi_lista, 1):
print(c, valor)
# Salida:
# 1 Ibias
# 2 Pesoz
# 3 Tinero
# 4 Boal
5
Este argumento opcional nos permite decirle al enumerate el primer elemento
del índice. También puedes creas tuplas que contengan el índice y la lista. Por
ejemplo:
mi_lista = ['Ibias', 'Pesoz', 'Tineo', 'Boal']

lista_contador = list(enumerate(mi_lista, 1))
print(lista_contador)
# Salida: [(1, 'Ibias'), (2, 'Pesoz'), (3, 'Tineo'), (4, 'Boal')]
introspección de objetos
En el mundo de la programación, la instrospección es la habilidad para
determinar el tipo de un objeto en tiempo de ejecución, y se trata de una de las
mejores características de Python. En Python todo es un objeto, y podemos
examinarlos de manera muy sencilla con las funciones por defecto que se nos
proporcionan.
14.1. dir
A continuación explicaremos el uso de dir y como podemos usarla. Se trata de
una de las funciones clave para la introspección de objetos en Python. Nos
devuelve una lista con todos los atributos y métodos que un determinado objeto
tiene.
mi_lista = [1, 2, 3]
dir(mi_lista)
# Salida: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
# '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
# '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',
# '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
# '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__',
# '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop',
# 'remove', 'reverse', 'sort']
Como podemos ver, se nos devuelven todos los atributos y métodos en una
lista. Esto puede ser útil si no recuerdas el nombre de un método y no tienes la
documentación a mano. Si ejecutamos dir() sin ningún argumento, se nos
devolverá todos los nombres en el scope actual.
14.2. type y id

La función type nos devuelve el tipo de un objeto:
5
print(type(''))
# Salida: <type 'str'>
print(type([]))
# Salida: <type 'list'>
print(type({}))
# Salida: <type 'dict'>
print(type(dict))
# Salida: <type 'type'>
print(type(3))
# Salida: <type 'int'>
Por otro lado, id devuelve un id o identificador único para cada objeto.
nombre = "Pelayo"
print(id(nombre))
# Salida: 139972439030304
14.3. Módulo inspect

El módulo inspect nos proporciona diferentes funciones para consultar
información de objetos. Por ejemplo, puedes consultar los miembros de un
objeto ejecutando el siguiente código:
import inspect
print(inspect.getmembers(str))
# Salida: [('__add__', <slot wrapper '__add__' of ... ...
Existen también otros métodos para realizar introspección sobre objetos. Te
recomendamos que consultes la documentación oficial y leas sobre ellos.
Comprensión
La comprensión o comprehensions en Python son una de las características
que una vez sabes usarlas, echarias mucho de menos si las quitaran. Se trata
de un tipo de construcción que permite crear secuencias a partir de otras
secuencias. Existen diferentes comprehensions soportadas en Python 2 y
Python 3:
 Comprensión de listas
 Comprensión de diccionarios
 Comprensión de sets
 Comprensión de generadores
A continuación las explicaremos una por una. Una vez que entiendes el uso
con las listas, cualquiera de las otras será entendia my fácilmente.
5
15.1. Comprensión de list

Las comprensiones de listas nos proporcionan una forma corta y concisa de
crear listas. Se usan con corchetes [] y en su interior contienen una expresión
seguida de un bucle for y cero o más sentencias for o if . La expresión
puede ser cualquier cosa que se te ocurra, lo que significa que puedes usar
cualquier tipo de objetos en la lista. El resultado es una nueva lista creada tras
evaluar las expresiones que haya dentro.
Uso
variable = [out_exp for out_exp in input_list if out_exp == 2]
Aquí mostramos un ejemplo:
multiples = [i for i in range(30) if i % 3 == 0]

print(multiples)
# Salida: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
Esto puede ser realmente útil para crear listas de manera rápida. De hecho hay
gente que las prefiere sobre el uso de la función filter . Las comprensiones de
listas son la mejor opción si por ejemplo quieres añadir elementos a una lista
fruto de un bucle for . Si queremos hacer algo como lo siguiente:
squared = []
for x in range(10):
squared.append(x**2)
Se podría simplificar en una línea de código con el uso de las comprensiones

de listas:
squared = [x**2 for x in range(10)]
15.2. dict comprehensions

Los diccionarios se usan de una manera muy similar. Aquí vemos un ejemplo:
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {
k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
for k in mcase.keys()
}
# mcase_frequency == {'a': 17, 'z': 3, 'b': 34}

5
En el ejemplo anterior combinamos los valores de las llaves o keys del

diccionario que sean las mismas pero en mayúsculas o minúsculas. Es decir, el
contenido de “a” y “A” se juntaría.
Otro ejemplo podría ser invertir las llaves y valores de un diccionario como se
muestra a continuación:
{v: k for k, v in some_dict.items()}
15.3. set comprehensions

Las comprensiones en los sets son muy similares a las listas. La única
diferencia es que es necesario hacer uso de llaves {} en vez de corchetes.
squared = {x**2 for x in [1, 1, 2]}

print(squared)
# Output: {1, 4}
15.4. generator comprehensions

Por último, tenemos los generadores. La única diferencia es que no asignan
memoria para toda la lista, sino que la asignan elemento a elemento, lo que las
hace mas eficientes desde el punto de vista del uso de la memoria.
multiples_gen = (i for i in range(30) if i % 3 == 0)

print(multiples_gen)
# Salida: <generator object <genexpr> at 0x7fdaa8e407d8>
for x in multiples_gen:
print(x)
# Salida numbers
Excepciones
El manejo de excepciones es un arte que una vez que entiendes resulta de lo
mas útil. Vamos a ver como pueden ser manejadas en Python.
Nota: Si aún no sabes muy bien lo que son las excepciones, te recomendamos
empezar por este post y este otro, donde se explican de manera muy sencilla y
didáctica.
Empecemos con el uso de try/except . El código que puede causar una
excepción se pone en el try y el código que maneja esa excepción se ubica en
el bloque except . Veamos un ejemplo:
5
try:
file = open('test.txt', 'rb')
except IOError as e:
print('Ocurrió un IOError {}'.format(e.args[-1]))
En ejemplo anterior estamos manejando la excepción IOError . Otra cosa que
veremos a continuación es que en realidad podemos manejar varias
excepciones.
16.1. Manejando múltiples excepciones:

Podemos manejar las excepciones de tres maneras distintas. La primera
consiste en poner todas las excepciones que puedan ocurrir separadas por
coma, en una tupla. Se muestra a continuación:
try:
except (IOError, EOFError) as e:
print("Ocurrió un error. {}".format(e.args[-1]))
Otra forma es manejar las excepciones de manera individual, creando un
bloque except para cada una. Veamos un ejemplo:
try:
except EOFError as e:
print("Ocurrió un EOFError")
print("Ocurrió un IOError")
De esta manera, si la excepción no es manejada en el primer bloque, lo será en
el segundo o en alguno de los sucesivos. Aunque también puede pasar que no
llegue a manejarse en ninguno.
Y por último, el siguiente método permite manejar todas las excepciones con
un solo bloque.
try:
except Exception as e:
# Puedes añadir algún tipo de información extra
pass
Esto puede ser útil cuando no se sabe con certeza que excepciones pueden
ser lanzadas por el programa.
16.1.1. Uso de finally
Ya hemos visto que debemos ubicar el código que pueda causar una
excepción en el try , y que en el except podemos tratar lo que hacer en el caso
5
de que se produzca una excepción determinada. A continuación veremos el

uso del finally , que permite ejecutar un determinado bloque de código
siempre, se haya producido o no una excepción. Se trata de un bloque muy
importante, y que suele ser usado para ejecutar alguna tarea de limpieza.
Veamos un ejemplo:
try:
print('Ocurrió un IOError. {}'.format(e.args[-1]))
finally:
print("Se entra aquí siempre, haya o no haya excepción")
# Salida: Ocurrió un IOError. No such file or directory

# Se entra aquí siempre, haya o no haya excepción
16.1.2. Uso de try/else
Puede ser también útil tener una determinada sección de código que sea
ejecutada si no se ha producido ninguna excepción. Esto se puede realizar con
el uso de else . Se trata de algo bastante útil porque puede haber determinadas
secciones de código que sólo tengan sentido ejecutar si el bloque
completo try se ha ejecutado correctamente. Si bien es cierto que no es muy
habitual ver su uso, es una herramienta a tener en cuenta.
try:
print('Estoy seguro de que no ocurrirá ninguna excepción')
except Exception:
print('Excepción')
else:
# El código de esta sección se ejecutará si no se produce
# ninguna excepción. Las excepciones producidas aquí
# tampoco serán capturadas.
print('Esto se ejecuta si no ocurre ninguna excepción')
finally:
print('Esto se imprimirá siempre')
# Salida: Estoy seguro de que no ocurrirá ninguna excepción

# Esto se ejecuta si no ocurre ninguna excepción
#. Esto se imprimirá siempre
El contenido del else sólo se ejecutará si no se ha producido ninguna
excepción, y será ejecutada antes del finally .
Clases
Las clases son el núcleo de Python. Nos dan un montón de poder, pero es muy
fácil usarlo de manera incorrecta. En esta sección compartiremos algunos de
los trucos relacionados con las clases en Python. ¡Vamos a por ello!
5
Nota: Si aún no entiendes bien la Programación Orientada a Objetos, te

recomendamos que empieces antes por este post dónde se explica de manera
muy fácil la POO y conceptos relacionados como la herencia y los métodos
estáticos y de clase.
17.1. 1. Variables de instancia y clase

La mayoría de principiantes o incluso algunos programadores avanzados de
Python, no entienden la diferencia entre instancia y clase. Dicha falta de
conocimiento, les fuerza a hacer un uso incorrecto de los mismos. Vamos a
explicarlos.
La diferencia es la siguiente:
 Las variables de instancia son usadas para almacenar datos que son únicos para
cada objeto.
 Por lo contrario, las variables de clase son compartidas entre diferentes instancias
de la clase.
Vamos a ver un ejemplo:
class Cal(object):
# pi es una variable de clase
pi = 3.142
def __init__(self, radio):

# self.radio es una variable de instancia
self.radio = radio
def area(self):
return self.pi * (self.radio ** 2)
a = Cal(32)
a.area()
# Salida: 3217.408
a.pi
# Salida: 3.142
a.pi = 43
a.pi
# Salida: 43
b = Cal(44)
b.area()
# Salida: 6082.912
b.pi
# Salida: 3.142
b.pi = 50
b.pi
# Salida: 50
5
En el ejemplo anterior no hay demasiados problemas al estar usando variables

de clase que son inmutables, es decir que no son modificadas. Esta es una de
las principales razones por la que ciertos programadores no intentan aprender
mas acerca de ellas, ya que no se suelen enfrentar a ningún problema. En el
siguiente ejemplo vemos como un mal uso de las variables de clase e instancia
pueden causar problemas.
class SuperClass(object):
superpowers = []
def __init__(self, name):

self.name = name
def add_superpower(self, power):

self.superpowers.append(power)
foo = SuperClass('foo')
bar = SuperClass('bar')
foo.name
# Salida: 'foo'
bar.name
# Salida: 'bar'
foo.add_superpower('fly')
bar.superpowers
# Salida: ['fly']
foo.superpowers
# Salida: ['fly']
Esto es un mal uso de las variables de clase. Si te das cuenta la
llamada add_superpower sobre el objeto foo modifica la variable de
clase superpowers , y dado que es compartida por todos los objetos de la clase,
hace que bar también cambie. Por lo tanto es importante tener cuidado con
esto, y salvo que realmente sepas lo que estás haciendo, no es muy
recomendable usar variables de clase mutables.
17.2. 2. Nuevo estilo de clases

Un nuevo estilo de clases fue introducido en Python 2.1, pero mucha gente aún
no sabe de ello. Puede ser en parte porque Python sigue manteniendo el
antiguo estilo para mantener lo que se llama compatibilidad hacia atrás
o backward compatibility. Veamos las diferencias:
 En el estilo antiguo, las clases no heredan de nada.

 En el nuevo estilo las clases heredan de object .
Un ejemplo muy sencillo podría ser:

5
class OldClass():
def __init__(self):
print('I am an old class')
class NewClass(object):
def __init__(self):
print('I am a jazzy new class')
old = OldClass()
# Salida: I am an old class
new = NewClass()
# Salida: I am a jazzy new class
Esta herencia de object permite que las clases pueden utilizar cierta magia.
Una de las principales ventajas es que puedes hacer uso de diferentes
optimizaciones como __slots__ . También puedes hacer uso de super() o de
descriptores. ¿Conclusión? Intenta usar el nuevo estilo de clases.
Nota: Python 3 solo tiene el estilo nuevo de clases. No importa si heredas

de object o no. Sin embargo es recomendable que heredes de object , aunque
tal vez en la práctica tampoco se hace.
17.3. 3. Métodos mágicos

Las clases en Python son famosas por sus métodos mágicos, comúnmente
referidos con dunder que viene del Inglés y significa double underscore. Es
decir, son métodos definidos con doble barra baja, tanto al principio con al final
del nombre del mismo. Vamos a explicar algunos de ellos.
 __init__
Se trata de un inicializador de clase o también conocido como constructor.

Cuando una instancia de una clase es creada, el método __init__ es llamado.
Por ejemplo:
class GetTest(object):
def __init__(self):
print('Saludos!!')
def another_method(self):
print('Soy otro método que no es llamado'
' automáticamente')
a = GetTest()
# Salida: Saludos!!
a.another_method()
# Salida: Soy otro método que no es llamado automáticamente
# called
5
Puedes ver como __init__ es llamado inmediatamente después de que la

instancia haya sido creada. También puedes pasar argumentos en la
inicialización, como se muestra a continuación.
def __init__(self, name):
print('Saludos!! {0}'.format(name))
def another_method(self):
print('Soy otro método que no es llamado'
' automáticamente')
a = GetTest('Pelayo')
# Salida: Saludos!! Pelayo
# Si intentas crear el objeto sin ningún argumento, da error.

b = GetTest()
TypeError: __init__() takes exactly 2 arguments (1 given)
Estoy seguro de que con esto ya entiendes perfectamente el método __init__ .
 __getitem__
Implementar el método __getitem__ en una clase permite a la instancia

usar [] para indexar sus elementos. Veamos un ejemplo:
def __init__(self):
self.info = {
'name':'Covadonga',
'country':'Asturias',
'number':12345812
}
def __getitem__(self,i):
return self.info[i]
foo = GetTest()
foo['name']
# Output: 'Covadonga'
foo['number']
# Output: 12345812
Sin implementar el método __getitem__ tendríamos un error si intentamos
hacerlo:
>>> foo['name']

TypeError: 'GetTest' object has no attribute '__getitem__'
5
Funciones Lambda
Las funciones lambda son funciones que se definen en una línea, y son
conocidas en otros lenguajes como funciones anónimas. Uno de sus usos es
cuando tienes una determinada función que sólo vas a llamar una vez. Por lo
demás, su uso y comportamiento es muy similar a las funciones «normales».
Forma
lambda argumentos: manipular(argumentos)

Ejemplo
suma = lambda x, y: x + y
print(suma(3, 5))
# Salida: 8
A continuación mostramos otras formas de usar las funciones lambda:
Ordenar una lista
a = [(1, 2), (4, 1), (9, 10), (13, -3)]

a.sort(key=lambda x: x[1])
print(a)
# Salida: [(13, -3), (4, 1), (1, 2), (9, 10)]
Ordenar listas paralelamente
datos = zip(lista1, lista2)

datos.sort()
lista1, lista2 = map(lambda t: list(t), zip(*datos))
Si quieres saber más acerca de las funciones lambda, puedes encontrar más
información en este post post.
Ejemplos en 1 línea
En este capítulo veremos algunos ejemplos en Python que pueden ser escritos
en una sola línea de código.
Servidor Web
5
¿Alguna vez has querido enviar un fichero a través de la red? En Python se

puede hacer de manera muy fácil de la siguiente forma. Vete al directorio
donde tengas el fichero, y escribe el siguiente código.
# Python 2
python -m SimpleHTTPServer
# Python 3
python -m http.server
Prints Organizados
Algo muy común a lo que a veces nos enfrentamos, es tener que imprimir un
determinado tipo con print() , pero a veces nos encontramos con un contenido
que es prácticamente imposible de leer. Supongamos que tenemos un
diccionario. A continuación mostramos como imprimirlo de una manera más
organizada. Para ello usamos pprint() que viene de pretty (bonito).
from pprint import pprint
my_dict = {'name': 'Pelayo', 'age': 'undefined', 'personality': 'collaciu'}

print(dir(my_dict))
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
'__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__',
'__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear',
'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
pprint(dir(my_dict))
# ['__add__',
# '__class__',
# '__contains__',
# '__delattr__',
# '__delitem__',
# '__dir__',
# '__doc__',
# '__eq__',
# '__format__',
# '__ge__',
# '__getattribute__',
# '__getitem__',
# '__gt__',
# '__hash__',
# '__iadd__',
# '__imul__',
# '__init__',
# '__init_subclass__',
# '__iter__',
# '__le__',
# '__len__',
# '__lt__',
# '__mul__',
# '__ne__',
# '__new__',
# '__reduce__',
# '__reduce_ex__',
5
# '__repr__',
# '__reversed__',
# '__rmul__',
# '__setattr__',
# '__setitem__',
# '__sizeof__',
# '__str__',
# '__subclasshook__',
# 'append',
# 'clear',
# 'copy',
# 'count',
# 'extend',
# 'index',
# 'insert',
# 'pop',
# 'remove',
# 'reverse',
# 'sort']
Usado en diccionarios anidados, resulta incluso más efectivo. Por otro lado,
también puedes imprimir un fichero json con el siguiente comando.
cat file.json | python -m json.tool

Profiling de un script
Esto puede ser realmente útil para ver donde se producen los cuellos de botella
de nuestro código. Se entiende por hacer profiling de un código, al analizar los
tiempos de ejecución de sus diferentes partes, para saber dónde se pierde más
tiempo y actuar en consecuencia.
python -m cProfile mi_script.py

Nota: cProfile es una implementación más rápida que profile ya que está
escrito en C.
Convertir CSV a json
Si ejecutas esto en el terminal, puedes convertir un CSV a json.
python -c "import csv,json;print json.dumps(list(csv.reader(open('csv_file.csv'))))"

Asegúrate de que cambias csv_file.csv por tu fichero.
Convertir una Lista anidada
Puedes convertir una lista con elemento anidados a una única lista de una
dimensión con itertools.chain.from_iterable del paquete itertools . Veamos un
ejemplo:
lista = [[1, 2], [3, 4], [5, 6]]

5
print(list(itertools.chain.from_iterable(lista)))
# Salida: [1, 2, 3, 4, 5, 6]
# Otra forma
print(list(itertools.chain(*lista)))
# Salida: [1, 2, 3, 4, 5, 6]
Construcciones en 1 línea
Otro código bastante interesante y que nos puede ahorrar varias líneas es el
siguiente. Tenemos el constructor de una clase con un determinado número de
parámetros. En vez de hacer self.nombre = nombre uno a uno, podemos
reemplazarlo por la siguiente línea.
class A(object):
def __init__(self, a, b, c, d, e, f):
self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})
Si quieres ver más construcciones de una línea, te recomendamos que leas
el siguiente enlace.
for/else
Los loops o bucles son una parte muy importante de cualquier lenguaje de

programación, y por supuesto también existen en Python. Sin embargo, tienen
algunas particularidades que mucha gente no conoce. A continuación las
explicaremos.
Nota: Si buscas una explicación más completa de los bucles for en Python te
recomendamos este post sobre el uso del for y este otro para el while.
Empecemos con un ejemplo básico de for , nada nuevo:
frutas = ['manzana', 'plátano', 'mango']

for fruta in frutas:
print(fruit.capitalize())
# Output: Manzana
# Plátano
# Mango
Un ejemplo sencillo en el que iteramos una lista que almacena diferentes
cadenas con for, y cambiamos su primera letra con una mayúscula. Veamos
ahora otras de las funcionalidades que tal vez no sean tan conocidas.
5
20.1. Uso del else

Los bucles for también tienen una cláusula else , y puede ser usada para
ejecutar un determinado fragmento de código cuando el bucle termina de
manera natural. Por manera natural se entiende que el bucle ha sido ejecutado
tantas veces como había sido planeado en su definición, y no termina por la
sentencia break . Por lo tanto, si un break rompe la ejecución del bucle, la
cláusula else no será ejecutada.
Un ejemplo muy clásico en el uso de bucles, es iterar una determinada lista

buscando un elemento concreto. Si el elemento se encuentra, es habitual
usar break para dejar de buscar, ya que una vez hayamos encontrado lo que
buscábamos, no tendría mucho sentido seguir buscando.
Por otro lado, podría ocurrir también que se acabara de iterar la lista y que no
se hubiera encontrado nada. En este caso, el bucle terminaría sin pasar por la
sentencia break . Por lo tanto, una vez sabidos estos dos posibles escenarios,
uno podría querer saber cual ha sido la causa por la que el bucle ha terminado,
si ha sido porque se ha encontrado el elemento que se buscaba, o si por lo
contrario se ha terminado sin encontrar nada.
Veamos un ejemplo de la estructura del for/else :
for item in container:

if busca_algo(item):
# Se ha encontrado
procesa(item)
break
else:
# No se encontró nada
no_encontrado()
Veamos un ejemplo en concreto, tomado de la documentación oficial.
for n in range(2, 10):

for x in range(2, n):
if n % x == 0:
print(n, 'igual', x, '*', n/x)
break
Este ejemplo itera números de 2 a 10, y para cada uno busca un número que
divida de manera entera a cada uno de ellos. Si se encuentra, se rompe el
primer bucle y se continúa con el siguiente número.
Al ejemplo anterior podemos añadir un bloque else , para mostrar determinada

información al usuario. Por ejemplo, si el número no es divisible por ninguno de
5
sus antecesores, significará que es un número primo.
for n in range(2, 10):

for x in range(2, n):
if n % x == 0:
print( n, 'igual', x, '*', n/x)
break
else:
# Si no se llama a break, se entra al else
print(n, 'es un número primo')
Conclusión:
Bueno este manual nos sirve de mucho para que nosotros aprendamos a
programar lo que es el programa de PYTHON es una de las herramientas
que se utiliza mucho en vida o en día de los programadores python en un
programa que se dedica a realizar páginas web python es un lenguaje de
programa ampliamente utilizado en las aplicaciones web, el desarrollo de
software, la ciencia de datos y el machine learning (ML. Los
desarrolladores utilizan python porque su eficiente y fácil de aprender,
además de que se puede ejecutar en muchas plataformas diferentes por eso
en este manual es una de lo que más podemos aprender a utilizar en
programa de python.
Cuando se creó este manual esta hecho para todos esos estudiantes que van
a empezar a desarrollar su primera página web o juegos o python con
blender es un programa que es muy utilizado en muchas cosas por esos este
manual está especialmente para que nosotros empezamos a programar este
programa
Muchas gracias a todos por leer este manual sobre python y espero que les
ayude mucho en sus tareas y a empezar a programar este programa que es
python.

Manual Sobre Python

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual Sobre Python

Cargado por

Copyright:

Formatos disponibles

2022

Autor: Alejandro Enrique Ispache García

Bucles iterativos (for).........................................................................................................16

Operadores booleanos en Python.................................................................................52

12.5. namedtuple ...................................................................................................................64

12.6. enum.Enum (Python 3.4+)...............................................................................................66

14.2. type y id .................................................................................................................68

14.3. Módulo inspect .......................................................................................................69

15.2. dict comprehensions........................................................................................70

15.3. set comprehensions..........................................................................................71

15.4. generator comprehensions.............................................................................71

16.1.2. Uso de try/else ...............................................................................................73

17.3. 3. Métodos mágicos....................................................................................................76

20.1. Uso del else .............................................................................................................82

En la actualidad las cosas tecnológicas son una de la cosas más importante

Python es un lenguaje de programación de alto nivel multiparadigma que permite:

Principales ventajas de Python

 Es de código abierto (certificado por la OSI).

Se leen y se ejecutan una a una todas las instrucciones del fichero.

Compilado a ejecutable del sistema

Tipos de Datos Primitivos Simples

Tipos de datos primitivos simples

 Números (numbers): Secuencia de dígitos (pueden incluir el - para negativos y el . para

 Cadenas (strings): Secuencia de caracteres alfanuméricos que representan texto. Se

Booleanos (boolean): Contiene únicamente dos elementos True y False que representan

Estos datos son inmutables, es decir, su valor es constante y no puede cambia

Tipos de datos primitivos compuestos (contenedores)

 Listas (lists): Colecciones de objetos que representan secuencias ordenadas de objetos

 Tuplas (tuples). Colecciones de objetos que representan secuencias ordenadas de

 Diccionarios (dictionaries): Colecciones de objetos con una clave asociada. Se

Clase de un dato (type)

>>>type((1, 'dos', 3))

Orden de prioridad de evaluación:

Se puede saltar el orden de evaluación utilizando paréntesis ( ).

Operadores lógicos con números

Operadores lógicos: == (igual que), > (mayor que), < (menor que), >= (mayor o igual

Secuencia de caracteres alfanuméricos que representan texto. Se escriben entre comillas

Acceso a los elementos de una cadena

C[i] devuelve el carácter de la cadena c con el índice i.

Operaciones con cadenas

 c1 + c2 : Devuelve la cadena resultado de concatenar las cadenas c1 y c2.

>>> 'Me gusta ' + 'Python'

Operaciones de comparación de cadenas

 c1 == c2 : Devuelve True si la cadena c1 es igual que la cadena c2 y False en caso

Utilizan el orden establecido en el código

>>> 'Python' == 'python'

len(c) : Devuelve el número .

 min(c) : Devuelve el carácter menor de la cadena c.

Cadenas formateadas (format(())

 c.format(valores): Devuelve la cadena c tras sustituir los valores de la

>>> 'Un {} vale {} {}'.format('€', 1.12, '$')

Datos lógicos o booleanos (clase bool)

Contiene únicamente dos elementos True y False que representan los valores lógicos

False False True False False

False True True False True

True False False False True

True True False True True

Conversión de datos primitivos simples

 int () convierte a entero.

Entrada y Salida por Terminal

Entrada por terminal (input(())

>>> language = input('¿Cuál es tu lenguaje favorito? ')

Salida por terminal (print(())