Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?

mode=python

1 # Programacion imperativa
2 enteros = [1,2,3,4,5,6]
3 '''
4 lista los números pares de la lista enteros
5 '''
6 lista_de_pares = []
7 for numero in enteros:
8 if numero%2 == 0:
9 lista_de_pares.append(numero)
10
11 print(lista_de_pares)
12 # Como podemos ver en el ejemplo anterior, mediante programación imperativa vamos
creando una serie de variables, modificando su estado y obteniendo un resultado.
13 #Ahora vamos a hacer lo mismo con programación funcional.
14 '''
15 lista los números pares de la lista enteros
16 '''
17 lista_de_pares = list(filter(lambda numero: numero%2 ==0, enteros))
18 print(lista_de_pares)
19
20 # Función lambda
21
22 #lambda num: num%2 == 0
23 # ^ ^
24 # argumento Cuerpo de la función
25
26 # A las lambdas se les pueden pasar varios parametros
27 import random
28 suma = lambda op1, op2: op1 + op2
29 numero_aleatorio = lambda x: random.randrange(x)
30 suma(numero_aleatorio(100),34)
31
32 # Tambien se le pueden pasar un numero indefinido de args
33
34 elevar_al_cuadrado = lambda *args: [num**2 for num in args] # con lista de
comprension
35 elevar_al_cuadrado(1,2,3,4) # -> [1, 4, 9, 16]
36
37 valores = [1,2,3,4,5,6]
38 numeros_pares = [ num for num in valores if num%2 == 0] # -> [2, 4, 6]
39 numeros_pares = [num if num%2 == 0 else 0 for num in valores] # -> [0, 2, 0, 4, 0, 6]
40
41 # Capitalizar un nombre
42 # Añadir sr al principio
43 capitalizar = lambda nombre: nombre[0].upper() + nombre[1:] # nombre.capitalize()
44 annadir_sr = lambda x: 'Sr. ' + x
45 saludar = lambda nombre: annadir_sr(capitalizar(nombre))
46 saludar('pablo') # -> 'Sr. Pablo'
47
48 # prog imperativa
49 def capitalizar(nombre):
50 return nombre.capitalize()
51
52 def annadir_sr(nombre):
53 return 'Sr. ' + nombre
54
55 def saludar(nombre):
56 nombre = capitalizar(nombre)
57 return annadir_sr(nombre)
58

1 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

59 # FILTER # Filtra los elementos de una lista

