Suma de vectores en Python

Blanco, Amarillo y el tercero es un número sin sentido.

El modelo RGB es una forma de representar colores como luces, es por eso que el negro es (0 0 0) ausencia completa de luz y el blanco es (255 255 255) todas las luces al máximo. Los números entre 0 y 255 representan la cantidad de luz emitida por el color y cualquier numero fuera del rango no tiene sentido en este sistema.

Como dato, existe otro modo de representar colores que es CYMK y que hace referencia a la cantidad de pigmentos de cada color Cyan, Yellow, Magenta and Key (black). Los colores RGB se utilizan para ser visualizados en una pantalla (luz) y los CMYK en imprenta (tintas)

La función zip(), toma iterables como argumento y retorna un iterador. El iterador genera una serie de tuplas que contiene elementos de cada iterable.

numeros = [1, 2, 3]
letras = [‘a’, ‘b’, ‘c’]

num_let = zip(numeros, letras)

list(num_let)
[(1, ‘a’), (2, ‘b’), (3, ‘c’)]

Respuesta a los ejercicios:

>>> a = np.array([0, 0, 255])
>>> rojo = np.array([255, 0, 0])
>>> verde = np.array([0, 255, 0])
>>> rojo + verde + a
array([255, 255, 255])
>>> rojo + verde
array([255, 255,   0])
>>> negro = np.array([0, 0, 0])
>>>
>>> negro - a
array([   0,    0, -255])
>>>

El primer color que obtengo es blanco(array([255, 255, 255])), le sigue amarillo(array([255, 255, 0])) y por ultimo, el color que se obtiene sumando negro - azul(array([ 0, 0, -255])) es inexistente dentro de los colores rgb, no tiene sentido ya que en clases anteriores el profesor comento que los numeros rgb son numeros que van desde el 0 hasta el 255.

# a = Azul
$a = np.array([0,0,255])
$rojo = np.array([255,0,0])
$verde = np.array([0,255,0])

$rojo+verde+a
array([255, 255, 255])
#Blanco

$rojo+verde
array([255, 255,   0])
#Amarillo

$negro-a
array([   0,    0, -255])
#Insertandolo a la página, nos da negro, 
#sin embargo no tiene sentido para el modelo RGB
# debido a que el modelo RGB está definido como (Z_+)^3
#que quiere decir que solo está definido sobre las entradas 
#positivas 

Como dato si escriben color ffffff en Google les aparecerá algo como esto. Que tiene varias representaciones de vectores para los colores, entre ellas RGB y CMYK.

Al principio del video, el profe utiliza la función zip, si alguien no la conocía al igual que yo, aca va una explicación rápida:
zip(parametro_1, parametro_2) lo que hace, en ese caso, es que de cada iterable que se le ingresa como parámetro, elige el primero de cada uno, y en ese caso, los suma, si los vectores seria uno de magnitud 3 y otro 4, zip lo que haría seria adaptarse al de menor magnitud y sumar desde el primer elemento hasta el tercero, dejando el cuarto fuera.
Fuente: https://likegeeks.com/python-zip-function/

Este es el ejercicio propuesto en la clase:

**La resta es posible en python pero no hace sentido en la escala de color RGB

