2/24/23, 12:00 AM Copia de colab-tutorial.

ipynb - Colaboratorio

Tutorial de Python CS231n con Google Colab

Este tutorial fue escrito originalmente porJustin Johnsonpara cs231n. Fue adaptado como un Jupyter
cuaderno para cs228 porVolodymyr KuleshovyIsaac Caswell.

Esta versión ha sido adaptada para Colab por Kevin Zakka para la edición de primavera de 2020 decs231n. Esto
ejecuta Python3 por defecto.

Introducción

Python es un gran lenguaje de programación de propósito general por sí mismo, pero con la ayuda de unos pocos
las bibliotecas populares (numpy, scipy, matplotlib) se convierten en un entorno poderoso para la ciencia
computación.

Esperamos que muchos de ustedes tengan algo de experiencia con Python y numpy; para el resto de ustedes,
esta sección servirá como una rápida introducción tanto al lenguaje de programación Python como a
el uso de Python para la computación científica.

Algunos de ustedes pueden tener conocimientos previos en Matlab, en cuyo caso también recomendamos el
página de numpy para usuarios de Matlab ([Link]
[Link]).

En este tutorial, cubriremos:

Python básico: Tipos de datos básicos (Contenedores, Listas, Diccionarios, Conjuntos, Tuplas), Funciones,
Clases
Numpy: Arrays, Array indexing, Datatypes, Array math, Broadcasting
Matplotlib: Graficación, Subgráficas, Imágenes
IPython: Creando cuadernos, Flujos de trabajo típicos

[Link] 1/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

Una breve nota sobre las versiones de Python

A partir del 1 de enero de 2020, Python tieneoficialmente dejó de ofrecer soporteparapython2. Estaremos usando Python 3.7
para esta iteración del curso. Puedes comprobar tu versión de Python en la línea de comandos ejecutando
python --versión. En Colab, podemos imponer la versión de Python haciendo clic enRuntime -> Change
Tipo de Tiempo de Ejecucióny seleccionandopython3Tenga en cuenta que a partir de abril de 2020, Colab utiliza Python 3.6.9 que
debería ejecutar todo sin errores.

!python --versión

Python 3.6.9

Conceptos básicos de Python

Python es un lenguaje de programación de alto nivel, de tipado dinámico y multiparadigma. El código de Python es

a menudo se dice que es casi como pseudocódigo, ya que te permite expresar ideas muy poderosas en muy
pocas líneas de código mientras son muy legibles. Como ejemplo, aquí hay una implementación de la
algoritmo clásico de quicksort en Python:

def ordenacionRapida(arr):
si len(arr) <= 1:
devuelve arr
pivot = arr[len(arr) // 2]
izquierda = [x para x en arr si x < pivote]
medio = [x for x in arr if x == pivote]
derecho = [x para x en arr si x > pivote]
retornar quicksort(izquierda) + medio + quicksort(derecha)

imprimir(ordenar rápido([3,6,8,10,1,2,1]))

[1, 1, 2, 3, 6, 8, 10]

Tipos de datos básicos

Números

Los enteros y los flotantes funcionan como cabría esperar de otros lenguajes:

[Link] 2/26
24/02/23, 12:00 AM Copia de [Link] - Colaboratorio

x=3
imprimir(x, tipo(x))

3 <clase 'int'>
¡ERROR! El número de sesión/línea no era único en la base de datos. El registro de historial se trasladó a una nueva sesión.

imprimir(x + 1) Adición
imprimir(x - 1) # Subtraction
print(x * 2) Multiplicación
print(x ** 2) # Exponenciación

4
2
6
9

x += 1
imprimir(x)
x *= 2
imprimir(x)

9
18

y = 2.5
imprimir(tipo(y))
print(y, y + 1, y * 2, y ** 2)

<clase 'flotante'>
2.5 3.5 5.0 6.25

Ten en cuenta que a diferencia de muchos lenguajes, Python no tiene incremento unario (x++) o decremento (x--).
operadores.

Python también tiene tipos incorporados para enteros largos y números complejos; puedes encontrar todos los detalles
en eldocumentación.

Booleanos

Python implementa todos los operadores habituales para la lógica booleana, pero utiliza palabras en inglés en lugar de

símbolos (&&, ||, etc.):

t, f = True, False
print(type(t))

[Link] 3/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

<clase 'bool'>

Ahora vamos a examinar las operaciones:

print(t y f) # Y lógico;
print(t o f) # OR lógico;
print(no t) # No lógico;
print(t != f) # XOR lógico;

Falso
Verdadero
Falso
Verdadero

Cadenas

hello = 'hello' # Las cadenas literales pueden usar comillas simples

world = "world" # o comillas dobles; no importa
imprimir(hola, len(hola))

hola 5

hw = hola + ' ' + mundo # Concatenación de cadenas

imprimir(hw)

hola mundo

hw12 = '{} {} {}'.format(hola, mundo, 12) # formato de cadena

imprimir(hw12)

hola mundo 12

Los objetos String tienen un montón de métodos útiles; por ejemplo:

hola
print([Link]()) # Capitaliza una cadena
print([Link]()) Convierte una cadena a mayúsculas; imprime 'HOLA'
print([Link](7)) Justificar a la derecha una cadena, rellenando con espacios
print([Link](7)) # Centrar una cadena, rellenando con espacios
print([Link]('l', '(ell)')) # Reemplazar todas las instancias de una subcadena con otra
print(' mundo '.strip()) # Eliminar espacios en blanco al principio y al final

Hola
HOLA
hola

[Link] 4/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

hola
h(e)(e)l(o)
mundo

You can nd a list of all string methods in the documentación.

Contenedores

Python incluye varios tipos de contenedores integrados: listas, diccionarios, conjuntos y tuplas.

Listas

Una lista es el equivalente en Python de un arreglo, pero es redimensionable y puede contener elementos de diferentes tipos.

types:

xs = [3, 1, 2] Crear una lista

imprimir(xs, xs[2])
print(xs[-1]) # Los índices negativos cuentan desde el final de la lista; imprime "2"

[3, 1, 2] 2
2

xs[2] = 'foo' # Las listas pueden contener elementos de diferentes tipos

imprimir(xs)

[3, 1, 'foo']

[Link]('bar') # Agrega un nuevo elemento al final de la lista

imprimir(xs)

[3, 1, 'foo', 'bar']

x = [Link]() Eliminar y devolver el último elemento de la lista

imprimir(x, xs)

bar [3, 1, 'foo']

Como de costumbre, puedes encontrar todos los espantosos detalles sobre las listas en eldocumentación.

Corte

[Link] 5/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

Además de acceder a los elementos de la lista uno a la vez, Python proporciona una sintaxis concisa para acceder

sublistas; esto se conoce como segmentación:

nums = lista(range(5)) # range es una función incorporada que crea una lista de enteros
imprimir(nums) # Imprime "[0, 1, 2, 3, 4]"
print(nums[2:4]) # Obtiene una porción desde el índice 2 hasta el 4 (exclusivo); imprime "[2, 3]"
print(nums[2:]) # Obtiene un segmento desde el índice 2 hasta el final; imprime "[2, 3, 4]"
print(nums[:2]) # Obtiene una porción desde el inicio hasta el índice 2 (exclusivo); imprime "[0, 1]"
imprimir(nums[:]) # Obtén una porción de toda la lista; imprime ["0, 1, 2, 3, 4"]
print(nums[:-1]) # Los índices de los cortes pueden ser negativos; imprime ["0, 1, 2, 3"]
nums[2:4] = [8, 9] # Asignar una nueva sublista a un corte
imprimir(nums) Imprime "[0, 1, 8, 9, 4]"

[0, 1, 2, 3, 4]
[2, 3]
[2,3,4]
[0, 1]
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0,1,8,9,4]

Bucles

Puedes recorrer los elementos de una lista así:

animals = ['cat', 'dog', 'monkey']

por animal en animales:
imprimir(animal)

gato
perro
mono

Si quieres acceso al índice de cada elemento dentro del cuerpo de un bucle, usa el integrado
enumerarfunción:

animals = ['cat', 'dog', 'monkey']

para idx, animal en enumerar(animales):
print('#{}: {}'.format(idx + 1, animal))

gato
perro
mono

Comprensiones de listas:
[Link] 6/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

Al programar, a menudo queremos transformar un tipo de dato en otro. Como un simple

ejemplo, considera el siguiente código que calcula números cuadrados:

nums = [0, 1, 2, 3, 4]
squares = []
para x en nums:
[Link](x ** 2)
imprimir(cuadrados)

[0, 1, 4, 9, 16]

Puedes simplificar este código utilizando una comprensión de lista.

nums = [0, 1, 2, 3, 4]
cuadrados = [x ** 2 para x en nums]
imprimir(cuadrados)

[0,1,4,9,16]