60 # filter( funcion , lista )
61 es_par = lambda x: x%2 == 0
62 numeros_pares = filter( es_par, [1,2,3,4,5,6,7,8,9,10] )
63 list(numeros_pares) # -> [2, 4, 6, 8, 10]
64
65 numeros = { '2': 2, '5': 1, '8': None, '7': None }
66 es_par_dict = lambda x: es_par(x[1]) if x[1] else es_par(int(x[0]))
67
68 numeros_pares = filter( es_par_dict, numeros.items() )
69 print(list(numeros_pares)) # -> [2, 4, 6, 8, 10]
70 '''
71 filtra los números mayores a 40 y menores a 60 de la lista enteros
72 '''
73 lista_enteros = [40, 32,86,48,78,15,43,12,78,95,45,52,69,78,84]
74 resultado = list(filter(lambda x: x > 40 and x < 60, lista_enteros))
75 print(resultado)
76
77 '''
78 crea una función lambda que reciba un año de nacimiento y devuelva la edad actual
79 '''
80 edad = lambda x: 2022 - x
81 print(edad(1990)) # -> 32
82
83 '''
84 ahora filtra una lista de usuarios que tengan una edad mayor a 18
85 '''
86 usuarios = [
87 {'nombre': 'Juan', 'nacimiento': 2017},
88 {'nombre': 'Pedro', 'nacimiento': 2018},
89 {'nombre': 'Maria', 'nacimiento': 1980},
90 {'nombre': 'Juana', 'nacimiento': 1995},
91 {'nombre': 'Jorge', 'nacimiento': 1985},
92 {'nombre': 'Pablo', 'nacimiento': 1990},
93 {'nombre': 'Clara', 'nacimiento': 1995},
94 {'nombre': 'Bea', 'nacimiento': 2019},
95 {'nombre': 'Pilar', 'nacimiento': 2010},
96 ]
97 mayores_de_edad = list(filter(lambda x: edad(x['nacimiento']) > 18, usuarios))
98 print(mayores_de_edad) # -> [{'nombre': 'Maria', 'nacimiento': 1980}, {'nombre':
'Juana', 'nacimiento': 1995},
99 #{'nombre': 'Jorge', 'nacimiento': 1985}, {'nombre': 'Pablo', 'nacimiento': 1990},
{'nombre': 'Clara', 'nacimiento': 1995}]
100
101 '''
102 Filtra las cadenas de la lista que tengan una longitud mayor a 5
103 '''
104 nombres_de_animales = ['perro', 'gato', 'pez', 'pajaro', 'vaca', 'caballo', 'cabra']
105 nombres_de_animales_mayores_a_5 = list(filter(lambda x: len(x) > 5,
nombres_de_animales))
106 print(nombres_de_animales_mayores_a_5) # -> ['pajaro', 'caballo']
107 '''
108 filtra las cadenas de la lista que tengan una longitud mayor al número indicado en el
argumento
109 '''
110 nombres_de_animales = ['perro', 'gato', 'pez', 'pajaro', 'vaca', 'caballo', 'cabra']
111 nombres_de_animales_filtrados = lambda x: list(filter(lambda y: len(y) > x,
nombres_de_animales))
112 print(nombres_de_animales_filtrados(5)) # -> ['pajaro', 'caballo']
113

2 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

114 #FUNCION MAP

115
116 # map( función, iterable)
117 # La funcion map aplica a cada elemento del iterable la función dada
118
119 numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
120 cuadrado = lambda x: x**2
121
122 elevar_al_cuadrado = map(cuadrado, numeros)
123 print(list(elevar_al_cuadrado)) # -> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
124
125 # función map con varios iterables
126 suma = lambda x,y: x+y
127
128 suma_listas = map(suma, [1,2,3,4,5], [1,2,3,4,5])
129 print(list(suma_listas)) # [2, 4, 6, 8, 10]
130
131 '''
132 Crea un función que reciba una lista de nombres y añada 'Hola' seguido de cada
nombre.
133 '''
134 nombres = ['Juan', 'Pedro', 'Maria', 'Juana', 'Jorge', 'Pablo', 'Pilar']
135 saludo = lambda x: 'Hola ' + x
136 saludos = map(saludo,nombres)
137 print(list(saludos)) # -> ['Hola Juan', 'Hola Pedro', 'Hola Maria', 'Hola Juana',
'Hola Jorge', 'Hola Pablo', 'Hola Pilar']
138
139 '''
140 Crea una función que reciba una lista de valores decimales y que devuelva una lista
con los valores convertidos a enteros.
141 '''
142 valores = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10]
143 entero = lambda x: int(x)
144 lista_enteros = map(entero, valores)
145 print(list(lista_enteros)) # -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
146
147 # FUNCION ZIP
148 lista = list(zip([1,2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17,18]))
149 # La función zip() combina elementos de dos iterables (en este caso,
150 # # las listas [1,2,3,4,5,6,7,8,9] y [10,11,12,13,14,15,16,17,18]) en pares
ordenados, Creando una secuencia de tuplas
151 # donde cada tupla contiene un elemento de cada iterable. -> [(1, 10), (2, 11), (3,
12), (4, 13), (5, 14), (6, 15), (7, 16), (8, 17), (9, 18)]
152
153 alumnos = ['Juan', 'Pedro', 'Maria', 'Juana', 'Jorge', 'Pablo', 'Pilar']
154 calificaciones = [ 3,9,6,7,5,4,3]
155
156 # programación imperativa
157 for elemento in zip(alumnos,calificaciones):
158 print(elemento) # ('Juan', 3)('Pedro', 9)('Maria', 6)...
159
160 for nombre, calificacion in zip(calificaciones,alumnos):
161 print(nombre, calificacion) # -> 3 Juan, 9 Pedro, 6 Maria...
162
163 # programación funcional
164 resultado_calificacion = lambda result: f'{result[0]} ha sacado un {result[1]}'
165 lista_de_notas = map(resultado_calificacion, zip(alumnos,calificaciones))
166 print(list(lista_de_notas)) # -> ['Juan ha sacado un 3', 'Pedro ha sacado un 9',
'Maria ha sacado un 6'...]
167