a = np.array([0,0,255])
color_misterioso=np.array([0,0,255])
verde = np.array([0,255,0])
print(color_misterioso)```
el Color misterioso es el azul

**Punto 1**

punto_1=rojo + verde +color_misterioso
print(punto_1)
el color es blanco

**Punto 2**

punto_2 =rojo + verde
print(punto_2)
el color es amarillo

**Punto 3**

punto_3 = negro - a
print(punto_3)
No tiene sentido rgb va de 0 a 255

Les comparto la forma en que implementé el ejercicio en python:

#¿Qué color obtienes si sumas  𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→+𝑎⃗?
#¿Qué color obtienes sumando  𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→ ?
#¿Qué color obtienes sumando  𝑛𝑒𝑔𝑟𝑜→−𝑎⃗  ?

#aprovechando la propiedad asociativa y que ya tenemos una función que suma dos vectores
#sumaré primero rojo y verde y ese resultado lo sumaré con a

suma_rojo_verde = suma_vectores(rojo,verde)
suma_rojo_verde_a = suma_vectores(suma_rojo_verde,a)
suma_negro_menos_a = suma_vectores(negro,-a)

print("vector obtenido de 𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→+𝑎⃗:",suma_rojo_verde_a,"Es color blanco",
      "\nvector obtenido de 𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒:",suma_rojo_verde, "Es color Amarillo",
      "\nvector obtenido de negro→-𝑎⃗:",suma_negro_menos_a, "no equivale a ningún color rgb, el campo de resultado debe ser R+",) 
    #se comprueba con el enlace de RGBs

Output:

vector obtenido de 𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→+𝑎⃗: [255, 255, 255] Es color blanco 
vector obtenido de 𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒: [255, 255, 0] Es color Amarillo 
vector obtenido de negro→-𝑎⃗: [0, 0, -255] no equivale a ningún color rgb, el campo de resultado debe ser R+

Te comparto una manera distinta para sumar vectores usando lambda

rojo = [255,0,0]
negro = [0,0,0]
suma_vectores = lambda vector_a, vector_b: [i + j for i,j in zip(vector_a,vector_b)]
print(suma_vectores(rojo,negro))

Si sumamos el vector rojo→ = [255, 0, 0] con el vector verde→ = [0, 255, 0] y el vector a = [0, 0, 255], ob tendremos:


suma = rojo→ + verde→ + a⃗ = [255, 0, 0] + [0, 255, 0] + [0, 0, 255] = [255, 255, 255]

El resultado es el color blanco, donde todos los componentes rojo, verde y azul tienen la máxima intensidad.

Si sumamos el vector rojo→ = [255, 0, 0] con el vector verde→ = [0, 255, 0], obtenemos:

suma = rojo→ + verde→ = [255, 0, 0] + [0, 255, 0] = [255, 255, 0]

El resultado es el color amarillo, que se obtiene mezclando los componentes rojo y verde sin presencia de azul.

Si sumamos el vector negro→ = [0, 0, 0] con el inverso del vector a⃗, es decir, -a⃗ = [0, 0, -255], obtenemos:

suma = negro→ - a⃗ = [0, 0, 0] - [0, 0, 255] = [-0, -0, -255] = [0, 0, -255]

El resultado es el color azul negativo, donde el componente azul tiene la máxima intensidad en sentido negativo.

En codigo con python

import numpy as np

rojo = np.array([255, 0, 0])
verde = np.array([0, 255, 0])
negro = np.array([0, 0, 0])
a = np.array([0, 0, 255])

# Sumando rojo + verde + a
color_suma = rojo + verde + a
print(color_suma)  # [  0 255 255]

# Sumando rojo + verde
color_suma2 = rojo + verde
print(color_suma2)  # [255 255   0]

# Sumando negro - a
color_suma3 = negro - a
print(color_suma3)  # [  0   0 -255]

Este es el reto cumplido:

a = np.array([0,0,255])
rojo = np.array([255,0,0])
verde = np.array([0,255,0])
negro = np.array([0,0,0])

r_v_a = a + rojo + verde
r_v = rojo + verde
n_a = negro - a

print("Este es el color rojo + verde + a: ", r_v_a) #Es el color Blanco
print("Este es el color rojo + verde: ", r_v) #Es el color Amarillo
print("Este es el color negro - a: ", n_a) #N/A ya que uno de los datos es negativo y no hay color con valores negativos

• Numpy es una biblioteca de Python que nos soporte para poder operar entre vectores y matrices. De igual manera contiene funciones matemáticas de alto nivel y que también podrán operar con los vectores y matrices.

Reto cumplido 💚

# Teniendo en cuenta que el vector a = [0,0,255]
a = np.array([0,0,255])
print(f'El vector a representa el color azul, según el código RGB: {a}')
# Definición de los arrays
rojo = np.array([255,0,0])
verde = np.array([0,255,0])
negro = np.array([0,0,0])
# Pregunta a:
pregunta_a = rojo+verde+a
print(f'El color que se obtiene de la suma de {rojo}, {verde} y {a} es {pregunta_a} : blanco')
# Pregunta b:
pregunta_b = rojo+verde
print(f'El color que se obtiene de la suma de {rojo} y {verde} es {pregunta_b} : amarillo')
# Pregunta c:
pregunta_c = negro-a
print(f'El color que se obtiene de la resta de {negro} y {a} es {pregunta_c} : No se puede determinar porque el vector componente [3] es negativo')

Solución al reto:

Hola muchachos,
este es mi aporte a la solución del reto:

Saludos!

uso de zip

1. Azul!
2. Blanco!
3. Amarillo!
4. No tiene sentido ya que los valores van de 0 a 255

Hola, mi aporte a la clase

Solución al ejercicio 🧮

1. El vector a=[0,0,255] corresponde al color azul 🔵
2. La suma entre rojo, verde y a es igual al color blanco ⚪ = [255,255,255]
3. La suma entre rojo y verde es igual al color amarillo 🟡 = [255,255,0]
4. La suma de negro - a es igual a [-255,-255,-255] lo cual se sale de la escala permitida de colores RGB

Muy buenos días, mi aporte:
los colores previamente definidos en el notebook: rojo, negro, z(azul), v(verde). Los resultados: el primero resulta blanco, el segundo resulta amarillo. El último ejercicio, no tiene sentido valores negativos; es como que fuera una ausencia, en este caso (0,0,-255) = (0,0,0) :negro.
Se hizo el intento con valores negativos en otras posiciones (255,-255, 0)=rojo; (-255,255,0) =verde, es decir, una sin alterar, ausencia. Por lo tanto, la operación no es cerrada.
Dejo los resultantes del colab en RGB. Saludos

Este es mi notebook, en este caso el rojo y el negro ya estaban definidos. El vector a nos representa el color azul. En el caso de la primera suma nos da como resultado el blanco, en la segunda suma nos da el amarillo y por último nos da como resultado un vector que no representa ningún color RGB.

Hasta aquí va muy fácil

Me gusta lo de “esto es una maratón, no una carrera de velocidad” ya me estaba frustrando por no llegar rápido a ser científico de datos, pero creo que ya estoy asimilando que me voy a demorar mas de lo que quisiera

rojo = np.array([255,0,0])
verde = np.array([0,255,0])
azul = np.array([0,0,255])
negro = np.array([0,0,0])
blanco = np.array([255,255,255])

C1 = rojo + verde + azul
print("el color que se obtiene a partir de la suma de rojo verde y azul es: “, C1 , " que es blanco”)

C2 = rojo + verde
print("La suma de los vectores del color rojo y verde da “, C2, " que es amarillo”)

C3 = negro - azul
print("Restar el azul al negro da ", C3, “no entra en los rangos de RGB”)

Antes de conocer Numpy me puse el reto que con POO hacer las funciones basicas para vectores, lo monte a Github aquí por si le quieren dar un vistaso.

Hola que tal… Mas que pregunta es una sugerencia para la plataforma, algunas veces durante la ejecución del video surgen preguntas relacionadas con el momento de la clase, sería interesante que en el icono del trebol donde aparecen las opciones de descargar y eso, se pudiera crear la pregunta ya sea por voz o voz y texto, y quede grabada la pregunta junto con el tiempo donde ocurrió, de esta forma ya no tenemos que dar el contexto de la pregunta, por otro lado ustedes podrían tener una idea de en qué mome to surgen más pregu tas y nosotros tener acceso a las pregu tas que otros hicieron y escucharlas de viva voz, no se es sólo una sugerencia que si se llega a implementar en la plataforma yo le tomaría mucho provecho, saludos

rojo + verde + a = blanco
rojo + verde = amarillo
negro - a = negro (Este resultado no tiene mucho sentido, dado que el vector del modelo rgb solo acepta números entre el rango de 0 a 255)

El vector a corresponde al color azul.

1. Corresponde a blanco.
2. Corresponde a amarillo.
3. No tiene sentido porque el RGB sólo son números naturales y restar (0,0,0) que es negro al vector a que es (0,0,255) daría (0,0,-255) pero no es una entrada válida

el valor de a es el correspondiente en RGB a azul.

rojo + verde + a = [255, 255, 255] que es blanco.

rojo + verde = [255, 255, 0] que es amarillo.

negro - a = [0, 0, -255] que no es un color en RGB

a = es el color azul

La suma de rojo, verde y azul nos da = [255 255 255] Que es el color blanco

La suma de rojo y verde nos da = [255 255 0] Que es el color amarillo

El resto de negro y azul nos da = [ 0 0 -255] Que no es un color pero da negro

a = np.array([0,0,255])
rpt_1 = rojo + verde + a
rpt_2 = rojo + verde
rpt_3 = negro - a

print(f'rpt_1: {rpt_1}')
print(f'rpt_2: {rpt_2}')
print(f'rpt_3: {rpt_3}')

Me está gustando demasiado el curso y como el profesor explica detalladamente los procesos, incluso la librería numpy: les comparto mi código del reto y de sumas entre vectores usando numpy:

import numpy as np

rojo = [255,0,0]
verde = [0,255,0]
azul = [0,0,255]
negro = [0,0,0]

# Numpy tiene una estructura de datos llamado numpy arrays y se pueden crear con la propiedad array
# Los numpy array tienen las propiedades de un vector y su suma puede ser como los vectores algebraicos
rojo = np.array(rojo)
verde = np.array(verde)
azul = np.array(azul)

print('La suma de los numpy array rojo mas verde es: ', rojo+verde)

# Ejercicio de clase #6
# vector a = [0,0,255] es el color azul

# Color al sumar rojo verde y azul
print('La suma de los vectores, rojo, verde y azul es: ', rojo+verde+azul)
# Color sumando rojo y verde
print('La suma de los vectores, rojo y verde es: ', rojo+verde)
# Color sumando negro - azul es:
print('La suma negro menos azul es: ', negro-(+azul))```

