\n", "####
![\"AeroPython\"](\"../images/aeropython_logo.png\"){kind=logo}
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Secciones de arrays"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"_Hasta ahora sabemos cómo crear arrays y realizar algunas operaciones con ellos, sin embargo, todavía no hemos aprendido cómo acceder a elementos concretos del array_"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Arrays de una dimensión"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"arr = np.arange(10)\n",
"arr"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Accediendo al primer elemento\n",
"arr[0] "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"9"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Accediendo al último\n",
"arr[-1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### __¡Atención!__ "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NumPy devuelve __vistas__ de la sección que le pidamos, no __copias__. Esto quiere decir que debemos prestar mucha atención a este comportamiento:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3 4 5 6 7 8 9]\n",
"[5 6 7 8 9]\n"
]
}
],
"source": [
"arr = np.arange(10)\n",
"a = arr[5:]\n",
"\n",
"print(arr)\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0 1 2 3 4 999 6 7 8 9]\n",
"[999 6 7 8 9]\n"
]
}
],
"source": [
"arr[5] = 999\n",
"\n",
"print(arr)\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lo mismo ocurre al revés:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3 4 5 6 7 8 9]\n",
"[5 6 7 8 9]\n"
]
}
],
"source": [
"arr = np.arange(10)\n",
"a = arr[5:]\n",
"\n",
"print(arr)\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0 1 2 3 4 5 6 7 8 999]\n",
"[ 5 6 7 8 999]\n"
]
}
],
"source": [
"a[-1] = 999\n",
"\n",
"print(arr)\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`a` apunta a las direcciones de memoria donde están guardados los elementos del array `arr` que hemos seleccionado, no copia sus valores, a menos que explícitamente hagamos:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3 4 5 6 7 8 9]\n",
"[5 6 7 8 9]\n"
]
}
],
"source": [
"arr = np.arange(10)\n",
"a = arr[5:].copy()\n",
"\n",
"print(arr)\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0 1 2 3 4 999 6 7 8 9]\n",
"[5 6 7 8 9]\n"
]
}
],
"source": [
"arr[5] = 999\n",
"\n",
"print(arr)\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Arrays de dos dimensiones"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([[0, 1, 2],\n",
" [3, 4, 5],\n",
" [6, 7, 8]])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"arr = np.arange(9).reshape([3, 3])\n",
"arr"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"arr[0, -1]"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"arr[2, 2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Secciones de arrays"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hasta ahora hemos visto cómo acceder a elementos aislados del array, pero la potencia de NumPy está en poder acceder a secciones enteras. Para ello se usa la sintaxis `inicio:final:paso`: si alguno de estos valores no se pone toma un valor por defecto. Veamos ejemplos:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0., 1., 2., 3., 4., 5., 6., 7., 8.],\n",
" [ 9., 10., 11., 12., 13., 14., 15., 16., 17.],\n",
" [ 18., 19., 20., 21., 22., 23., 24., 25., 26.],\n",
" [ 27., 28., 29., 30., 31., 32., 33., 34., 35.]])"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M = np.arange(36, dtype=float).reshape(4, 9)\n",
"M"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 9., 10., 11., 12., 13., 14., 15., 16., 17.],\n",
" [ 18., 19., 20., 21., 22., 23., 24., 25., 26.]])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# De la segunda a la tercera fila, incluida\n",
"M[1:3]"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1., 3.],\n",
" [ 10., 12.]])"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Hasta la tercera fila sin incluir y de la segunda a la quinta columnas saltando dos\n",
"M[:2, 1:5:2]\n",
"#M[1:2:1, 1:5:2] # Equivalente"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Ejercicio"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pintar un tablero de ajedrez usando la función `plt.matshow`."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([[0, 1, 0, 1, 0, 1, 0, 1],\n",
" [1, 0, 1, 0, 1, 0, 1, 0],\n",
" [0, 1, 0, 1, 0, 1, 0, 1],\n",
" [1, 0, 1, 0, 1, 0, 1, 0],\n",
" [0, 1, 0, 1, 0, 1, 0, 1],\n",
" [1, 0, 1, 0, 1, 0, 1, 0],\n",
" [0, 1, 0, 1, 0, 1, 0, 1],\n",
" [1, 0, 1, 0, 1, 0, 1, 0]])"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tablero = np.zeros([8, 8], dtype=int)\n",
"\n",
"tablero[0::2, 1::2] = 1\n",
"tablero[1::2, 0::2] = 1\n",
"\n",
"tablero"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"![\"Licencia](\"http://i.creativecommons.org/l/by/4.0/88x31.png\")