Las comprensiones de listas también pueden contener condiciones:

nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(cuadrados_pares)

[0,4,16]

Diccionarios

Un diccionario almacena pares (clave, valor), similar a unMapaen Java o un objeto en Javascript. Puedes usar
es así:

d = {'cat': 'cute', 'dog': 'furry'} # Create a new dictionary with some data
imprimir(d['gato']) Obtén una entrada de un diccionario; imprime "lindo"
print('gato' in d) Verifica si un diccionario tiene una clave dada; imprime "Verdadero"

lindo
Verdadero

d['fish'] = 'wet' Establecer una entrada en un diccionario

imprimir(d['pez']) Imprime "mojado"

[Link] 26/7
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

mojado

print(d['mono']) # KeyError: 'mono' no es una clave de d

---------------------------------------------------------------------------
Error de clave Traza (llamada más reciente al final)
<ipython-input-31-78fc9745d9cf>en<module>()
----> 1print(d['mono'])# KeyError: 'mono' no es una clave de d

KeyError: 'monkey'

BUSCAR STACK OVERFLOW

print([Link]('mono', 'N/A')) # Obtiene un elemento con un valor por defecto; imprime 'N/A'
imprimir([Link]('pez', 'N/A')) Obtén un elemento con un valor predeterminado; imprime "mojado"

N/A
mojado

del d['pescado'] Eliminar un elemento de un diccionario

print([Link]('fish', 'N/A')) # "fish" ya no es una clave; imprime "N/A"

N/A

Puedes encontrar todo lo que necesitas saber sobre diccionarios en eldocumentación.

Es fácil iterar sobre las claves en un diccionario:

d = {'person': 2, 'cat': 4, 'spider': 8}

para animal, patas en [Link]():
print('Un {} tiene {} patas'.format(animal, legs))

Una persona tiene 2 piernas

Un gato tiene 4 patas
Una araña tiene 8 patas

Comprensiones de diccionarios: Estas son similares a las comprensiones de listas, pero te permiten hacerlo fácilmente.

construir diccionarios. Por ejemplo:

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
imprimir(cuadrado_num_par)

{0: 0, 2: 4, 4: 16}

[Link] 26/8
24/02/23, 12:00 AM Copia de [Link] - Colaboratory

Conjuntos

Un conjunto es una colección desordenada de elementos distintos. Como un ejemplo simple, considera lo siguiente:

animals = {'cat', 'dog'}

Comprueba si un elemento está en un conjunto; imprime "True"
imprimir('gato' en animales)
print('pez' in animales) # imprime "Falso"

Verdadero
Falso

[Link]('pez') Agregar un elemento a un conjunto

print('pez' en animales)
print(len(animals)) Número de elementos en un conjunto;

Verdadero
3

[Link]('gato') Agregar un elemento que ya está en el conjunto no hace nada

print(len(animals))
[Link]('gato') # Eliminar un elemento de un conjunto
imprimir(len(animals))

3
2

Los bucles: Iterar sobre un conjunto tiene la misma sintaxis que iterar sobre una lista; sin embargo, dado que los conjuntos son
desordenado, no puedes hacer suposiciones sobre el orden en el que visitas los elementos del conjunto:

animals = {'cat', 'dog', 'fish'}

para idx, animal en enumerar(animals):
print('#{}: {}'.format(idx + 1, animal))

perro
gato
pescado

Comprensiones de conjuntos: Al igual que las listas y los diccionarios, podemos construir fácilmente conjuntos utilizando set

comprehensions:

de matemáticas importación raiz

imprimir({int(raíz_cuadrada(x)) para x en rango(30)})

[Link] 26/9
24/02/23, 12:00 AM Copia de [Link] - Colaboratorio

{0, 1, 2, 3, 4, 5}

Tuplas

Una tupla es una lista de valores (inmutable) ordenada. Una tupla es en muchos aspectos similar a una lista; uno de los
las diferencias más importantes son que las tuplas se pueden usar como claves en diccionarios y como elementos de
conjuntos, mientras que las listas no pueden. Aquí hay un ejemplo trivial:

d = {(x, x + 1): x for x in range(10)} # Crear un diccionario con claves de tupla

t = (5, 6) Crear una tupla
print(type(t))
imprimir(d[t])
imprimir(d[(1, 2)])

<clase 'tupla'>
5
1

t[0] = 1

---------------------------------------------------------------------------
TypeErrorTraceback (última llamada más reciente)
<ipython-input-43-c8aeb8cd20ae> en <módulo>()
1t[0] =1