<3

`#¿Qué color obtienes si sumas 𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→+𝑎⃗ ?
a = np.array([0,0,255])
verde = np.array([0,255,0])

su1 = rojo + verde + a
print('El color que obtenemos es ', su1, ‘(Blanco)’)`

 verde = np.array([0,255,0])
 a = np.array([0,0,255])
 print('rojo+verde+a:', rojo+verde+a)
 print('rojo+verde: ', rojo+verde)
 print('negro - a: ', negro - a)

La ultima operación no tiene sentido, ya que
negro + (-a) = -b no esta definido en el espacio vectorial de estos vectores

Aquí mi solución:

<
verde = np.array([0,255,0])
negro = np.array([0,0,0])
rojo = np.array ([255,0,0])
a = np.array([0,0,255])  #Este vector es el color Azul

print(f'Suma rojo + verde + a resulta:   {verde + rojo + a}')

print(f'Suma rojo + verde resulta:   {verde + rojo}')

print(f'Negro - a resulta:   {negro - a},   este resultado no tiene sentido en el RGB')
> 

Respuestas a problema:

• ¿Qué color se obtiene al sumar rojo + verde + a? Blanco
• ¿Qué color obtienes sumando rojo + verde? Amarillo
• ¿Qué color obtienes sumando negro - a? Se obtiene un vector [0,0,-255], el cual no tiene sentido en el modelo RGB, ya que este solo abarca números positivos.
  Existe una razón más allá de la matemática para que el modelo RGB se representa así, y tiene que ver con la electronica detras de las luces LED. Las luces leds se iluminan con diferente intensidad dependiendo del voltaje que reciben, cuando este voltaje es 0, están apagadas, y cuando el voltaje es de 5 están iluminando al máximo (algunos leds requieren menos voltaje). Lo importante aquí es que los LEDS solo funcionan con corriente continua, la cual es siempre “positiva”, es por eso que no tiene sentido hablar de un modelo RGB negativo.

