Saltar al contenido principal

# 4.3: Vectores en Python

$$\newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} }$$

$$\newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}}$$

$$\newcommand{\id}{\mathrm{id}}$$ $$\newcommand{\Span}{\mathrm{span}}$$

( \newcommand{\kernel}{\mathrm{null}\,}\) $$\newcommand{\range}{\mathrm{range}\,}$$

$$\newcommand{\RealPart}{\mathrm{Re}}$$ $$\newcommand{\ImaginaryPart}{\mathrm{Im}}$$

$$\newcommand{\Argument}{\mathrm{Arg}}$$ $$\newcommand{\norm}[1]{\| #1 \|}$$

$$\newcommand{\inner}[2]{\langle #1, #2 \rangle}$$

$$\newcommand{\Span}{\mathrm{span}}$$

$$\newcommand{\id}{\mathrm{id}}$$

$$\newcommand{\Span}{\mathrm{span}}$$

$$\newcommand{\kernel}{\mathrm{null}\,}$$

$$\newcommand{\range}{\mathrm{range}\,}$$

$$\newcommand{\RealPart}{\mathrm{Re}}$$

$$\newcommand{\ImaginaryPart}{\mathrm{Im}}$$

$$\newcommand{\Argument}{\mathrm{Arg}}$$

$$\newcommand{\norm}[1]{\| #1 \|}$$

$$\newcommand{\inner}[2]{\langle #1, #2 \rangle}$$

$$\newcommand{\Span}{\mathrm{span}}$$ $$\newcommand{\AA}{\unicode[.8,0]{x212B}}$$

$$\newcommand{\vectorA}[1]{\vec{#1}} % arrow$$

$$\newcommand{\vectorAt}[1]{\vec{\text{#1}}} % arrow$$

$$\newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} }$$

$$\newcommand{\vectorC}[1]{\textbf{#1}}$$

$$\newcommand{\vectorD}[1]{\overrightarrow{#1}}$$

$$\newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}}$$

$$\newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}}$$

$$\newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} }$$

$$\newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}}$$

$$\newcommand{\avec}{\mathbf a}$$ $$\newcommand{\bvec}{\mathbf b}$$ $$\newcommand{\cvec}{\mathbf c}$$ $$\newcommand{\dvec}{\mathbf d}$$ $$\newcommand{\dtil}{\widetilde{\mathbf d}}$$ $$\newcommand{\evec}{\mathbf e}$$ $$\newcommand{\fvec}{\mathbf f}$$ $$\newcommand{\nvec}{\mathbf n}$$ $$\newcommand{\pvec}{\mathbf p}$$ $$\newcommand{\qvec}{\mathbf q}$$ $$\newcommand{\svec}{\mathbf s}$$ $$\newcommand{\tvec}{\mathbf t}$$ $$\newcommand{\uvec}{\mathbf u}$$ $$\newcommand{\vvec}{\mathbf v}$$ $$\newcommand{\wvec}{\mathbf w}$$ $$\newcommand{\xvec}{\mathbf x}$$ $$\newcommand{\yvec}{\mathbf y}$$ $$\newcommand{\zvec}{\mathbf z}$$ $$\newcommand{\rvec}{\mathbf r}$$ $$\newcommand{\mvec}{\mathbf m}$$ $$\newcommand{\zerovec}{\mathbf 0}$$ $$\newcommand{\onevec}{\mathbf 1}$$ $$\newcommand{\real}{\mathbb R}$$ $$\newcommand{\twovec}[2]{\left[\begin{array}{r}#1 \\ #2 \end{array}\right]}$$ $$\newcommand{\ctwovec}[2]{\left[\begin{array}{c}#1 \\ #2 \end{array}\right]}$$ $$\newcommand{\threevec}[3]{\left[\begin{array}{r}#1 \\ #2 \\ #3 \end{array}\right]}$$ $$\newcommand{\cthreevec}[3]{\left[\begin{array}{c}#1 \\ #2 \\ #3 \end{array}\right]}$$ $$\newcommand{\fourvec}[4]{\left[\begin{array}{r}#1 \\ #2 \\ #3 \\ #4 \end{array}\right]}$$ $$\newcommand{\cfourvec}[4]{\left[\begin{array}{c}#1 \\ #2 \\ #3 \\ #4 \end{array}\right]}$$ $$\newcommand{\fivevec}[5]{\left[\begin{array}{r}#1 \\ #2 \\ #3 \\ #4 \\ #5 \\ \end{array}\right]}$$ $$\newcommand{\cfivevec}[5]{\left[\begin{array}{c}#1 \\ #2 \\ #3 \\ #4 \\ #5 \\ \end{array}\right]}$$ $$\newcommand{\mattwo}[4]{\left[\begin{array}{rr}#1 \amp #2 \\ #3 \amp #4 \\ \end{array}\right]}$$ $$\newcommand{\laspan}[1]{\text{Span}\{#1\}}$$ $$\newcommand{\bcal}{\cal B}$$ $$\newcommand{\ccal}{\cal C}$$ $$\newcommand{\scal}{\cal S}$$ $$\newcommand{\wcal}{\cal W}$$ $$\newcommand{\ecal}{\cal E}$$ $$\newcommand{\coords}[2]{\left\{#1\right\}_{#2}}$$ $$\newcommand{\gray}[1]{\color{gray}{#1}}$$ $$\newcommand{\lgray}[1]{\color{lightgray}{#1}}$$ $$\newcommand{\rank}{\operatorname{rank}}$$ $$\newcommand{\row}{\text{Row}}$$ $$\newcommand{\col}{\text{Col}}$$ $$\renewcommand{\row}{\text{Row}}$$ $$\newcommand{\nul}{\text{Nul}}$$ $$\newcommand{\var}{\text{Var}}$$ $$\newcommand{\corr}{\text{corr}}$$ $$\newcommand{\len}[1]{\left|#1\right|}$$ $$\newcommand{\bbar}{\overline{\bvec}}$$ $$\newcommand{\bhat}{\widehat{\bvec}}$$ $$\newcommand{\bperp}{\bvec^\perp}$$ $$\newcommand{\xhat}{\widehat{\xvec}}$$ $$\newcommand{\vhat}{\widehat{\vvec}}$$ $$\newcommand{\uhat}{\widehat{\uvec}}$$ $$\newcommand{\what}{\widehat{\wvec}}$$ $$\newcommand{\Sighat}{\widehat{\Sigma}}$$ $$\newcommand{\lt}{<}$$ $$\newcommand{\gt}{>}$$ $$\newcommand{\amp}{&}$$ $$\definecolor{fillinmathshade}{gray}{0.9}$$

Para quienes son nuevos en Python, hay muchos errores comunes que ocurren en este curso. Intenta arreglar los siguientes códigos.

## SyntaxError

Significa que el código no tiene sentido en Python. Nos gustaría definir un vector con cuatro números.

##### Hacer esto

Fija el siguiente código para crear tres vectores con cuatro números.

x = [1 2 3.4 4]
y = [1, 2, 3, 5]]
z = [[1, 2, 3, 6.3]
  File "<ipython-input-1-cd07b469c255>", line 1
x = [1 2 3.4 4]
^
SyntaxError: invalid syntax


Aunque es posible que hayas podido deshacerte de los mensajes de error, la respuesta a tu problema aún puede no ser correcta. A lo largo del semestre usaremos un programa python llamado answercheck para permitirte verificar algunas de tus respuestas. Este programa no te dice la respuesta correcta pero está destinado a ser utilizado como una forma de obtener retroalimentación inmediata y acelerar el aprendizaje.

##### Hacer esto

Primero necesitaremos descargar answercheck.py a tu directorio de trabajo actual. Realmente solo necesitas hacer esto una vez. No obstante, si eliminas este archivo por error en algún momento del semestre, puedes volver a este cuaderno y volver a descargarlo ejecutando la siguiente celda:

from urllib.request import urlretrieve

'answercheck.py');
##### Hacer esto

Cómo simplemente ejecutar el siguiente comando para ver si tienes$$x$$,$$y$$ y$$z$$ corregir cuando arreglaste el código anterior.

from answercheck import checkanswer

checkanswer([x,y,z],'e80321644979a873b273aebbbcd0e450');
##### Nota

asegúrese de no cambiar los comandos checkanswer. La cadena larga con números y letras es el código secreto que codifica la respuesta verdadera. Este código también se llama el hash. Siéntase libre de mirar el código answercheck.py y ver si puede averiguar cómo funciona?

## Numpy

Numpy es una forma común de representar vectores, y se le sugiere usar numpy a menos que se especifique lo contrario. El beneficio de numpy es que puede realizar las operaciones de álgebra lineal enumeradas en la sección anterior.

Por ejemplo, el siguiente código usa numpy.array para definir un vector de cuatro elementos.

import numpy as np
x_np = np.array([-1, 0, 2, 3.1])
x_np

### Escalares versus 1 vectores

En matemáticas, 1-vector es considerado como escalar. Pero en Python, no son lo mismo.

x = 2.4
y = [2.4]
x == y
False
x == y[0]
True

### Listas de vectores

Tenemos una lista de matrices numpy o una lista de listas. En este caso, los vectores pueden tener diferentes dimensiones.

##### Hacer esto

Modifique la sentencia print usando indexación para imprimir únicamente el valor 3 de la list_of_vectors definida a continuación.

x_np = np.array([-1,0, 2 , 3.1])
y_np = np.array([1,-1,3])
z_np = np.array([0,1])
list_of_vectors = [x_np,y_np,z_np]

print(list_of_vectors)
[array([-1. ,  0. ,  2. ,  3.1]), array([ 1, -1,  3]), array([0, 1])]


### Indexación

El índice de un vector va de 0 a$$n−1$$ para un$$n$$ -vector.

##### Hacer esto

El siguiente código intenta obtener el tercer elemento de x_np, que es el número 2.0. Arregla este código para proporcionar la respuesta correcta.

print(x_np(3))
##### Hacer esto

Reemplaza solo el tercer elemento de x_np con el número 20.0 de tal manera que los nuevos valores de x_np sean [-1, 0, 20., 3.1]

# Replace the third element using 20.0, then the resulting element is

print(x_np)
from answercheck import checkanswer

checkanswer(x_np,'993d5cbc6ddeb10776ed48159780a5d3');

Hay un índice especial -1, que representa el último elemento de una matriz. Hay varias formas de obtener más de un elemento consecutivo.

• x_np [1:3] da solo los elementos 2do y 3er. Comienza con el primer índice y termina antes del segundo índice. Entonces el número de elemento es solo la diferencia entre estos dos números.
• x_np [1: -1] es lo mismo que x_np [1:3] para un vector 4.
• Si quieres el último elemento también, entonces no necesitas poner el índice, por ejemplo, x_n [1:] da todos los elementos excepto el primero. Se puede hacer lo mismo que el primero.
##### Hacer esto

se le da un vector (x_np) de$$n$$ elementos, definir un nuevo vector (d) de tamaño$$n−1$$ tal que$$d_i = x_{i+1} - x_i$$ para$$i=1, \dots, n-1$$.

Sugerencia intenta hacer esto sin escribir tu propio bucle. Debería poder usar la indexación numpy simple como se describió anteriormente.

x_np = np.array([1,8,3,2,1,9,7])

## Put your answer to the above question here.
from answercheck import checkanswer

checkanswer(d,'14205415f0ed56e608d0a87e7253fa70');

## Asignación versus copia

Echa un vistazo al siguiente código.

• creamos una matriz numpy x_np
• dejamos y_np = x_np
• cambiamos el tercer elemento de y_np
• El tercer elemento de x_np también se cambia

Esto parece agotado y puede que no tenga sentido para aquellos usos de otros lenguajes como MATLAB.

La razón de esto es que no estamos creando una copia de x_np y nombrarla como y_np. Lo que hicimos es que le damos un nuevo nombre y_np a la misma matriz x_np. Por lo tanto, si se cambia uno, y el otro también se cambia, porque se refieren a la misma matriz.

x_np = np.array([-1, 0, 2, 3.1])
y_np = x_np
y_np[2] = 20.0
x_np
##### Hacer esto

Hay un método llamado copy que se puede utilizar para crear una nueva matriz. Puedes buscar cómo funciona y arreglar el código a continuación. Si esto se hace correctamente el vector x_np debería permanecer igual y el y_np ahora será [-1 0 2 3.1].

## modify the following code to copy the x_np instead of just giving it a new name
x_np = np.array([-1, 0, 2, 3.1])
y_np = x_np
y_np[2] = 20.0
print(x_np)
from answercheck import checkanswer

checkanswer(x_np,'0ba269d18692155ba252e6addedf37ad');
from answercheck import checkanswer

checkanswer(y_np,'993d5cbc6ddeb10776ed48159780a5d3');

## Igualdad vectorial en numpy y lista

El operador relacional (==, <, >,! =, etc.) para comprobar si los vectores son iguales o no. Sin embargo, actuarán de manera diferente si el código está comparando objetos numpy.array o una lista. En numpy, In numpy operadores relacionales comprueba la igualdad para cada elemento de la matriz. Para la lista, los operadores relacionales verifican todos los elementos.

x = [-1, 0, 2, 3.1]
y = x.copy()
y[2] = 20.2

x_np = np.array(x)
y_np = np.array(y)
x == y
False
np.array(x_np) == np.array(y_np)
array([ True,  True, False,  True])

## Vectores cero y vectores Ones en numpy

• ceros (n) crea un vector con todos los 0s
• ones (n) crea un vector con todos los 1s
##### Hacer esto

Crea un vector cero (llamado zero_np) con la misma dimensión que el vector x_np. Crear un vector ones (llamado ones+np) también con la misma dimensión que el vector x_np.

x_np = np.array([-1, 0, 2, 3.1])
### Define zero_np and ones_np here 
from answercheck import checkanswer

checkanswer([zero_np, ones_np],'7f874c2e446786655ff96f0bbae8a0c6');

## Vectores aleatorios

• random.random (n) crea un vector aleatorio con dimensión$$n$$.
random_np = np.random.random(2)
print(random_np)
[0.44542519 0.09046139]


## Suma y resta de vectores

En esta sección, comprenderá por qué usamos numpy para operaciones de álgebra lineal. Si x e y son matrices numpy del mismo tamaño, podemos tener x + y y x-y para su suma y resta, respectivamente.

x_np = np.array([1,2,3])
y_np = np.array([100,200,300])

v_sum = x_np + y_np
v_diff = x_np - y_np

print (f'Sum of vectors: {v_sum}')
print (f'Difference of vectors: {v_diff}')
Sum of vectors: [101 202 303]
Difference of vectors: [ -99 -198 -297]


A modo de comparación, también ponemos a continuación la adición de dos listas. Recordemos de la asignación pre-clase, tenemos que definir una función para agregar dos listas para álgebra lineal.

##### Hacer esto

Modifique el siguiente código para sumar y restar correctamente las dos listas.

SUGERENCIA que está perfectamente bien NO escribir tu propia función prueba deberías poder lanzar las listas como matrices:

x = [1,2,3]
y = [100,200,300]

v_sum = x + y
v_diff = x - y

print (f'Sum of vectors: {v_sum}')
print (f'Difference of vectors: {v_diff}')

Una adición de vector escalar significa que el escalar (o un vector 1) se agrega a todos los elementos del vector.

##### Hacer esto

Agregue un escalar 20.20 a todos los elementos del siguiente vector x_np y almacene el resultado de nuevo en x_np

x_np = np.array([1.0,2.0,3.0])
from answercheck import checkanswer

checkanswer(x_np,'2f8cbcce405fa12b8608422ff28544bb');

## Multiplicación y división de vectores escalares

Cuando a es un escalar y x es matriz numpy. Podemos expresar la multiplicación vectorial escalar como a*x o x*a.

También podemos hacer división escalar-vector para x/a o a/x. (tenga en cuenta que x/a y a/x son diferentes)

##### Hacer esto

Divide todos los elementos del siguiente vector x_np por 20.20 y póngalo en y_np

x_np = np.array([1,2,3])
y_np =
print(y_np)
from answercheck import checkanswer

checkanswer(y_np,'90c1b8639f9d350af1d971d89209a0c6');

## Operaciones elementales

Como se indicó anteriormente, las operaciones relacionales en matrices numpy se realizan por elementos. Ejemplos que mencionamos anteriormente son

• El operador ==
• La suma + y resta -
##### Nota

para que esto funcione los dos vectores tienen que ser las mismas dimensiones.

Si no son tienen la misma dimensión, como un escalar y un vector, podemos pensar en expandir el escalar para tener la misma dimensión que el vector y realizar las operaciones. Por ejemplo.

• Suma y resta vector-escalar
• Multiplicación y división vector-escalar
##### Hacer esto

Supongamos que invirtió tres activos con valores iniciales almacenados en p_initial, y después de una semana, sus valores se almacenan en p_final. Entonces, ¿cuál es el ratio de retorno de activos (r) para estos tres activos (es decir, cambio de precio sobre el valor inicial)?

p_initial = np.array([22.15, 89.32, 56.77])
p_final = np.array([23.05, 87.32, 53.13])
from answercheck import checkanswer

checkanswer(r,'0e231e6cfbef65cf178208cf377af85c');

## Combinación lineal

Tenemos dos vectores$$x$$ y$$y$$ podemos obtener la combinación lineal de estos dos vectores como$$ax+by$$ donde$$a$$ y$$b$$ son coeficientes escalares.

En el siguiente ejemplo, se nos dan dos vectores (x_np y y_np), y dos escalares (alfa y beta), obtenemos la combinación lineal alfa*x_np + beta*y_np.

x_np = np.array([1,2])
y_np = np.array([3,4])
alpha = 0.5
beta = -0.8
c = alpha*x_np + beta*y_np
print(c)

También podemos definir una función lincomb para realizar la combinación lineal.

##### Hacer esto

Termina el siguiente código para lincomb y compara los resultados que acabamos de obtener.

def lincomb(coef, vectors):
n = len(vectors[0])  # get the dimension of the vectors. note they have to be of the same dimension
comb = np.zeros(n)   # initial the value with all zeros.
### Add code here to calculate the linear combination of the input vecotrs and the coefficients.
return comb
from answercheck import checkanswer

combination = lincomb([alpha, beta], [x_np,y_np])

checkanswer(combination,'8bab7329c94f3e3cda423add411685c2');

También podemos probar las funciones nosotros mismos usando valores para los que conocemos la respuesta. Por ejemplo, las siguientes pruebas están multiplicando y sumando por cero sabemos cuáles deben ser estas respuestas y podemos verificarlas.

combination = lincomb([0, 0], [x_np,y_np])

combination == np.zeros(combination.shape)
combination = lincomb([2, 2], [combination,np.zeros(combination.shape)])

combination == 2*combination

Si quieres comprobar que todos los valores en un numpy.array son iguales podrías convertirlo a una lista o hay un método llamado alltrue que comprueba si todo es verdadero. Es una buena idea utilizar este método si los vectores se hacen grandes.

combination = lincomb([2, 2], [combination,np.zeros(combination.shape)])

np.alltrue(combination == 2*combination)

This page titled 4.3: Vectores en Python is shared under a CC BY-NC 4.0 license and was authored, remixed, and/or curated by Dirk Colbry via source content that was edited to the style and standards of the LibreTexts platform.