Ayudantía 11 Programación Python

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.

3f4a05fa73be3e28667149056fbd50a1?s=128

Gonzalo Correa

March 14, 2012
Tweet

Transcript

  1. 4.

    Como listas, pero guardan un solo tipo de dato a

    la vez 4 miércoles 14 de marzo de 12
  2. 6.

    Porque algo adicional a los tipos de datos que ya

    teníamos? 6 miércoles 14 de marzo de 12
  3. 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
  4. 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
  5. 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
  6. 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
  7. 12.

    Para obtener elementos usamos la misma notación de las listas,

    indicando la posición 12 miércoles 14 de marzo de 12
  8. 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
  9. 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
  10. 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
  11. 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
  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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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