import numpy as np


red = np.array([255, 0, 0])
black = np.array([0, 0, 0])
green = np.array([0, 255, 0])
a = np.array([0, 0, 255])

print('¿Qué color obtienes si sumas rojo + verde + a?:', red + green + a)
print('¿Qué color obtienes sumando rojo + verde?:', red + green)
print('¿Qué color obtienes sumando negro - a?¿Tiene sentido este resultado dentro del modelo aditivo RGB?:',
 black + a)

Para los que quieran instalar numpy

Windows:

0.- Entras a CMD.
1.- Entras a tu carpeta con el comando cd.
2.- Ingresa el comando “py -m pip install virtualenv”.
3.- Pones el comando py -m venv nombre_de_tu_espacio_virtual".
4.- Colocas "nombre_de_tu_espacio_virtual\Scripts\activate"
5.- Por último, tipeas “pip install nombre_de_librería” en este caso, el nombre de la librería que queremos en “numpy”.

a = np.array([0,0,255])
rojo = np.array([255,0,0])
verde = np.array([0,255,0])
negro = np.array([0,0,0])

1. rojo+verde+a [255 255 255] = Blanco
2. rojo + verde[255 255 0] = Amarillo
3. nebro - a[ 0 0 -255] =No tiene sentido porque se sale del espacio vectorial

vector a [0,0,255] corresponde al color azul

rojo + verde + a = [255,0,0] + [0,255,0] + [0,0,255] = [255,255,255]
Se obtiene el color blanco

rojo + verde = [255,0,0] + [0,255,0] = [255,255,0]
Se obtiene el color amarillo

negro - a = [0,0,0] - [0,0,255] = [0,0,-255]
Este resultado no tiene sentido dentro del modelo RGB

para los que están trabajando en algún editor de código y no les funciona el numpy hay que instalarlo primero.
en la terminal ubuntu o Mac se ejecuta el comando pip install numpy y luego se importa. espero les funciones
saludos

El color de [0,0,255] es azul.

rojo_vector = [255,0,0]
verde_vector = [0,255,0]
a_vector = [0,0,255]
negro_vector = [0,0,0]