TypeError: 'tuple' object does not support item assignment

BUSCAR STACK OVERFLOW

Funciones

Las funciones de Python se definen utilizando eldefpalabra clave. Por ejemplo:

def sign(x):
si x > 0:
devuelve 'positivo'
elif x < 0:
devolver 'negativo'
sino:
cero

para x en [-1, 0, 1]:

imprimir(signo(x))

[Link] 26/10
24/02/23, 12:00 AM Copia de [Link] - Colaboratorio

negativo
cero
positivo

A menudo definiremos funciones para tomar argumentos de palabras clave opcionales, así:

def hola(nombre, ruidoso=False):

si es ruidoso:

print('HOLA, {}'.format([Link]()))
sino:
print('¡Hola, {}!'.format(nombre))

hola('Bob')
hola('Fred', ruidoso=True)

¡Hola, Bob!
HOLA, FRED

Clases

La sintaxis para definir clases en Python es sencilla:

clase Saludo:

Constructor
def __init__(self, nombre):
[Link] = name # Crear una variable de instancia

Método de instancia
def saludar(self, ruidoso=False):
si ruidoso:
print('HOLA, {}'.format([Link]()))
sino:
print('¡Hola, {}!'.format([Link]))

g = Greeter('Fred') # Construir una instancia de la clase Greeter

[Link]() Llama a un método de instancia; imprime "Hola, Fred"
[Link](loud=True) # Call an instance method; prints "HELLO, FRED!"

¡Hola, Fred!
HOLA, FRED

Numpy

[Link] 11/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratory

Numpy es la biblioteca principal para la computación científica en Python. Proporciona un alto rendimiento.
objeto de arreglo multidimensional, y herramientas para trabajar con estos arreglos. Si ya estás familiarizado
con MATLAB, podrías encontrar estotutorialútil para empezar con Numpy.

Para usar Numpy, primero necesitamos importar elnumpypaquete:

importar numpy como np

Arreglos

Un array de numpy es una cuadrícula de valores, todos del mismo tipo, y se indexa mediante una tupla de números no negativos.

números enteros. El número de dimensiones es el rango del arreglo; la forma de un arreglo es una tupla de
enteros que indican el tamaño del arreglo a lo largo de cada dimensión.

Podemos inicializar arreglos de numpy a partir de listas anidadas de Python y acceder a los elementos utilizando corchetes.

corchetes

a = [Link]([1, 2, 3]) # Crear un arreglo de rango 1

print(type(a), [Link], a[0], a[1], a[2])
a[0] = 5 Cambiar un elemento del array
imprimir(a)

<clase '[Link]'> (3,) 1 2 3

[5 2 3]

b = [Link]([[1,2,3],[4,5,6]]) Crea un array de rango 2

imprimir(b)

[[1 2 3]
[4 5 6]]

imprimir([Link])
imprimir(b[0, 0], b[0, 1], b[1, 0])

(2, 3)
124

Numpy también proporciona muchas funciones para crear arreglos:

[Link] 12/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

a = [Link]((2,2)) # Crea un array de ceros

imprimir(a)

