PYTHON 3

COMENTARIOS Y DOCSTRING I. CLASES DE VARIABLES EN PYTHON

En programación, lo más importante es entender cómo resolver un problema Un comentario es un texto explicativo que acompaña al código, pero que En Python se tienen varias clases de variables, las cuales se describen a
por medio de un algoritmo, el cual se puede representar por medio de no se ejecuta, va antecedido por ( # ). Se suele ubicar antes del código que continuación. Para saber la clase de una variable se utiliza la función
diagramas de flujo y pseudocódigos. Un algoritmo es eficaz cuando soluciona explica, o a la derecha del mismo. type(var). Para saber la identidad de un objeto se utiliza la función id(var).
el problema y es eficiente cuando gasta el mínimo de espacio de memoria y
tiempo de ejecución posible. >>> lista = [-4, -2, 0, 2, 4]
tipo de datos mutabilidad ordenamiento itr
>>> # crear una nueva lista con los valores duplicados
Ejemplo de un algoritmo: Calcular el área de un rectángulo. >>> [x * 2 for x in lista] int inmutable
número
[-8, -4, 0, 4, 8] float inmutable
Datos de entrada > Proceso > Datos de salida
carácter str inmutable ordenado
Base (b), Altura (h) A=bxh Área (A) >>> altura = 10
>>> base = 30 list mutable ordenado
Un lenguaje de programación es el medio para expresar un algoritmo (serie >>> area = altura * base # área del rectángulo tuple inmutable ordenado
secuencia iterables
de pasos para solucionar un problema), mientras que, una computadora es set mutable no ordenado
el medio para ejecutar dicho algoritmo. El Docstring es una cadena de texto que se escribe en varias líneas, utilizado frozenset inmutable no ordenado
para documentar (explicar) funciones o clases, se ubica justo después de la
diccionario dict mutable no ordenado
Python es un lenguaje de programación multiplataforma, cuya filosofía definición de la función o clase. Se indica con triples comillas ( ‘’’ ‘’’ ).
hace hincapié en una sintaxis sencilla que favorezca un código legible.
>>> def potencia(x, y): 1. VALORES BOOLEANOS
Es un lenguaje de alto nivel, cuya sintaxis se asemeja más al lenguaje natural. ‘’’
Mientras que un lenguaje de bajo nivel es aquel cuya sintaxis se asemeja Indica cómo qué hace y cómo funciona el elemento, qué Un elemento booleano (bool) es una variable que solo puede tomar dos
parámetros recibe. También se pueden poner ejemplos. valores: True o False. Cualquier objeto se puede considerar booleano. En
más al lenguaje máquina (código binario). ‘’’ general, los elementos nulos o vacíos se consideran False (0, None, [ ], { }) y
Es de tipado fuerte, el lenguaje distingue de una manera clara los distintos # resto del código de la función
el resto se considera True.
tipos de variables. También es de tipado dinámico, es decir, no es necesario
declarar el tipo de variable, él mismo lo establece durante la ejecución del La función bool(obj) retorna el valor booleano de cualquier objeto (obj).
GUÍA DE ESTILO – PEP8
programa (si hay que declarar la variable antes de ejecutar el programa, se >>> print(bool(0.0)) >>> print(bool("Tomás"))
denomina tipado estático). - Usar sangrías de cuatro (4) espacios, no tabulación. False True
También es un lenguaje interpretado, el cual utiliza un intérprete para - Las líneas de código no deben superar los 72 caracteres. Si la línea es muy
traducir el lenguaje de programación, línea por línea, al código máquina, sin larga, se puede cortar con ( \ ) y seguir escribiendo en la siguiente línea. Operadores de Comparación
== Igual que != Diferente que
guardar la traducción (archivo .exe). Mientras que en un lenguaje compilado,
> Mayor que < Menor que
se traduce el código en un archivo ejecutable para una determinada >>> frase = ‘Si la línea es muy larga, se puede cortar \ >= Mayor o igual que <= Menor o igual que
plataforma. para seguir escribiendo en la siguiente línea.’ Operadores lógicos
>>> print(frase) or Es True si al menos un argumento es verdadero (True). (menor prioridad)
Si la línea es muy larga, se puede cortar para seguir escribiendo en la siguiente línea. and Es True si todos los argumentos son verdaderos (True).
not Niega una expresión booleana. (mayor prioridad)
VARIABLES - Usar líneas en blanco para separar funciones y clases, y bloques grandes de Operadores de identidad
código dentro de funciones. is Compara si dos objetos (variables) son realmente el mismo objeto.
Espacio en la memoria del ordenador donde se almacenará un valor o dato is not Compara si dos objetos (variables) son realmente el mismo objeto.
- Cuando sea posible, poner comentarios en una sola línea. Operadores de pertenencia
(objeto) que podrá cambiar durante la ejecución del programa. Una variable in Verifica si un valor está en una secuencia.
es la etiqueta que hace referencia a un objeto (dato), lo cual significa, que la - Documentar el código (ver PEP 257). No exagerar con los comentarios. not in Verifica si un valor no está en una secuencia.
variable no ocupa memoria, lo que ocupa memoria es el objeto al que apunta.
- Usar espacios alrededor de operadores y luego de las comas, pero no
>>> edad = 30 Python es CaseSensitive, es decir, distingue directamente dentro de paréntesis  variable = f(1, 2) + g(3, 4) Operadores de comparación
>>> edad = 31 mayúsculas de minúsculas. Estos operadores comparan dos valores o expresiones, y retornan True o
- Nombrar las variable, clases y funciones consistentemente, utilizando False según sea el caso. Es posible encadenar expresiones de comparación, por
En el ejemplo anterior, la variable edad ahora hace referencia a un nuevo nombres que faciliten su identificación. La convención para clases es usar ejemplo, ( A < B and B == C ) se puede encadenar así ( A < B == C ).
objeto. El objeto anterior (int 30) sigue existiendo en memoria, solo que no NombreCompuesto y para variables, funciones y métodos se usa
hay nada que lo referencia ahora, con lo cual el garbage collector lo >>> print((10 + 15) < 45) >>> print('Andrés' != 'Andrea')
minusculas_con_guiones_bajos. True True
eliminará en algún momento para liberar el espacio de memoria que ocupa.
- Las importaciones deben estar en líneas separadas, y deben seguir el Los operadores ( < <= > >= ) solo evalúan los mismos tipos de variables
>>> A = 1 >>> A = 1 siguiente orden: (1) Importaciones de librería estándar. (2) Importaciones
>>> B = A >>> B = A siguiendo un orden lexicográfico. Si se evalúan dos variables de distinta clase,
terceras relacionadas. (3) Importaciones locales de la librería. Se debe poner arrojará TypeError.
>>> print(B) >>> A = 2
1 >>> print(B)
una línea en blanco entre cada grupo.
1 Operadores lógicos
- Aunque es posible hacer varias declaraciones en una línea, separándolas con En los operadores lógicos, la prioridad de not > and > or. De manera que,
( ; ) esto no es aconsejable. Lo ideal es una declaración por línea. por ejemplo, ( A and not B or C ) equivale a ( (A and (not B)) or C ).
En el primer ejemplo, las variables (etiquetas) A y B hacen referencia al mismo >>> base = 10; altura = 20 # No >>> base = 10 # Si # es igual a ((not False) or (True and False))  True or False.
objeto (int 1), mientras que en el segundo ejemplo, en primera instancia, >>> altura = 20 >>> print(not 40 != (20 * 2) or (5 + 5) > 9.0 and (7 - 2) < 0.2)
ambas variables hacen referencia al mismo objeto (int 1), al utilizar la etiqueta True
A para apuntar a un nuevo objeto (int 2), la variable B sigue apuntando a (int Además de lo anterior, se debe procurar escribir un código simple y
1), porque este no ha dejado de existir. explícito, fácil de leer. Si el código es difícil de explicar, tal vez sea debido a Además, and y or son operadores de cortocircuito, sus argumentos se
que no está bien escrito. evalúan de izquierda a derecha, y la evaluación se detiene en el momento en
Se puede eliminar una variable así ( del variable ).
que se determina su resultado. De esta manera, and se detiene al encontrar >>> print(x) 2
el primer False, mientras que or para al encontrar el primer True. 5.04386 >>> print(5 ** 2) # 5 ** 2 es equivalente a pow(5, 2).
25
Valor de retorno de los operadores lógicos # introduce una variable comodín, para luego autoasignar un valor.
>>> eleccion = None >>> print(10 / 2) >>> print(10 // 2)
Cuando los operadores de cortocircuito se usan como un valor general y no 5.0 5
como un booleano, estos devuelven el último argumento evaluado. >>> while eleccion != 5:
>>> eleccion = int(input(‘Ingrese número distinto de 5: ’)) >>> operacion = 5 + 2 * 4 - 3 / (3 + 1) # se pueden colocar paréntesis para
>>> print('Ana' or 'Juan' or 'Alex') >>> print('Ana' and 'Juan' and 'Alex') >>> else: >>> print(operacion) hacer explícita la prioridad así:
Ana Alex >>> print(‘Has escrito el 5’) 12.25 (5 + (2 * 4)) - (3 / (3 + 1))
>>> print(3.5 or 'happy') >>> print(3.5 and 'happy') # otro ejemplo >>> num = 6
3.5 happy >>> eleccion = None >>> num += 2 # num += 2 equivale a num = num + 2
>>> print(None or 50) >>> print(None and 50) >>> while eleccion is None or eleccion > 5: >>> print(num)
50 None >>> eleccion = int(input(‘Ingrese número mayor que 5: ’)) 8
>>> else:
Operadores de pertenencia >>> print(‘Has escrito un número menor que 5’)
Redondear números
Los operadores in y not in permiten verificar si un valor se encuentra o no, en La función integrada round(num[, ndigits]) permite redondear un número. El
una secuencia específica. Como no se pueden comparar dos valores de distinto tipo con ( > ), es necesario primer argumento es el número en cuestión (num). El segundo argumento (ndigits
utilizar el operador or, el cual se detiene al encontrar el primer True, evalúa – opcional) es el número de decimales requerido, si se omite, devuelve el
>>> fruta = ['mango', 'banano', 'pera'] >>> fruta = ['mango', 'banano', 'pera'] la primera sentencia (eleccion is None) y entra al bucle, luego en la segunda entero más cercano.
>>> print('mango' in fruta) >>> print('fresa' not in fruta) iteración, eleccion corresponderá a un número y por tanto se evaluará la
True True >>> print(round(4.347)) >>> print(round(4.347, 2))
segunda sentencia (eleccion > 5). 4 4.35
Operadores de identidad
Los operadores is y is not permiten verificar si dos variables apuntan al mismo 3. NÚMEROS Sumar un conjunto de valores
objeto o no, es decir, comprueban si realmente son el mismo objeto. Esto es La función integrada sum(itr[, num]) calcula la suma de un conjunto de
significativo solo para objetos mutables, como las listas. Consisten en cualquier valor numérico inmutable (que no esté encerrado valores. El primer argumento es una secuencia (itr) (list, tuple, set, dict). El
entre comillas). Existen tres clases principales: segundo argumento (num – opcional), es otro número que se agrega a la suma.
>>> nombre = 'Andrés' >>> num = [10, 20, 30, 40, 50]
>>> usuario = 'Andrés' >>> decenas = [10, 20, 30, 40, 50] Enteros (int), que son números positivos o negativos sin decimales. >>> print(sum((1, 2, 3), 4)) >>> print(sum((1, 2, 3), 3.5))
>>> print(nombre is usuario) >>> print(num is decenas) 10 9.5
True False
Reales (float), que tienen parte decimal (con punto separador ( . )).
También existen los tipo División y módulo
Diferencia entre los operadores de identidad y de igualdad Complejo (complex), los cuales tienen parte imaginaria, la cual se La función integrada divmod(x, y), acepta como argumento dos números (x,
El operador de identidad is y is not verifica si dos variables apuntan al mismo indica con el sufijo j o J (e.g. 4+5j). y) y devuelve una tupla con dos valores: la división entera (x // y) y el módulo
objeto. Mientras que el operador de igualdad == verifica si los valores de las (x % 2) de dichos números.
variables evaluadas son iguales, sin que necesariamente sean el mismo objeto >>> num_1 = 22 >>> type(num_1) >>> type(num_2)
(las variables mutables son las que pueden ser iguales sin ser el mismo objeto). >>> num_2 = 4.2 <class ‘int’> <class ‘float’> >>> div = divmod(6, 2) >>> div = divmod(23, 3)
>>> print(div) >>> print(div)
>>> lista_uno = [1, 2, 3, 4, 5] Al ser una clase de variable inmutable, al cambiar el valor de un tipo de dato (3, 0) (7, 2)
>>> lista_dos = [1, 2, 3, 4, 5] numérico, se da como resultado un objeto recién asignado.
Potencia
>>> print(lista_uno == lista_dos) # las dos variables tienen los mismos valores.
True
>>> num = 55 >>> num = 98 La función integrada pow(x, y[, z]) retorna ( x ) a la potencia ( y ). Si el tercer
>>> print(id(num)) >>> print(id(num)) argumento está presente, devuelve ( x ) a la potencia ( y ) módulo ( z ), aunque
>>> print(lista_uno is lista_dos) # las dos variables no son el mismo objeto, 1939225696 1939226384
False a pesar de tener los mismos valores.
esto último se puede computar más eficientemente como pow(x, y) % z. Esta
función es equivalente al operador ( ** ).
Operadores Aritméticos
2. TIPO NONETYPE: + Suma - Resta >>> print(pow(8, 3, 5)) >>> print(pow(7, 2))
* multiplicación / División (retorna un float) 2 49
A esta clase solo pertenece el objeto None, el cual no indica ningún valor. // División entera (redondea hacia abajo) % Módulo (residuo de la división)
None es el valor de retorno de algunas funciones cuando “no devuelven nada”. ** Potencia (equivale a pow(x)) Convertir tipos de datos
None no significa 0, ni vacío, ni False. Operadores de Asignación La función int(float / str) permite convertir números decimales (float) o
= Asigna un valor a una variable += Agrega un valor a la variable cadenas de texto (str) a números enteros (int). La función float(int / str)
>>> None == 0 >>> None == ' ' >>> None == False -= Quita un valor a la variable *= /= %= **= //= permite convertir un número entero (int) o cadena de texto (str) a punto
False False False flotante (float).
>>> def valor_absoluto(x): # como la función no define que hacer cuando Operaciones matemáticas
>>> num = int('32') >>> num = float(5) >>> num = int(9.97)
>>> if x < 0: x = 0, imprimirá None en dicho cado. Python resuelve las operaciones matemáticas según la prioridad de los >>> print(num) >>> print(num) >>> print(num)
>>> return –x operadores. Primero evalúa las operaciones aritméticas (resuelve primero 32 5.0 9
>>> elif x > 0: >>> print(valor_absoluto(0)) los paréntesis, luego la potencia, luego multiplicación y división, de último
>>> return x None # al convertir float a int, el número no se redondea, solo se ocultan los decimales.
suma y resta), luego evalúa las expresiones de comparación y por último
El objeto None se suele usar para inicializar una variable previamente las expresiones lógicas. En la practica, muchos datos numéricos que pueden ser tratados como cadenas
declarada si no sabemos qué tipo de dato va a contener. También para La multiplicación y la división tienen la misma prioridad, así que se resuelve la de caracteres, por ejemplo, el número de la cédula, un código, etc.
introducir una variable “comodín” dentro del código, para que se le que aparezca primero (de izquierda a derecha). Los mismo para suma y resta. Valor absoluto de un número
“autoasigne” un valor durante la ejecución del script.
Para mejorar la legibilidad y hacer explícita la prioridad de evaluación, ayuda La función integrada abs(num) retorna el valor absoluto de un número. El
# inicializa una variable previamente declarada sin indicar que tipo de dato será. añadir paréntesis ( ). argumento (num) puede ser de tipo int o float.
>>> x = None
>>> y = 233
Los operadores de asignación, solamente sirven para agilizar la escritura. >>> print(abs(-5)) >>> print(abs(-4.56))
>>> z = 4.56 Asi, por ejemplo, ( A += 2 ) equivale a ( A = A + 2 ). 5 4,56
>>> x = y / z >>> print(17 % 3) # al dividir 17 entre 3, sobran 2, ese es el módulo.
Convertir un número entero a un binario – str El método str.expandtabs(tabsize=4) permite definir el ancho de la >>> num = str(1996) >>> num = str(4.57)
La función integrada bin(int) convierte un número entero (int) a una cadena tabulación, que por defecto es de 4 espacios (tabsize=4). >>> print(type(num)) >>> print(type(num))
de texto que representa un binario con prefijo 0b- <class 'str'> <class 'str'>
>>> cadena = 'Vaca \tToro' >>> cadena = 'Vaca \tToro'
>>> print(bin(-4)) >>> print(bin(258)) >>> print('Capitulo I. \t El fin del mundo'.expandtabs())
>>> print(repr(cadena)) >>> print(cadena)
-0b100 0b100000010 Capitulo I. El fin del mundo
'Vaca \tToro' Vaca Toro
>>> print('Capitulo I. \t El fin del mundo'.expandtabs(12))
Mínimo y máximo Capitulo I. El fin del mundo En términos generales, la función str(int / float) retorna la representación de
Las funciones min(itr[, default=obj, key=function]) y max(itr[, default=obj, como un humano leería el valor, mientras que repr(int / float / str) devuelve
key=function]), arrojan el menor o mayor número, respectivamente, de un - Imprimir texto en varias líneas la representación de como el intérprete de la máquina leería el valor indicado.
conjunto de datos. El primer argumento puede ser una secuencia (itr) o varios El carácter ( \n ) o las triple comillas permiten imprimir el texto en varias
elementos separados por coma (arg1, arg2, arg3, …). El segundo argumento líneas. Esto es útil para darle formato a la salida de datos. Las cadenas de texto, igualmente, se pueden convertir a otros tipos.
(default – opcional) indica el valor que retorna si el iterable está vacío, si no se >>> print(set('Andres')) >>> print(tuple('Andres'))
>>> print('Bienvenidos a\nnuestro hogar') >>> print('''Bienvenidos a
especifica, lanza ValueError. El tercer argumento (key – opcional) Bienvenidos a nuestro hogar''') {'d', 'A', 'r', 'e', 's', 'n'} ('A', 'n', 'd', 'r', 'e', 's')
corresponde a una función que permita personalizar el orden de clasificación. nuestro hogar Bienvenidos a >>> print(int('876231')) >>> print(float('54.87'))
>>> edades = (23, 17, 41, 25) >>> edades = ([23, 17, 41, 25], 0) nuestro hogar 876231 54.87
>>> print(min(edades)) >>> print(max(edades)) - Escribir texto en varias líneas
17 41 El caracter ( \ ) permite dividir una cadena en varias líneas, las cuales al Concatenación de cadenas de texto
imprimirse, se verán en una sola línea. Esto es útil cuando se quieren separar Se utiliza el operador ( + ) para concatenar cadenas de texto. No se pueden
El problema de los números de coma flotante – float cadenas largas. También es posible concatenar dos cadenas literales encerradas concatenar cadenas con números, para esto el número (int / float) se debe
Desafortunadamente, la mayoría de fracciones decimales no se pueden entre paréntesis. convertir previamente a una cadena de texto utilizando str(int / float).
representar exactamente como fracciones binarias, solamente son una
# se puede utilizar el carácter \ para dividir líneas. >>> frase_1 = "Hola" >>> frase1 = ”Yo tengo ”
aproximación. En general, esto no representa un problema, pero, para los >>> frase_2 = " a todos" >>> frase2 = 37
casos que requieran una representación decimal exacta, se puede utilizar los >>> texto = 'La separación proviene de la máquina \
de escribir, creada hace un par de siglos.' >>> print(frase_1 + frase_2) >>> frase3 = ” años”
módulos decimal o fraction. >>> print(texto) Hola a todos >>> print(frase1 + str(frase2) + frase3)
La separación proviene de la máquina de escribir, creada hace un par de siglos. Yo tengo 37 años
>>> 0.1 + 0.1 + 0.1 == 0.3 # como 0.1 no es exactamente 1 / 10, sumar tres
False # valores de 0.1 puede no dar exactamente 0.3. # también se puede dos cadenas literales encerradas entre paréntesis. También se pueden concatenar utilizando el operador ( += ), el cual
>>> round(0.1 + 0.1 + 0.1, 10) == round(0.3, 10) >>> texto = ('La separación proviene de la máquina' sobreescribe la variable (crea otro objeto con la misma referencia).
'de escribir, creada hace un par de siglos.')
True
>>> print(texto) >>> frase = "Hola "
El método float.as_integer_ratio() expresa el valor de un ( float ) como una La separación proviene de la máquina de escribir, creada hace un par de siglos. >>> frase += "mundo"
fracción compuesta por un par de enteros. >>> print(frase)
Cadenas crudas – r Hola mundo
>>> pi = 3.14159 # la división entre los enteros arrojados Son cadenas en donde los caracteres especiales ( \t \n ) no se sustituyen por
>>> print(pi.as_integer_ratio()) # da exactamente el valor de pi. su contrapartida. Repetir una cadena de texto varias veces
(3537115888337719, 1125899906842624) Se utiliza * para repetir una cadena tantas veces lo indique el número.
>>> print('C:\tablas\nomina_2016') # aquí \t significa tabulación
C: ablas y \n significa nueva línea. >>> animal = "iguana "
4. CADENAS DE TEXTO O STRINGS omina_2016 >>> animal * 3
>>> print(r'C:\tablas\nomina_2016') # nota la r antes de la cadena. 'iguana iguana iguana '
Una cadena de texto (str) es una secuencia inmutable de código Unicode o
C:\tablas\nomina_2016
de caracteres (letras, números, símbolos, espacios en blanco, etc.) encerrados Acceder a un carácter o realizar slicing en cadenas de texto
entre comillas (pueden ser comillas simples o comillas dobles). Asignación múltiple Cada carácter ocupa una posición (i – índice), iniciando en [0] de izquierda a
Es la combinación del empaquetado y desempaquetado de secuencias. Permite derecha (de derecha a izquierda inicia con [-1]). Así, es posible acceder a un
>>> texto = "Hola mundo" >>> cod = ‘601310800’ >>> texto = ' '
>>> print(texto) >>> type(cod) >>> type(texto) asignar valores a varias variables en una sola línea, o incluso es posible asignar carácter de una cadena de texto (str) con la sintaxis str[i].
Hola mundo <class 'str'> <class 'str'> el contenido de un iterable a varias variables. El slicing consiste en particionar una cadena en subcadenas indicando su
>>> nombre, apellido = 'Juan', 'Gil' posición de inicio y final [inicio:final:salto].
Caracteres especiales
>>> print(apellido) Así, por ejemplo, es posible invertir una cadena de texto utilizando [::-1].
- Escribir comillas dentro de strings Gil
Se pueden escribir comillas simples en cadenas delimitadas con comillas >>> usuario = ('Julia', 24) >>> dic = {'nombre': 'Juan', 'edad': 19} >>> frase = ‘Hola mundo’ >>> frase = ‘muchas gracias’
dobles y viceversa, o también se puede utilizar ( \” … \” o \’ … \’ ). >>> nombre, edad = usuario >>> user, age = dic.values() >>> print(frase[:5] + ‘Python’) >>> print(frase[::-1])
>>> print(edad) >>> print(user) 'Hola Python' saicarg sahcum
>>> print('Hola "amigo"') >>> print('Hola \"amigo\"')
24 Juan # los str al ser elementos inmutables, no se pueden modificar, pero haciendo uso del
Hola "amigo" Hola "amigo"
slicing es posible hacer cambios en la cadena.
- Escribir barra invertida dentro de strings Ejecutar strings como código
>>> frase = 'Bienvenidos todos' >>> frase = 'Bienvenidos todos'
Si se quiere escribir la barra invertida ( \ ) en el texto, se utiliza ( \\ ). Este La función eval(expression) permite ejecutar una cadena de texto (expression) >>> frase[:4] = 'Mal' >>> print('Mal' + frase[4:])
solo se suele usar en directorios y rutas de archivo. como un código de Python, retornando así un objeto. >>> print(frase) Malvenidos todos
>>> print(eval('8+4-2')) >>> print(eval('"hello".upper()')) TypeError
>>> print('Ir a la carpeta E:\\anferubu\\Geología') # también se puede escribir
10 HELLO La función obj[slice(x, y, z)] es equivalente al slicing obj[x:y:z], una ventaja de
Ir a la carpeta E:\anferubu\Geología con una cadena r.
Convertir distintos tipos de datos a cadenas de texto un objeto slice es que se puede almacenar y recuperar posteriormente como
- Agregar tabulación al texto un solo objeto, en lugar de almacenar x, y, z. Normalmente se usa para
Se utiliza el carácter ( \t ) para agregar tabulación al imprimir un mensaje. La función str(int / float) transforma el argumento (int / float) en una cadena
de texto sin tener en cuenta los caracteres especiales. Mientras que la función permitir que el usuario defina su propia porción que se aplicará a los datos.
>>> print('Capitulo I. \t El fin del mundo') repr(int / float / str) convierte el argumento en una cadena de texto (str), Su uso no suele ser muy común.
Capitulo I. El fin del mundo incluyendo los caracteres especiales y las comillas. >>> frase = 'Hola mundo' >>> frase = 'Hola mundo'
 >>> print(frase[5:]) >>> print(frase[slice(5, None, None)]) En general, delimitadores consecutivos no se agrupan, sino que se considera que >>> frase = ‘Hola mundo’ >>> frase = ‘Hola mundo’
mundo mundo agrupan cadenas vacías (excepto si el delimitador es un espacio en blanco). El >>> palabra = frase.find(‘mundo’) >>> palabra = frase.index(‘mundo’, 0, 4)
delimitador puede constar de varios caracteres. La división de una cadena vacía >>> print(palabra) >>> print(palabra)
5 ValueError
>>> frase = 'Hola mundo' con una separador especificado, retorna [' '].
>>> print(frase[slice(7)]) # la función puede tener un solo argumento, El método str.find(sub[, start[, end]]) / str.index(sub[, start[, end]]) solo se
Hola mu quedando de la forma slice(stop). >>> animales = 'perro gato loro' >>> fecha = '17/05/2012'
>>> print(animales.split()) >>> print(fecha.split('/', 1)) deben utilizar si se desea saber la posición de la subcadena (sub). Si solo se
Eliminar los caracteres del inicio y final de una cadena de texto ['perro', 'gato', 'loro'] ['17', '05/2012'] necesita comprobar si la subcadena está presente o no, se utiliza el operador
El método str.strip([charts]) elimina los caracteres ([charts] – por defecto son >>> nombres = 'Ana, Andrés,, Felipe' >>> numeros = '16<1>45<1>9856'
in / not in.
espacios en blanco) que aparecen al inicio y final de una cadena (str). No >>> print(nombres.split(',')) >>> print(numeros.split('<1>')) >>> print(‘Py’ in ‘Python’) >>> print(‘Py’ not in ‘Python’)
importa el orden de los caracteres, el método busca si evalúa uno por uno ['Ana', ' Andrés', '', ' Felipe'] ['16', '45', '9856'] True False
los caracteres de la cadena y termina de evaluar al encontrar el primer >>> nombres = ' ' >>> nombres = ' '
carácter que no coincida con el argumento. >>> print(nombres.split()) >>> print(nombres.split(',')) Además, ambos métodos realizan la búsqueda de izquierda a derecha. Para
[] [' '] buscar una subcadena desde el final (de derecha a izquierda), para así encontrar
El método str.lstrip([charts]) elimina los caracteres ([charts]) que aparecen
el índice más alto, se utilizan str.rfind(sub[, start[, end]]) / str.rindex(sub[,
solo al inicio de una cadena (str). El método str.partition(sep) divide la cadena (str) en la primera ocurrencia del start[, end]]).
El método str.rstrip([charts]) elimina los caracteres ([charts]) que aparecen separador (sep) y retorna una tupla de 3 elementos, el primer elemento es el
solo al final de una cadena (str). contenido de la cadena previo al separador, el segundo elemento es el separador >>> frase = ‘Todos son buenos’ >>> frase = ‘Todos son buenos’
mismo, y el tercer elemento de la tupla es el contenido de la cadena posterior >>> letra = frase.rfind(‘o’) >>> letra = frase.rindex('o', 0, 9)
>>> frase = '0tb1092b0t' >>> frase = '0tb1092b0t' >>> print(letra) >>> print(letra)
al separador. 14 7
>>> print(frase.strip('tb0')) >>> print(frase.lstrip('tb0'))
1092 1092b0t El método str.rpartition(sep) realiza la búsqueda del separador de derecha a
izquierda. En ambos casos, si no encuentra el separador (sep), devuelve una Verificar prefijos y sufijos
Reemplazar subcadena por otra tupla que contenga la cadena misma, seguida de dos cadenas vacías. El método str.startswith(prefix[, start[, end]]) devuelve True si la cadena de
El método str.replace(old, new[, count]) retorna una copia de la cadena (str) texto (str) comienza con la subcadena (prefix) indicada. El método
con todas las ocurrencias de la subcadena vieja (old) reemplazadas por la >>> direccion = 'http://www.radio.com' >>> numero = '987700013412' str.endswith(suffix[, start[, end]]) devuelve True si la cadena de texto (str)
subcadena nueva (new). El tercer argumento (count – opcional), indica el número >>> print(direccion.partition('.')) >>> print(numero.partition('000')) termina en la subcadena (suffix) indicada. Los argumentos opcionales (start /
máximo de reemplazos. ('http://www', '.', 'radio.com') ('9877', '000', '13412') end) sirven para aplicar slicing a la cadena de caracteres (str). El primer
>>> direccion = 'http://www.radio.com' >>> name = 'Julián' argumento también puede ser una tupla de strings.
>>> frase = 'Todos somos tú' >>> print(direccion.rpartition('.')) >>> print(name.partition(','))
>>> nuevo = frase.replace('os', 'xz', 1) ('http://www.radio', '.', 'com') ('Julián', '', '') >>> frase = 'Hola a todo mundo' >>> frase = 'Hola a todo mundo'
>>> print(nuevo) >>> print(frase.startswith('Ho')) >>> print(frase.endswith('o mundo'))
Todxz somos tú Las principales diferencias entre los métodos anteriores son que, True True
str.split(sep=None, maxsplit=-1) retorna una lista sin incluir el separador, >>> frase = 'Hola a todo mundo' >>> frase = 'Hola a todo mundo'
Reemplazar caracteres dentro de una cadena de texto
mientras que str.partition(sep) retorna una tupla incluyendo al separador. >>> print(frase.startswith('todo', 7)) >>> print(frase.endswith('Hola', 4, 10))
El método str.maketrans(x[, y[, z]]) devuelve una tabla de traducción
También se tiene el método str.splitlines(keepends=False) que separa una True False
utilizable por el método str.translate(table), que retorna una copia de la
cadena donde cada carácter se ha asignado a través de la tabla de traducción. cadena de varías líneas, convirtiendo cada línea en un elemento de una lista. >>> frase = 'Hola a todo mundo'
El argumento opcional (keepends=True) conserva los caracteres especiales >>> print(frase.startswith(('Hola', 'azul', 'perro')))
Si el método str.maketrans(x) solo tiene un argumento, este debe ser un True
(\n, \r). Aunque str.split(sep=None, maxsplit=-1) también funciona en estos
diccionario en donde las claves son cadenas de longitud 1 (1 caracter), el
casos si no se especifica el separador (sep). Métodos de validación en cadenas de texto
valor del diccionario puede ser un string de cualquier longitud o None.
>>> frase = '''Vaca >>> frase = '''Vaca Para saber si una cadena es alfanumérica se utiliza str.isalnum(), para saber
>>> cifrado = {'a': 'eo', 'e': '12', 'o': None, '1': 'hi'} si es alfabética se utiliza str.isalpha(), para saber si es numérica se utiliza
… Toro … Toro
>>> frase = '1. Hola de nuevo' … Buey''' … Buey''' str.isdigit(), para saber si la cadena contiene solo minúsculas o solo
>>> tabla = frase.maketrans(cifrado)
>>> print(frase.translate(tabla)) >>> print(tabla)
>>> print(frase.splitlines()) >>> print(frase.splitlines(keepends=True)) mayúsculas se utiliza str.islower() y str.isupper(), para saber si una cadena
['Vaca', 'Toro', 'Buey'] ['Vaca\n', 'Toro\n', 'Buey'] contiene solo espacios en blanco se utiliza str.isspace(), para saber la
hi. Hleo d12 nu12v {97: 'eo', 101: '12', 111: None, 49: 'hi'}
Construir una cadena a partir de múltiples fragmentos cadena tiene formato de título se utiliza str.istitle() y para saber si todos los
Si el método str.maketrans(x, y[, z]) tiene dos argumentos, ambos deben ser caracteres de una cadena son imprimibles se utiliza str.isprintable().
El método str.join(itr) retorna una cadena que resulta de la concatenación de
cadenas de texto (str) de igual longitud, para así reemplazar el carácter de (x) Todos estos métodos retornan True o False.
los elementos del iterable (deben ser cadenas también). Generará TypeError
por el carácter de (y) que está en la misma posición. El tercer argumento (z)
si algún elemento del iterable (itr) no es una cadena. El separador (str) entre >>> num = '1234' >>> name = 'Andrés'
debe ser una cadena (str) cuyos caracteres serán eliminados del resultado.
elementos es la cadena que proporciona este método. >>> print(num.isdigit()) >>> print(name.islower())
>>> clave = 'aeiou' # mayúsculas y minúsculas son caracteres distintos. True False
>>> valor = 'zdklj' >>> frutas = ['mango', 'fresa', 'uva'] >>> codigos = ['6013', '1285', '4763']
>>> frase = 'Bienvenidos a todos' >>> print(', '.join(frutas)) >>> print('---'.join(codigos)) Convetir primer letra de la oración en mayúscula
mango, fresa, uva 6013---1285---4763 El método str.capitalize() retorna una copia de la cadena (str) con el primer
>>> tabla = frase.maketrans(clave, valor, 'n')
>>> print(frase.translate(tabla)) # este método es el opuesto a str.split(sep=None, maxsplit=-1). carácter en mayúsculas y el resto en minúsculas.
Bkdvdkdls z tldls
Encontrar una subcadena dentro de una cadena de caracteres >>> frase = 'HOLA A TODO MUNDO'
Separar elementos de una cadena de caracteres El método str.find(sub[, start[, end]]), busca la subcadena indicada (sub) dentro >>> print(frase.capitalize())
El método str.split(sep=None, maxsplit=-1) convierte una cadena (str) en una de la cadena de texto (str) y devuelve el índice más bajo de dicha subcadena. Hola a todo mundo
lista utilizando una cadena como separador (sep), si no se indica, utiliza los Si esta no está presente, devuelve (-1). Los argumentos opcionales (star / end) Convertir primer letra de cada palabra en mayúscula
espacios en blanco o los saltos de línea (\n) como separador. El segundo sirven para acortar la búsqueda dentro de la cadena de texto, a modo de El método str.title() retorna una copia de la cadena (str) con el primer
argumento (maxsplit – opcional) indica el máximo de divisiones que puede slicing. carácter de cada palabra en mayúsculas, y el resto en minúsculas.
tener lugar. El método str.rsplit(sep=None, maxsplit=-1) hace lo mismo, solo
que realiza el proceso de derecha a izquierda. El método str.index(sub[, start[, end]]) funciona igual que str.find(substr), >>> frase = 'Hola a todo mundo'
excepto que devuelve ValueError si no se encuentra dicha subcadena. >>> print(frase.title())
Hola A Todo Mundo
 Dentro de una cadena se pone el especificador de conversión ( %s : string, >>> print('{0:*=+6}'.format(55)) >>> print('{0:$^+6}'.format(55))
Convertir mayúsculas a minúsculas y viceversa a la vez %d : int, %o : octal, %x : hexadecimal, %f : float ) en el lugar donde van las +***55 $+55$$
El método integrado str.swapcase() retorna una copia de la cadena (str), variables y después de la cadena se coloca ( % ) y especificamos, en orden, >>> print('{0:#^+9b}'.format(55)) >>> print('{0:$^+#11b}'.format(55))
con los caracteres en mayúsculas convertirdos a minúscula, y viceversa. entre paréntesis y separados por comas, a qué variables se refieren esos #+110111# $+0b110111$
>>> frase = 'Hola A Todo Mundo' especificadores. Si solo es una expresión o variable, no es necesario usar Para los números de punto flotante (float), se sigue la sintaxis {[índice] :
>>> print(frase.swapcase()) paréntesis. Para escribir el símbolo de porcentaje se usa ( %% ). [relleno][alineación][signo][longitud_mínima][.cantidad_decimales][formato][%
hOLA a tODO mUNDO ]}. Para la alineación se utiliza ( < : izquiera ) ( ^ : centro ) ( > : derecha ) ( = :
>>> print("Hola %s" % "mundo") ubica el relleno entre el signo y el número ). Para el signo solo se suele usar ( +
Convertir texto a minúsculas o mayúsculas Hola mundo ) para forzar su visualización. Para el formato se utiliza ( e/E : exponencial ) ( f
Los métodos str.lower() y str.upper() convierten todos los caracteres de la >>> print("el %.2f es muy %s" % (3.1416, "importante")) : punto flotante ) ( g/G : general ). El formato general ( g/G ) es similar a ( f )
cadena de texto (str) en minúsculas o mayúsculas, respectivamente. el 3.14 es muy importante # %.2g hubiera arrojado 3.1 solo que en vez de indicar el número de decimales, indica el número de
>>> valor = 13 dígitos, salvo que la cifra sea muy grande, en cuyo caso es similar a ( e/E ).
>>> frase = ‘Hola mundo’ >>> frase = ‘Hola mundo’
>>> porciento = 15 También se puede utilizar al final ( % ) para expresar porcentaje.
>>> print(frase.lower()) >>> print(frase.upper())
>>> porcentaje = (valor * porciento) / 100
hola mundo HOLA MUNDO
>>> print("El %d%% de %.2f es %.2f." % (porciento, valor, porcentaje)) >>> print('{0:15.2e}'.format(345.874653329)) >>> print('{0:.2g}'.format(8.45))
El método str.casefold() es similar a str.lower() pero más fuerte, lo que El 15% de 13.00 es 1.95. 3.46e+02 8.4
significa que convertirá más caracteres en minúscula y encontrará más >>> dic = {"Fruta":"Banano", "costo":24} >>> print('{0:*>15.4f}'.format(345.874653329)) >>> print('{0:.2f}'.format(8.45))
coincidencias cuando compare dos cadenas. >>> print("El %(Fruta)s cuesta %(costo).1f pesos" % dic) *******345.8747 8.45
El Banano cuesta 24.0 pesos
>>> print('{0:*<+15.5}'.format(3.874653329))
print('der Fluß'.casefold() == 'der Fluss'.casefold()) >>> print('%(language)s has %(number)03d quote types.' % +3.8747********
True ... {'language': "Python", "number": 2})
>>> print('{0:#=+15.5g}'.format(3.874653329))
>>> print("XßΣ".casefold()) >>> print("XßΣ".lower()) Python has 002 quote types. +########3.8747
xssσ xßς
Formato de cadena – más reciente >>> print('{0:-<+15.4%}'.format(3.874653329))
Centrar y alinear a la izquierda o derecha un texto Una forma más reciente utiliza el método str.format(*args, **kwargs). Este +387.4653%-----
Los métodos str.center(width[, fillchar]), str.ljust(width[, fillchar]) y admite a diferencia de la forma anterior, cualquier tipo de dato (str, int, float, También se tiene la función integrada format(*args, **kwargs), la cual toma
str.rjust(width[, fillchar]) retornan una copia de la cadena (str) centrada o list, tuple, etc.). La cadena de texto (str) contiene un campo de reemplazo como primer argumento un ( str ) ( int ) ( float ), mientras que el segundo
alineada a la izquierda o derecha, respectivamente. delimitado por llaves { } el cual puede ser llamado por medio de un índice argumento es el formato que se le va a dar al dato ingresado. Sigue la sintaxis
(*args) o por medio de un nombre de campo (**kwargs). Este método [relleno][alineación][signo][0-longitud][,][.decimales][tipo]. Si no se indica
El primer argumento indica la longitud (width) de la cadena resultante, y el retorna una copia de la cadena de texto, donce cada campo de reemplazo se
segundo argumento (fillchar – opcional) indica el carácter de relleno que por relleno ni alineación, la longitud se rellena con espacios en blanco, o con
sustituye con el valor del argumento correspondiente. ceros si se indica [0longitud]. [,] permite escribir al estilo europeo (miles con
defecto es espacio en blanco. Se retorna la cadena original si la longitud indicada
es menor o igual a len(str). Estos métodos son útiles para imprimir tablas. >>> ‘La suma de 1 + 2 es {}’.format(1+2) # no es necesario indicar el índice. comas y decimales con puntos)
La suma de 1 + 2 es 3
>>> titulo = 'Bienvenidos todos' >>> titulo = 'Bienvenidos todos' >>> print(format(124.3, '-=+12')) >>> print(format(12.3456, '.2f'))
>>> ‘La palabra {0} tiene {{{1}}} letras’.format(‘luna’, len(‘luna’)) +------124.3 12.35
>>> print(titulo.ljust(30, '-')) >>> print(titulo.rjust(30, '-')) La palabra luna tiene {4} letras # para escribir { } se doblan.
Bienvenidos todos------------- -------------Bienvenidos todos >>> print(format(33245.98, ',')) >>> print(format(0.08232, '.2%'))
>>> ‘El precio es: {}{}’.format(5.0, ‘$’) # permite concatenar str e int. 33,245.98 8.23%
>>> print(titulo.center(30, '-')) >>> print(titulo.center(5, '-')) El precio es: 5.0$
------Bienvenidos todos------- Bienvenidos todos >>> print(format('Alex', '.2')) >>> print(format('Ana', '-^7'))
>>> print('{niño} tiene una cita con {niña}'.format(niño='Javier'[:2], niña='Luisa')) Al --Ana—
Rellenar un texto anteponiendo ceros Javier tiene una cita con Luisa # se puede usar slicing.
>>> print(format(33245.98, '020')) >>> print(format(5, '10b'))
El método str.zfill(width), retorna una copia de la cadena de texto (str), rellena >>> prov = ['Segovia', 'Cadiz', 'Murcia'] 00000000000033245.98 101
con ceros a la izquierda hasta alcanzar la longitud (width) indicada. Se retorna la >>> print('La provincia de {0} pertenece a {comunidad}'.format(prov[2],
>>> print(format(589674.9075, 'v>+20,.3f'))
cadena original si la longitud indicada es menor o igual a len(str). Si la cadena comunidad='Galicia')) # se puede llamar a un elemento de una lista.
La provincia de Murcia pertenece a Galicia vvvvvvvv+589,674.907
(str) tiene un signo como prefijo ( + / - ), los ceros se añadirán después del signo.
>>> cine = {'actor': 'Alex', 'film': 'Jungla'} Cadenas f
>>> factura = '2342578' >>> factura = '+2342578' >>> print('El actor {0[actor]} protagoniza {0[film]}'.format(cine)) Las cadenas f brindan una forma concisa de construir cadenas formateadas
>>> print(factura.zfill(10)) >>> print(factura.zfill(10)) El actor Alex protagoniza Jungla de muy fácil lectura. A diferencia de los métodos de formato anteriores, con
0002342578 +002342578
Para dar un formato más específico a las strings, se tiene en cuenta esta esta forma se pueden escribir expresiones, no simples especificadores. Consiste
Contar cuantas veces aparece una subcadena sintaxis {[nombre_campo] : [caracter_relleno][alineación][longitud_mínima]}. en una cadena de texto precedida por una f, dentro de la cadena, para
El método str.count(sub[, start[, end]]) retorna el número total de ocurrencias Para la alineación se utiliza ( < : izquiera ) ( ^ : centro ) ( > : derecha ). Se puede especificar las variables, se utilizan llaves { } y al igual que str.format(*args,
de una subcadena (sub) dentro de la cadena de texto (str). Los argumentos poner un punto ( . ) antes de una longitud que sea menor que la longitud de la **kwargs), se pueden utilizar distintos formatos.
opcionales (start / end) indican el rango a modo de slicing. cadena, para recortarla. >>> nombre = 'Miguel'
>>> frase = "Hola a todos" >>> frase = "Hola a todos" >>> print('Hola {0:$>10}'.format('Juan')) >>> print('Hola {0:.2}'.format('Juan')) >>> edad = 39.5
>>> print(frase.count(‘o’)) >>> print(frase.count(‘o’, 3, -1)) >>> print(f'Dentro de {{5}} años tendrás {(edad + 5):.2g}')
Hola $$$$$$Juan Hola Ju
3 2 Dentro de {5} años tendrás 44
Para los números enteros (int), se sigue la sintaxis {[índice] : >>> print(f'Él se llama {nombre.upper()}')
Extensión de la cadena de caracteres [relleno][alineación][signo][longitud_mínima][base]}. Para la alineación se utiliza Él se llama MIGUEL
La función len(str) retorna la longitud (número de caracteres) que contine una ( < : izquiera ) ( ^ : centro ) ( > : derecha ) ( = : ubica el relleno entre el signo y >>> print(f'Su nombre al revés es {nombre[::-1]!r}') # !r corresponde a repr().
cadena de texto (str). el número ). Para el signo solo se suele usar ( + ) para forzar su visualización. Su nombre al revés es 'leugiM'
>>> frase = ‘Hola mundo’ Para la base se utiliza ( b : binaria ) ( x : hexadecimal ) ( o : octal ) ( d : decimal >>> fruta = ['mango', 'pera', 'banano']
>>> print(len(frase)) ). Si se escribe ( # ) entre el signo y la longitud mínima, se muestra el prefijo >>> print(f'A mi me gusta el {fruta[0]}')
10 de la base. A mi me gusta el mango
>>> print(f'Hola {"Juan":->10}') >>> print(f'{55:-^+12b}')
Formato de cadena – antiguo >>> print('{0:*<+5}'.format(55)) >>> print('{0:*>+6}'.format(55)) Hola ------Juan --+110111---
+55** ***+55
>>> print(f'{3.8756:x>15.4f}') >>> print(f'{54.23123:@>+16.2%}')
 xxxxxxxxx3.8756 @@@@@@@+5423.12% [1, 4, 7, 10] [1, 2, 3, 4, 5]
# al agregar el elemento, # una forma de solucionarlo es con for.
>>> print(lista[4:]) >>> print(lista[3::2]) se agrega a todos, porque >>> lista = [[] for i in range(3)]
[5, 6, 7, 8, 9, 10] [4, 6, 8, 10] todos son el mismo objeto >>> lista[0].append(5)
>>> print(lista[::-1]) >>> print(lista[-8:-1]) solo que está referenciado >>> print(lista)
Otras funciones aplicables a las cadenas de texto [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] [3, 4, 5, 6, 7, 8, 9] varias veces. [[5], [], []]
La función reversed(seq) retorna un objeto reversed el cual contiene todos
>>> print(lista[-9:8:2]) >>> print(lista[4:-2]) >>> lista[0].append(5) >>> for i in range(3):
los caracteres de la cadena (seq) en orden inverso, se suele convertir a una lista [2, 4, 6, 8] [5, 6, 7, 8] >>> print(lista) >>> lista[i] = [i+1]
para visualizar los datos. [[5], [5], [5]] >>> print(lista)
>>> lista[:4:2] = [0, 0] >>> lista[-6:-1] = ['vacío']
>>> print(lista) >>> print(lista) [[1], [2], [3]]
>>> print(list(reversed('anaconda')))
['a', 'd', 'n', 'o', 'c', 'a', 'n', 'a'] [0, 2, 0, 4, 5, 6, 7, 8, 9, 10] [1, 2, 3, 4, 'vacío', 10]
Comparación entre listas
>>> lista[4:-1] = ['x', 'x', 'x', 'x', 'x'] >>> lista[2:] = [] Dos listas son iguales cuando tienen el mismo tamaño y cada uno de sus
Las funciones max(itr[, default=obj, key=func]) y min(itr[, default=obj, >>> print(lista) >>> print(lista)
key=func]) retornan el máximo y mínimo valor de una secuencia (itr). El segundo [1, 2, 3, 4, 'x', 'x', 'x', 'x', 'x', 10] [1, 2]
elementos correspondientes tienen el mismo valor. Se compara el primer
argumento (default – opcional) es el valor que retorna en caso de que la elemento de cada objeto, luego el segundo elemento y así.
secuencia (itr) esté vacía, si no se especifica, lanza ValueError. El tercer La función list[slice(x, y, z)] es equivalente al slicing list[x:y:z], aunque se
>>> print([1, 2, 3] < [1, 3, 4]) >>> print(('gato', 'perro') > ('leon', 'cebra'))
argumento (key – opcional) permite personalizar el orden de clasificación por puede usar para permitir que el usuario defina su propia porción que se True False
medio de una función. aplicará a los datos, no suele ser muy común.
Listas como pilas y como colas
Una segunda sintaxis es max(arg1, arg2, *args[, key]). >>> numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Las listas funcionan naturalmente como una pila (último en entrar, primero en
>>> print(numeros[slice(1, 5)])
>>> print(max('Estados Unidos')) # compara los caracteres [2, 3, 4, 5] salir), haciendo uso de los métodos list.append(elem) y list.pop() para
t según el orden lexicográfico. agregar un item a la cima de la pila y retirar un item de la cima de la pila,
>>> print(max('Estados Unidos', key=str.lower)) # compara los caracteres Eliminar elemento de una Lista respectivamente.
U en minúsculas. La palabra reservada del permite eliminar un elemento indicando su índice,
Para usar una lista como una cola (primero en entrar, primero en salir), se debe
>>> print(max('Ana', 'Alex', 'Miguel', key=len)) # compara cadenas según eliminar una sección o incluso vaciar toda la lista utilizando el slicing.
importar collections.deque el cual fue diseñado para agregar y sacar de
Miguel su longitud. ambas puntas de forma rápida.
>>> numeros = [1, 2, 's', 4] >>> frutas = ['mango', 'fresa', 'limón', 'pera']
>>> print(min(' ', default='Vacío')) # si la secuencia está vacía, >>> del numeros[2] >>> del frutas[1:3]
Vacío retorna el valor de default. >>> print(numeros) >>> print(frutas) >>> name = ['Juan', 'Alex', 'Felipe', 'Camilo']
[1, 2, 4] ['mango', 'pera'] >>> print(name.pop()) # funciona como pila.
El ordenamiento lexicográfico para las cadenas de texto utiliza el orden de Camilo
los códigos ASCII de sus caracteres. >>> del numeros[:] >>> del frutas[-1] >>> from collections import deque
>>> print(numeros) >>> print(frutas)
[] ['mango'] >>> name = deque(['Juan', 'Alex', 'Felipe', 'Camilo'])
5. LISTAS >>> print(name.popleft()) # funciona como cola.
Concatenar listas y añadir elementos a listas Juan
Una lista es un conjunto ordenado y mutable que puede contener cualquier El operador suma ( + ) permite concatenar varias listas, dando como resultado
tipo de dato. Los valores se indican entre corchetes [ ] y separados por comas. Convertir listas a otros tipos de variables
una lista nueva que contiene los elementos de dichas listas. Mientras que el
Las listas se pueden convertir a cualquier tipo de secuencia: tuplas, sets,
>>> lista = [1, "sol", (1,2), True] >>> lista = [5] >>> lista = [ ] método list.extend(list2) permite agregar los elementos de una lista (list2) al
cadenas de texto y diccionarios. Las funciones tuple(itr) y set(itr) convierten
final de otra lista (list), es decir, modifica una lista existente, no crea otra nueva.
Índices y particionados en listas – modificando elementos una lista (itr) en una tupla y en un set, respectivamente.
Se puede acceder a cada elemento de una lista por medio de su índice (i), El operador ( += ) también permite añadir elementos a una lista (la modifica).
La función dict(itr) convierte una lista (itr) en un diccionario, pero la lista debe
según la sintaxis list[i], en donde [0] es el primer elemento. Es posible usar >>> city = ['Denver', 'Bostón'] >>> decenas = [10, 20, 30, 40, 50] contener secuencias anidadas de dos elementos (par clave – valor).
índices negativos, donde [-1] es el último elemento y [-2] el penúltimo. >>> ciudad = ['Tunja', 'Pasto'] >>> centenas = [100, 200, 300, 400, 500]
Utilizando los índices es posible modificar o eliminar un elemento de la lista. >>> print(city + ciudad) >>> print(decenas + centenas) >>> colores = ['rojo', 'azul', 'verde'] >>> colores = ['rojo', 'azul', 'verde']
['Denver', 'Bostón', 'Tunja', 'Pasto'] [10, 20, 30, 40, 50, 100, 200, 300, 400, 500] >>> print(tuple(colores)) >>> print(set(colores))
>>> lista = [1, "sol", (1,2), True] >>> lista = ['Hi', 10, ['45', '33', 'Ob']] ('rojo', 'azul', 'verde') {'rojo', 'verde', 'azul'}
# los métodos que no crean nuevos objetos, sino que modifican los ya existentes, devuelven
>>> print(lista[-1]) >>> print(lista[2][1]) >>> usuario = [['name', 'Juan'], ['surname', 'Ruiz']]
True 33 None si se intentan imprimir, se debe imprimir es el objeto modificado.
>>> print(dict(usuario))
>>> city = ['Denver', 'Bostón'] >>> city = ['Denver', 'Bostón'] {'name': 'Juan', 'surname': 'Ruiz'}
>>> lista[2] = 'luna' >>> lista[-1][-1] = '89'
>>> ciudad = ['Tunja', 'Pasto'] >>> ciudad = ['Tunja', 'Pasto']
>>> print(lista) >>> print(lista) >>> capitales = [('Tolima', 'Ibagué'), ('Chocó', 'Quibdó'), ('Sucre', 'Sincelejo')]
[1, 'sol', 'luna', True] ['Hi', 10, ['45', '33', '89']] >>> print(city.extend(ciudad)) >>> city.extend(ciudad)
>>> print(dict(capitales))
None >>> print(city)
['Denver', 'Bostón', 'Tunja', 'Pasto'] {'Tolima': 'Ibagué', 'Chocó': 'Quibdó', 'Sucre': 'Sincelejo'}
También es posible por medio del particionado o slicing, crear nuevas
sublistas (devuelve una copia de la lista) al elegir porciones de una lista, indicando >>> alumnos = ['Ana', 'Juan'] Por otro lado, el método str.join(itr) convierte una lista (itr) en una cadena
>>> alumnos.extend(['Miguel']) >>> alumnos = ['Ana', 'Juan']
los índices de inicio (start) y final (end) de la nueva sublista según la sintaxis >>> print(alumnos) >>> alumnos += ['Liliana', 'Carmen']
de texto, uniendo los elementos del iterable por medio de un string (str). Los
list[star:end:step]. Python lo interpreta como una sublista que va desde la ['Ana', 'Juan', 'Miguel'] >>> print(alumnos) elementos del iterable deben ser cadenas de texto.
posición [start] hasta la posición [end], sin incluir este último. El tercer numero ['Ana', 'Juan', 'Liliana', 'Carmen'] >>> name = ['Ana', 'Juan', 'Alex'] >>> num = ['1', '2', '3', '4']
(step) determina cada cuantas posiciones añadir un elemento a la sublista. Se # el operador ( + ) solo puede concatenar listas con listas. En cambio, el método >>> print(', '.join(name)) >>> print(' - '.join(num))
usa para modificar o incluso eliminar porciones de la lista. list.extend(arg) y el operador ( += ) permiten añadir elementos de tuplas a listas, debido Ana, Juan, Alex 1-2-3-4
No es necesario indicar el principio y el final del slicing. Si estos se omiten, se a que no crean un nuevo elemento, sino que modifican la lista ya existente.
Convertir otro tipo de variables a listas
usará por defecto las posiciones de inicio y final de la lista. Así mismo, se Repetir una lista varias veces Las tuplas, sets, diccionarios y cadenas de texto se pueden convertir a listas por
permite el uso de índices negativos. El operador ( * ) funciona con listas como repetidor. Aquí, los elementos en medio de la función list(itr).
>>> lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] las listas no se copian, sino que se referencian varias veces.
En el caso de los diccionarios, la lista solo contendrá las claves. Si se desea
>>> print(lista[1:5]) >>> print(lista[1:9:2]) >>> lista = [[]] * 3 >>> lista = [1, 2] convertir un diccionario a una lista que contenga solo los valores, se utiliza el
[2, 3, 4, 5] [2, 4, 6, 8] >>> print(lista) >>> print(lista * 3) método dict.values(). Si se desea convertir un diccionario a una lista que
>>> print(lista[::3]) >>> print(lista[:5]) [[], [], []] [1, 2, 1, 2, 1, 2] contenga tuplas con los pares clave – valor, se utiliza el método dict.items().
 # crea una lista de tuplas de dos números (número, cuadrado) >>> args = [3, 6]
>>> frutas = ('mango', 'pera', 'uva') >>> ciudades = {'Cali', 'Zarzal', 'Buga'} >>> print([(x, x ** 2) for x in range(6)]) >>> print(list(range(*args))) # llamada a la función range() con los argumentos
>>> print(list(frutas)) >>> print(list(ciudades)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)] [3, 4, 5] desempaquetados de la lista args.
['mango', 'pera', 'uva'] ['Cali', 'Buga', 'Zarzal']
# aplica un método a todos los elementos – convierte a mayúscula los elementos. Ordenar elementos de una lista (elementos del mismo tipo)
>>> num = {'a':1, 'b':2, 'c':3} >>> num = {'a':1, 'b':2, 'c':3} >>> nombres = ['andrés', 'ana', 'alex']
>>> print(list(num)) >>> print(list(num.values()))
>>> print([i.upper() for i in nombres])
El método integrado list.sort(key=None, reverse=False) modifica una lista,
['a', 'b', 'c'] [1, 2, 3]
['ANDRÉS', 'ANA', 'ALEX'] ordenando sus elementos de forma ascendente. Mientras que la función
>>> num = {'a':1, 'b':2, 'c':3} incorporada sorted(itr, key=None, reverse=False) crea una nueva lista ordenada
# aplicando funciones anidadas y expresiones complejas
>>> print(list(num.items()))
>>> pi = 3.14159
ascendentemente a partir de un iterable (itr).
[('a', 1), ('b', 2), ('c', 3)]
>>> print([str(round(pi, i)) for i in range(6)]) # los elementos de la secuencia deben ser del mismo tipo, sino, lanza TypeError.
Si una cadena de texto se convierte en una lista, cada elemento de la lista sería ['3.0', '3.1', '3.14', '3.142', '3.1416', '3.14159']
>>> num = [9, 2, 7, 3, 6] >>> num = (9, 2, 7, 3, 6)
un carácter. Mientras que el método str.split(sep=None, maxsplit=-1) # filtra nombres por la inicial A. >>> num.sort() >>> num2 = sorted(num)
convierte una cadena (str) en una lista utilizando una cadena como separador >>> nombre = ['Ana', 'Luis', 'Andrés', 'Alex', 'Pablo'] >>> print(num) >>> print(num2)
(sep), si no se indica, utiliza los espacios en blanco o los saltos de línea (\n) como >>> print([i for i in nombre if i[0] == 'A']) [2, 3, 6, 7, 9] [2, 3, 6, 7, 9]
separador. El segundo argumento (maxsplit – opcional) indica el máximo de ['Ana', 'Andrés', 'Alex']
El parámetro (key) debe ser una función que tome un solo argumento y
divisiones que puede tener lugar. El método str.rsplit(sep=None, maxsplit=- # realiza la multiplicación entre dos range().
>>> multiplications = [i*n for i in range(1,4) for n in range(1,11)] devuelva una clave para cada elemento de la lista con propósitos de
1) hace lo mismo, solo que realiza el proceso de derecha a izquierda.
>>> print(multiplications) comparación. Se puede utilizar una función hecha por uno mismo.
>>> capital = 'Bogotá' >>> frutas = 'mango, pera, uva' [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21,
>>> name = ['Fabian', 'brayan', 'Andrés', 'camilo']
>>> print(list(capital)) >>> print(frutas.split(', ')) 24, 27, 30]
['B', 'o', 'g', 'o', 't', 'á'] ['mango', 'pera', 'uva'] >>> name.sort(key=str.lower) # trata a mayúsculas y minúsculas igual.
# mostrar los índices de los elementos de ListaB presentes en ListaA. >>> print(name)
Empaquetado y desempaquetado de secuencias (ordenadas) >>> ListaA = [1,4,1,4,6,5,5,5,4,2,3] ['Andrés', 'brayan', 'camilo', 'Fabian']
>>> ListaB = [1,3,5]
El empaquetado de secuencias se refiere a que varios valores se pueden >>> print([[i for i, x in enumerate(ListaA) if x == e] for e in ListaB])
>>> name = ['Fabio', 'ana', 'Alejandra', 'camilo']
empaquetar juntos en una secuencia (lista, tupla, conjunto). [[0, 2], [10], [5, 6, 7]] >>> name.sort(key=len) # ordena las cadenas por longitud.
>>> print(name)
El desempaquetado de secuencias se refiere a que los valores individuales # dividir la Lista en sublistas con tantos elementos como lo indica nElementos. ['ana', 'Fabio', 'camilo', 'Alejandra']
de una secuencia (lista, tupla, conjunto) pueden ser asignados a una serie de >>> Lista = [2,5,4,3,7,3,2,5,8,1]
>>> def second(elem):
variables, esto requiere que la cantidad de variables a la izquierda del ( = ) sea >>> nElementos = 2
>>> return elem[1]
del tamaño de la secuencia. >>> print([Lista[i:i+nElementos] for i in range(0,len(Lista),nElementos)])
>>> num = [(2, 2), (3, 4), (4, 1), (1, 3)]
La asignación múltiple solo es una combinación del empaquetado y [[2, 5], [4, 3], [7, 3], [2, 5], [8, 1]]
>>> num.sort(key=second) # ordena según el elemento con índice [1].
desempaquetado de secuencias, en donde los valores individuales de una Listas por compresión anidadas >>> print(num)
secuencia son asignados a una serie de variables. La expresión de retorno de una lista por compresión puede ser cualquier [(4, 1), (2, 2), (1, 3), (3, 4)]

>>> nombres = ['Andrés', 'Julián', 'Germán'] # empaquetado de tuplas. expresión arbitraria, incluyendo otra lista por compresión. Así, la lista por Un patrón común es ordenar objetos complejos usando algunos de los
>>> jefe, asesor, cliente = nombres # desempaquetado de secuencias. compresión anidada se evalúa en el contexto del for que lo sigue. índices del objeto como clave. Por ejemplo:
>>> print(asesor)
>>> matriz = [ >>> student = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
Julián
... [1, 2, 3, 4], >>> print(sorted(student, key=lambda student: student[2]))
>>> jefe, asesor, cliente = ['Andrés', 'Julián', 'Germán'] # asignación múltiple. ... [5, 6, 7, 8], [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> print(cliente) ... [9, 10, 11, 12],
Germán ... ] Python proporciona funciones de conveniencia para que las funciones de acceso
Listas por compresión # lista por compresión que transpone filas y columnas. sean más fáciles y rápidas. Así, el módulo Operator tiene las funciones
Una forma de crear listas de manera compacta es por medio de las listas por
>>> print([[fila[i] for fila in matriz] for i in range(4)]) itemgetter(), attrgetter() y methodcaller().
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
compresión. De esta forma, es posible crear una lista a partir de cualquier >>> from operator import itemgetter
elemento iterable (lista, tupla, string, etc.). El ejemplo anterior es equivalente a: >>> student = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
[<expresión que retorna> <cláusula for> <cláusula if - filtrado>] >>> transpuesta = [] >>> print(sorted(student, key=itemgetter(2))) # ordena según el elemento [2]
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> for i in range(4):
Se usan comúnmente para crear nuevas listas donde cada elemento es el >>> transpuesta.append([fila[i] for fila in matriz]) Las funciones del módulo operator permiten múltiples niveles de clasificación.
resultado de algunas operaciones aplicadas a cada miembro de otra >>> print(transpuesta) Por ejemplo, para ordenar por grado [1] y luego por edad [2]:
secuencia. [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
>>> print(sorted(student, key=itemgetter(1,2)))
# crea una lista de cuadrados Sin embargo, en el mundo real, es preferible utilizar funciones predefinidas en [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
>>> cuadrados = [x ** 2 for x in range(10)]
>>> print(cuadrados)
vez de declaraciones con flujo complejo. Así, la función zip(*itr) hace un buen
trabajo para este caso en concreto. Por otro lado, tanto list.sort(key=None, reverse=False) como sorted(itr,
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] key=None, reverse=False) aceptan un parámetro reverse con un valor
# combina los elementos de dos listas si no son iguales >>> print(list(zip(*matriz))) booleano. Se usa reverse=True para marcar un orden descendente.
>>> print([(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]) [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)] >>> print(sorted(student, key=itemgetter(2), reverse=True))
Desempaquetando una lista de argumentos [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
# filtra la lista para excluir números negativos
>>> vec = [-4, -2, 0, 2, 4]
Cuando los argumentos ya están en una lista o tupla, pero necesitan ser
desempaquetados para llamar a una función que requiere argumentos Invertir el orden de una lista
>>> print([x for x in vec if x >= 0]) Para invertir el orden de una secuencia, se puede utilizar el método
[0, 2, 4] posicionalmente separados. Para esto se puede escribir la función con el
operador ( * ) para desempaquetar argumentos de una lista o tupla. list.reverse() el cual invierte los elementos de la lista (modifica la lista).
# aplica una función a todos los elementos También se puede invertir la lista utilizando slicing [::-1]. Mientras que la
>>> print([abs(x) for x in vec]) >>> print(list(range(3, 6))) # llamada a la función range() normal, con los función reversed(itr) crea un objeto reversed el cual se puede convertir a una
[4, 2, 0, 2, 4] [3, 4, 5] argumentos separados. lista.
 >>> user = ['Juan', 'Alex', 'Ana'] >>> user = ['Juan', 'Alex', 'Ana'] >>> keys = ['alpha', 'beta', 'gamma'] Esta función puede parecer un bucle for, pero al ser una función incorporada,
>>> user.reverse() >>> print(list(reversed(user))) >>> values = [10, 20, 30] es más rápida.
>>> print(user) ['Ana', 'Alex', 'Juan'] >>> print(dict(zip(keys, values)))
['Ana', 'Alex', 'Juan'] {'alpha': 10, 'beta': 20, 'gamma': 30} # filtra los elementos cuyo módulo sea igual a cero.
# se puede combinar zip(*itr) con listas de compresión. >>> numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Valores máximos y mínimos de una lista >>> resultado = filter(lambda x: x % 2 == 0, numeros)
>>> name = ['Juan', 'Alex', 'Ana']
Las funciones max(itr[, default=obj, key=func]) y min(itr[, default=obj, >>> user = ['Juan01', 'Al3', 'Ana96']
>>> print(list(resultado))
key=func]) retornan el máximo y mínimo valor de una lista (itr). El segundo >>> age = [17, 20, 19]
[2, 4, 6, 8, 10]
argumento (default – opcional) es el valor que retorna en caso de que la lista >>> [print(x, y, z) for x, y, z in zip(name, user, age)] Reducir los valores de una lista a un solo valor
(itr) esté vacía, si no se especifica, lanza ValueError. El tercer argumento (key Juan Juan01 17
La función reduce(function, itr) del módulo functools como su nombre lo
– opcional) permite personalizar el orden de clasificación por medio de una Alex Al3 20
Ana Ana96 19 indica, reduce los valores de una lista (itr) a un solo valor, aplicando una función
función.
reductora (function). La función reductora debe tener dos argumentos.
# desempaquetando una lista de argumentos
>>> letras = ['c', 'b', 'Y', 'Z'] >>> letras = ['c', 'b', 'Y', 'Z'] >>> coordinate = ['x', 'y', 'z']
>>> print(min(letras)) >>> print(min(letras, key=str.lower)) >>> from functools import reduce
>>> value = [3, 4, 5, 0, 9]
Y b # suma los elementos de la lista entre sí.
>>> result = zip(coordinate, value)
>>> numeros = [1, 2, 3, 4, 5]
>>> lenguajes = ['python', 'lua', 'ruby'] >>> lenguajes = ['python', 'lua', 'ruby'] >>> resultList = list(result) >>> resultado = reduce(lambda x, y: x + y, numeros)
>>> print(max(lenguajes)) >>> print(max(lenguajes, key=len)) >>> print(resultList) >>> print(resultado)
ruby python [('x', 3), ('y', 4), ('z', 5)] 15
Función range([start], stop[, step]) – range(stop) >>> c, v = zip(*resultList) # la tendencia ahora es usar listas por compresión, dejando a un lado las funciones
Genera una objeto range inmutable de números enteros (int) en sucesión >>> print('c =', c) map() y filter(), y usando reduce() en casos muy aislados.
c = ('x', 'y', 'z')
aritmética, que van desde un inicio (start – opcional) que por defecto es cero,
Otros métodos y funciones para las listas
hasta un número final (stop) sin incluir este último. El tercer argumento (step – Además, si se tienen secuencias de diferente longitud, y se desea rellenar los
opcional) indica los saltos entre elementos (diferencia entre cada número de la espacios faltantes, se puede utilizar el método it.zip_longest(*itr, fillvalue=’ list.append(x) añade un elemento (x) al final de la lista. El ítem puede ser
secuencia). La función se suele usar para recorrer bucles for. Para ver los ’) del módulo itertools. cualquier tipo (número, string, iterable, etc.) Equivale a list[len(list):] = [x]
elementos, se debe convertir a list(). >>> numeros = [1, 2, 3, 4, 5] >>> numeros = [1, 2, 3, 4, 5]
>>> import itertools as it
>>> print(range(-1)) >>> print(type(range(1))) >>> numeros.append((6, 7, 8)) >>> numeros[4:] = [(6, 7, 8)]
>>> name = ('Juan', 'Alex', 'Ana', 'Manuel')
range(0, -1) <class 'range'> >>> print(numeros) >>> print(numeros)
>>> age = [22, 19]
[1, 2, 3, 4, 5, (6, 7, 8)] [1, 2, 3, 4, (6, 7, 8)]
>>> print(list(it.zip_longest(name, age, fillvalue='?')))
>>> print(range(3)[1]) # se puede acceder a un elemento del range() [('Juan', 22), ('Alex', 19), ('Ana', '?'), ('Manuel', '?')] list.extend(itr) amplia la lista añadiendo todos los elementos del iterable (itr).
1 indicando su índice. Equivale a list[len(list):] = itr.
Aplicar una función a cada elemento de una lista
>>> print(range(6)[2:5]) # acortar un range con slicing devuelve otro range. La función map(function, itr) devuelve un objeto map con la función (function) >>> numeros = [1, 2, 3, 4, 5] >>> numeros = [1, 2, 3, 4, 5]
range(2, 5)
aplicada a cada argumento de la lista original (itr). Para visualizar los elementos >>> numeros.extend((6, 7, 8)) >>> numeros[4:] = (6, 7, 8)
>>> pais = ['Colombia', 'Venezuela'] >>> print(list(range(2, -8, -2))) se debe convertir a una lista. Se suele utilizar junto a expresiones lambda ya que >>> print(numeros) >>> print(numeros)
>>> for n in range(len(pais)): [2, 0, -2, -4, -6] permite ahorrarnos el esfuerzo de crear bucles for. [1, 2, 3, 4, 5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8]
>>> print(n+1, pais[n])
1 Colombia # el valor devuelto por la función len(), puede Se puede colocar como argumento varios iterables, solo hay que asegurarse list.insert(i, x) inserta un ítem (x) y da su posición (i). El primer argumento es el
2 Venezuela ser usado como parámetro de range(). que la función tenga un parámetro para cada iterable. índice (i) del elemento a insertar. Así, list.insert(0, x) inserta el elemento (x) al
>>> list(range(4))+list(range(5)) # solo se pueden concatenar tipos range() principio de la lista, y list.insert(len(lista), x) equivale a list.append(x).
# el método str.upper() no es aplicable a listas, pero se puede aplicar a cada elemento.
[0, 1, 2, 3, 0, 1, 2, 3, 4] convertidos previamente a listas.
>>> nombres = ['Raúl', 'Andrés', 'Germán'] >>> numeros = [1, 2, 4, 5] >>> numeros = [1, 2, 3, 4, 5]
Combinar varias secuencias en una sola >>> NOMBRES = map(str.upper, nombres) >>> numeros.insert(2, ‘tres’) >>> numeros.insert(0, (1, 1))
>>> print(list(NOMBRES)) >>> print(numeros) >>> print(numeros)
La función zip(*itr) toma varias secuencias (itr) y combina los elementos de ['RAÚL', 'ANDRÉS', 'GERMÁN'] [1, 2, ‘tres’, 4, 5] [(1, 1), 1, 2, 3, 4, 5]
cada secuencia con la misma posición en una tupla. La función retorna un zip
object, el cual se puede convertir en list, tuple, dict, set para poder visualizar >>> numeros = [1, 2, 3, 4, 5]
>>> resultado = list(map(lambda x: x + 5, numeros))
list.remove(x) remueve el primer ítem de la lista cuyo valor es igual a (x). Arroja
los elementos. Cuando se proporcionan múltiples iterables de diferente >>> print(resultado) ValueError si no se encuentra tal elemento.
longitud, se detiene cuando se agota la secuencia más corta. El operador ( * [6, 7, 8, 9, 10]
) permite desempaquetar los argumentos. >>> frutas = ['mango', 'fresa', 'salmón'] >>> frutas = [‘mango’, ‘fresa’]
>>> a = [1, 2, 3, 4, 5] >>> frutas.remove('salmón') >>> frutas.remove(‘salmón’)
>>> name = ('Juan', 'Alex', 'Ana') >>> b = [6, 7, 8, 9, 10] >>> print(frutas) >>> print(frutas)
>>> age = [22, 19, 24] >>> multiplicacion = list(map(lambda x, y: x * y, a, b)) ['mango', 'fresa'] ValueError
>>> height = [1.75, 1.81, 1.62] >>> print(multiplicacion)
>>> personal_data = zip(name, age, height) [6, 14, 24, 36, 50] list.pop([i]) elimina el elemento de la posición (i) dada y lo devuelve. El
# cambiar el tipo de variable de cada elemento, de str a int.
argumento es opcional, si no se especifica ningún índice, list.pop() elimina y
>>> print(personal_data)
<zip object at 0x00857DA0> >>> num = ['10', '20', '30'] devuelve el último elemento de la lista.
>>> result = map(int, num) # otra forma de cambiar el tipo de variable.
>>> print(list(personal_data)) >>> numeros = [1, 2, 4, 5] >>> numeros = [1, 2, 3, 4, 5]
>>> print(list(result)) >>> for i in range(len(lista)):
[('Juan', 22, 1.75), ('Alex', 19, 1.81), ('Ana', 24, 1.62)] >>> numeros.pop(2) >>> print(numeros.pop())
[10, 20, 30] >>> lista[i] = int(lista[i]) >>> print(numeros) [5]
# se utiliza para iterar múltiples secuencias en paralelo.
Filtrar elementos de una lista [1, 2, 5]
>>> for nombre, edad in zip(name, age):
>>> print('{} tiene {} años.'.format(nombre, edad)) La función filter(function, itr) ofrece una forma simple de filtrar todos los list.clear() remueve todos los elementos de la lista. Equivale a del list[:]
Juan tiene 22 años. elementos de una lista (itr) para los que la función (function) devuelve True
Alex tiene 19 años. (es decir, cumplen una condición). Como la función retorna un objeto filter, es >>> numeros = [1, 2, 4, 5] >>> numeros = [1, 2, 3, 4, 5]
Ana tiene 24 años. necesario convertir a una lista para poder visualizar los elementos. >>> numeros.clear() >>> print(numeros.clear())
>>> print(numeros) None
# permite crear diccionarios a partir de dos secuencias.
[]
 >>> cosas = ['bolso', 'lapiz', 'regla'] >>> cosas = ['bolso', 'lapiz', None] La función tuple[slice(x, y, z)] es equivalente al slicing tuple[x:y:z], aunque se
list.index(x, [star, end]) devuelve el índice del primer elemento cuyo valor es >>> print(all(cosas)) >>> print(all(cosas)) puede usar para permitir que el usuario defina su propia porción que se
igual a (x). Genera ValueError si no hay tal elemento. Los argumentos True False aplicará a los datos, no suele ser muy común.
opcionales (start) y (end) se utilizan para limitar la búsqueda a una subcadena
particular (pero el índice devuelto se calcula en relación con el comienzo de la any(itr) retorna True al menos un elemento de la lista es verdadero. Si la lista >>> numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
secuencia completa en lugar del argumento de inicio). está vacía devuelve False. >>> print(numeros[slice(1, 5)])
(2, 3, 4, 5)
>>> numeros = [1, 2, 4, 5] >>> numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> cosas = [' ', 'lapiz', None] >>> cosas = [ ]
>>> print(any(cosas)) >>> print(any(cosas)) Concatenar tuplas
>>> print(numeros.index(4)) >>> print(numeros.index(7, 3, 7))
2 6 True False El operador suma ( + ) permite concatenar varias tuplas, dando como resultado
sum(itr[, number]) retorna la suma de los elementos de la lista (itr). El segundo una tupla nueva que contiene los elementos de dichas tuplas. El operador ( +=
list.count(x) devuelve el número de veces que un elemento (x) aparece en la ) permite concatenar una tupla a otra ya existente.
lista. argumento (number – opcional) es un número que se agrega al resultado final.
>>> num = [10, 20, 30] >>> num = [10, 20, 30] >>> city = ('Denver', 'Bostón') >>> alumnos = ('Juan', 'Esteban')
>>> nombres = ['Luis', 'Ana', 'Luis', 'Luis'] >>> cod = (102, 104, 102) >>> ciudad = ('Tunja', 'Pasto') >>> alumnos += ('Ana', 'Jimena')
>>> print(sum(num)) >>> print(sum(num, 40))
>>> print(nombres.count('Luis')) >>> print(cod.count(102)) >>> print(city + ciudad) >>> print(alumnos)
3 2 60 100
('Denver', 'Bostón', 'Tunja', 'Pasto') ('Juan', 'Esteban', 'Ana', 'Jimena')
list.sort(key=None, reverse=False) ordena los elementos de la lista de manera 5. TUPLAS Repetir una tupla varias veces
ascendente (modifica la lista). Si (reverse=True) se ordenará de forma El operador ( * ) funciona con listas como repetidor. Aquí, los elementos en
descendente. En cambio, la función sorted(itr, key=None, reverse=False) crea Una tupla es un conjunto ordenado e inmutable (no se puede modificar las listas no se copian, sino que se referencian varias veces.
una copia de la lista ordenada de forma ascendente. una vez creado) que puede contener cualquier tipo de dato. Los elementos
se indican entre paréntesis ( ) y separados por comas. En realidad, los paréntesis >>> tupla = ([ ],) * 3 >>> tupla = ('Camilo', 'Laura')
>>> user = ['Juan', 'Alex', 'Ana'] >>> user = ['Juan', 'Alex', 'Ana'] no son necesarios, el constructor de la tupla es la coma ( , ). Así, una tupla de >>> print(tupla) >>> print(tupla * 2)
>>> user.sort() >>> print(sorted(user)) ([ ], [ ], [ ]) ('Camilo', 'Laura', 'Camilo', 'Laura')
>>> print(user) ['Alex', 'Ana', 'Juan']
un único elemento, debe contener una coma.
['Alex', 'Ana', 'Juan'] Las tuplas ocupan menos espacio de memoria que las listas (mayor velocidad de Comparación entre tuplas
procesamiento). Dos tuplas son iguales cuando tienen el mismo tamaño y cada uno de sus
list.reverse() invierte los elementos de la lista (modifica la lista). También se elementos correspondientes tienen el mismo valor. Se compara el primer
puede invertir la lista utilizando slicing [::-1]. Mientras que la función >>> tupla = ("hola", 3.2, 1) >>> tupla = (5,) >>> tupla = ( ) elemento de cada objeto, luego el segundo elemento y así.
reversed(itr) crea un objeto reversed el cual se puede convertir a una lista.
Índices y particionados en tuplas – acceder a los elementos >>> print((1, 2, 3) < (1, 3, 4)) >>> print(('gato', 'perro') > ('leon', 'cebra'))
>>> numeros = [1, 9, 3, 7, 5] >>> numeros = [1, 9, 3, 7, 5] Se puede acceder a cada elemento de una tupla por medio de su índice (i), True False
>>> numeros.reverse() >>> print(numeros[::-1]) según la sintaxis tuple[i], en donde [0] es el primer elemento. Es posible usar
>>> print(numeros) [5, 7, 3, 9, 1] índices negativos, donde [-1] es el último elemento y [-2] el penúltimo. Como Convertir tuplas a otros tipos de variables
[5, 7, 3, 9, 1] Las tuplas se pueden convertir a cualquier tipo de secuencia: listas, sets,
la tupla es inmutable, no es posible modificar o eliminar un elemento de ella.
>>> numeros = [1, 9, 3, 7, 5] >>> numeros = [1, 9, 3, 7, 5] cadenas de texto y diccionarios. Las funciones list(itr) y set(itr) convierten una
>>> print(reversed(numeros)) >>> print(list(reversed(numeros))) >>> tupla = (1, "sol", (1,2), True) >>> tupla = ('Hi', 10, ['45', '33', 'Ob']) tupla (itr) en una lista y en un set, respectivamente.
<list_reverseiterator object …> [5, 7, 3, 9, 1] >>> print(tupla[-1]) >>> print(tupla[2][1])
True 33 La función dict(itr) convierte una tupla (itr) en un diccionario, pero la tupla
list.copy() devuelve una copia de la lista. Equivale a list[:]. >>> tupla[2] = 'luna' # las tuplas no soportan la asignación de elementos, debe contener secuencias anidadas de dos elementos (par clave – valor).
>>> numeros = [1, 2, 3, 4, 5] >>> print(tupla) el intentar modificar una tupla provoca un TypeError.
>>> colores = ('rojo', 'azul', 'verde') >>> colores = ('rojo', 'azul', 'verde')
>>> numeros2 = numeros.copy() TypeError tampoco soporta la eliminación de sus elementos (del).
>>> print(list(colores)) >>> print(set(colores))
>>> print(numeros2) ['rojo', 'azul', 'verde'] {'rojo', 'verde', 'azul'}
[1, 2, 3, 4, 5]
El particionado o slicing, permite crear nuevas subtuplas (devuelve una copia
de la tupla) al elegir porciones de una tupla con sus índices, según la sintaxis >>> usuario = (('name', 'Juan'), ('surname', 'Ruiz'))
Los métodos como insert, remove, sort, etc., que solo modifican la lista, no list[star:end:step]. Python lo interpreta como una subtupla que va desde la >>> print(dict(usuario))
{'name': 'Juan', 'surname': 'Ruiz'}
tienen un valor de retorno impreso, por lo cual devuelven None, para así evitar posición [start] hasta la posición [end], sin incluir este último. El tercer numero
confusiones. (step) determina cada cuantas posiciones añadir un elemento a la subtupla. Por otro lado, el método str.join(itr) convierte una tupla (itr) en una cadena
>>> numeros = [1, 2, 3, 4, 5] >>> numeros = [1, 2, 3, 4, 5] No es necesario indicar el principio y el final del slicing. Si estos se omiten, se de texto, uniendo los elementos del iterable por medio de un string (str). Los
>>> print(numeros.append(6)) >>> print(numeros.insert(1, 1.5)) usará por defecto las posiciones de inicio y final de la tupla. elementos del iterable deben ser cadenas de texto.
None None
>>> tupla = (1, 2, 3, 4, 5, 6, 7, 8, 9) >>> tupla = (1, 2, 3, 4, 5, 6, 7, 8, 9) >>> name = ('Vaca', 'Toro', 'Pollo') >>> name = ('amor', 'paz', 'felicidad')
enumerate(itr, [start]) crea un objeto enumerate, que convertido a una lista, >>> print(' + '.join(name)) >>> print(' con '.join(name))
>>> print(tupla[2:6]) >>> print(tupla[1:8:2])
Vaca + Toro + Pollo amor con paz con felicidad
corresponde a un conjunto de tuplas de dos elementos (índice, valor) por cada (3, 4, 5, 6) (2, 4, 6, 8)
elemento del iterable (itr). El segundo argumento (start – opcional), señala el >>> print(tupla[5:]) >>> print(tupla[:5]) Convertir otro tipo de variables a tuplas
número desde donde comenzará a contar el índice (0 por defecto). (6, 7, 8, 9) (1, 2, 3, 4, 5) Las listas, sets, diccionarios y cadenas de texto se pueden convertir a tuplas por
>>> nombres = ['Luis', 'Ana', 'Luis', 'Luis'] >>> print(tupla[::3]) >>> print(tupla[:7:2]) medio de la función tuple(itr).
(1, 4, 7) (1, 3, 5, 7)
>>> print(list(enumerate(nombres, 1))) En el caso de los diccionarios, la tupla solo contendrá las claves. Si se desea
[(1, 'Luis'), (2, 'Ana'), (3, 'Luis'), (4, 'Luis')] >>> print(tupla[5::3]) >>> print(tupla[-7::2]) convertir un diccionario a una tupla que contenga solo los valores, se utiliza el
(6, 9) (3, 5, 7, 9)
len(itr) retorna la longitud (número de items) de una lista (itr). método dict.values(). Si se desea convertir un diccionario a una tupla que
>>> print(tupla[-8:-3]) >>> print(tupla[1:-2:2]) contenga tuplas con los pares clave – valor, se utiliza el método dict.items().
>>> capitales = ['Bogotá', 'Quito', 'Venezuela'] (2, 3, 4, 5, 6) (2, 4, 6)
>>> print(len(capitales)) >>> print(tupla[::-2]) >>> print(tupla[:-1:3]) >>> frutas = ['mango', 'pera', 'uva'] >>> ciudades = {'Cali', 'Zarzal', 'Buga'}
3 (9, 7, 5, 3, 1) (1, 4, 7) >>> print(tuple(frutas)) >>> print(tuple(ciudades))
('mango', 'pera', 'uva') ('Cali', 'Buga', 'Zarzal')
>>> tupla[4:-1] = ('vacío') # las tuplas no soportan la asignación de elementos.
all(itr) retorna True si todos los elementos de la lista son verdaderos, o si la >>> print(tupla) >>> num = {'a':1, 'b':2, 'c':3} >>> num = {'a':1, 'b':2, 'c':3}
lista está vacía. TypeError >>> print(tuple(num)) >>> print(tuple(num.values()))
 ('a', 'b', 'c') (1, 2, 3) ((1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)) >>> lenguajes = ('python', 'lua', 'ruby') >>> lenguajes = ('python', 'lua', 'ruby')
>>> num = {'a':1, 'b':2, 'c':3} >>> print(max(lenguajes)) >>> print(max(lenguajes, key=len))
>>> print(tuple(num.items()))
Sin embargo, es preferible utilizar funciones predefinidas siempre que se pueda, ruby python
(('a', 1), ('b', 2), ('c', 3)) en vez de declaraciones con flujo complejo.
Combinar varias secuencias en una sola
Si una cadena de texto se convierte en una tupla, cada elemento de la tupla >>> print(tuple(zip(*matriz))) La función zip(*itr) toma varias secuencias (itr) y combina los elementos de
((1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)) cada secuencia con la misma posición en una tupla. La función retorna un zip
sería un carácter. Mientras que el método str.split(sep=None, maxsplit=-1)
convierte una cadena (str) en una lista utilizando una cadena como separador Desempaquetando una lista de argumentos object, el cual se puede convertir en list, tuple, dict, set para poder visualizar
(sep), si no se indica, utiliza los espacios en blanco o los saltos de línea (\n) como Cuando los argumentos ya están en una lista o tupla, pero necesitan ser los elementos. Cuando se proporcionan múltiples iterables de diferente
separador. El segundo argumento (maxsplit – opcional) indica el máximo de desempaquetados para llamar a una función que requiere argumentos longitud, se detiene cuando se agota la secuencia más corta. El operador ( *
divisiones que puede tener lugar. El método str.rsplit(sep=None, maxsplit=- posicionalmente separados, se debe escribir la función con el operador ( * ) para ) permite desempaquetar los argumentos.
1) hace lo mismo, solo que realiza el proceso de derecha a izquierda. Esta lista desempaquetar argumentos de una lista o tupla. >>> name = ('Juan', 'Alex', 'Ana')
resultante, se puede convertir luego a una tupla. >>> age = [22, 19, 24]
>>> args = (2, 12, 2)
>>> height = [1.75, 1.81, 1.62]
>>> capital = 'Bogotá' >>> frutas = 'mango, pera, uva' >>> print(tuple(range(*args))) # llamada a la función range() con los argumentos
>>> print(tuple(capital)) >>> print(tuple(frutas.split(', '))) (2, 4, 6, 8, 10) desempaquetados de la lista args. >>> personal_data = zip(name, age, height)
('B', 'o', 'g', 'o', 't', 'á') ('mango', 'pera', 'uva') >>> print(personal_data)
<zip object at 0x00857DA0>
Empaquetado y desempaquetado de secuencias (ordenadas) Ordenar elementos de una tupla >>> print(tuple(personal_data))
El empaquetado de secuencias se refiere a que varios valores se pueden La función incorporada sorted(itr, key=None, reverse=False) crea una nueva lista (('Juan', 22, 1.75), ('Alex', 19, 1.81), ('Ana', 24, 1.62))
empaquetar juntos en una secuencia (lista, tupla, conjunto). ordenada ascendentemente a partir de un iterable (itr), la lista resultante se
# desempaquetando una lista de argumentos
El desempaquetado de secuencias se refiere a que los valores individuales puede convertir una tupla posteriormente. >>> info = (('Juan', 'Camilo'), (19, 17))
de una secuencia (lista, tupla, conjunto) pueden ser asignados a una serie de El parámetro (key) debe ser una función que tome un solo argumento y >>> print(tuple(zip(*info)))
variables, esto requiere que la cantidad de variables a la izquierda del ( = ) sea devuelva una clave para cada elemento de la lista con propósitos de (('Juan', 19), ('Camilo', 17))
del tamaño de la secuencia. comparación. Se puede utilizar una función hecha por uno mismo. Además, si se tienen secuencias de diferente longitud, y se desea rellenar los
La asignación múltiple solo es una combinación del empaquetado y El parámetro (reverse) acepta un valor booleano. Se usa reverse=True para espacios faltantes, se puede utilizar el método it.zip_longest(*itr, fillvalue=’
desempaquetado de secuencias, en donde los valores individuales de una marcar un orden descendente. ’) del módulo itertools.
secuencia son asignados a una serie de variables.
# los elementos de la secuencia deben ser del mismo tipo, sino, lanza TypeError. >>> import itertools as it
>>> nombres = ('Andrés', 'Julián', 'Germán') # empaquetado de tuplas. >>> num = (9, 2, 7, 3, 6) >>> name = ('Fabio', 'ana', 'Alejandra', 'camilo') >>> name = ('Juan', 'Alex', 'Ana', 'Manuel')
>>> jefe, asesor, cliente = nombres # desempaquetado de secuencias. >>> num2 = sorted(num) >>> result = sorted(name, key=len) >>> age = [22, 19]
>>> print(asesor) >>> print(tuple(num2)) >>> print(tuple(result)) >>> print(tuple(it.zip_longest(name, age, fillvalue='?')))
Julián (2, 3, 6, 7, 9) ('ana', 'Fabio', 'camilo', 'Alejandra') (('Juan', 22), ('Alex', 19), ('Ana', '?'), ('Manuel', '?'))
>>> jefe, asesor, cliente = ('Andrés', 'Julián', 'Germán') # asignación múltiple. >>> num = (9, 2, 7, 3, 6)
>>> print(cliente) >>> num2 = sorted(num, reverse=True)
Aplicar una función a cada elemento de una tupla
Germán >>> print(tuple(num2)) La función map(function, itr) devuelve un objeto map con la función (function)
(9, 7, 6, 3, 2) aplicada a cada argumento de la tupla original (itr). Para visualizar los elementos
Tuplas por compresión se debe convertir a una tupla. Se suele utilizar junto a expresiones lambda ya
Una forma de crear tuplas de manera compacta es por medio de las tuplas por Un patrón común es ordenar objetos complejos usando algunos de los índices que permite ahorrarnos el esfuerzo de crear bucles for.
compresión. De esta manera se crea un generator object, el cual se puede del objeto como clave. Para facilitar esto, se tiene el módulo Operator y sus
convertir a una tupla posteriormente. Se suele usar para crear tuplas donde funciones itemgetter(), attrgetter() y methodcaller(). Se puede colocar como argumento varios iterables, solo hay que asegurarse
cada elemento es resultado de alguna operación aplicada a la secuencia. que la función tenga un parámetro para cada iterable.
>>> from operator import itemgetter
>>> a = (10, 20, 30, 40)
[<expresión que retorna> <cláusula for> <cláusula if - filtrado>] >>> user = (('Jhon', 14), ('Juan', 20), ('Ana', 17)) >>> b = (15, 42, 27, 10)
# crea una tupla de cuadrados # ordena según los elementos de índice [1]. >>> c = (3, 5, 1, 7)
>>> cuadrados = (x ** 2 for x in range(10)) >>> print(tuple(sorted(user, key=itemgetter(1)))) >>> suma = tuple(map(lambda x, y, c: x + y + c, a, b, c))
>>> print(cuadrados) (('Jhon', 14), ('Ana', 17), ('Juan', 20)) >>> print(suma)
<generator object <genexpr> at 0x00DEBB70> (28, 67, 58, 57)
Invertir el orden de una tupla
>>> print(tuple(cuadrados)) Se puede utilizar el slicing [::-1]. O la función reversed(itr) que crea un objeto Filtrar elementos de una tupla
(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
reversed el cual se puede convertir a una tupla. La función filter(function, itr) ofrece una forma simple de filtrar todos los
# combina los elementos de dos listas si no son iguales elementos de una tupla (itr) para los que la función (function) devuelve True.
>>> print(((x, y) for x in [1,2,3] for y in [3,1,4] if x != y)) >>> user = ['Juan', 'Alex', 'Ana'] # reversed(itr) crea un objeto reversed,
>>> print(tuple(reversed(user))) mientras que sorted(itr, reverse=True) crea
Como la función retorna un objeto filter, es necesario convertir a una tupla para
<generator object <genexpr> at 0x002DBB70>
('Ana', 'Alex', 'Juan') una lista. poder visualizar los elementos.
>>> print(tuple((x, y) for x in [1,2,3] for y in [3,1,4] if x != y))
((1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)) Esta función puede parecer un bucle for, pero al ser una función incorporada,
Valores máximos y mínimos de una lista
es más rápida.
Listas por compresión anidadas Las funciones max(itr[, default=obj, key=func]) y min(itr[, default=obj,
La expresión de retorno de una lista por compresión puede ser cualquier key=func]) retornan el máximo y mínimo valor de una tupla (itr). El segundo # filtra los elementos cuyo módulo sea igual a cero.
expresión arbitraria, incluyendo otra lista por compresión. Así, la lista por argumento (default – opcional) es el valor que retorna en caso de que la tupla >>> numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(itr) esté vacía, si no se especifica, lanza ValueError. El tercer argumento (key >>> resultado = filter(lambda x: x % 2 == 0, numeros)
compresión anidada se evalúa en el contexto del for que lo sigue. >>> print(tuple(resultado))
– opcional) permite personalizar el orden de clasificación por medio de una
>>> matriz = ((1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12)) (2, 4, 6, 8, 10)
función.
# lista por compresión que transpone filas y columnas. Reducir los valores de una lista a un solo valor
>>> print(((fila[i] for fila in matriz) for i in range(4))) >>> letras = ('c', 'b', 'Y', 'Z') >>> letras = ('c', 'b', 'Y', 'Z')
>>> print(min(letras)) >>> print(min(letras, key=str.lower)) La función reduce(function, itr) del módulo functools como su nombre lo
<generator object <genexpr> at 0x007FBB70>
Y b indica, reduce los valores de una tupla (itr) a un solo valor, aplicando una función
>>> print(tuple((tuple(fila[i] for fila in matriz) for i in range(4)))) reductora (function). La función reductora debe tener dos argumentos.
 Nota que para crear un conjunto vacío hay que usar set( ) y no { } (esto último >>> print(code) >>> print(code)
>>> from functools import reduce {1, 2, 3, 4} {1, 2, 4}
crea un diccionario).
# suma los elementos de la lista entre sí.
>>> numeros = (1, 2, 3, 4, 5) >>> conjunto = { } >>> conjunto = set( ) Similar a set.discard(elem) se tiene set.remove(elem), con la diferencia de
>>> resultado = reduce(lambda x, y: x + y, numeros) >>> print(type(conjunto)) >>> print(type(conjunto)) que si el elemento (elem) no se encuentra es simplemente ignorado en el primer
>>> print(resultado) <class 'dict'> <class 'set'> caso, mientras que el segundo método lanza la excepción KeyError.
15
Se utilizan normalmente para verificación de pertenencia y eliminación de El método set.add(elem) sirve para añadir otro elemento. Si se quiere añadir
# la tendencia ahora es usar listas por compresión, dejando a un lado las funciones todos los elementos de otro contenedor, se utiliza el método
map() y filter(), y usando reduce() en casos muy aislados.
entradas duplicadas. Se puede iterar sobre un set, pero lo hará con un orden
indefinido. set.update(contenedor).
Otros métodos y funciones para las listas >>> letra = {'F', 'M', 'E'} >>> letra = {'F', 'M', 'E'}
# elimina las entradas duplicadas. # verificación de pertenencia.
tuple.index(x, [star, end]) devuelve el índice del primer elemento cuyo valor es >>> canasta = {9, 5, 2, 5, 5, 2, 2} >>> print(9 in canasta) >>> letra.add(('S', 'X')) >>> letra.update(('S', 'X'))
>>> print(canasta) True >>> print(letra) >>> print(letra)
igual a (x). Genera ValueError si no hay tal elemento. Los argumentos {'M', 'E', ('S', 'X'), 'F'} {'X', 'E', 'S', 'F', 'M'}
{9, 2, 5}
opcionales (start) y (end) se utilizan para limitar la búsqueda a una subcadena
particular (pero el índice devuelto se calcula en relación con el comienzo de la Convertir sets a otros tipos de variables Eliminar todos los elementos o uno de forma aleatoria
secuencia completa en lugar del argumento de inicio). Un set se puede convertir a cualquier tipo de secuencia: listas, tuplas, El método set.clear() elimina todos los elementos del set, dejando así un set
diccionarios y cadenas de texto. Las funciones list(itr) y tuple(itr) convierten vacío. El método set.pop() devuelve y elimina un elemento de forma aleatoria,
>>> numeros = (1, 2, 4, 5) >>> numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> print(numeros.index(4)) >>> print(numeros.index(7, 3, 7)) un set (itr) en una lista y en una tupla, respectivamente. lanza la excepción KeyError cuando ya no hay elementos.
2 6 >>> code = {1, 2, 3} >>> code = {4, 2, 7, 3, 9, 1}
La función dict(itr) convierte un set (itr) en un diccionario, pero dicho set debe
contener secuencias anidadas de dos elementos (par clave – valor). >>> code.clear() >>> code.pop()
tuple.count(x) devuelve el número de veces que un elemento (x) aparece en la >>> print(code) >>> print(code)
tupla. El método str.join(itr) convierte un set (itr) en una cadena de texto, uniendo set() {2, 3, 4, 7, 9}
>>> nombres = ('Luis', 'Ana', 'Luis', 'Luis') >>> cod = (102, 104, 102) los elementos del iterable por medio de un string (str). Los elementos del
iterable deben ser cadenas de texto. Compresión de conjuntos
>>> print(nombres.count('Luis')) >>> print(cod.count(102))
3 2
Al igual que con las listas, es posible crear sets de manera compacta a partir
>>> colores = {'rojo', 'azul', 'verde'} >>> colores = {'rojo', 'azul', 'verde'} de cualquier elemento iterable (listas, tuplas, cadenas), por medio de la sintaxis
enumerate(itr, [start]) crea un objeto enumerate, que convertido a una tupla, >>> print(list(colores)) >>> print(tuple(colores)) {<expresión que retorna> <cláusula for> <cláusula if - filtrado>}
corresponde a un conjunto de tuplas de dos elementos (índice, valor) por cada ['verde', 'rojo', 'azul'] ('verde', 'rojo', 'azul')
>>> num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
elemento del iterable (itr). El segundo argumento (start – opcional), señala el >>> user = {('Jhon', '601'), ('Ana', '543')} >>> fruta = {'pera', 'uva', 'mango'}
>>> num_2 = {n for n in num if n > 5} # filtra los números mayores que 5.
número desde donde comenzará a contar el índice (0 por defecto). >>> print(dict(user)) >>> print(' / '.join(fruta))
>>> print(num_2)
{'Ana': '543', 'Jhon': '601'} mango / uva / pera
{6, 7, 8, 9, 10}
>>> nombres = ('Luis', 'Ana', 'Luis', 'Luis')
>>> print(list(enumerate(nombres, 1))) Convertir otro tipo de variables a sets
Operaciones principales: unión, intersección, diferencia
((1, 'Luis'), (2, 'Ana'), (3, 'Luis'), (4, 'Luis')) Las listas, tuplas, diccionarios y cadenas de texto se pueden convertir a sets por
Si se tienen dos conjuntos A y B:
medio de la función set(itr).
len(itr) retorna la longitud (número de items) de una tupla (itr). La unión ( | ) ( A.union(B) ) retorna un nuevo conjunto que contiene los
En el caso de los diccionarios, el set solo contendrá las claves. Si se desea
>>> capitales = ('Bogotá', 'Quito', 'Venezuela') elementos que se hallan en al menos uno de los dos sets involucrados.
convertir un diccionario a un set que contenga solo los valores, se utiliza el
>>> print(len(capitales)) método dict.values(). Si se desea convertir un diccionario a un set que La intersección ( & ) ( A.intersection(B) ) retorna un nuevo conjunto que
3 contiene los elementos que se encuentran en ambos sets.
contenga tuplas con los pares clave – valor, se utiliza el método dict.items().
all(itr) retorna True si todos los elementos de la tupla son verdaderos, o si la Si una cadena de texto se convierte en un set, cada elemento del set sería un La diferencia ( – ) ( A.difference(B) ) retorna un nuevo set que contiene
tupla está vacía. carácter. El método str.split(sep=None, maxsplit=-1) convierte una cadena los elementos del set A que no están en el set B.
>>> numeros = (1, 2, 3, 4, 5) >>> numeros = (0, 1, 2, 3, 4, 5) (str) en una lista utilizando una cadena como separador (sep) (espacios en La diferencia simétrica ( ^ ) ( A.symmetric_difference(B) ) retorna un
>>> print(all(numeros)) >>> print(all(numeros)) blanco por defecto). El segundo argumento (maxsplit – opcional) indica el nuevo conjunto que contiene los elementos que pertenecen a alguno de los
True False máximo de divisiones que puede tener lugar. El método str.rsplit(sep=None, dos conjuntos, pero no a ambos.
maxsplit=-1) hace lo mismo, solo que realiza el proceso de derecha a izquierda.
any(itr) retorna True si al menos un elemento de la tupla es verdadero. Si la Esta lista resultante, se puede convertir luego a un set. >>> niños = {'Juan', 'Felipe'} >>> niños = {'Juan', 'Felipe'}
tupla está vacía devuelve False. >>> niñas = {'Ana', 'Juliana'} >>> niñas = {'Ana', 'Juliana'}
>>> ciudad = ['Cali', 'Zarzal', 'Buga'] >>> fruta = ('mango', 'pera', 'uva') >>> print(niños | niñas) >>> print(niños.union(niñas))
>>> cosas = (0, 'lapiz', None) >>> cosas = ( ) >>> print(set(ciudad)) >>> print(set(fruta)) {'Ana', 'Juliana', 'Juan', 'Felipe'} {'Felipe', 'Ana', 'Juan', 'Juliana'}
>>> print(any(cosas)) >>> print(any(cosas)) {'Cali', 'Zarzal', 'Buga'} {'mango', 'uva', 'pera'}
True False >>> cls_a = {'Ana', 'Karen', 'Alex'} >>> cls_a = {'Ana', 'Karen', 'Alex'}
>>> num = {'A': 1, 'B': 2, 'C': 3} >>> num = {'A': 1, 'B': 2, 'C': 3} >>> cls_b = {'Juan', 'Ana', 'Karen'} >>> cls_b = {'Juan', 'Ana', 'Karen'}
sum(itr[, number]) retorna la suma de los elementos de la tupla (itr). El segundo >>> print(set(num)) >>> print(set(num.values())) >>> print(clase_a & clase_b) >>> print(cls_a.intersection(cls_b))
argumento (number – opcional) es un número que se agrega al resultado final. {'B', 'A', 'C'} {1, 2, 3} {'Ana', 'Karen'} {'Ana', 'Karen'}
>>> num = {'A': 1, 'B': 2, 'C': 3} >>> palabra = 'Amigo' >>> cls_a = {'Ana', 'Karen', 'Alex'} >>> cls_a = {'Ana', 'Karen', 'Alex'}
>>> num = (10, 20, 30) >>> num = (10, 20, 30) >>> print(set(num.items())) >>> print(set(palabra)) >>> cls_b = {'Juan', 'Ana', 'Karen'} >>> cls_b = {'Juan', 'Ana', 'Karen'}
>>> print(sum(num)) >>> print(sum(num, 40)) {('C', 3), ('A', 1), ('B', 2)} {'m', 'g', 'A', 'i', 'o'} >>> print(cls_a – cls_b) >>> print(cls_a.difference(cls_b))
60 100
{'Alex'} {'Alex'}
>>> cuerpo = 'cabeza, torso, piernas'
>>> print(set(cuerpo.split(', '))) >>> con1 = {1, 2, 3, 4} >>> con1 = {1, 2, 3, 4}
6. CONJUNTOS (SET) {'piernas', 'cabeza', 'torso'} >>> con2 = {3, 4, 5, 6} >>> con2 = {3, 4, 5, 6}
Un set es una colección no ordenada y mutable de objetos únicos (sin Añadir y remover un elemento seleccionado >>> print(con1 ^ con2) >>> print(con1.symmetric_difference(con2))
Los métodos set.add(elem) y set.discard(elem) permiten añadir y remover, {1, 2, 5, 6} {1, 2, 5, 6}
elementos repetidos). Los elementos pueden ser de diversos tipos, no obstante,
no pueden incluir objetos mutables (listas, diccionarios y sets). Para escribir un respectivamente, un elemento (elem) al indicarlo como argumento. >>> print(con2 ^ con1) >>> print(con2.symmetric_difference(con1))
{1, 2, 5, 6} {1, 2, 5, 6}
set, se especifican sus elementos entre llaves { } o se utiliza la función set(itr). >>> code = {1, 2, 3} >>> code = {1, 2, 3, 4}
>>> code.add(4) >>> code.discard(3)
Las operaciones de unión, intersección y diferencia aceptan más de dos Otros métodos y funciones aplicables a sets Los métodos dict.values() y dict.items() permiten que al convertir el
conjuntos, por ejemplo ( A | B | C | … ) ( A.union(*others) ) donde el ( * ) set.copy() devuelve una copia del set. diccionario a otra variable, se conserven sus valores o los pares clave – valor
se refiere al desempaquetado de argumentos. La diferencia simétrica si como tuplas de 2 elementos, respectivamente.
solamente compara dos conjuntos a la vez. >>> numeros = {1, 2, 3, 4, 5}
>>> numeros2 = numeros.copy() >>> num = {'uno': 'one', 'dos': 'two', 'tres': 'three'}
Actualización de los sets (no se crean nuevos objetos) >>> print(numeros2) >>> print(list(num)) >>> print(list(num.values()))
Si se tienen dos conjuntos A y B: {1, 2, 3, 4, 5} ['uno', 'dos', 'tres'] ['one', 'two', 'three']
El método A.update(B) agrega todos los elementos de B al conjunto A, es >>> print(list(num.items())) >>> print(tuple(num))
len(itr) retorna la longitud (número de items) de un set (itr). [('uno', 'one'), ('dos', 'two'), ('tres', 'three')] ('uno', 'dos', 'tres')
decir, sustituye al conjunto A con el resultado de la unión entre A y B.
>>> capitales = {'Bogotá', 'Quito', 'Venezuela'} >>> print(tuple(num.values())) >>> print(set(num))
El método A.intersection_update(B) deja en el conjunto A solo los >>> print(len(capitales)) ('one', 'two', 'three') {'dos', 'tres', 'uno'}
elementos que también pertenecen a B, es decir, sustituye al conjunto A con 3 >>> print(', '.join(num)) >>> print(', '.join(num.values()))
el resultado de la intersección entre A y B. uno, dos, tres one, two, three
all(itr) retorna True si todos los elementos del set son verdaderos, o si el set
El método A.difference_update(B) elimina todos los elementos de B en el está vacío. Convertir otro tipo de iterable a diccionarios
conjunto A, es decir, sustituye al conjunto A con el resultado de la diferencia Las listas, tuplas y sets se pueden convertir a un diccionario por medio de la
entre A y B. >>> numeros = {1, 2, 3, 4, 5} >>> numeros = {0, 1, 2, 3, 4, 5}
>>> print(all(numeros)) >>> print(all(numeros)) función dict(itr). Es necesario que la secuencia (itr) esté compuesta de pares
El método A.symmetric_difference_update(B) sustituye al conjunto A True False clave – valor.
con el resultado de la diferencia simétrica entre A y B. También varias asignaciones de variables se pueden convertir en un diccionario,
any(itr) retorna True si al menos un elemento del set es verdadero. Si el set
>>> cjt = {1, 2, 3, 4} >>> cjt = {1, 2, 3, 4} está vacío devuelve False. haciendo uso de la misma función. Esto resulta útil cuando las claves son
>>> unn = {3, 4, 5, 6} >>> unn = {3, 4, 5, 6} cadenas simples.
>>> cjt.update(unn) >>> cjt.difference_update(unn) >>> cosas = {0, 'lapiz', None} >>> cosas = set( )
>>> print(cjt) >>> print(cjt) >>> print(any(cosas)) >>> print(any(cosas)) # crea el diccionario a partir de secuencias de pares clave – valor.
{1, 2, 3, 4, 5, 6} {1, 2} True False >>> tupla = (('uno', 'one'), ('dos', 'two'))
>>> print(dict(tupla))
Igualdad entre sets max(itr[, default=obj, key=func]) y min(itr[, default=obj, key=func]) retornan {'uno': 'one', 'dos': 'two'}
Dos conjuntos son iguales si y solo si contienen los mismos elementos, sin el máximo y mínimo valor de un set (itr). El segundo argumento (default – >>> lista = [['uno', 'one'], ['dos', 'two']]
importar el orden. opcional) es el valor que retorna en caso de que el set (itr) esté vacío, si no se >>> print(dict(lista))
especifica, lanza ValueError. El tercer argumento (key – opcional) permite {'uno': 'one', 'dos': 'two'}
>>> cdg = {2, 6, 8, 4, 3} >>> cdg = {2, 6, 8, 4, 3}
>>> nmr = {4, 2, 3, 8, 6} >>> nmr = {4, 2, 3, 8, 6}
personalizar el orden de clasificación por medio de una función. >>> conjunto = {('uno', 'one'), ('dos', 'two')}
>>> print(cdg == nmr) >>> print(cdg is nmr) >>> print(dict(conjunto))
>>> frutas = {'uva', 'pera', 'banano'} >>> frutas = {'uva', 'pera', 'banano'}
True False {'uno': 'one', 'dos': 'two'}
>>> print(max(frutas, key=len)) print(min(frutas))
banano banano # especifica los pares usando argumentos por palabra clave.
Por otro lado, el método set1.isdisjoint(set2) retorna True si ambos >>> print(dict(uno='one', dos='two'))
conjuntos no comparten ni un solo elemento entre sí. Estos se denominan sum(itr[, number]) retorna la suma de los elementos del set (itr). El segundo {'uno': 'one', 'dos': 'two'}
conjuntos disconexos. argumento (number – opcional) es un número que se agrega al resultado final.
También, la función zip(*itr) permite crear diccionarios a partir de dos
>>> cdg = {2, 3, 4} >>> cdg = {2, 3, 4} >>> num = {10, 20, 30} >>> num = {10, 20, 30} secuencias (*itr). La función recibe dos argumentos, ambos secuencias que
>>> nmr = {5, 6, 7} >>> nmr = {4, 5, 6} >>> print(sum(num)) >>> print(sum(num, 40))
>>> print(cdg.isdisjoint(nmr)) >>> print(cdg.isdisjoint(nmr))
representarán las claves y los valores, respectivamente.
60 100
True False

Superconjunto y subconjunto 7. DICCIONARIOS

>>> keys = ['alpha', 'beta', 'gamma']
El método A.issubset(B) ( A <= B ) indica si A es un subconjunto de B. El >>> values = [10, 20, 30]
Es un conjunto mutable y no ordenado de pares clave – valor. Las claves
método A.issuperset(B) ( A >= B ) indica si A es un superconjunto de B. >>> print(dict(zip(keys, values)))
deben ser elementos únicos e inmutables (no pueden ser list, set ni dict),
Ambos métodos retornan True en caso de ser verdadero. {'alpha': 10, 'beta': 20, 'gamma': 30}
mientras que, los valores pueden ser de cualquier tipo.
>>> cdg = {1, 2, 3, 4} >>> cdg = {1, 2, 3, 4} Las listas y tuplas se diferencian porque sus elementos se identifican por su Crear un diccionario con varias claves y el mismo valor
>>> nmr = {2, 3} >>> nmr = {2, 3} El método dict.fromkeys(itr[, val]) crea un nuevo diccionario, tomando como
>>> print(nmr.issubset(cdg)) >>> print(cdg.issuperset(nmr))
posición, en cambio en los diccionarios los elementos se identifican por su clave,
por esto, no pueden haber dos claves iguales en un mismo diccionario. claves los elementos de una secuencia (itr) y como valor (val – opcional) un
True True
argumento proporcionado por el usuario, que por defecto es None.
Para crear un diccionario se emplean llaves { } y dentro se colocan la clave
Conjuntos inmutables
y el valor separados por ( : ), los pares clave – valor se separan por ( , ). >>> datos = ('nombre', 'apellido', 'edad')
La función frozenset(itr) convierte a cualquier iterable (itr) en un objeto >>> print(dict.fromkeys(datos))
inmutable. Comparte las mismas operaciones que set, excepto aquellas que >>> user = {'nombre': 'Carlos', 'edad': 22, 'cursos': ['Python', 'Java']} {'nombre': None, 'apellido': None, 'edad': None}
impliquen alterar sus elementos (add(), discard(), remove()). >>> print(type(user)) >>> datos = ('nombre', 'apellido', 'edad')
<class 'dict'> >>> valor = '???'
>>> cdg = frozenset((1, 2, 3)) >>> cdg = frozenset([1, 2, 3])
Convertir un diccionario a otro iterable >>> user = dict.fromkeys(datos, valor)
>>> cdg.add(4) >>> nmr = frozenset((3, 4, 5))
>>> print(user)
>>> print(cdg) >>> print(cdg | nmr) Los diccionarios se pueden convertir a listas, tuplas y sets por medio de las {'nombre': '???', 'apellido': '???', 'edad': '???'}
AtributeError frozenset({1, 2, 3, 4, 5}) funciones list(itr), tuple(itr) y set(itr), respectivamente. Sin embargo, al
>>> user['nombre'] = 'Juan'
Es posible realizar operaciones binarias entre sets y frozensets, en donde el convertir un diccionario a otro iterable, solo se conservan sus claves. >>> print(user)
valor de retorno corresponderá al tipo del primer operando. También se puede convertir un diccionario (itr) en una cadena de texto por {'nombre': 'Juan', 'apellido': '???', 'edad': '???'}
medio del método str.join(itr), uniendo los elementos del iterable con una # contar las vocales de una frase.
>>> print(frozenset(['A', 'B', 'C']) | set(['C', 'D', 'E']))
frozenset({'B', 'A', 'C', 'E', 'D'})
string (str) previamente definida. Los elementos del iterable deben ser >>> vocales = 'aeiou'
cadenas de texto. >>> texto = 'Bienvenidos sean todos'.casefold()
>>> cantidad_vocales = dict.fromkeys(vocales, 0)
 >>> for caracter in texto: >>> print(valores_datos) None
>>> if caracter in cantidad_vocales: dict_values(['Alex', 'Gil', 22]) >>> print(person)
>>> cantidad_vocales[caracter] += 1 >>> del datos['edad'] # las vistas del diccionario se actualizan junto con {'name': 'Phill', 'age': 22, 'salary': None}
>>> print(cantidad_vocales) >>> print(valores_datos) el diccionario original. >>> print(person.setdefault('user', 'username10'))
{'a': 1, 'e': 3, 'i': 2, 'o': 3, 'u': 0} dict_values(['Alex', 'Gil']) username10
Compresión de diccionarios Retornar una vista con los pares clave – valor >>> print(person)
Se pueden crear diccionarios desde expresiones arbitrarias de clave – valor, dict.items() retorna una vista del diccionario con los pares clave – valor, en {'name': 'Phill', 'age': 22, 'salary': None, 'user': 'username10'}
siguiendo la sintaxis {<expresión que retorna> <cláusula for> <cláusula if - forma de lista con tuplas de dos elementos (clave – valor). Se suele utilizar para Elimina una clave y retorna su valor
filtrado>}. iterar sobre diccionarios y poder recuperar la clave y el valor al mismo dict.pop(key[, default]) recibe como parámetro una clave (key), elimina esta y
tiempo. retorna su valor. Si no se encuentra la clave, devuelve la excepción KeyError,
>>> cuadrados = {x: x ** 2 for x in (2, 4, 6)}
>>> print(cuadrados) >>> ventas = {'naranja': 2, 'mango': 3, 'fresa': 6} a menos que se especifique un segundo argumento (default – opcional), el cual
{2: 4, 4: 16, 6: 36} >>> ventas_list =ventas.items() se muestra en caso de no encontrar la clave.
>>> print(ventas_list)
Iterar o recorrer un diccionario normalmente dict_items([('naranja', 2), ('mango', 3), ('fresa', 6)])
>>> person = {'name': 'Phill', 'age': 22}
Al iterar o recorrer un diccionario, este normalmente retorna sus claves. Sin >>> print(person.pop('name'))
>>> print(list(ventas_list)[1][0]) Phill
embargo, con el método dict.values() es posible retornar sus valores. mango
También el método dict.items() permite retornar los pares clave – valor. >>> print(person)
# ejemplo de como se actualizan los datos. {'age': 22}
>>> num = {'uno': 'one', 'dos': 'two'} >>> num = {'uno': 'one', 'dos': 'two'} >>> del ventas['mango']
>>> print(person.pop('salary'))
>>> for i in num: >>> for i in num.values(): >>> print(ventas_list)
KeyError
>>> print(i) >>> print(i) dict_items([('naranja', 2), ('fresa', 6)])
>>> print(person.pop('salary', 'No se encuentra'))
uno one # ejemplos de dict.items() iterando sobre un diccionario. No se encuentra
dos two >>> name = {"first_name": "Alfred", "last_name":"Hitchcock"}
>>> num = {'uno': 'one', 'dos': 'two'} >>> for key, val in name.items(): También se puede eliminar una clave y su valor con del dict[key]. De esta
>>> for i, j in num.items(): >>> print("{} = {}".format(key, val)) manera, no se retorna ningún valor.
>>> print(i, j) first_name = Alfred
uno one last_name = Hitchcock >>> person = {'name': 'Phill', 'age': 22}
dos two >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'} >>> del person['age']
>>> for key, val in knights.items(): >>> print(person)
Vistas del diccionario >>> print(key, val) {'name': 'Phill'}
Los métodos dict.keys(), dict.values() y dict.items() retornan una vista del gallahad the pure
diccionario. Es como si se observara el diccionario desde una perspectiva robin the brave
El método dict.popitem() retorna una tupla clave – valor aleatoria y luego la
diferente que solo permite apreciar determinadas características (claves, remueve del diccionario. En un diccionario vacío lanza la excepción KeyError.
valores o ambos, respectivamente). Acceder a un valor a partir de una clave
>>> user = {'nombre': 'Andrés', 'apellido': 'Ruiz', 'edad': 23}
El método dict.get(key[, default]) recibe como parámetro una clave (key) y >>> print(user.popitem())
Aunque soporta operaciones como prueba de pertenencia e iteración, sus retorna el valor de la clave. Si no encuentra la clave, devuelve el segundo
contenidos dependen del diccionario original, ya que son sólo una vista. Es ('edad', 23)
argumento (default – opcional) que por defecto es None. >>> print(user)
decir, si modificamos el diccionario, la vista se actualizará dinámicamente.
{'nombre': 'Andrés', 'apellido': 'Ruiz'}
>>> person = {'name': 'Phill', 'age': 22}
>>> print('Nombre:', person.get('name')) Combinar y actualizar diccionarios
Nombre: Phill
dict.update([other]) actualiza el diccionario (dict) con los pares clave – valor
de otros (other), sobreescribiendo las claves ya existente. Retorna None
Retornar una vista de la claves del diccionario >>> print('Salario:', person.get('salary'))
Salario: None
debido a que no crea un nuevo diccionario, solo actualiza el primero.
El método dict.keys() retorna una vista del diccionario con las claves. Esta
vista de puede convertir después a una lista con la función list(dict.keys()). >>> print('Salario:', person.get('salary', 0.0)) >>> clase_a = {'Ana': 22, 'Juan': 19, 'Alex': 25}
Salario: 0.0 >>> clase_b = {'Camilo': 21, 'Esteban': 17}
Si se quiere que las claves estén ordenadas, se utiliza sorted(dict.keys()). >>> clase_a.update(clase_b)
>>> datos = {'nombre': 'Alex', 'apellido': 'Gil', 'edad': 22, }
También se puede acceder al valor de un diccionario según la sintaxis >>> print(clase_a.update(clase_b))
>>> print(datos.keys()) dict[key]. Pero a diferencia del método anterior, si no existe la clave, lanza None
dict_keys(['nombre', 'apellido', 'edad']) una excepción KeyError. >>> print(clase_a)
>>> print(list(datos.keys())) >>> print(list(datos.keys())[0]) {'Ana': 22, 'Juan': 19, 'Alex': 25, 'Camilo': 21, 'Esteban': 17}
>>> datos = {'nombre': 'Alex', 'apellido': 'Gil', 'edad': 22, }
['nombre', 'apellido', 'edad'] nombre >>> print((datos['nombre'])) >>> clase_a.update(Felipe = 23) # también se puede ({'Felipe': 23})
>>> print(sorted(datos.keys())) # sorted() permite ordenar las claves. Alex >>> print(clase_a)
['apellido', 'edad', 'nombre'] {'Ana': 22, 'Juan': 19, 'Alex': 25, 'Camilo': 21, 'Esteban': 17, 'Felipe': 23}
>>> print((datos['salario']))
>>> for claves in datos.keys(): KeyError Los diccionarios también se pueden combinar o actualizar con la función
>>> print(claves) dict(dic1, **dic2).
nombre Acceder a un valor a partir de una clave. Si no existe, la crea
apellido dict.setdefault(key[, default]) recibe como parámetro una clave (key) y >>> clase_a = {'Ana': 22, 'Juan': 19, 'Alex': 25}
edad retorna el valor de la clave, si no encuentra la clave, la crea y la agrega al >>> clase_b = {'Camilo': 21, 'Esteban': 17, 'Alex': 26}
diccionario, siendo el valor por defecto None. El segundo argumento (default >>> print(dict(clase_a, **clase_b))
Retornar una vista de los valores del diccionario {'Ana': 22, 'Juan': 19, 'Alex': 26, 'Camilo': 21, 'Esteban': 17}
– opcional) indica el valor de la nueva clave.
El método dict.values() retorna una vista del diccionario con los valores. Esta
vista de puede convertir después a una lista con la función list(dict.values()). >>> person = {'name': 'Phill', 'age': 22} De igual manera, la sintaxis dict['key'] = 'value' permite asignar un nuevo valor a la
Si se quiere que los valores estén ordenados, se utiliza sorted(dict.values()). >>> print(person.setdefault('name')) clave o agregar nuevos pares clave – valor.
Phill
>>> datos = {'nombre': 'Alex', 'apellido': 'Gil', 'edad': 22, } >>> person = {'name': 'Phill', 'age': 22}
>>> print(person.setdefault('salary')) >>> person['age'] = 23 # actualiza un valor de una clave.
>>> valores_datos = datos.values()
 >>> person['salary'] = 1500 # agrega un nuevo par clave – valor. >>> print(sorted(user.values(), reverse=True))
>>> print(person) [47, 17, 14]
{'name': 'Phill', 'age': 23, 'salary': 1500}
len(itr) retorna la longitud (número de items) de un diccionario (itr).
Verificar la existencia de una clave o un valor en el diccionario
Para verificar la existencia de una clave se utiliza la sintaxis key in dict, >>> num = {'uno': 1, 'dos': 2, 'tres': 3}
>>> print(len(num))
mientras que para un valor se usa la sintaxis value in dict.values(). 3
>>> user = {'nombre': 'Andrés', 'apellido': 'Ruiz', 'edad': 23}
>>> print('nombre' in user)
all(itr) retorna True si todas las claves del diccionario son verdaderas, o si el
True diccionario está vacío. all(itr.values()) hace lo mismo, pero con los valores.
>>> print('Ruiz' in user.values()) >>> num = {'cero': 0, 'uno': 1} >>> num = { } >>> num = {'cero': 0}
True >>> print(all(num.values())) >>> print(all(num)) >>> print(all(num))
False True True
Para verificar si una clave no se encuentra, se escribe key not in dict, o su
equivalente not key in dict, mientras que para un valor se utiliza value not in any(itr) retorna True al menos una clave del diccionario es verdadera. Si el
dict.values() o también not value in dict.values(). diccionario está vacío devuelve False. any(itr.values()) hace lo mismo, pero con
los valores.
>>> user = {'nombre': 'Andrés', 'apellido': 'Ruiz', 'edad': 23}
>>> print('salario' not in user) >>> num = {0: 'cero', 1: 'uno'} >>> num = { }
True >>> print(any(num)) >>> print(any(num))
>>> print(not 'Ruiz' in user.values()) True False
False
sum(itr[, number]) retorna la suma de las claves del diccionario (itr). El segundo
Desempaquetando un diccionario de argumentos argumento (number – opcional) es un número que se agrega al resultado final. Se
Cuando los argumentos ya están en un diccionario, pero necesitan ser pueden sumar los valores del diccionario utilizando su respectiva vista.
desempaquetados para llamar a una función que requiere argumentos
>>> num = {'uno': 1, 'dos': 2, 'tres': 3}
posicionalmente separados. Para esto se utiliza la sintaxis function(**dict) en >>> print(sum(num.values()))
donde el diccionario contiene pares de palabras clave (keywords) y sus valores 6
correspondientes.
>>> num = {'sep': 'os', 'maxsplit': 2}
>>> texto = 'Estamos todos unidos y urgidos'
>>> print(texto.split(**num))
['Estam', ' tod', ' unidos y urgidos']

Otras funciones y métodos comúnes en los diccionarios

dict.clear() elimina todos los items de un diccionario, dejándolo vacío.
>>> datos = {'nombre': 'Alex', 'apellido': 'Gil', 'edad': 22, }
>>> datos.clear()
>>> print(datos)
{}

dict.copy() devuelve una copia del diccionario (un objeto distinto).

>>> num = {'uno': 1, 'dos': 2, 'tres': 3}
>>> digitos = num.copy()
>>> print(digitos)
{'uno': 1, 'dos': 2, 'tres': 3}

max(itr[, default=obj, key=func]) y min(itr[, default=obj, key=func]) retornan

el máximo y mínimo valor de un diccionario (itr). El segundo argumento (default
– opcional) es el valor que retorna en caso de que el diccionario (itr) esté vacío.
Si no se especifica, lanza ValueError. El tercer argumento (key – opcional)
permite personalizar el orden de clasificación por medio de una función.
Los datos deben ser del mismo tipo, sino lanza una excepción TypeError.
>>> user = {'Ana': 47, 'Juan': 17} >>> user = {'Ana': 47, 'Juan': 17}
>>> print(max(user)) >>> print(min(user.items()))
Juan ('Juan', 17)
>>> print(max(user.values())) >>> print(min(user.values()))
47 17

sorted(itr, key=None, reverse=False) crea una copia del diccionario ordenado de

forma ascendente. (reverse=True) lo ordena descendentemente.
>>> user = {'Ana': 47, 'Sebas': 17, 'Juan': 14}
>>> print(sorted(user))
['Ana', 'Juan', 'Sebas']
 ENTRADA Y SALIDA ESTRUCTURAS DE FLUJO DE CONTROL Sentencias condicionales anidadas (no recomendado)
Una sentencia condicional puede contener a su vez otra sentencia anidada. Se
1. SENTENCIA CONDICIONAL (IF – ELIF – ELSE ) pueden anidar tantas sentencias condicionales se deseen. Aunque no es
Entrada por teclado – Función input([str])
La función input([str]) permite ingresar texto escrito en el teclado. Al llegar La sentencia condicional if permite que se ejecute una serie de instrucciones recomendable anidar a más de dos niveles, porque dificulta la legibilidad del
a esta función, el programa se detiene esperando que se escriba algo y se cuando se cumple una condición (expresión lógica True). Si la expresión es código. A veces esto se puede evitar utilizando operadores lógicos (and, or).
pulse la tecla intro. El argumento (str – opcional) muestra un texto que indica False, el bloque de código es ignorado. >>> if num >= 0: Ingrese un número: 0
al usuario que información se le solicita. >>> if num == 0: Cero
If <condición – expresión booleana>:
<bloque de código que se ejecuta si la condición es True> >>> print('Cero')
>>> nombre = input('¿Cómo te llamas? ')
>>> else: Ingrese un número: 5
>>> print(f'Me alegro de conocerte, {nombre}') >>> print('Número positivo') Número positivo
La primera línea comienza con la palabra reservada (if) seguida por una
¿Cómo te llamas? Andrés >>> else:
Me alegro de conocerte, Andrés
expresión booleana (condición) y termina con dos puntos ( : ). La siguiente
>>> print('Número negativo') Ingrese un número: -9
línea debe estar indentada y debe contener el código (bloque de órdenes) Número negativo
Esta función convierte la entrada en una cadena texto de manera que se ejecuta en caso de que la expresión booleana sea True.
predeterminada, aunque escribamos un número, el lenguaje lo interpretará Sentencias condicionales con varias ramificaciones – if – elif – else
>>> num = int(input('Escriba un número positivo: '))
como una cadena. Si se desea que la entrada se interprete como un número, Esto permite evaluar varias condiciones, utilizando para esto, la palabra
se debe convertir al tipo int(str) o float(str). >>> if num < 0: reservada (elif) (contracción de else if). Pueden haber tantos bloques elif como
>>> print('Has escrito un número negativo')
>>> print(f'El número ingresado es {num}')
sean necesarios. El bloque else (que es opcional) se ejecuta si no se cumple
>>> cantidad = int(input("Dinero en pesos: "))
>>> print(f"{cantidad} pesos son {round(cantidad / 166.386, 2)} euros")
ninguna de las condiciones anteriores.
Escriba un número positivo: -5
Dinero en pesos: 500 Has escrito un número negativo If <condición 1 – expresión booleana>:
500 pesos son 3.01 euros El número ingresado es -5 <bloque de código que se ejecuta si la condición 1 es True>
elif <condición 2 – expresión booleana>:
Como se ha visto, las cadenas f permiten incorporar variables en el argumento Sentencias condicionales con dos ramificaciones – if – else <bloque de código que se ejecuta si la condición 2 es True>
de la función input(str). Esto permite que se ejecuta un bloque de instrucciones cuando la expresión elif <condición 3 – expresión booleana>:
booleana es True, si es False se ejecuta otro bloque de código distinto. <bloque de código que se ejecuta si la condición 3 es True>
>>> numero1 = int(input("Dígame un número: ")) else:
>>> numero2 = int(input(f"Dígame un número mayor que {numero1}: ")) If <condición – expresión booleana>: <bloque de código que se ejecuta si todas las condiciones anteriores son False>
>>> print(f"La diferencia entre ellos es {numero2 - numero1}.") <bloque de código que se ejecuta si la condición es True>
Dígame un número: 5 else: Las condiciones se comprueban en orden. Si la primera condición es False, se
Dígame un número mayor que 5: 8 <bloque de código que se ejecuta si la condición es False> comprueba la siguiente y así con las demás. Si una condición es True, se
La diferencia entre ellos es 3.
>>> edad = int(input("¿Cuántos años tienes? ")) ejecuta el código correspondiente y termina la sentencia condicional. Incluso,
>>> if edad < 18:
si es cierta más de una condición, solo se ejecuta la primera que sea verdadera.
Salida por pantalla – Función print(*objects, sep=' ', end='\n') >>> print("Eres menor de edad") Esta estructura es equivalente a la siguiente estructura de if – else anidados.
La función print(*objects, sep=' ', end='\n') permite mostrar un valor >>> else:
(*objects) en la pantalla (pueden haber varios, separados por ( , )). El argumento >>> print("Eres mayor de edad") If <condición>: >>> num = float(input('Ingrese un número: '))
opcional (sep=) indica la separación entre valores, por defecto es un espacio >>> print("¡Hasta la próxima!") <bloque de código>
else: >>> if num == 0:
en blanco ( ' ' ). El argumento opcional (end=) indica cómo termina la salida por ¿Cuántos años tienes? 18 ¿Cuántos años tienes? 16 If <condición>: >>> print('El número es cero')
pantalla, por defecto es un salto de línea ( \n ). Eres mayor de edad Eres menor de edad <bloque de código> >>> elif num % 2 == 0:
¡Hasta la próxima! ¡Hasta la próxima! else: >>> print('El número es par')
>>> name = 'Jaime' >>> print(name, surname, sep='--')
>>> surname = 'Bonilla' Jaime--Bonilla >>> x = int(input('Ingrese un número: ')) If <condición>: >>> elif num % 2 != 0:
>>> age = 35 >>> print(surname, end=', ') <bloque de código> >>> print('El número es impar')
>>> if x <= 0:
>>> print(name) >>> print(name) >>> print('Por favor, use sólo números positivos.') (…) Ingrese un número: 17
Jaime Bonilla, Jaime >>> else: El número es impar
>>> print(name, surname, age) # imprime varias variables. >>> resultado = round(x ** 0.5, 2)
>>> print(f'La raíz cuadrada de {x} es {resultado}') La diferencia entre usar varios if – if juntos versus varios if – elif, es
Jaime Bonilla 35
Ingrese un número: -4 Ingrese un número: 5
basicamente que, al usar varios if, se evalúan todos, pudiendo el programa
>>> print('Hola mundo') # imprime cadenas de texto. arrojar varias respuestas no coherentes. En cambio, al usar if – elif, evalúa
Hola mundo Por favor, use sólo números positivos. La raíz cuadrada de 5 es 2.24
hasta el primer bloque que cumple la condición.
>>> print('Hola señor', name) # imprime cadenas y variables, dejando un Un bloque de código puede contener varias instrucciones. Todas las
Hola señor Jaime espacio entre ambas. instrucciones del bloque deben tener el mismo sangrado. >>> nota=int(input(‘Nota: ’)) >>> nota=int(input(‘Nota: ’))
>>> print('En el año ' + str(1984)) # solo se pueden concatenar str. >>> if nota >= 9: >>> if nota >= 9:
En el año 1984 >>> edad = int(input("¿Cuántos años tiene? ")) >>> print(‘Bien’) >>> print(‘Bien’)
>>> print('Alex el "Grande"') # se pueden poner comillas. >>> if edad < 18: >>> if nota >= 7: >>> elif nota >= 7:
Alex el “Grande” >>> print("Es usted menor de edad") >>> print(‘Maso’) >>> print(‘Maso’)
>>> print("Recuerde que está en la edad de aprender") >>> if nota >= 5: >>> elif nota >= 5:
>>> print(2019 - 1996) # imprime el resultado de operaciones.
>>> else: >>> print(‘Regular’) >>> print(‘Regular’)
23
>>> print("Es usted mayor de edad") Nota: 10 Nota: 10
>>> semanas = 4 >>> print("Recuerde que debe seguir aprendiendo")
>>> print(f'En {semanas} semanas hay {semanas * 7} días') Bien Bien
>>> print("¡Hasta la próxima!") Maso
En 4 semanas hay 28 días
¿Cuántos años tiene? 19 Regular
La función print() sin argumentos, imprime un salto de línea. Es usted mayor de edad
Recuerde que debe seguir aprendiendo
¡Hasta la próxima!
 2. BUCLE FOR … IN … Técnicas de iteración con el bucle for >>> print('key = {}, value = {}'.format(i, j))
key = one, value = 1
Un bucle es una estructura de control que repite un bloque de instrucciones. 1 – iterar sobre una secuencia de números key = two, value = 2
Si se necesita iterar sobre una secuencia de números, se puede utilizar la función key = three, value = 3
El bucle for es un ciclo que repite el bloque de instrucciones (cuerpo del bucle) integrada range([start, ]stop[, step]), la cual genera una lista de números en
un número predeterminado de veces, cada repetición se denomina iteración. progresión aritmética. Esta función retorna un range object, que se comporta 7 – modificar elementos de la secuencia
Las instrucciones se iteran sobre cada uno de los elementos de la secuencia, en el como una lista, pero no lo es, por lo cual ahorra espacio. Si se desea modificar, eliminar, agregar o consultar los datos de cada elemento
orden en que aparecen dentro del iterable. Es decir, el cuerpo del bucle se ejecuta del iterable, hay que asegurarse de utilizar la sintaxis adecuada para cada tipo
>>> for i in range(3): de iterable (lista, tupla, set, diccionario, cadena).
tantas veces como elementos tenga la secuencia. … print(i, end=' ')
for <i> in <iterable>: 012 >>> lista = [1, 2, 3] >>> lista = [1, 2, 3]
<bloque de código que se ejecuta len(iterable) veces>
2 – iterar sobre los índices de una secuencia >>> for i in lista: >>> for i in range(3):
… i=i+2 … lista[i] = lista[i] + 2
# midiendo la longitud de cada palabra de una lista.
Para iterar sobre los índices de una secuencia se puede combinar las funciones
range(len(itr)). Aunque en la mayoría de casos, conviene usar la función >>> print(i) >>> print(i)
>>> palabras = ['sal', 'cubo', 'hielo'] sal 3 5 2
>>> for p in palabras: cubo 4 enumerate(itr, [start]), que permite obtener el índice junto al valor de cada
… print(p, len(p)) hielo 5 ítem. >>> print(lista) >>> print(lista)
[1, 2, 3] [3, 4, 5]
Variable de control del bucle for >>> for i, j in enumerate(['Do', 'Re', 'Mi']):
… print(i, j, end=', ') En el primer ejemplo, la variable de control (i) toma el valor de cada elemento
La variable de control ( i ) corresponde a cada elemento dentro del iterable
0 Do, 1 Re, 2 Mi, del iterable, pero la lista no cambia porque esa no es la sintaxis para cambiar un
(cadena, lista, tupla o diccionario) y se puede llamar de cualquier manera.
>>> lista = ['uno', 'dos', 'tres'] >>> nombres = ['Mary', 'Lisa']
elemento de una lista. En el segundo ejemplo se muestra como cambiar cada
No es necesario declarar antes la variable de control. Esta se crea durante la elemento de una lista utilizando el bucle for.
ejecución del bucle y toma el valor de cada elemento del iterable en cada >>> for i in range(len(lista)): >>> for i in range(len(nombres)):
… lista[i] = lista[i].upper() … print(i, nombres[i]) Modificar la secuencia durante la ejecución del bucle
iteración del ciclo. Al final, la variable de control tendrá como valor el último >>> print(lista) 0 Mary
elemento del iterable. A veces uno intenta cambiar una lista mientras la está iterando. Sin embargo,
['UNO', 'DOS', 'TRES'] 1 Lisa
a menudo es más simple y seguro crear una nueva lista:
Hay que tener en cuenta que esta variable de control, aunque se crea dentro
3 – iterar sobre dos o más secuencias
del bucle for, se puede utilizar fuera de él. Así, si se llama a la variable de control >>> datos = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Para iterar sobre dos o más secuencias al mismo tiempo, los valores pueden >>> datos_filtrados = [ ]
igual que a otra variable anteriormente declarada por fuera de dicho bucle,
emparejarse con la función zip(*itr).
se sobreescribirá el valor a la última iteración del bucle. >>> for i in range(len(datos)):
>>> preguntas = ['nombre', 'objetivo', 'color favorito'] … if datos[i] >= 5:
>>> lista = [1, 2, 3] … datos_filtrados.append(datos[i])
>>> respuestas = ['lancelot', 'el santo grial', 'azul']
>>> x = 15 # variable x referencia al objeto int 15.
>>> for p, r in zip(preguntas, respuestas): >>> print(datos_filtrados)
>>> for x in lista: # dentro del bucle for, se llama a una variable de control x, … print('Cual es tu {0}? {1}.'.format(p, r)) [5, 6, 7, 8, 9, 10]
>>> x = x + 1 la cual en cada iteración referencia a un objeto distinto.
Cual es tu nombre? lancelot. Si se necesita modificar la secuencia sobre la que se está iterando mientras
>>> print(x) # al final, si se llama a la variable x por fuera del bucle for, Cual es tu objetivo? el santo grial.
4 tendrá el valor de la última iteración (ya no vale int 15).
se está dentro del bucle for, se recomienda hacer primero una copia. Iterar
Cual es tu color favorito? azul.
sobre una secuencia no crea implícitamente una copia. El slicing o notación
Iterables del bucle for 4 – iterar sobre una secuencia en orden inverso de rebanadas es conveniente en estos casos.
El bucle for itera sobre cada elemento de una secuencia. Esta puede ser una Para iterar sobre una secuencia en orden inverso, se utiliza la función El siguiente ejemplo, intentería crear una lista infinita insertando el elemento
lista, una tupla, una cadena o un diccionario. En el caso de las cadenas de texto, reversed(itr) y como argumento a la secuencia sobre la que se desea iterar. cuya longitud sea mayor a 4, una y otra vez. Esto es debido a que la variable
cada elemento corresponde a un carácter dentro de la cadena. Mientras que (p) toma el valor de cada elemento hasta el último, y si en cada iteración se
en los diccionarios, se pueden utilizar las vistas para iterar sobre las claves, los >>> for i in reversed(range(5)):
… print(i, end='--') agrega un nuevo elemento, no se llegará nunca a un último elemento en la lista.
valores o ambos. 4--3--2--1--0--
>>> palabras = ['sal', 'cubo', 'hielo']
# iterar elementos de una lista. # iterar elementos de una tupla.
>>> lista = ['uno', 'dos', 'tres'] >>> tupla = ('uno', 'dos', 'tres')
5 – iterar sobre una secuencia ordenada >>> for p in palabras:
Para iterar sobre una secuencia ordenada, se utiliza la función sorted(itr, … if len(p) > 4:
>>> for elem in lista: >>> for elem in tupla:
… print(elem.upper(), end=' ') … print(elem[::-1], end='-')
key=None, reverse=False), que crea una nueva lista ordenada ascendentemente, … palabras.insert(0, p)
UNO DOS TRES onu-sod-sert- dejando a la secuencia original intacta.
Esto se puede evitar iterando sobre una copia de la lista ([:]). Así, la variable
>>> print(elem) >>> print(elem) >>> canasta = ['manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banana'] (p) toma como valor cada elemento de la copia, mientras agrega el elemento
tres tres >>> for f in sorted(set(canasta)): a la lista original.
# iterar caracteres de una cadena. # iterar claves de un diccionario. … print(f, end=' ')
>>> palabras = ['sal', 'cubo', 'hielo']
>>> palabra = 'paz' >>> num = {'uno': 1, 'dos': 2} banana manzana naranja pera
>>> for p in palabras[:]:
>>> for letra in palabra: >>> for key in num: 6 – iterar sobre diccionarios … if len(p) > 4:
… print(letra) … print(f'Sigue {key}')
p Sigue uno
Cuando iteramos sobre diccionarios, se utilizan las diferentes vistas del … palabras.insert(0, p)
a Sigue dos diccionario (métodos dict.keys(), dict.values() y dict.items()) para obtener
las claves, los valores o ambos, respectivamente. Sentencias break, continue y pass
z
# iterar valores de un diccionario. # iterar claves y valores de un dict.
La sentencia break termina el bucle for sin ejecutar las instrucciones que hay
>>> dic = {'one': 1, 'two': 2, 'three': 3}
>>> num = {'uno': 1, 'dos': 2} >>> num = {'uno': 1, 'dos': 2} debajo de dicha sentencia dentro del cuerpo del ciclo y sin ejecutar las
>>> for i in dic.keys(): >>> for j in dic.values(): iteraciones faltantes. Se usa para salir del bucle al cumplirse una condición.
>>> for val in num.values(): >>> for key, val in num.items(): >>> print(i) >>> print(j)
… print(f'Tengo {val + 1}') … print(key, '=', val) one 1 for <i> in <iterable>: # el bucle for ejecuta las instrucciones 1, si la condición
Tengo 2 uno = 1 two 2 <instrucciones 1> de la sentencia if es verdadera, se rompe abruptamente
Tengo 3 dos = 2 three 3 if <condición>: el bucle, sin que se ejecuten las instrucciones 2.
>>> for i, j in dic.items(): break
 <instrucciones 2> >>> else: Bucles anidados – Variables dependientes
… print(f'{i} es un número primo') Se da cuando los valores que toma la variable de control del bucle interno
La sentencia continue, vuelve al inicio del bucle sin ejecutar las instrucciones que 2 es un número primo dependen del valor de la variable de control del bucle externo.
habían debajo, continuando así con la siguiente iteración del bucle. 3 es un número primo
4 es igual a 2 * 2.0 >>> for i in [1, 2, 3]:
for <i> in <iterable>: # el bucle for ejecuta las instrucciones 1, si la condición 5 es un número primo … for j in range(i):
<instrucciones 1> de la sentencia if es verdadera, no se ejecutan las 6 es igual a 2 * 3.0 … print(f"i vale {i} y j vale {j}")
if <condición>: instrucciones 2, y se salta inmediatamente a la 7 es un número primo
continue siguiente iteración. i vale 1 y j vale 0
8 es igual a 2 * 4.0
<instrucciones 2> i vale 2 y j vale 0
9 es igual a 3 * 3.0
i vale 2 y j vale 1
>>> suma = 0 Contador i vale 3 y j vale 0
>>> for i in [1, 2, 3, 4, 5, 0, 7, 8]: i vale 3 y j vale 1
Es una variable que incrementa o decrementa su contenido en un valor i vale 3 y j vale 2
… if i == 0: constante. Se suele utilizar para llevar la cuenta del número de veces que se ha
… break # el bucle for realiza una iteración por cada elemento
… if i % 2 != 0: de la lista. Si el elemento es igual a cero, se termina el
cumplido una condición. Así, el contador se suele inicializar en 0, y luego se
incrementa (aumenta en uno) cada vez que se cumple una condición. 3. BUCLE WHILE
… continue ciclo y no se ejecutan las instrucciones que están por
… suma += 1 debajo de la sentencia break.
>>> cuenta = 0 El bucle while es un ciclo que repite el bloque de instrucciones (cuerpo del bucle)
>>> print(suma) # si el elemento es impar, no se ejecuta la instrucción un número indeterminada de veces, siempre que se cumpla una condición,
>>> for i in range(1, 6):
2 que está por debajo de continue (suma += 1).
… if i % 2 == 0: es decir, mientras que la condición tenga el valor True.
>>> for i in range(10): # si el número es par, la sentencia continue hace que … cuenta = cuenta + 1 # contador = contador + constante Primero, se evalúa la condición del bucle, si es verdadera, se ejecuta el bloque
… if i % 2 == 0: no se ejecute la siguiente instrucción del bucle. >>> print(f"Desde 1 hasta 5 hay {cuenta} múltiplos de 2") de código, al terminar se regresa al inicio del bucle y vuelve a evaluar la
… continue Desde 1 hasta 5 hay 2 múltiplos de 2 condición, y así hasta que la condición sea falsa.
… print(i, end=' ') # si se utilizara break, el ciclo inmediatamente se >>> nombre = 'Andrés Felipe'
13579 terminaría, sin ejecutar otra iteración. Este tipo de bucle también puede hacer uso de contadores y acumuladores. Así
>>> contador = 0
mismo, se pueden tener bucles anidados (aunque su uso no es recomendable).
La sentencia pass no hace nada. Se suele usar para construir el esqueleto del >>> for i in nombre:
programa, como marca de lugar en la sintaxis del programa, sin que se … if i == ' ': while <condición>:
… continue # si se encuentra con espacio en blanco, <bloque de código que se ejecuta mientras la condición sea verdadera>
requiera ninguna acción.
… contador += 1 ignora la siguiente línea (contador += 1).
# pide un número positivo al usuario varias veces hasta que lo haga correctamente.
for <i> in <iterable>: # si la condición de la sentencia if es verdadera, no pasa >>> print(contador) >>> numero = int(input("Escriba un número positivo: "))
<instrucciones 1> nada, aún así se ejecutarían las instrucciones 1 y 2. 12
if <condición>: Es como si la sentencia if no existiera. Se usa como >>> while numero < 0:
pass relleno temporal. Acumulador … print("¡Ha escrito un número negativo! Inténtelo de nuevo")
<instrucciones 2> Es una variable que incrementa o decrementa su contenido en cantidades … numero = int(input("Escriba un número positivo: "))
variables. Igualmente, se suele inicializar en cero antes de ingresar al bucle. Se >>> else:
def initlog(*args): … print("Gracias por su colaboración")
pass # marca de lugar dentro del esqueleto del programa. utiliza para acumular el resultado de una operación.
# sucesión de Fibonacci. # imprime mientras no sea un número.
Sentencias break y continue en bucles anidados >>> suma = 0 >>> a, b = 0, 1 >>> texto, i = 'abcd123fgh', 0
Si la sentencia break o continue se ubican dentro de un bucle anidado, solo >>> for i in [1, 2, 3, 4]: >>> while b < 100: >>> while not texto[i] in '1234567890':
afectarán la ejecución del bucle más interno en el que se encuentran. … suma = suma + i # acumulador = acumulador + variable … print(b, end=', ') … print(texto[i], end=' ')
>>> print(f"La suma de los números de 1 a 4 es {suma}") … a, b = b, a + b … i=i+1
>>> for i in range(3): La suma de los números de 1 a 4 es 10 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, abcd
… for j in range(5):
… if j > i: Bucles anidados # solicita el nombre hasta que se escriba algo.
>>> nombre = ''
… break Es posible escribir un bucle dentro del cuerpo de instrucciones de otro bucle.
… print(i, j, end=' | ') No es recomendable tener muchos niveles de anidamiento, debido a que >>> while not nombre: # se puede añadir la sentencia not a la sintaxis while.
00|10|11|20|21|22| esto hace que el código sea más complicado de entender. … nombre = input('Escribe tu nombre: ')
# imprime los números del 0 al 9. # imprime el cuadrado.
Se aconseja intentar no utilizar las sentencias break y continue siempre que se Se recorre todo el bucle interior para cada elemento del bucle exterior. >>> num = 0 >>> num = 2
pueda, para facilitar así la lectura del código. for <i> in <iterable 1>: # para el primer elemento i, se entra en el segundo >>> while num < 10: >>> while num < 10000:
Sentencia else en bucles for for <j> in <iterable 2>: bucle y se realizan todas las iteraciones de j. Luego … print(num, end=', ') … num = pow(num, 2)
<instrucciones 1> se toma el segundo i y se ejecutan todas las j. … num += 1 … print(num, end=' - ')
Los bucles for pueden ser acompañados de una sentencia else, la cual se 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 4 - 16 - 256 - 65536 -
ejecuta cuando el bucle termina, es decir, después de haber realizado todas las Bucles anidados – Variables independientes
iteraciones posibles. Se dice que las variables de los bucles son independientes cuando los valores Sentencias break, continue, pass y else
La única ocasión en que la sentencia else no se ejecuta, es cuando el bucle for que toma la variable de control del bucle interno no dependen del valor de La sentencia break termina el bucle while sin ejecutar las instrucciones que hay
ha sido terminado con la sentencia break. la variable de control del bucle externo. debajo de dicha sentencia dentro del cuerpo del ciclo. Se usa para salir del
>>> for i in [0, 1, 2]: bucle al cumplirse una condición.
>>> for i in range(3):
… print(i, end=' ') … for j in [0, 1]: # rompe el ciclo cuando i == 5. # rompe cuando num ** 3 == 343.
… print(f"i vale {i} y j vale {j}") >>> i = 10 >>> num = 0
>>> else:
… print('Terminado') i vale 0 y j vale 0 >>> while i > 0: >>> while num < 10:
0 1 2 Terminado i vale 0 y j vale 1 … i=i–1 … if num ** 3 == 343:
i vale 1 y j vale 0 … if i == 5: … break
>>> for i in range (2, 10):
i vale 1 y j vale 1 … break … num += 1
… for j in range(2, i): # si la condición de la sentencia if
i vale 2 y j vale 0 … print(i, end=' ') … print(num, end='/ ')
… if i % j == 0: es verdadera, se ejecuta el print()
i vale 2 y j vale 1 9876 1/ 2/ 3/ 4/ 5/ 6/ 7/
… print(f'{i} es igual a {j} * {i / j}') y se rompe el bucle (break), por lo
… break que no se ejecuta el else.
La sentencia continue, vuelve al inicio del bucle sin ejecutar las instrucciones que
habían debajo, continuando así con la siguiente iteración del bucle.

# si num es impar, lo salta. # si num ** 3 == 343, lo salta.

>>> num = 0 >>> num = 0
>>> while num < 10: >>> while num < 10:
… num += 1 … num += 1
… if num % 2 != 0: … if num ** 3 == 343:
… continue … continue
… print(num, end='/ ') … print(num, end='/ ')
2/ 4/ 6/ 8/ 10/ 1/ 2/ 3/ 4/ 5/ 6/ 8/ 9/ 10/

Las sentencias break y continue en bucles anidados, solo afectan al bucle más
interno en el que se encuentran.
La sentencia pass no hace nada. Se suele usar como marca de lugar dentro
del esqueleto del programa.
>>> while True: # marca de lugar cuando se está realizando el esqueleto
… pass de un programa.

Sentencia else
El bucle while se ejecutar siempre y cuando la condición sea True. En el
momento en que la condición sea False, se termina el bucle while y se ejecuta
la sentencia else.
Si el bucle termina por una sentencia break, las instrucciones de la sentencia
else no se ejecutan.
>>> num = 0 >>> num = 0
>>> while num < 10: >>> while num < 10:
… print(num, end=' ') … num += 1
… num += 1 … if num ** 3 == 343:
>>> else: … break
… print('Fin del ciclo') … print(num, end='/ ')
0 1 2 3 4 5 6 7 8 9 Fin del ciclo >>> else:
… print('No se cumple la condición')
1/ 2/ 3/ 4/ 5/ 6/
Bucles infinitos
Si la condición del bucle while se cumple siempre, el ciclo no terminará nunca
de ejecutarse y se tendrá, lo que se conoce como un bucle infinito. Para
interrumpir un bucle infinito se puede utilizar Ctrl + C.
La manera más fácil de crear un bucle infinito es con la sintaxis while True, la
cual se debe acompañar con la sentencia break, para terminar el bucle cuando
se cumpla una condición específica.
Funciones y módulos
while True:
<bloque de código que se ejecuta siempre> Las agrupaciones de código que se pueden reutilizar en distintos programas
If <condición>: se denominan subrutinas. Estas se pueden incluir en ficheros (llamados
break bibliotecas o librerías) al que los programas pueden acceder. En Python,
>>> i = 1 >>> contador = 0 se utiliza el término función para referirse a las subrutinas y el término
>>> while i > 0: >>> while True:
módulo para referirse a las bibliotecas.
… print(i, end=" ") … while contador <= 5:
… i += 1 … print(contador, end=' ')
123456789… … contador += 1 Funciones
… Break
012345 Definir funciones
Para utilizar una función, primero se debe definir. Para esto se escribe la
palabra def, el nombre de la función y paréntesis que pueden incluir los
argumentos, seguidos de dos punto. Las instrucciones que forman la función
se escriben con sangría con respecto a la primera línea.
>>> def licencia():
print('''Copyright 2018 Anferubu
Todos los derechos reservados''')
return

Para ejecutar una función, simplemente se llama por su nombre.

 >>> licencia() if intento < 3:
Copyright 2018 Anferubu Número indeterminado de argumentos print('¡Fallaste! Inténtalo de
Todos los derechos reservados Las funciones pueden admitir una cantidad indeterminada de valores, nuevo')
asignando un nombre precedido de *. Estos argumentos se presentan en intento += 1
En las funciones, las variables pueden ser locales o globales. Local cuando la jugar(intento)
forma de tupla. Es posible obtener parámetros arbitrarios como pares de
variable se define dentro de la función. else:
clave=valor. En estos casos, al nombre del parámetro se preceden **
print('¡Perdiste!')
def potencia(): else:
def calcula_media(*args):
Lista = (1, 2, 3) print('¡Ganaste!')
total = 0
for i in Lista[0:2]: jugar()
for i in args:
print(a**i, end=' - ')
total += i
for i in Lista[2:3]:
resultado = total / len(args)
print(a**i)
return resultado
return
a = float(input('''Determinar las primeras a, b, c = 3, 5, 10
tres potencias de un número. media = calcula_media(a, b, c)
Por favor, ingrese un número positivo: ''')) print(f"La media de {a}, {b} y {c} es: {media}")
if a < 0: print("Programa terminado")
print('''Ha ingresado un número negativo,
vuelvalo a intentar''') Ejemplo función suma, en donde la primera función solo acepta sumar dos
else: elementos, mientras que la segunda funció acepta cualquier cantidad de
potencia() números.
Función sin argumentos def suma(a, b): def suma(*args):
Este tipo de función es muy dificil de reutilizar en otros programas, ya que res = a+b res = 0
solo es capaz de usar las variables a y b. Si en el programa no se utilizan esos return res for arg in args:
nombres de variables, la función no servirá. res += arg
return res
def escribe_media():
media = (a + b) / 2 Retornar varios valores a la vez
print(f"La media de {a} y {b} es: {media}") Las funciones pueden devolver varios valores simultáneamente.
return
def calcula_media_desviacion(*args):
a = 3 total = 0
b = 5 for i in args:
escribe_media() total += i
print("Programa terminado") media = total / len(args)
total = 0
Funciones con argumentos for i in args:
Las funciones pueden admitir argumentos, de manera que se puedan total += (i - media) ** 2
reutilizar más fácilmente. desviacion = (total / len(args)) ** 0.5
return media, desviacion
def escribe_media(x, y):
media = (x + y) / 2 a, b, c, d = 3, 5, 10, 12
print(f"La media de {x} y {y} es: {media}") media, desviacion_tipica =
return calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
a = 3 print(f"Media: {media}")
b = 5 print(f"Desviación típica: {desviacion_tipica}")
escribe_media(a, b) print("Programa terminado")
print("Programa terminado")
Datos: 3 5 10 12 PROGRAMACIÓN ORIENTADA A OBJETOS (POO)
La media de 3 y 5 es: 4.0 Media: 7.5
Programa terminado Desviación típica: 3.640054944640259 La Programación Orientada a Objetos es un paradigma de la programación,
Programa terminado en donde un programa se moldea a través de clases y objetos que interactúan
Retorno de valores de la función
entre sí. Una clase es el razonamiento abstracto de un objeto, mientras que
En el ejemplo anterior, el programa principal no puede utilizar la variable
el objeto es su materialización.
media calculada por la función y tiene que ser la función la que escriba el Valores por defecto en los argumentos
valor. Para evitar este problema, las funciones pueden devolver valores, Al asignar un valor por defecto a un argumento, se puede colocar solo un Clase
utilizando la palabra return. Generalmente, si no se especifica y si la función argumento. Es una plantilla que define cuáles atributos y métodos tendrán los objetos de
no sabe que valor devolver, retornará None. dicha clase. Una clase se define con la instrucción class, seguida de un
def saludar(nombre, mensaje='Hola'):
print(mensaje, nombre) nombre genérico para los objetos.
def calcula_media(x, y):
resultado = (x + y) / 2 class Automovil:
return resultado saludar('Pepe')
Hola Pepe def __init__(self, gasolina):
self.gasolina = gasolina
a = 3
b = 5 Llamadas recursivas print(f'Tenemos {gasolina} Litros')
media = calcula_media(a, b) Una función dentro de su algoritmo, puede hacer referencia a sí misma. def arrancar(self):
print(f"La media de {a} y {b} es: {media}") if self.gasolina > 0:
print("Programa terminado") def jugar(intento=1):
respuesta = input("¿De qué color es una print('Arranca')
naranja? ") else:
La media de 3 y 5 es: 4.0
if respuesta != "naranja": print('No arranca')
Programa terminado
 def conducir(self):
if self.gasolina > 0:
self.gasolina -= 1
print(f'Quedan {self.gasolina}
Litros')
else:
print('No se mueve')

El primer método __init__ es el constructor de la clase.

Objeto (instancia)
En Python, todo es un objeto (sustantivo), el cual posee una serie de
propiedades o atributos (variables), y tiene la capacidad de realizar acciones
denominadas métodos (funciones). Para crear un objeto (instanciar una
clase), se asigna la clase como valor de una variable, junto con cualquier
parámetro necesario entre paréntesis.
mi_auto = Automovil(1)

Accediendo a las propiedades y métodos de un objeto

Una vez creado un objeto, para acceder a sus propiedades y métodos, se
debe escribir la sintaxis objeto.atributo o objeto.método(). El primer
parámetro de todos los métodos de la clase es siempre self, el cual sirve
para referirse al objeto actual, aunque no es necesario escribirlo, ya que
Python lo hace automáticamente.
>>> mi_auto.gasolina
1
>>> mi_auto.arrancar()
Arranca
>>> mi_auto.conducir()
Quedan 0 Litros
>>> mi_auto.conducir()
No se mueve
>>> mi_auto.arrancar()
No arranca
>>> mi_auto.gasolina
0

En Python todos son objetos. Las cadenas de texto, por ejemplo, tienen
métodos como upper(), que devuelve el texto en mayúsculas, o count()
que devuelve el número de veces que se encontró una subcadena en el texto.
>>> texto = 'Hola mundo'
>>> texto.upper()
‘HOLA MUNDO’

Herencia