3 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

168 # lo mismo sin el zip

169 resultado_calificacion = lambda nombre, calif: f'{nombre} ha sacado un {calif}'
170 lista_de_notas = map(resultado_calificacion, alumnos, calificaciones)
171 print(list(lista_de_notas))
172
173 # FUNCION REDUCE
174 from functools import reduce
175
176 # reduce( funcion, iterable, acumulador=0)
177
178 # Suma todos los elementos de una lista
179 suma = lambda acumulador, valor: acumulador + valor
180
181 suma_valores = reduce(suma, [1,2,3,4], 0)
182 print(suma_valores) # -> 10
183
184 '''
185 acum = 0 (o el valor que se especifique)
186 suma(acumulador, 1 )
187 acum = 1
188 suma(acumulador, 2 )
189 acum = 3
190 suma(acumulador, 3 )
191 acum = 6
192 suma(acumulador, 4 )
193 acum = 10
194 '''
195 # Hacer un join de los nombres de los alumnos
196 alumnos = ['Juan', 'Pedro', 'Maria', 'Juana', 'Jorge', 'Pablo', 'Pilar']
197 '-'.join(alumnos)
198
199 # ejemplo con lambda
200 une_nombres = lambda acumulador, nombre: acumulador+'-'+nombre
201
202 nombres_unidos = reduce(une_nombres,alumnos)
203 print(nombres_unidos) # Juan-Pedro-Maria-Juana-Jorge-Pablo-Pilar
204
205 from functools import reduce
206 '''
207 Dada una lista de numeros, devuelve el valor del numero mayor. Utilizando reduce
208 '''
209
210 maximo = lambda valores: reduce(lambda x,y: x if x > y else y, valores )
211 maximo([ 1,34,20,8,51,9,32,43,10])
212
213 #-----------------------------------------
214 maximo_de_valores = lambda x,y: x if x > y else y
215 maximo = lambda valores: reduce(maximo_de_valores, valores)
216 maximo([ 1,34,20,8,51,9,32,90,10]) # ->90
217
218 booleanos = [True, True, True, True, True, True, True, True, True, True]
219
220 todos_true = reduce( lambda acumulado, valor: acumulado and valor, booleanos) #
Reduce retorna un valor
221 print(todos_true) # True
222
223 #-------------Pasar valores por argumento
224 ambos_true = lambda acumulado,valor: acumulado and valor
225 todos_true = lambda valores: reduce(ambos_true, valores) # Lambda retorna una función
226 todos_true(booleanos) # true

4 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

