Ayudantía 11 Programación Python

Ayudantía 10\1 Programación Python en la USM, 2011-2. Se ve materia y ejercicios sobre arreglos unidimensionales y bidimensionales usando la librería Numpy.

Transcript

1. Programación Ayudantía 11 Gonzalo Correa gonzalo.correa@alumnos.usm.cl @gonchimon 1 miércoles 14 de marzo de 12
2. Consultas sobre archivos? 2 miércoles 14 de marzo de 12
3. Arreglos 3 miércoles 14 de marzo de 12
4. Como listas, pero guardan un solo tipo de dato a la vez 4 miércoles 14 de marzo de 12
5. ...y tienen operaciones especiales para este tipo de dato 5 miércoles 14 de marzo de 12
6. Porque algo adicional a los tipos de datos que ya teníamos? 6 miércoles 14 de marzo de 12
7. Para hacer operaciones matemáticas mas eficientes y fáciles de programar! 7 miércoles 14 de marzo de 12
8. from numpy import array a = array([6, 1, 3, 9, 8]) b = array([6.0, 3, 4, 5, 7]) >>> a.astype(float) array([ 6., 1., 3., 9., 8.]) >>> a.astype(complex) array([ 6.+0.j, 1.+0.j, 3.+0.j, 9.+0.j, 8.+0.j]) # Las operaciones son elemento a elemento >>> a + b >>> a * b >>> a - b >>> a = array([55, 21, 19, 11, 9]) >>> a * 0.1 >>> a - 9.0 8 miércoles 14 de marzo de 12
9. a = array([5.1, 2.4, 3.8, 3.9]) b = array([4.2, 8.7, 3.9, 0.3]) c = array([5, 2, 4, 4]) + array([1, 4, -2, -1]) / 10.0 # Las comparaciones son elemento a elemento >>> a < b array([False, True, True, False], dtype=bool) >>> a == c array([True, True, True, True], dtype=bool) # Alguno? >>> any(a < b) True >>> any(a == b) False # Todos? >>> all(a == c) True 9 miércoles 14 de marzo de 12
10. a = array([4.1, 2.7, 8.4, pi, -2.5, 3, 5.2]) # Menor del arreglo >>> a.min() -2.5 # Mayor del arreglo >>> a.max() 8.4000000000000004 # Posición mínimo >>> a.argmin() 4 # Posición máximo >>> a.argmax() 2 # Suma de todos los valores >>> a.sum() 24.041592653589795 # Multiplicación de todos los valores >>> a.prod() -11393.086289208301 10 miércoles 14 de marzo de 12
11. # Array con ‘n’ ceros >>> zeros(6) array([ 0., 0., 0., 0., 0., 0.]) # Array con ‘n’ unos >>> ones(5) array([ 1., 1., 1., 1., 1.]) # Como range() pero con float >>> arange(3.0, 9.0) array([ 3., 4., 5., 6., 7., 8.]) # linspace(a, b, c), inicia en ‘a’, termina en # ‘b’, con ‘c’ elementos equiespaciados >>> linspace(1, 2, 5) array([ 1. , 1.25, 1.5 , 1.75, 2. ]) # Cálculo del seno de los valores generados x = linspace(0, pi/2, 9) >>> sin(x) array([ 0. , 0.19509032, 0.38268343, 0.55557023, 0.70710678, 0.83146961, 0.92387953, 0.98078528, 1. ]) 11 miércoles 14 de marzo de 12
12. Para obtener elementos usamos la misma notación de las listas, indicando la posición 12 miércoles 14 de marzo de 12
13. Y podemos sacar rebanadas! 13 miércoles 14 de marzo de 12
14. Arreglos Bidimensionales 14 miércoles 14 de marzo de 12
15. Son matrices (dos dimensiones) 15 miércoles 14 de marzo de 12
16. from numpy import * # Todas las filas del mismo largo a = array([[5.1, 7.4, 3.2, 9.9], [1.9, 6.8, 4.1, 2.3], [2.9, 6.4, 4.3, 1.4]]) # Filas, columnas >>> a.shape (3, 4) # Total de elementos >>> a.size 12 # Cantidad de filas >>> len(a) 3 16 miércoles 14 de marzo de 12
17. >>> a = array([[5, 1, 4], [0, 3, 2]]) >>> b = array([[2, 3, -1], [1, 0, 1]]) >>> a + 2 array([[7, 3, 6], [2, 5, 4]]) >>> a ** b array([[25, 1, 0], [ 0, 1, 2]]) 17 miércoles 14 de marzo de 12
18. # El formato siempre es (filas, columnas) >>> zeros((3, 2)) array([[ 0., 0.], [ 0., 0.], [ 0., 0.]]) >>> ones((2, 5)) array([[ 1., 1., 1., 1., 1.], [ 1., 1., 1., 1., 1.]]) >>> random((5, 2)) array([[ 0.80177393, 0.46951148], [ 0.37728842, 0.72704627], [ 0.56237317, 0.3491332 ], [ 0.35710483, 0.44033758], [ 0.04107107, 0.47408363]]) 18 miércoles 14 de marzo de 12
19. Acceder a elementos de una matriz requiere indicar fila-columna 19 miércoles 14 de marzo de 12
20. >>> a = array([[ 3.21, 5.33, 4.67, 6.41], [ 9.54, 0.30, 2.14, 6.57], [ 5.62, 0.54, 0.71, 2.56], [ 8.19, 2.12, 6.28, 8.76], [ 8.72, 1.47, 0.77, 8.78]]) >>> a[4, 3] 8.78 >>> a[0, -1] 6.41 20 miércoles 14 de marzo de 12
21. Y nuevamente, podemos usar rebanadas 21 miércoles 14 de marzo de 12
22. >>> a[2:3, 1:4] array([[ 0.54, 0.71, 2.56]]) >>> a[1:4, 0:4] array([[ 9.54, 0.3 , 2.14, 6.57], [ 5.62, 0.54, 0.71, 2.56], [ 8.19, 2.12, 6.28, 8.76]]) >>> a[1:3, 2] array([ 2.14, 0.71]) >>> a[0:4:2, 3:0:-1] array([[ 6.41, 4.67, 5.33], [ 2.56, 0.71, 0.54]]) >>> a[::4, ::3] array([[ 3.21, 6.41], [ 8.72, 8.78]]) 22 miércoles 14 de marzo de 12
23. # Toda una fila >>> a[2, :] array([ 5.62, 0.54, 0.71, 2.56]) # Toda una columna >>> a[:, 3] array([ 6.41, 6.57, 2.56, 8.76, 8.78]) # Notar los diferentes resultados >>> a[2, 3] 2.56 >>> a[2:3, 3] array([ 2.56]) >>> a[2:3, 3:4] array([[ 2.56]]) 23 miércoles 14 de marzo de 12
24. Otros métodos útiles array.transpose() Intercambiar filas con columnas. array.reshape((row, col)) Mismos elementos que ‘array’, pero con la forma dada por ‘row’ y ‘col’. diag(array, col) Entrega la diagonal de ‘array’, empezando en la columna ‘col’ (por defecto cero). Si ‘array’ es un arreglo de una dimensión, retorna una matriz con ‘array’ en la diagonal. 24 miércoles 14 de marzo de 12
25. Otro métodos útiles dot(array_1, array_2) Entrega la multiplicación entre ‘array_1’ y ‘array_2’. El resultado retornado depende del tipo de cada dato array_1 array_2 Resultado vector vector número matriz vector vector matriz matriz matriz 25 miércoles 14 de marzo de 12
26. Ejercicios 26 miércoles 14 de marzo de 12
27. Transmisión de Datos En varios sistemas de comunicaciones digitales, los datos viajan de manera serial (en “fila”), y en bloques (conjuntos) de una cantidad fija de bits. Esto es a nivel lógico, pero a nivel físico (cables), no hay concepto de bloques o bits! Para organizar los datos recibidos, es necesario usar programas que lo hagan. Los datos transmitidos/recibidos los representaremos como arreglos con ceros y unos (bits) 27 miércoles 14 de marzo de 12
28. Transmisión de Datos Una secuencia de bits puede interpretarse como número decimal, como se muestra a continuación 01001 = 0·24 + 1·23 + 0·22 + 0·21 + 1·20 = 9 Escribir la función numero_decimal(datos) que entregue la representación decimal de un arreglo de datos >>> a = array([0, 1, 0, 0, 1]) >>> numero_decimal(a) 9 28 miércoles 14 de marzo de 12
29. Transmisión de Datos Suponiendo que el tamaño de los bloques es de 4 bits, escribir la función bloque_valido(datos) que verifique que un stream de datos tiene una cantidad entera de bloques >>> bloque_valido(array([0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0])) True >>> bloque_valido(array([0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1])) False 29 miércoles 14 de marzo de 12
30. Transmisión de Datos Escribir la función decodificar_bloques(datos) que entregue un arreglo con la representación númerica de cada bloque. Si un bloque está incompleto, esto debe indicarse con el valor -1. >>> a = array([0, 1, 0, 1]) >>> b = array([0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0]) >>> c = array([0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1]) >>> decodificar_bloques(a) array([5]) >>> decodificar_bloques(b) array([5, 7, 2]) >>> decodificar_bloques(c) array([5, 7, 2, -1]) 30 miércoles 14 de marzo de 12
31. Transmisión de Datos Desafío: Ahora cada bloque puede ser un número positivo y negativo, usando bloques de 5 bits. Como representar los números negativos? Como tratar los bloques incompletos? 31 miércoles 14 de marzo de 12
32. Sudoku El sudoku es un juego en el que se cuenta con una grilla de 9x9, dividida en 9 regiones de 3x3, las que deben ser llenadas con números del 1 al 9. Las reglas son: Ningún número puede estar repetido en una misma fila o columna Cada región debe tener solo una vez cada número del 1 al 9 32 miércoles 14 de marzo de 12
33. Sudoku Crear un programa para llenar la grilla, sin considerar las reglas del juego. Esto debe realizarse con arreglos Crear la función solucion_es_correcta(sudoku) que indique si solución dada en la grilla ‘sudoku’ es correcta, es decir, sigue las reglas del juego. 33 miércoles 14 de marzo de 12
34. Sudoku from numpy import array sr = array([[4, 2, 6, 5, 7, 1, 3, 9, 8], [8, 5, 7, 2, 9, 3, 1, 4, 6], [1, 3, 9, 4, 6, 8, 2, 7, 5], [9, 7, 1, 3, 8, 5, 6, 2, 4], [5, 4, 3, 7, 2, 6, 8, 1, 9], [6, 8, 2, 1, 4, 9, 7, 5, 3], [7, 9, 4, 6, 3, 2, 5, 8, 1], [2, 6, 5, 8, 1, 4, 9, 3, 7], [3, 1, 8, 9, 5, 7, 4, 6, 2]]) >>> solucion_es_correcta(s) True >>> s[0, 0] = 9 >>> solucion_es_correcta(s) False 34 miércoles 14 de marzo de 12
35. Buscaminas En el buscaminas se tiene una grilla rectangular, en donde algunas casillas tienes minas. El juego consiste en encontrar todas las casillas que no tienen minas. Para representar esta grilla, se puede ocupar un arreglo en donde las minas sean -1, y las casillas vacías sean 0 35 miércoles 14 de marzo de 12
36. Buscaminas >>> from numpy import * >>> campo = array([[ 0, 0, -1, 0, 0, 0, 0, 0], [-1, 0, 0, 0, -1, 0, 0, 0], [ 0, 0, 0, 0, -1, 0, 0, -1], [ 0, 0, -1, 0, 0, 0, 0, 0], [ 0, 0, 0, 0, 0, 0, -1, 0], [ 0, -1, 0, 0, -1, 0, 0, 0], [ 0, 0, -1, 0, 0, 0, 0, 0], [ 0, 0, 0, 0, 0, 0, 0, 0]]) 36 miércoles 14 de marzo de 12
37. Buscaminas Escribir la función crear_campo(forma, n) que retorne un nuevo campo aleatorio con la forma indicada, que tenga ‘n’ minas y ‘forma’ sea una tupla de la forma (filas, columnas) >>> crear_campo((4, 4), 5) array([[-1, 0, 0, 0], [ 0, 0, 0, 0], [ 0, -1, -1, 0], [ 0, -1, -1, 0]]) >>> crear_campo((4, 4), 5) array([[ 0, 0, -1, 0], [ 0, 0, 0, -1], [-1, 0, 0, 0], [ 0, 0, -1, -1]]) >>> crear_campo((4, 4), 5) array([[ 0, 0, 0, -1], [ 0, 0, -1, -1], [-1, 0, 0, 0], [ 0, 0, -1, 0]]) 37 miércoles 14 de marzo de 12
38. Buscaminas Al descubrir una casilla no minada, en ella aparece la cantidad de minas que hay en sus ocho casillas vecinas. Escribir la función descubrir(campo) que modifique el campo poniendo en cada casilla la cantidad de minas vecinas. >>> c = crear_campo((4, 4), 5) >>> c array([[ 0, 0, -1, -1], [ 0, 0, -1, 0], [ 0, 0, 0, -1], [ 0, 0, 0, -1]]) >>> descubrir(c) >>> c array([[ 0, 2, -1, -1], [ 0, 2, -1, 4], [ 0, 1, 3, -1], [ 0, 0, 2, -1]]) 38 miércoles 14 de marzo de 12