rojo = np.array(rojo_vector)
verde = np.array(verde_vector)
a = np.array(a_vector)
negro = np.array(negro_vector)

print(f'La suma del vector rojo y verde y a es {rojo+verde+a}')
print(f'La suma del vector rojo y el vector verdes es {rojo+verde}')
print(f'La resta de negro con a es {negro-a}')

rojo + verde + azul = blanco
rojo + verde = amarillo
El tercero no tiene sentido, RGB sólo usa los valores desde 0 hasta 255.

import numpy as np

a = np.array([0,0,255])
verde = np.array([0,255,0])
rojo = np.array([255,0,0])
negro = np.array([0,0,0])

#¿Qué color obtienes si sumas rojo+verde+a?
color1 = rojo + verde + a
print('Color 1 es:',color1, 'blanco')

# ¿Qué color obtienes sumando rojo+verde?
color2 = rojo + verde
print('Color 2 es:',color2, 'amarillo' )

# ¿Qué color obtienes sumando negro−a? ¿Tiene sentido este resultado dentro del modelo aditivo RGB?
color3 = negro - a
print('Color 3 es:',color3, 'No tiene sentido RGB es de 0 a 255')

Color 1 es: [255 255 255] blanco
Color 2 es: [255 255 0] amarillo
Color 3 es: [ 0 0 -255] No tiene sentido RGB es de 0 a 255

<rojo = np.array([255,0,0])
verde = np.array([0,255,0])
a = np.array([0,0,255])
negro = np.array([0,0,0])

print(rojo + verde + azul) #blanco
print(rojo + verde) #amarillo
print(negro - azul) #negro>

El último reto debe ser color negro porque los valores mínimos aceptados por el modelo son [0,0,0] como negro, además que el modelo solo acepta números enteros entre 0-255.

#¿Qué color obtienes si sumas  𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→+𝑎⃗ ?
a = np.array([0,0,255])
verde = np.array([0,255,0])

su1 = rojo + verde + a
print('El color que obtenemos es ', su1, '(Blanco)')

#¿Qué color obtienes sumando  𝑟𝑜𝑗𝑜→+𝑣𝑒𝑟𝑑𝑒→ ?
su2 = rojo + verde
print('El color que obtenemos es ', su2, '(Amarillo)')

#¿Qué color obtienes sumando  𝑛𝑒𝑔𝑟𝑜→−𝑎⃗ ? ¿Tiene sentido este resultado dentro del modelo aditivo RGB?
su3 = negro - a
print(su3)
# Este color no tiene sentido ya que el negro es ausencia de color, asi que no le podemos quitar color a algo que no lo tiene

rojo = np.array([255,0,0])
verde = np.array([0,255,0])
azul = np.array([0,0,255])
negro = np.array([0,0,0])

RoVeAz = rojo + verde + azul ## blanco
RoVe = rojo + verde ## amarillo
NeAz = negro - azul ## NO TIENE SENTIDO DA UN VALOR NEGATIVO EN LA POSICIÓN 2


print(RoVeAz)
print(RoVe)
print(NeAz)

El primero es blanco, el segundo es amarillo y el tercero sale negativo que seria no definido

El primer color es Blanco, el segundo es amarillo y el tercero es [0, 0, -255]

a = [0, 0, 255] # 3-vector a (Azul)
rojo = [255, 0, 0] # 3-vector rojo
negro = [0,0,0] # 3-vector negro
verde = [0, 255, 0] # 3-vector verde

a = np.array(a)
rojo = np.array(rojo)
negro = np.array(negro)
verde = np.array(verde)

print(rojo+verde+a)
print(rojo+verde)
print(negro-a)

#Este fue el resultado
[255 255 255]
[255 255   0]
[   0    0 -255]

El color rgb (0, 0, 255) es azul

¿ rojo + rojo no es rojo ?

[255, 0, 0] + [255, 0, 0] != [255, 0, 0]

Al no ser cerrada esta operación en su espacio vectorial, puede parecer contra-intuitivo, pero en este caso, lo mejor sería limitar la suma al rango de 0 a 255 (enteros positivos incluido el cero)

ans = rojo + rojo
ans[ans<0] = 0            # limite inferior es cero
ans[ans>255] = 255        # limite superior es 255
ans
# array([255,   0,   0])      # rojo

O para el caso de negro - a:

ans = negro - a
ans[ans<0] = 0            # limite inferior es cero
ans[ans>255] = 255        # limite superior es 255
ans
# array([0, 0, 0])           # negro (ya no se le puede quitar color o luz al negro, por tanto sigue siendo negro)

Blanco, amarillo y negro