227
228 from functools import reduce
229
230 '''
231 Cuenta el número de elementos de un iterable que cumplan una condición.
232 '''
233 numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
234 contador = reduce(lambda x, y: x + 1 if y > 5 else x, numeros, 0) # valores mayores a
5
235 print(contador) # 5
236
237 # FUNCION PARTIAL
238 from functools import partial
239 '''
240 La función partial() en Python se encuentra en el módulo functools y se utiliza para
crear
241 una versión parcial de una función existente con algunos de sus argumentos
predefinidos.Cuando se utiliza partial(),
242 se especifica una función y se proporcionan valores para algunos de sus argumentos.
La función devuelta por partial()
243 se puede llamar posteriormente con los argumentos restantes para completar la llamada
a la función original.
244 '''
245 # Dada una lista de números, si es par suma 2, si es impar suma 10
246
247 suma = lambda op1,op2: op1 + op2
248 multiplica = lambda op1,op2: op1 * op2
249
250 suma_2 = partial(suma,2)
251 suma_10 = partial(suma,op2=10)
252 lista_numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
253
254
255 lista_procesada = list(map(lambda x: suma_2(x) if x%2==0 else suma_10(x) ,
lista_numeros ))
256 lista_procesada # -> [11, 4, 13, 6, 15, 8, 17, 10, 19, 12]
257
258 # 1. Data una lista de cadenas obtener una lista de cadenas en mayúsculas
259 lista_cadena=['a','b','c']
260 mayu= lambda x : x.upper()
261 list(map(mayu,lista_cadena)) # -> ['A', 'B', 'C']
262 '''
263 # 1. Data una lista de cadenas obtener una lista de cadenas en mayúsculas
264 entrada = ['hola', 'adios', 'buenas', 'tardes']
265 print(list(map(lambda x: x.upper(), entrada)))
266 '''
267 # 2. Dada una lista de alumnos con sus calificaciones,
268 # obtener una lista con el nombre de los que han obtenido una calificación media
mayor a 7
269 entrada = [ {'nombre': 'Juan','calificaciones': [10, 9, 6]},{'nombre':
'Pedro','calificaciones': [8, 7, 5]},
270 {'nombre': 'Maria','calificaciones': [9, 8, 7]},{'nombre':
'Juana','calificaciones': [3,6,4]},
271 {'nombre': 'Jorge','calificaciones': [10, 10, 10]},{'nombre':
'Pablo','calificaciones': [2, 0, 1]},
272 {'nombre': 'Pilar','calificaciones': [5,6,6] }]
273 for diccionario in entrada:
274 lista=[]
275 calificaciones = diccionario['calificaciones']
276 media= diccionario['calificaciones']

5 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