[[0. 0.]
[0. 0.]

b = [Link]((1,2)) Crea un arreglo de unos

imprimir(b)

[[1. 1.]]

c = [Link]((2,2), 7) # Crear un arreglo constante

imprimir(c)

[[7 7]
[7 7]

d = [Link](2) Crea una matriz identidad de 2x2

imprimir(d)

[[1. 0.] ]
[0. 1.]

e = [Link]((2,2)) # Crear un arreglo lleno de valores aleatorios

imprimir(e)

[[0.8690054 0.57244319]
[0.29647245 0.81464494]

Indexación de arreglos

Numpy ofrece varias maneras de indexar en arreglos.

Corte: Similar a las listas de Python, los arreglos de numpy pueden ser cortados. Dado que los arreglos pueden ser multidimensionales,

you must specify a slice for each dimension of the array:

importar numpy como np

# Crea el siguiente array de rango 2 con forma (3, 4)

# [[ 1 2 3 4]
# [5 6 7 8
# [ 9 10 11 12
a = [Link]([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

Utiliza el slicing para extraer el subarreglo que consiste en las 2 primeras filas

[Link] 13/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

# y las columnas 1 y 2; b es el siguiente arreglo de forma (2, 2):

# [[2 3]
# [6 7]
b = a[:2, 1:3]
imprimir(b)

[[2 3]
[6 7]]

Una porción de un array es una vista de los mismos datos, por lo que modificarla modificará el array original.

imprimir(a[0, 1])
b[0, 0] = 77 # b[0, 0] es la misma pieza de datos que a[0, 1]
imprimir(a[0, 1])

2
77

También puedes mezclar la indexación entera con la indexación por porciones. Sin embargo, hacerlo dará como resultado un array de menor

clasificación que la matriz original. Tenga en cuenta que esto es bastante diferente de la forma en que MATLAB maneja las matrices

slicing:

Crea el siguiente arreglo de rango 2 con forma (3, 4)

a = [Link]([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
imprimir(a)

[]
[ 5 6 7 8]
[ 9 10 11 12]

Dos formas de acceder a los datos en la fila del medio del arreglo. Mezclando indexación entera con rebanadas.
produce un arreglo de menor rango, mientras que usar solo rebanadas produce un arreglo del mismo rango que el original
arreglo:

row_r1 = a[1, :] Vista de rango 1 de la segunda fila de un

row_r2 = a[1:2, :] # Vista de rango 2 de la segunda fila de a
row_r3 = a[[1], :] # Vista de rango 2 de la segunda fila de a
imprimir(row_r1, row_r1.shape)
imprimir(row_r2, row_r2.shape)
imprimir(row_r3, fila_r3.shape)

[5 6 7 8] (4,)
[[5 6 7 8]] (1, 4)
[[5 6 7 8]] (1, 4)

[Link] 14/26
24/02/23, 12:00 AM Copia de [Link] - Colaboratorio

Podemos hacer la misma distinción al acceder a las columnas de un array:

col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape)
imprimir()
imprimir(col_r2, col_r2.shape)

[ 2 6 10] (3,)

[[ 2]
[6]
[10]] (3, 1)

Indexación de arreglos enteros: Cuando indexas en arreglos numpy utilizando rebanado, la vista del arreglo resultante será
siempre será un subarreglo del arreglo original. En contraste, el indexado de arreglos enteros te permite construir
arreglos arbitrarios utilizando los datos de otro arreglo. Aquí hay un ejemplo:

a = [Link]([[1,2], [3, 4], [5, 6]])

Un ejemplo de indexación de arreglos enteros.

El array devuelto tendrá forma (3,) y
imprimir(a[[0, 1, 2], [0, 1, 0]])

El ejemplo anterior de indexación de arreglos enteros es equivalente a esto:

print([Link]([a[0, 0], a[1, 1], a[2, 0]]))

[1 4 5]
[1 4 5]

Cuando utilizas el índice de un array entero, puedes reutilizar el mismo

# elemento del arreglo fuente:
imprimir(a[[0, 0], [1, 1]])

Equivalente al ejemplo anterior de indexación de arreglos enteros

imprimir([Link]([a[0, 1], a[0, 1]]))

[2 2]
[2 2]

Un truco útil con la indexación de arreglos enteros es seleccionar o mutar un elemento de cada fila de un
matrix:

Crea un nuevo arreglo del cual seleccionaremos elementos

a = [Link]([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
imprimir(a)

[Link] 15/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]

Crea un array de índices

b = [Link]([0, 2, 0, 1])

Seleccione un elemento de cada fila de a utilizando los índices en b

imprimir(a[[Link](4), b]) # Imprime "[ 1 6 7" 11]

[ 1 6 7 11]

Mutar un elemento de cada fila de a utilizando los índices en b

a[[Link](4), b] += 10
imprimir(a)

[[11 2 3]
[ 4 5 16]
[17 8 9]
[10 21 12]]

Indexación de arreglos booleanos: La indexación de arreglos booleanos te permite seleccionar elementos arbitrarios de un arreglo.

Frecuentemente, este tipo de indexación se utiliza para seleccionar los elementos de un arreglo que satisfacen alguna

condición. Aquí hay un ejemplo:

importar numpy como np

a = [Link]([[1,2], [3, 4], [5, 6]])

bool_idx = (a > 2) # Encontrar los elementos de a que son mayores que 2;

esto devuelve un array de numpy de Booleans del mismo
# forma como a, donde cada espacio de bool_idx indica
si ese elemento de a es > 2.

imprimir(bool_idx)

[[Falso Falso]
[ Verdadero Verdadero]
[ Verdadero Verdadero ]

[Link] 16/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio
Usamos la indexación de arreglos booleanos para construir un arreglo de rango 1
consistiendo en los elementos de un correspondiente a los valores Verdaderos
# of bool_idx
imprimir(a[bool_idx])

Podemos hacer todo lo anterior en una sola declaración concisa:

imprimir(a[a > 2])

[3 4 5 6]
[3 4 5 6]

Por brevedad, hemos omitido muchos detalles sobre el indexado de matrices de numpy; si deseas saber más
deberías leer la documentación.

Tipos de datos

Cada arreglo de numpy es una cuadrícula de elementos del mismo tipo. Numpy proporciona un gran conjunto de numéricos

tipos de datos que puedes usar para construir arreglos. Numpy intenta adivinar un tipo de dato cuando creas
un arreglo, pero las funciones que construyen arreglos generalmente también incluyen un argumento opcional para explícitamente

specify the datatype. Here is an example:

x = [Link]([1, 2]) # Deja que numpy elija el tipo de dato

y = [Link]([1.0, 2.0]) # Deja que numpy elija el tipo de dato
z = [Link]([1, 2], dtype=np.int64) # Forzar un tipo de dato particular

print([Link], [Link], [Link])

int64 float64 int64

Puedes leer todo sobre los tipos de datos de numpy en eldocumentación.

Array math

Las funciones matemáticas básicas operan elemento a elemento en matrices, y están disponibles tanto como operadores.

sobrecargas y funciones como en el módulo numpy:

x = [Link]([[1,2],[3,4]], dtype=np.float64)
y = [Link]([[5,6],[7,8]], dtype=np.float64)

Suma elemento a elemento; ambos producen el arreglo

[Link] 17/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

imprimir(x + y)
[[ 6. 8.]]
imprimir([Link](x, y))
[10. 12.]
[[ 6. 8.]
[10. 12.]

Diferencia elemento a elemento; ambos producen el arreglo

imprimir(x - y)
imprimir([Link](x, y))

[[-4. -4.]
[-4. -4.]
[[-4. -4.]
[-4. -4.]

# Producto elemento a elemento; ambos producen el arreglo

imprimir(x * y)
imprimir([Link](x, y))

[[ 5. 12. ]]
[21. 32.]
[[ 5. 12.]]
[21. 32.]

División elemento a elemento; ambos producen el arreglo

# [[ 0.2 0.33333333
# [ 0.42857143 0.5 ]]
imprimir(x / y)
imprimir([Link](x, y))

[[0.2 0.33333333
[0.42857143 0.5 ] ]]
0.2 0.33333333
[0.42857143 0.5] ]]

Raíz cuadrada elemento a elemento; produce el array

# [[ 1. 1.41421356
# [ 1.73205081 2. ]]
imprimir([Link](x))

[[1. 1.41421356]
[1.73205081 2. ]]

Ten en cuenta que a diferencia de MATLAB,* es multiplicación elemento a elemento, no multiplicación de matrices. En su lugar
utiliza la función punto para calcular productos internos de vectores, para multiplicar un vector por una matriz y para
multiplicar matrices. el producto punto está disponible tanto como una función en el módulo numpy como una instancia

método de objetos de arreglo:

[Link] 18/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

x = [Link]([[1,2],[3,4]])
y = [Link]([[5,6],[7,8]])

v = [Link]([9,10])
w = [Link]([11, 12])

Producto interno de vectores; ambos producen 219

imprimir([Link](w))
imprimir([Link](v, w))

219
219

También puedes usar el@ operador que es equivalente a numpy'spuntooperador.

print(v @ w)

219

# Producto de matriz / vector; ambos producen el arreglo de rango 1 [29 67]

imprimir([Link](v))
imprimir([Link](x, v))
imprimir(x @ v)

[29 67]
[29 67]
[29 67]

# Matriz / producto de matrices; ambos producen un arreglo de rango 2

# [[19 22]
# [43 50]
imprimir([Link](y))
imprimir([Link](x, y))
imprimir(x @ y)

[[19 22]]
[43 50]
[[19 22]
[43 50]]
[[19 22]
[43 50]]

Numpy proporciona muchas funciones útiles para realizar cálculos en arreglos; una de las más
útil essuma:

x = [Link]([[1,2],[3,4]])

[Link] 19/26
24/02/23, 12:00 AM Copy of [Link] - Colaboratory

print([Link](x)) # Calcular la suma de todos los elementos; imprime "10"

print([Link](x, axis=0)) # Calcula la suma de cada columna; imprime "[4 6]"
print([Link](x, axis=1)) # Calcular la suma de cada fila; imprime "[3 7]"
10
[4 6]
[3 7]

Puedes encontrar la lista completa de funciones matemáticas proporcionadas por numpy en eldocumentación.

Aparte de calcular funciones matemáticas utilizando matrices, frecuentemente necesitamos cambiar la forma o
de lo contrario, manipule datos en arreglos. El ejemplo más simple de este tipo de operación es la transposición
una matriz; para transponer una matriz, simplemente usa el atributo T de un objeto array:

imprimir(x)
print("transponer\n", x.T)

[[1 2]]
[3 4]]
transponer
[[1 3]
[2 4]

v = [Link]([[1,2,3]])
imprimir(v)
print("transponer\n", v.T)

[[1 2 3]]
transponer
[[1]
[2]
[3]

Transmisión

La transmisión es un mecanismo poderoso que permite a numpy trabajar con matrices de diferentes formas.
al realizar operaciones aritméticas. Con frecuencia tenemos un arreglo más pequeño y un arreglo más grande, y
queremos usar el arreglo más pequeño varias veces para realizar alguna operación en el arreglo más grande.

Por ejemplo, supongamos que queremos añadir un vector constante a cada fila de una matriz. Podríamos hacerlo
así:

Agregaremos el vector v a cada fila de la matriz x,

# almacenando el resultado en la matriz y
x = [Link]([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = [Link]([1, 0, 1])

[Link] 20/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratory

y = np.empty_like(x) Crea una matriz vacía con la misma forma que x

Agrega el vector v a cada fila de la matriz x con un bucle explícito.

para i en rango(4):
y[i, :] = x[i, :] + v

imprimir(y)
[[ 2 2 4]
[ 5 5 7]
[ 8 8 10]
[11 11 13]

Esto funciona; sin embargo, cuando la matrizxes muy grande, computar un bucle explícito en Python podría ser
lento. Tenga en cuenta que agregar el vector v a cada fila de la matrizxes equivalente a formar una matrizvv
apilando múltiples copias devverticalmente, luego realizando la suma elemento por elemento dexyvv.
Podríamos implementar este enfoque de la siguiente manera:

vv = [Link](v, (4, 1)) # Apilar 4 copias de v una sobre otra

imprimir(vv) [[1 0 1]
# [1 0 1]
# [1 0 1]
# [1 0 1]]

[[1 0 1]
[1 0 1]
[1 0 1]
[1 0 1]]

y = x + vv # Sumar x y vv elemento por elemento

imprimir(y)

[[ 2 2 4]
[ 5 5 7]
[ 8 8 10]
[11 11 13]]

La difusión de Numpy nos permite realizar este cálculo sin crear realmente múltiples
copias de v. Considera esta versión, utilizando difusión:

[Link] 21/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratory

importar numpy como np

Agregaremos el vector v a cada fila de la matriz x.

# almacenando el resultado en la matriz y
x = [Link]([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = [Link]([1, 0, 1])
y = x + v # Sumar v a cada fila de x usando broadcasting
imprimir(y)

[[ 2 2 4]
[ 5 5 7]
[ 8 8 10]
[11 11 13]]

La líneay = x + vfunciona aunquextiene forma(4, 3)yvtiene forma(3,)debido a

difusión; esta línea funciona como si v realmente tuviera forma(4, 3), donde cada fila era una copia dev ,
y la suma se realizó elemento por elemento.

Emitir dos arreglos juntos sigue estas reglas:

1. Si los arreglos no tienen el mismo rango, anteponga la forma del arreglo de menor rango con 1s hasta que
ambas formas tienen la misma longitud.
2. Se dice que los dos arreglos son compatibles en una dimensión si tienen el mismo tamaño en el
dimensión, o si uno de los arreglos tiene tamaño 1 en esa dimensión.
3. Los arreglos pueden ser transmitidos juntos si son compatibles en todas las dimensiones.
4. Después de la difusión, cada matriz se comporta como si tuviera una forma igual al máximo elemento a elemento
de las formas de los dos arreglos de entrada.

5. En cualquier dimensión donde un arreglo tenía un tamaño de 1 y el otro arreglo tenía un tamaño mayor que 1, el
El primer array se comporta como si estuviera copiado a lo largo de esa dimensión

Si esta explicación no tiene sentido, intenta leer la explicación desde eldocumentacióno esto
explicación.
Las funciones que admiten la transmisión se conocen como funciones universales. Puedes encontrar la lista de todas

funciones universales en eldocumentación.

Aquí hay algunas aplicaciones de la transmisión:

# Calcular el producto exterior de vectores

v = [Link]([1,2,3]) # v tiene forma (3,)
w = [Link]([4,5]) # w tiene forma (2,)
Para calcular un producto exterior, primero reorganizamos v para que sea una columna
vector de forma (3, 1); luego podemos difundirlo contra w para obtener
una salida de forma (3, 2), que es el producto exterior de v y w:

print([Link](v, (3, 1)) * w)

[Link] 22/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

[[ 4 5]
[ 8 10]
[12 15]

Agregar un vector a cada fila de una matriz

x = [Link]([[1,2,3], [4,5,6]])
# x tiene forma (2, 3) y v tiene forma (3,) por lo que se transmiten a (2, 3),
# giving the following matrix:

imprimir(x + v)

[[2 4 6]]
[5 7 9]]

Añadir un vector a cada columna de una matriz

# x tiene forma (2, 3) y w tiene forma (2,).
Si transponemos x, entonces tiene forma (3, 2) y se puede transmitir
contra w para obtener un resultado de forma (3, 2); trasponiendo este resultado
# produce el resultado final de forma (2, 3) que es la matriz x con
# el vector w añadido a cada columna. Da la siguiente matriz:

print((x.T + w).T)

[[ 5 6 7]
[ 9 10 11]

Otra solución es remodelar w para que sea un vector fila de forma (2, 1);
podemos transmitirlo directamente contra x para producir lo mismo
# output.
imprimir(x + [Link](w, (2, 1)))

[[ 5 6 7]
[ 9 10 11]]

Multiplicar una matriz por una constante:

# x tiene forma (2, 3). Numpy trata los escalares como arreglos de forma ();
estos pueden ser transmitidos juntos para dar forma a (2, 3), produciendo el
# array siguiente:
imprimir(x * 2)

[[ 2 4 6]
[ 8 10 12 ]

La transmisión generalmente hace que tu código sea más conciso y rápido, así que debes esforzarte por usarla.
donde sea posible.

[Link] 23/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

Este breve resumen ha tocado muchos de los aspectos importantes que necesitas saber sobre
numpy, pero está lejos de ser completo. Echa un vistazo a lareferencia de numpypara descubrir mucho más sobre

numpy.

Matplotlib

Matplotlib es una biblioteca de gráficos. En esta sección, se ofrece una breve introducción a [Link]
módulo, que proporciona un sistema de graficación similar al de MATLAB.

importar [Link] como plt

Al ejecutar este comando especial de iPython, estaremos mostrando gráficos en línea:

%matplotlib inline

Trazado

La función más importante enmatplotlibes un gráfico, que te permite representar datos 2D. Aquí está un
ejemplo simple:

Calcula las coordenadas x e y para los puntos en una curva sinusoidal

x = [Link](0, 3 * [Link], 0.1)
y = [Link](x)

Dibuja los puntos usando matplotlib

[Link](x, y)

[Link] 24/26
24/02/23, 12:00 AM Copia de [Link] - Colaboratorio

[<[Link].Line2D en 0x7f0f3a0b4208>]
Con solo un poco de trabajo extra, podemos trazar fácilmente varias líneas a la vez y agregar un título, leyenda,
y etiquetas de los ejes:

y_sin = [Link](x)
y_cos = [Link](x)

# Traza los puntos usando matplotlib

[Link](x, y_sin)
[Link](x, y_cos)
[Link]('etiqueta del eje x')
[Link]('etiqueta del eje y')
Título de Seno y Coseno
[Link](['Seno', 'Coseno'])

<[Link] en 0x7f0f39c04780>

Subgráficas

Puedes trazar diferentes cosas en la misma figura utilizando la función subplot. Aquí hay un ejemplo:

# Calcular las coordenadas x e y para puntos en las curvas seno y coseno

x = [Link](0, 3 * [Link], 0.1)
y_sin = [Link](x)
y_cos = [Link](x)

Configura una cuadrícula de subgráficos que tenga una altura de 2 y un ancho de 1,

# y establece el primer subtítulo de este tipo como activo.

[Link](2, 1, 1)

Haz el primer gráfico

[Link](x, y_sin)
[Link] 25/26
2/24/23, 12:00 AM Copia de [Link] - Colaboratorio

[Link]('Seno')

Establezca el segundo subplot como activo y haga la segunda gráfica.

[Link](2, 1, 2)
[Link](x, y_cos)
[Link]('Coseno')

Muestra la figura.
[Link]()

[Link] 26/26