Listas
Contents
3.1. Listas#
Referencia
https://docs.python.org/3.5/tutorial/introduction.html#lists
3.1.1. Definición y creación de listas#
Una lista es un conjunto ordenado de objetos que se escriben separados por coma entre corchetes
L = [0, 2, -1, 3]
M = ['hola', 'buenas', 'hi', 'hello']
N = [2, 'hola', True, [2, 6]]
Las listas son estructuras de datos que permiten almacenar diferentes tipos de objetos (numéricos, de texto, binarios o listas) secuencialmente:
no son escalares: tienen elementos (se parecen a las cadenas y en este sentido son diferentes de los tipos numéricos)
los elementos se ordenan secuencialmente por su posición como en las cadenas
las podemos modificar: son mutables
Como las cadenas, las listas están formadas por elementos ordenados secuencialmente. Pero a diferencia de las cadenas, los elmentos de las listas pueden se de cualquier tipo y estas, las listas, son nmutables (las cadenas son imutables).
l0 = []
l1 = [1,6,8]
l2 = [1, 'ab', 3, 8.0, True]
l3 = [7, [9, 1, 7], 'mn']
l0
[]
l1
[1, 6, 8]
l2
[1, 'ab', 3, 8.0, True]
l3
[7, [9, 1, 7], 'mn']
type(l0)
list
Las listas son mutables
l1[0]='a'
l1
['a', 6, 8]
Con cadenas esta operación arroja un error
s1 = 'ab'
s1[0] = 'x'
s1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [9], in <cell line: 2>()
1 s1 = 'ab'
----> 2 s1[0] = 'x'
3 s1
TypeError: 'str' object does not support item assignment
3.1.1.1. Creación de listas por iteración#
Las listas se pueden crear escribiendo todos los elementos que la contienen pero también se pueden crear usando la iteración:
l6 = [x**3 for x in range(7)]
l6
[0, 1, 8, 27, 64, 125, 216]
l7 = [20 + 0.001*n for n in range(6)]
l7
[20.0, 20.001, 20.002, 20.003, 20.004, 20.005]
[x**3 for x in l7]
[8000.0,
8001.2000600010015,
8002.400240007999,
8003.6005400270005,
8004.800960064002,
8006.0015001249985]
Lo que estamos haciendo es lo siguiente:
Sea f una función e I un iterable.
Con la instrucción
[f(u) for u in I (if condición)]
se define la lista
[f(u1), f(u2),..., f(um)]
siendo u1, u2,…,um los elementos del iterable I para los cuales la condición es True.
Ejemplos
[i**2 for i in range(8)]
[0, 1, 4, 9, 16, 25, 36, 49]
[2*a for a in 'champiñón']
['cc', 'hh', 'aa', 'mm', 'pp', 'ii', 'ññ', 'óó', 'nn']
[i**2 for i in range(20) if i%5 == 1]
[1, 36, 121, 256]
[[i,i + 1] for i in range(5)]
[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]]
[letra for letra in 'esqueleto' if letra in 'aeiou']
['e', 'u', 'e', 'e', 'o']
¿Qué se hace en las líneas siguientes?
a, b = 0, 1
N = 10
h = (b - a)/N
L = [a + k*h for k in range(N + 1)]
L
[0.0,
0.1,
0.2,
0.30000000000000004,
0.4,
0.5,
0.6000000000000001,
0.7000000000000001,
0.8,
0.9,
1.0]
def f(x):
return x**3 - 3*x**2 + 1
[f(u) for u in L]
[1.0,
0.971,
0.888,
0.7569999999999999,
0.5839999999999999,
0.375,
0.1359999999999998,
-0.12700000000000022,
-0.40800000000000036,
-0.7010000000000001,
-1.0]
3.1.2. Operaciones con listas#
3.1.2.1. Concatenación#
Usaremos el símbolo +. Se dice que es un símblo sobrecargado (‘overloaded’): tiene diferentes significados según el contexto.
l1 + l2 + l3
['a', 6, 8, 1, 'ab', 3, 8.0, True, 7, [9, 1, 7], 'mn']
M = [2, 1, 5]
N = ['h', 'o', 'l', 'a']
M + N
[2, 1, 5, 'h', 'o', 'l', 'a']
Obserbad el siguiente código. Arroja diferentes resultados según la línea que utilicemos al cambiar de lugar el símbolo #
salida = []
for letra in 'hola':
#salida += [letra]
#salida = salida + [letra]
salida = [letra] + salida
salida
['a', 'l', 'o', 'h']
3.1.2.2. Repetición#
7 * l1
['a', 6, 8, 'a', 6, 8, 'a', 6, 8, 'a', 6, 8, 'a', 6, 8, 'a', 6, 8, 'a', 6, 8]
3.1.2.3. Obtener un elemento#
l2
[1, 'ab', 3, 8.0, True]
l2[1]
'ab'
l2[1][-1]
'b'
l2[-1]
True
l2[-1][-1]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [29], in <cell line: 1>()
----> 1 l2[-1][-1]
TypeError: 'bool' object is not subscriptable
Se produce un error si no hay elemento con el índice indicado
l2[7]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
Input In [30], in <cell line: 1>()
----> 1 l2[7]
IndexError: list index out of range
Observación:
El tipo del objeto que devuelve la anterior operación depende el tipo del elemento que tiene el índice pedido.
3.1.2.4. Operador corte (troceado, “slicing”): extraer una sublista#
Observación: Esta operación siempre devuelve un objeto de tipo lista
l1 = [1, 6, 8]
l2 = [1, 'ab', 3]
l3 = [7, [9, 1, 7], 'mn']
l1[2:]
[8]
l2[:-1]
[1, 'ab']
l3[1:2]
[[9, 1, 7]]
l3[1]
[9, 1, 7]
Elegir los elementos de índice par
L = 7*l1
L
[1, 6, 8, 1, 6, 8, 1, 6, 8, 1, 6, 8, 1, 6, 8, 1, 6, 8, 1, 6, 8]
L[::2]
[1, 8, 6, 1, 8, 6, 1, 8, 6, 1, 8]
Elegir los elementos de índice múltiplo de 3
L[::3]
[1, 1, 1, 1, 1, 1, 1]
Invertir un lista
l1[::-1]
[8, 6, 1]
3.1.2.5. Pertenencia#
l1 = [1, 6, 8]
l2 = [1, 'ab', 3]
l3 = [7, [9, 1, 7], 'mn']
'a' in l1
False
'ab' not in l2
False
1 in l3
False
3.1.3. Funciones para listas#
3.1.3.1. Longitud#
len(l1)
3
len(l2)
3
len(l3)
3
3.1.3.2. Max y min#
Los elementos del objeto deben de ser comparables; deben de ser del mismo tipo
l1 = [1, 6, 8]
l2 = [1, 'ab', 3]
l3 = [7, [9, 1, 7], 'mn']
max(l1)
8
min(l2)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [49], in <cell line: 1>()
----> 1 min(l2)
TypeError: '<' not supported between instances of 'str' and 'int'
l4 = ['ab', '1cb', 'W']
min(l4)
'1cb'
l4 = ['ab', 'W']
min(l4)
'W'
3.1.3.3. Ordenar#
La función del nucleo de Python sorted() proporciona un procedimiento para ordenar listas si están formadas por elementos del mismo tipo. Por ejemplo: todos son cadenas, todos son números.
l1 = [1, 8, 6, 0]
l2 = [1, 'ab', 3]
l4 = ['ab', '1cb', 'W', 'x', 'ñ']
sorted(l1)
[0, 1, 6, 8]
sorted(l2)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [54], in <cell line: 1>()
----> 1 sorted(l2)
TypeError: '<' not supported between instances of 'str' and 'int'
sorted(l4)
['1cb', 'W', 'ab', 'x', 'ñ']
l1
[1, 8, 6, 0]
3.1.4. Iteración con listas#
Las listas son variables iterables, veremos algunos ejemplos de su uso
Un ejemplo: sumar los dígitos de un número entero positivo
n = 743
# sumar los dígitos de un entero introducido con una cadena
l = []
for p in str(n):
l += [int(p)]
l
[7, 4, 3]
# ahora se suman los elementos de la lista formada por enteros positivos
suma = 0
for p in l:
suma += p
suma
14
Función para sumar los dígitos de un número natural
# función para sumar los dígitos de un número entero positivo
def suma_digitos(entero):
temp = []
rsltd = 0
for p in str(entero):
temp += [int(p)]
for q in temp:
rsltd += q
return rsltd
z = suma_digitos(346)
z
13
Otro ejemplo: formar una lista con los tipos de los elementos de una lista
l3 = [7, [9, 1, 7], 'mn']
# formar una tupla con los tipos de los elementos de una tupla
rsltd = []
for p in l3:
rsltd += [type(p)]
rsltd
[int, list, str]
Un último ejemplo:
Considerar una lista formada por enteros positivos, cadenas o listas. Generar una lista con la longitud de los elementos de una lista del tipo anterior asignando la suma de sus dígitos a los enteros de dicha lista.
l5 = ['abs', 123, 430, '', ['a', 1, 3]]
# formar una lista con la longitud de los elementos de una lista
# la lista debe estar formada por cadenas, listas o enteros positivos
# si es un entero posotivo da la suma de los dígitos del entero
l = []
for p in l5:
if type(p) == int:
l += [suma_digitos(p)]
else:
l += [len(p)]
l
[3, 6, 7, 0, 3]
3.1.5. Métodos para listas#
https://docs.python.org/3.5/tutorial/datastructures.html#more-on-lists
Los métodos son funciones de un tipo específico o de varios tipos.
Lo veremos más adelante cuando veamos métodos para cadenas. En este sentido es similar a la operación +: es una operación para los tipos numéricos pero también para cadenas y listas
3.1.5.1. Índice#
Devuelve el índice de la primera vez que aparece el elemento especificado. Si este elemento no existe, se produce un error
l1 = [1, 6, 8, 1]
[1, 6, 8, 1].index(1)
0
l1.index(6)
1
l1.index(3)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Input In [68], in <cell line: 1>()
----> 1 l1.index(3)
ValueError: 3 is not in list
l1.index
<function list.index(value, start=0, stop=9223372036854775807, /)>
l1.index()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [70], in <cell line: 1>()
----> 1 l1.index()
TypeError: index expected at least 1 argument, got 0
También se puede utilizar limitando el segmento de la búsqueda
l1.index(1, 1, -1)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Input In [71], in <cell line: 1>()
----> 1 l1.index(1, 1, -1)
ValueError: 1 is not in list
l1.index(1, 0, 1)
0
3.1.5.2. Contar#
l1.count('z')
0
l1.count(1)
2
No se puede usar limitando el segmento de búsqueda
3.1.5.3. Métodos que cambian listas (los objetos del tipo lista son objetos mutables)#
Recordemos que las listas son objetos mutables, se puede cambiar un elemento (cambia el valor de la lista)
# Cambiar un elemento indicando la posición
l8 = [7, [9, 1, 7], 'mn', 'adiós', 55]
l8[-1] = 'c'
l8
[7, [9, 1, 7], 'mn', 'adiós', 'c']
Insertar un elmento (cambia el valor de la lista pero no devuelve nada)
Inserta un elemento, que corresponde al segundo argumeto, en la posición de índice que corresonde al primer argumento todos los elementos a partir de dicha posición se mueven hacia la derecha
l8.insert(1, 0)
l8
[7, 0, [9, 1, 7], 'mn', 'adiós', 'c']
Este método no devuelve nada. Lo que hace es cambiar el valor de la lista l8.
type(l8.insert(1, 0))
NoneType
l8
[7, 0, 0, [9, 1, 7], 'mn', 'adiós', 'c']
l8.insert(1, 0), l8
(None, [7, 0, 0, 0, [9, 1, 7], 'mn', 'adiós', 'c'])
Añadir un elemento después de la última posición (cambia el valor de la lista pero no devuelve nada)
# añadir un elemento después de la última posición
l8.append([7])
l8
[7, 0, 0, 0, [9, 1, 7], 'mn', 'adiós', 'c', [7]]
Ejemplo: Crear una lista de 20 ceros. Podemos hacerlo de varias formas:
L = 20 * [0]
L
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
M = []
for k in range(20):
M += [0]
M
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
N = []
for k in range(20):
N.append(0)
N
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Luego veremos más formas de crear esa lista.
Añadir varios elementos al final: extender una lista con los elementos de otra lista (cambia el valor de la lista pero no devuelve nada)
# extiende una lista con los elmentos de otra, colocándolos al final
l8.extend([3, 2, 1, 'hola', ['a', 56]])
l8
[7, 0, 0, 0, [9, 1, 7], 'mn', 'adiós', 'c', [7], 3, 2, 1, 'hola', ['a', 56]]
Quitar un elemento por su valor (cambia el valor de la lista pero no devuelve nada)
Quita de la lista la primera vez que aparece el elemnto especificado.
l8.remove([9, 1, 7])
l8
[7, 0, 0, 0, 'mn', 'adiós', 'c', [7], 3, 2, 1, 'hola', ['a', 56]]
l8.remove(3)
l8
[7, 0, 0, 0, 'mn', 'adiós', 'c', [7], 2, 1, 'hola', ['a', 56]]
Quitar un elemento por su índice (cambia el valor de la lista pero no devuelve nada)
# Quitar un elemento por su índicde
del(l8[3])
l8
[7, 0, 0, 'mn', 'adiós', 'c', [7], 2, 1, 'hola', ['a', 56]]
Quitar un trozo de una lista (cambia el valor de la lista pero no devuelve nada)
# Quitar un trozo de una lista
del(l8[:3])
l8
['mn', 'adiós', 'c', [7], 2, 1, 'hola', ['a', 56]]
Quitar un elemento por su posición y devolverlo.
El método .pop() devuelve el elemento del índice especificado y lo quita del objeto. Si no se especifica índice alguno, devuelve y quita el último elemento.
l8.pop()
['a', 56]
l8
['mn', 'adiós', 'c', [7], 2, 1, 'hola']
l8.pop(0)
'mn'
l8
['adiós', 'c', [7], 2, 1, 'hola']
Ordenar
.sort()
# ordena en orden 'creciente'
l9 = [2, 9, 1, 7, 0]
l9.sort(), l9
(None, [0, 1, 2, 7, 9])
# ordena en orden 'decreciente'
l9 = [2, 9, 1, 7, 0]
l9.sort(reverse=True), l9
(None, [9, 7, 2, 1, 0])
# ordena en orden 'creciente'
l9 = [2, 9, 1, 7, 0]
l9.sort(reverse=False), l9
(None, [0, 1, 2, 7, 9])
¡NO cofundir con sorted! Esta es una función propia de Python que ordena una lista sin transformarla, como antes se ha visto
Funciones propias de Python: https://docs.python.org/3.7/library/functions.html
Revertir la posición de los elementos de una lista
.reverse()
# cambia los elemetos de posición revirtiendo la posición de los elemento
# este método revierte la posición de los elementos de una lista no la ordena
l9 = [2, 9, 1, 7, 0]
l9.reverse(), l9
(None, [0, 7, 1, 9, 2])
3.1.6. Efectos colaterales del uso de listas#
3.1.6.1. Dos comportamientos diferentes: (i) Listas iguales con nombres diferentes (clones)#
Los valores son iguales pero la dirección en la memoria es diferente excepto para los enteros y ciertas cadenas la dirección en la memoria es la misma
L1 = [7, 2, 9, 0]
L2 = [7, 2, 9, 0]
L1 == L2
True
L1 is L2
False
Tienen identificadores diferentes
print(id(L1))
print(id(L2))
139977467275200
139977466944768
Cambiar una lista no implica cambios en la otra la otra, igual que para los otros tipos. Son dos objeto distintos aunque tengan el mismo valor
L1[0] = 420
print(L1)
print(L2)
print(L1 == L2)
print(L1 is L2)
[420, 2, 9, 0]
[7, 2, 9, 0]
False
False
Otro ejemplo
lista1 = ['azul', 'violeta', 'marrón']
lista2 = ['azul', 'violeta', 'marrón']
print(lista1)
print(lista2)
['azul', 'violeta', 'marrón']
['azul', 'violeta', 'marrón']
print(lista1)
print(lista2)
print(lista1 == lista2)
print(lista1 is lista2)
['azul', 'violeta', 'marrón']
['azul', 'violeta', 'marrón']
True
False
lista2[2] = 'verde'
print(lista1)
print(lista2)
['azul', 'violeta', 'marrón']
['azul', 'violeta', 'verde']
print(lista1)
print(lista2)
print(lista1 == lista2)
print(lista1 is lista2)
['azul', 'violeta', 'marrón']
['azul', 'violeta', 'verde']
False
False
El siguiente código genera dos listas distintas con el mismo valor
L1 = [7, 2, 9, 0]
L3 = []
for l in L1:
L3.append(l)
L3
[7, 2, 9, 0]
print(L1 == L3)
print(L1 is L3)
True
False
Nota: Este comportamiento es similar para los números decimales (tipo float) pero no para los enteros (tipo int) y las cadenas (tipo str)
Enteros:
a = 3
b = 3
print(a == b)
print(a is b)
True
True
print(id(a))
print(id(b))
9801312
9801312
Cadenas:
c1 = 'a'
c2 = 'a'
print(c1 == c2)
print(c1 is c2)
True
True
print(id(c1))
print(id(c2))
139978106046576
139978106046576
Decimales
f = 3.1
g = 3.1
print(f == g)
print(f is g)
True
False
print(id(f))
print(id(g))
139977467271152
139977467269616
3.1.6.1.1. Clonar listas: Generar un nuevo objeto con el valor de otro#
Primer procedimiento
L5 = ['azul', 'violeta', 'marrón']
L6 = L5[:]
print(L5)
print(L6)
['azul', 'violeta', 'marrón']
['azul', 'violeta', 'marrón']
print(L5 == L6)
print(L5 is L6)
True
False
print(id(L5))
print(id(L6))
139977466986240
139977466938048
De esta forma si cambio una no se ve afectada la otra
L6.append('negro')
print(L5)
print(L6)
['azul', 'violeta', 'marrón']
['azul', 'violeta', 'marrón', 'negro']
Segundo procedimiento
L5 = ['azul', 'violeta', 'marrón']
L7 = []
for elemento in L5:
L7.append(elemento)
L7
['azul', 'violeta', 'marrón']
print(L5 == L7)
print(L5 is L7)
True
False
print(id(L5))
print(id(L7))
139977466940608
139977466918272
3.1.6.2. Dos comportamientos diferentes: (ii) Dos nombres distintos para un mismo objeto (alias)#
L1 = [7, 2, 9, 0]
L4 = L1
L4
[7, 2, 9, 0]
print(L1 == L4)
print(L1 is L4)
True
True
print(id(L1))
print(id(L4))
139977953953920
139977953953920
De esta forma se crea un alias o un apodo para la lista L1. Ahora tenemos un solo objeto con dos nombres y si cambio uno cambia el otro
L1[0] = 420
print(L1)
print(L4)
[420, 2, 9, 0]
[420, 2, 9, 0]
L4[-1] = 759
print(L1)
print(L4)
print(L1 == L4)
print(L1 is L4)
print(id(L1))
print(id(L4))
[420, 2, 9, 759]
[420, 2, 9, 759]
True
True
139977953953920
139977953953920
Otro ejemplo
frio = ['marrón', 'ocre', 'naranja']
fresco = frio
print(frio)
print(fresco)
['marrón', 'ocre', 'naranja']
['marrón', 'ocre', 'naranja']
print(id(fresco))
print(id(frio))
139977466978624
139977466978624
fresco is frio
True
frio.append('marillo')
print(frio)
print(fresco)
['marrón', 'ocre', 'naranja', 'marillo']
['marrón', 'ocre', 'naranja', 'marillo']
print(id(fresco))
print(id(frio))
139977466978624
139977466978624
fresco is frio
True
3.1.6.3. Efectos colaterales con listas anidadas#
Si una lista está formada por sublistas el cambio en una de estas sublistas produce cambios en la lista que las contiene
lista1 = ['azul', 'violeta']
lista2 = ['rojo']
lista3 = [lista1]
print(lista3)
[['azul', 'violeta']]
lista3.append(lista2)
print(lista3)
[['azul', 'violeta'], ['rojo']]
lista2.append('verde')
print(lista2)
print(lista3)
['rojo', 'verde']
[['azul', 'violeta'], ['rojo', 'verde']]
lista3esta formada por dos elemnetos, las listas lista1 y lista2. Al cambiar lista2 cambia lista3
3.1.6.4. Efectos colaterales al iterar sobre listas#
Al iterar sobre una lista que estamos cambiando, no se tendrán en cuenta todos los elementos de la lista original
La siguiente función pretende quitar los elementos de la lista L que están en la lista M
def quitar_rep(L, M):
for e in L:
if e in M:
L.remove(e)
return L
L = [1, 2, 3, 4]
M = [1, 2, 5, 6]
L9 = quitar_rep(L, M)
L9
[2, 3, 4]
L.remove(e) cambia la longitud de la lista pero Python no actualiza el contador que corresponde a L.remove(e).
Al quitar el 1, en la siguiente iteración hay que coger el elemento de la posición con índice 1 que en la lista cambiada es 3: el bucle nunca ve el 2
def quitar_rep_nueva(L, M):
L1_nueva = L[:]
for e in L1_nueva:
if e in M:
L.remove(e)
return L
L = [1, 2, 3, 4]
M = [1, 2, 5, 6]
L10 = quitar_rep_nueva(L, M)
L10
[3, 4]
3.1.6.5. Otro ejemplo para visualizar efectos colaterares en las listas#
Ejemplo 1
m = [3]
n = [3]
print(m == n)
print(m is n)
True
False
p = m
print(p == m)
print(p is m)
True
True
n.append(7)
n
[3, 7]
m
[3]
p
[3]
p.append(7)
p
[3, 7]
m
[3, 7]
print(n == m)
print(n is m)
True
False
print(p == m)
print(p is m)
True
True
Ejemplo 2
def lista(L):
rsltd = []
for l in L:
rsltd.append(l)
return rsltd
L_entrada = ['a', 34.3, ['abs'], True]
L_salida = lista(L_entrada)
L_salida
['a', 34.3, ['abs'], True]
L_entrada == L_salida
True
L_entrada is L_salida
False
print(id(L_entrada))
print(id(L_salida))
139977466983360
139977467222144
3.1.7. Ejemplos#
Lista de las palabras que se obtienen al eliminar, alternativamente, cada una de las letras de una palabra dada
def lista_palabras(palabra):
lista = []
for n in range(len(palabra)):
elemento = palabra[:n] + palabra[n+1:]
lista.append(elemento)
return lista
lista_palabras('abcdefg')
['bcdefg', 'acdefg', 'abdefg', 'abcefg', 'abcdfg', 'abcdeg', 'abcdef']
Lista ordenada de los dígitos que no se repiten en un entero que no es negativo. Esta función devuelve un lista de números enteros, ordenados de menor a mayor.
def digitos(num):
L = list(str(num))
aux = L[:]
se_repite = []
for e in L:
aux.remove(e)
if e in aux:
se_repite.append(e)
rsltd = []
for e in L:
if int(e) not in rsltd and e not in se_repite:
rsltd.append(int(e))
rsltd.sort()
return rsltd
digitos(7745730)
[0, 3, 4, 5]
Otra versión
def digitos(num):
L = list(str(num))
rsltd = []
for e in L:
if int(e) not in rsltd and L.count(e) == 1:
rsltd.append(int(e))
rsltd.sort()
return rsltd
digitos(7745730)
[0, 3, 4, 5]
3.1.8. Ejercicios#
En los siguientes ejercicios, siempre que sea posible, trata de resolverlos también sustituyendo las listas por tuplas.
Sea
L = [1, -4, 8, -9]. Encontrar funciones f para que la instrucción[f(u) for u in L]genere las siguientes listas:[5, -20, 40, -45][1, 4, 8, 9][2, -3, 9, -8]
Generar las siguientes listas:
[1,2,3,4,5,6,7,8,9,10,11,12 ][2,4,...,48][1,1,...,1](N veces el número \(1\))[1,4,9,16,25,36,49,64,81,100]\([1,\frac{1}{3},\frac{1}{5},\frac{1}{7},\frac{1}{9},\frac{1}{11},\frac{1}{13},\frac{1}{15}]\)
\([\rm{True,}\;\rm{False,}\;\rm{True,}\;\rm{False,}\;\rm{True,}\;\rm{False,}\;\rm{True,}\;\rm{False}]\)
[[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]][1,12,123,1234,12345,123456,1234567,12345678,123456789]
Definir la función aplicar_a_todos(f,L) que devuelva la misma lista que genera [f(u) for u in L] sin utilizar esta instrucción.
Definir la función pares(lista) que dada una lista, devuelva la lista con los elementos de lista con índice impar.
Definir la función mas_corta(lista_1,lista_2) que devuelva la más corta de las listas lista_1 y lista_2.
Definir la función alguno_comun(lista_1,lista_2) que devuelve True o False si las listas tienen algún elemento en común o no.
Definir la función comunes(lista_1,lista_2) que devuelva la lista de los elementos comunes a las listas lista_1 y lista_2.
Definir la función diferencia(lista_1,lista_2) que devuelva una lista con los elementos de lista_1 que no están en lista_2.
Definir la función mayor_que(lista,a) que devuelva una lista con los elementos de lista que son mayores que a. Si algún elemento de lista no puede compararse con a la función debe devolver la cadena ‘datos incorrectos’.
Definir la función mi_suma(lista) que devuelva la suma de los elementos de lista.
Definir a función mi_max(lista) que devuelva la máximo de los elementos de lista.
Definir a función simple(lista) que devuelva una lista en la que aparecen los elementos de lista solo una vez (elimina multiplicidades).
Definir la función frecuencia(lista,a) que devuelva el número de veces que a está contenido en lista.
Definir la función indice(lista,a) que devuelva el índice de a en lista si pertenece a lista y len(lista) si no pertenece.
Definir la función traslacion_circular(lista, n) que devuelve una translación circular de n unidades de lista. Ejemplos: traslacion_circular([1,2,3,5,6],3); devuelve [5,6,1,2,3] traslacion_circular([‘a’,’b’],1); devuelve [‘b’,’a’]
Definir la función id_circular(lista_1, lista_2) que devuelve True o False según se obtenga lista_1 por una traslación circular de lista_2 o no.
Definir la función
alfa(L1, L2)que devuelveTrueoFalsesegún los elementos deL1estén todos enL2o no.Definir la función
es_trozo(L1, L2)que devuelveTruesiL1es un trozo (una sublsita) deL2yFalseen caso contrario.Definir la función
beta(L)que devuelve el máximo de las sumas de dos elementos consecutivos de la listaL.Definir la función
delta(L, n)que devuelveTruesiLcontiene dos elemento consecutivos que sumennyFalseen caso contrario.Definir la función maximo(f,a,b,N) que devuelva el valor máximo de la función f en una malla uniforme del intervalo (a,b) con N subintervalos.
Definir la función frecuencia_maximo(f,a,b,N) que devuelva el número de puntos de la malla donde se alcanza el máximo de la función f (ver ejercicio anterior).
Definir la función puntos_maximo(f,a,b,N) que devuelva la lista de puntos de la malla donde se alcanza el máximo de la función f (ver ejercicios anteriores).
Definir la función sublistas(lista) que devuelve una lista con todas las sublistas de lista. Entenderemos por sublista, un lista de lementos consecutivos de la lista original; es decir, el porducto del operador corte (“slicing”) sin saltos.