277 media=np.array(media).mean()
278 if media.mean() >7:
279 lista.append(diccionario['nombre'])
280
281
282 promedio = lambda x: sum(x['calificaciones']) / len(x['calificaciones'])
283 nombre = lambda x: x['nombre']
284
285 notables = list(map(lambda alumno: nombre(alumno) ,filter(lambda x: promedio(x) > 7,
entrada)))
286
287 # 3. Dada una lista de palabras, obtener una lista con las palabras que son
palíndromos
288 # palíndromo: una palabra que se lee de izquierda a derecha igual que de derecha a
izquierda
289 palabras = ['rajar', 'amar', 'radar', 'salar', 'alada', 'oro', 'arar']
290 palindromo= lambda palabra: palabra[::-1]==palabra
291 palabra=list(filter(palindromo,palabras))
292 palindromos = list(filter(lambda x: x == x[::-1], palabras)) # todas las posiciones
con paso -1
293
294 # 4. Define una función que dado un valor genere una lista con los números desde 1
hasta ese valor elevados al cuadrado
295
296 def cuadrado(numero):
297 lista=[]
298 for i in range(numero+1):
299 lista.append(i**2)
300 return lista
301 cuadrado(5)
302 cuadrados = lambda x: list(map(lambda y: y ** 2, range(1,x+1)))
303 cuadrados(5)
304
305 # 5. Define una función que devuelva las palabras mayores de 5 letras
306 palabras = ['HTML', 'CSS', 'JavaScript', 'Python', 'Ruby', 'PHP', 'SQL', 'Java',
'Swift', 'Objective-C' ]
307 longitud_mayor_5 = list(filter(lambda x: len(x) > 5, palabras))
308 print(longitud_mayor_5)
309
310 # 6. Define una función que retorne las palabras de una lista que contengan una letra
dada
311 palabras = ['HTML', 'CSS', 'JavaScript', 'Python', 'Ruby', 'PHP', 'SQL', 'Java',
'Swift', 'Objective-C' ]
312 contiene_letra = lambda letra, listado: list(filter(lambda x: letra in x, listado))
313 contiene_letra('a', palabras)
314
315 # 7. Define una función que dada una lista de palabras contatene todas con un '|'
mediante reduce
316 palabras = ['HTML', 'CSS', 'JavaScript', 'Python', 'Ruby', 'PHP', 'SQL', 'Java',
'Swift', 'Objective-C' ]
317 concatenadas = reduce(lambda acumulador, palabra: acumulador + '|' + palabra,
palabras)
318 concatenadas
319
320 '''
321 -----------------------
322 | | | |
323 | 1 | 2 | 3 |
324 | a b c | d e f | g h i |
325 -----------------------

6 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

326 | | | |
327 | 4 | 5 | 6 |
328 | j k l | m n o | p q r |
329 -----------------------
330 | | | |
331 | 7 | 8 | 9 |
332 | s t u | v w x | y z |
333 -----------------------
334
335 ejemplo:
336 3541 => hola
337 57525 => mundo
338 11455 => cajón, bajón, balón
339 Definir una función que dado un número, devuelva una lista con las palabras que se
pueden escribir en ese número
340 '''
341 teclado = { 'abc': 1, 'def': 2, 'ghi': 3, 'jkl': 4, 'mno': 5, 'pqr': 6, 'stu': 7,
'vwx': 8, 'yz': 9 }
342
343 letra_a_numero = lambda letra: str([teclado[key] for key in teclado.keys() if letra
in key][0])
344 version_numeral = lambda palabra: ''.join(list(map(letra_a_numero, palabra)))
345
346 valores = ['hola', 'mundo', 'cajon', 'bajon', 'balon', 'melon']
347
348 palabras_en_numero = lambda numero, palabras: [ palabra for palabra in palabras if
version_numeral(palabra) in str(numero) ]
349 #------------------------------------------------------------------------------------
---------------------------------------
350 cuadrados = [x**2 for x in range(1, 6)]
351
352 palabras = ["hola", "mundo", "python", "listas", "comprension"]
353 longitudes = [len(palabra) for palabra in palabras]
354 # Resultado: [4, 5, 6, 6, 12]
355
356 numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
357 pares = [x for x in numeros if x % 2 == 0]
358 # Resultado: [2, 4, 6, 8, 10]
359
360 # sintasix listas compresion --> nueva_lista = [expresion for elemento in
secuencia if condicion]
361 '''
362 Donde:
363
364 nueva_lista: es la lista resultante que se va a crear.
365 expresion: es una expresión que define cómo se va a modificar
cada elemento de la secuencia original para crear los elementos de la nueva lista.
366 elemento: es una variable que representa cada elemento de la
secuencia original.
367 secuencia: es una secuencia iterable, como una lista, tupla,
rango, etc.
368 condicion (opcional): es una condición que se evalúa para cada elemento de la
secuencia original. Solo los elementos que cumplan esta condición se incluirán en la
nueva lista.
369 '''
370
371 # Una función lambda en Python puede devolver cualquier tipo de expresión válida en
Python. Algunos ejemplos de expresiones comunes que puede devolver una función lambda
son
372 # Un valor numérico:

7 de 8 20/06/2023, 15:50
Repaso Programacion FUNCINAL.ipynb http://localhost:4649/?mode=python

373 cuadrado = lambda x: x**2

374 resultado = cuadrado(5) # Devuelve el valor numérico 25
375 #Una cadena de texto:
376 saludo = lambda nombre: "Hola, " + nombre
377 mensaje = saludo("Juan") # Devuelve la cadena "Hola, Juan"
378 # Una lista o tupla:
379 duplicar = lambda lista: [elemento * 2 for elemento in lista]
380 resultado = duplicar([1, 2, 3]) # Devuelve la lista [2, 4, 6]
381 #Un diccionario:
382 obtener_edad = lambda persona: persona.get('edad', 0)
383 edad = obtener_edad({'nombre': 'Juan', 'edad': 30}) # Devuelve el valor 30
384 #Una función:
385 operacion = lambda x, y: x + y if x > y else x - y
386 resultado = operacion(5, 3) # Devuelve el valor numérico 8
387
388

8 de 8 20/06/2023, 15:50