Introducción a Python - Optimización 2019

Contenidos

• ¿Por qué usar Python?
• Sintaxis
• Objetos Básicos de Python
  • Bool
  • int & float
  • Strings
  • Listas
  • Tupla
  • Diccionario
• Mutables e Immutables
• Algunos trucos de Python
• Funciones
  • Funciones factoría
• Librería Numpy
  • Comandos útiles para arrays
• Librería Matplotlib

¿Por qué usar Python?

• ¡Gratis!
• Gran comunidad ($\Rightarrow$ Diversidad de paquetes y funcionalidades)
• Versátil
• Es fácil plasmar ideas
• Sintaxis amena

Sintaxis

• Asignar valor: =

• Operadores aritméticos: +, -, *, /, %, **

  En Python son equivalentes, por ejemplo: x = x + 1 y x += 1

• Operadores de comparación: ==, !=, >, <, >=, <=

• Operadores de pertenencia: in, not in

  Ejemplo:

ls = [1, 2, 9, 11]
print(9 in ls)
print(5 in ls)
print (5 not in ls)

True
False
True

• Loops: for, while (indentar el bloque!)
• Condicionales: if, else, elif (indentar el bloque!)

Objetos básicos de Python

| Bool | string | set | int | list | dict| float | tuple |

Bool

• Puede tomar dos valores: True o False

• Se pueden concatenar condiciones con conectores lógicos (and, or) y/o combinarlos con la negación not

  x + 4 >= 3 and not x \% 2 == 0

  x % 2 == 0 and (x < 0 or x > 4)

• Importante: Python realiza una evaluación lazy de las condiciones lógicas.

• Si pasamos 0 u otros objetos vacíos ([], {}, (), set([])) como condición lógica Python los interpreta como False

x = 0
if x:
    x = x + 1
print('el valor de x es: ', x)

el valor de x es:  0

int & float

Los objetos int son utilizados para los números enteros mientras que los float son utilizados para los "reales" (en realidad, para los racionales)

• Importante: en Python 2.7 el operador / representa la división piso, mientras que en Python 3+ el operador / representa la división común (devuelve un float) y // representa la división piso.

# Este codigo es ejecutado en Python 3.6
x = 2
y = 5
print('Resultado de x/y: ', y/x)
print('Resultado de x//y: ', y//x)

Resultado de x/y:  2.5
Resultado de x//y:  2

Si deseamos llevar a cabo la división común en Python 2.7, basta con convertir al divisor o al dividendo en float

x = 2
y = 5
# Ejecutar y/x en Python 2.7 nos daría como resultado 2
print('Resultado de y/float(x): ', y/float(x))

Resultado de y/float(x):  2.5

Strings

Limitados por comillas: " " o ' '

A continuación, algunos ejemplos de operaciones con strings:

# Definimos dos strings
s = "Hola"
t = "Mundo"
print('s : ', s)
print('t : ', t)

# Podemos acceder a una parte de cada  string utilizando 
# la sintaxis: [indice_inicial, indice_final]. El índice final es excluido
print('s[1:3] : ',s[1:3])

# Usamos el operador + para concatenar strings (o partes de ellos)
print('s + t : ', s+t)
print('s[1:3] + " " + t : ', s[1:3] + " " + t)

# El operador * va seguido de un entero positivo n, y sirve para repetir el string n veces
print('s * 3 : ', s*3)

s :  Hola
t :  Mundo
s[1:3] :  ol
s + t :  HolaMundo
s[1:3] + " " + t :  ol Mundo
s * 3 :  HolaHolaHola

Listas (list)

Uno de los objetos más maleables de Python. No es necesario que los elementos de una lista sean todos del mismo tipo. Por ejemplo, podríamos crear una lista que contenga str e int e incluso que contenga otra lista

A = [1, 3, 'casa', [11, 9]]
print(A)

[1, 3, 'casa', [11, 9]]

Importante: en Python las secuencias (como listas y tuplas) comienzan en la posición 0

Hay varias funciones para las listas que permiten, por ejemplo, agregar un elemento al final de la lista (append) o encontrar el índice de un determinado elemento (index). Una lista comprensiva puede encontrarse en este link

# Definimos una lista
A = [1, 11, 3, -4]
print('A : ', A)

# Agregamos un elemento al final
A.append('casa')
print('A : ', A)

# Eliminamos el elemento del índice 2
del A[2]
print('A : ', A)

# Cambiamos el primer elemento
A[0] = 13
print('A : ', A)

# Queremos obtener el una porción de A: desde el índice 1 hasta el final (la lista A no se modifica)
print('A[1:] : ', A[1:])

# Definimos otra lista y las concatenamos (ninguna de las dos listas es modificada)
B = [-1, [1,3]]
print ('A + B :', A + B )

A :  [1, 11, 3, -4]
A :  [1, 11, 3, -4, 'casa']
A :  [1, 11, -4, 'casa']
A :  [13, 11, -4, 'casa']
A[1:] :  [11, -4, 'casa']
A + B : [13, 11, -4, 'casa', -1, [1, 3]]

Listas por comprensión

Definir listas por comprensión es una manera más elegante y compacta que utilizar for's e if's anidados.

La desventaja es que puede dificultar la lectura del código. La ventaja es que es más rápido definirla que utilizar un loop.

# Definamos una lista de todos los enteros no negativos hasta 21, inclusive

# Sin definición por comprensión:
A = []
for x in range(22):      # range(22) = [0, 1, 2, ..., 21]
    if x % 2 == 0:
        A.append(x)
print('A : ', A)

# Con definición por comprensión
A = [x for x in range(22) if x % 2 == 0]
print('A : ', A)

A :  [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
A :  [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Tuplas (tuple)

Las tuplas son parecidas a las listas: tienen un orden y pueden estar conformadas por distintos tipos de objetos. La gran diferencia es que, una vez que definimos la tupla, no podemos agregarle ni quitarle elementos. La sintaxis para acceder a sus elementos es igual a la de las listas.

Las tuplas son útiles para cuando sabemos que no realizaremos modificaciones. Además, iterar sobre una tupla es levemente más rápido que iterar sobre una lista.

# Creamos una tupla
A = (1, 5, [3, 7])
print(A)

# Accedemos a su primer elemento
print(A[0])

(1, 5, [3, 7])
1

Conjuntos (set)

La definición es análoga a los conjuntos que conocemos de toda la vida. A diferencia de listas y tuplas, no pueden tener elementos repetidos y sus elementos no están ordenados.

Además, los elementos de un set pueden ser sólo int, float, str, bool o tuple. Los set tienen varios métodos que permiten realizar las operaciones usuales (como intersección, unión, etc.). Pueden consultarse en este link

# Definimos un conjunto A
A = set([2, 3, 4, 11 , 12])
print('A : ', A)

# Podemos definir conjuntos por compresión. Lo siguiente es lo mismo que hacer:
# B=set([])
# for x in range(15):
#     if x not in A:
#        B.add(2*x-1)

B = set([2*x+1 for x in range(15) if x not in A])
print('B : ', B)

# Creamos un nuevo conjunto que resulta de intersecar A y B
C = A.intersection(B)
print('C = A n B : ', C)

# Creamos un nuevo conjunto que resulta de la diferencia entre B y C (B/C)
D = B.difference(C)
print('B / C : ', D)

A :  {2, 3, 4, 11, 12}
B :  {1, 3, 11, 13, 15, 17, 19, 21, 27, 29}
C = A n B :  {11, 3}
B / C :  {1, 13, 15, 17, 19, 21, 27, 29}

Diccionarios (dict)

Finalmente tenemos a los diccionarios. Los diccionarios tienen claves y valores (keys y values, respectivamente). Se definen encerrados entre llaves, de la siguiente manera: {key1: value1, key2: value2,...}

Importante: las claves (keys) no pueden repetirse y deben ser alguno de los siguientes tipos: int, float, str o tuple. Los valores (values) pueden ser un objeto de cualquier tipo.

Veamos algunos ejemplos:

# Definimos un nuevo diccionario
D = {'Pedro': 101, 'Ana': 203, 'Julían': 112, 'Marcos': 164, 'Tamara': 187}

# También podemos definirlo como un diccionario vacío e ir añadiendo claves y valores
D = dict()
D['Pedro'] = 101    # Como la entrada 'Pedro' no existe en D, la añade. Si no, modifica su valor
D['Ana'] = 203
D['Julián'] = 112
D['Marcos'] = 164
D['Tamara'] = 187

# También podemos definirlo por compresión:
nombres = ['Pedro', 'Ana', 'Julián', 'Marcos', 'Tamara']
habitaciones = [101, 203, 112, 164, 187]
D = {nombres[i]: habitaciones[i] for i in range(len(nombres))}
print('D : ', D)

# Podemos acceder al valor de una llave
print('D["Ana"] :', D['Ana'])

D :  {'Pedro': 101, 'Ana': 203, 'Julián': 112, 'Marcos': 164, 'Tamara': 187}
D["Ana"] : 203

Para más información sobre diccionarios y sus métodos, se puede visitar este link

mutables e immutables

Los objetos que vimos anteriormente se dividen en dos categorías: mutables e immutables, de la siguiente manera:

Mutables: list, set, dict

Immutables: string, bool, int, float, tuple

Un objeto mutable puede cambiar su estado o contenidos, pero un objeto immutable no. En Python, cuando uno asigna un objeto a una variable no está copiando el objeto, sino creando una referencia a él. Para entender la diferencia entre las dos categorías, veremos algunos ejemplos. Utilizaremos el comando id

# Definimos dos variables
x = 10
y = x
print('x : ', x)
print('y : ', y)

# Los identificadores de ambas variables apuntan al mismo objeto: 10
print('id(x) == id(y) : ', id(x) == id(y))
print('id(y) == id(10) : ', id(y) == id(10))

x :  10
y :  10
id(x) == id(y) :  True
id(y) == id(10) :  True

Efectuamos una operación que cambia el valor de x. Veamos qué ocurre:

# Ahora efectuamos una operación que modifica el valor de x
print('Cambia el valor de x')
x = x + 1

# Los identificadores de ambas variables apuntan distintos objetos
print('id(x) == id(y) : ', id(x) == id(y))
print('id(y) == id(10) : ', id(y) == id(10))

Cambia el valor de x
id(x) == id(y) :  False
id(y) == id(10) :  True

Asignamos un nuevo valor a x pero el objeto 10 no cambió. Notar que tampoco cambió el valor de y (sigue valiendo 10)

Veamos qué ocurre con un objeto mutable:

# Definimos una lista A
A = [2, 1, 11, -1, 0]
print('A : ', A)
print('id(A) : ', id(A))

# Definimos otra lista B como igual a A
B = A
print('B : ', B)
print('id(B) : ', id(B))

# Los identificadores de A y de B apuntan al mismo objeto: [2, 1, 11, -1, 0]
print('id(A) == id(B) : ', id(A) == id(B))

A :  [2, 1, 11, -1, 0]
id(A) :  140139823164232
B :  [2, 1, 11, -1, 0]
id(B) :  140139823164232
id(A) == id(B) :  True

Veamos qué ocurre si modificamos A:

# Ahora efecutamos una modificación a A: por ejemplo, agregamos un elemento
A.append(99)

# Los identificadores de A y de B siguen apuntando al mismo objeto: [2, 1, 11, -1, 0, 99] 
# Esto ocurre porque, en este caso, el objeto sí cambió
print('A : ', A)
print('id(A) : ', id(A))
print('id(A) == id(B) : ', id(A) == id(B))

A :  [2, 1, 11, -1, 0, 99]
id(A) :  140139823164232
id(A) == id(B) :  True

En este caso, como el objeto lista es mutable, el objeto sí cambia. Ahora el objeto es [2,1,11,-1,0,99] y las variables A y B siguen apuntando a él.

Importante: si A hace referencia a un objeto mutable (como un set) y queremos copiar A porque, por ejemplo, queremos guardar su estado actual antes de efectuar modificaciones sobre él, debemos recurrir a la función copy.

# Definimos A
A = set([2, 1, 11, -1, 0])

# Queremos definir B, una copia de A
B = A.copy()

print('A : ', A)
print('B : ', B)
print('id(A) == id(B) : ', id(A) == id(B))

A :  {0, 1, 2, 11, -1}
B :  {0, 1, 2, 11, -1}
id(A) == id(B) :  False

Notar que tanto A como B son set con los mismos elementos, pero hacen referencia a distintos objetos. Ahora, si efectuamos cambios sobre A, B no se modifica.

# Eliminamos el elemento más chico de A
A.discard(min(A))

# Agregamos un nuevo elemento a A
A.add(99)

print('A : ', A)
print('B : ', B)

A :  {0, 1, 2, 99, 11}
B :  {0, 1, 2, 11, -1}

Notar que B no sufrió cambios.

El comando deepcopy se utiliza de igual manera. Es utilizado cuando hay mutables que contienen a otros mutables (como diccionarios que tengan listas como valores). La desventaja de copy y, especialmente, de deepcopy es que pueden incrementar el tiempo de cómputo significativamente.

Observación: si queremos realizar una copia de la lista A, basta con escribir B = A[:]

Algunos trucos de Python

Iteración

En Python generalmente se aprovecha el operador in para iterar. Por ejemplo, si deseamos imprimir los números del $2$ al $10$ basta con escribir:

for i in range(2, 11):
    print(i)

2
3
4
5
6
7
8
9
10

range tiene la siguiente sintaxis range(inicio, fin, paso) donde fin no está incluido e inicio y paso son opcionales (sus valores por defecto son $0$ y $1$, respectivamente).

Asimismo, con in podemos iterar sobre los elementos de cualquier iterable como, por ejemplo, una lista:

L = [-1, 4, 5, 7]

for i in L:
    print(i)

-1
4
5
7

Sumatoria

Como se ha visto en cursos previos, si uno desea computar la siguiente sumatoria:

$$ \sum_{i=0}^{100} i $$

lo hace de la siguiente manera

s = 0
for i in range(101):
    s = s + i

En Python existe una manera más compacta de lograr el mismo resultado:

s = sum(i for i in range(101))

De ser necesario, también se pueden agregar condiciones sobre $i$. Si queremos computar la siguiente sumatoria:

$$ \sum_{i \in I} (i + 1)^2 \quad I=\{n\in\mathbb{N}\colon 0\leq n\leq 100 \; \wedge n\;\text{múltiplo de 3}\} $$

Basta con escribir la siguiente línea

s = sum((i+1)**2 for i in range(101) if i % 3 == 0)

Funciones

Declaramos funciones con el comando def. El bloque de la función debe estar indentado (al igual que cuando definimos un while, for o if).

Si necesitamos que la función devuelva un valor, usamos el comando return.

def cuadrado(n):
    return n**2

x = 4
print(cuadrado(4))

16

Las funciones pueden ser definidas con argumentos opcionales que tienen un valor por defecto.

def potencia(n, m=2):
    return n**m

x = 3

# Si no pasamos el argumento m, la función considera su valor por defecto.
y = potencia(3)
print('potencia(3) : ', y)

# En cambio, si le otorgamos un valor a m:
y = potencia(3,4)
print('potencia(3,4) : ', y)

potencia(3) :  9
potencia(3,4) :  81

Importante: las funciones pueden efectuar cambios sobre los objetos mutables . Esto significa pero tenemos que prestar atención a los cambios realizados sobre estos objetos, especialmente si los seguiremos utilizando en otras partes del código.

# La función 'foo' obtiene el último elemento de una lista, 
# lo borra de ella y lo eleva al cuadrado 
def foo(ls):
    y = ls.pop()
    return y**2
    
# Definimos una lista
A = [2, 3 ,7, 11]
print('A : ', A)

# Aplicamos la función
x = foo(A)

# Notar que, aunque Python tenga un scope local en las funciones, 'A' ha sido modificada
print('A después de aplicar la función : ', A)

A :  [2, 3, 7, 11]
A después de aplicar la función :  [2, 3, 7]

El mismo comportamiento no se observa con los objetos immutables

def siguiente(n):
    n += 1
    print('x en la función :', n)
    
# Definimos x
x = 3
print('x antes de la función : ', x)

# Aplicamos la función
siguiente(x)
print('x después de correr la función : ', x)  # El valor de x no cambió fuera de la función

x antes de la función :  3
x en la función : 4
x después de correr la función :  3

# Si queremos que efectivamente x cambie, redefinimos la función de la siguiente manera:
def siguiente(n):
    n += 1
    return n

# Definimos x
x = 3
print('x antes de la función : ', x)

# Aplicamos la función, pero tenemos que asignarle el resultado a x.
x = siguiente(x)
print('x después de asignarle el resultado de la función : ', x) 

x antes de la función :  3
x después de asignarle el resultado de la función :  4

Funciones factoría

En nuestro contexto, llamaremos funciones factoría a las funciones que devuelven una función. En otras palabras, cada vez que llamamos a una función factoría, lo que obtendremos como output es una función. Veamos un ejemplo:

# Definimos la función factoría: queremos que, dada una base, nos devuelva una función
# que permita calcular sus potencias.
def generar_potencia(base):
    
    # Definimos la función del output
    def potencia_enesima(potencia):
        return base ** potencia
    
    return potencia_enesima

# Definamos la función que permita calcular las potencias de 2
elevar_2 = generar_potencia(2)

# Ejecutamos la función elevar_2
print('elevar_2(3) : ', elevar_2(3))
print('elevar_2(6) : ', elevar_2(6))

# Ahora podemos  definir una función que permita calcular las potencias de 3
elevar_3 = generar_potencia(3)

# Ejecutamos la función elevar_3
print('elevar_3(2) : ', elevar_3(2))
print('elevar_3(7) : ', elevar_3(7))

elevar_2(3) :  8
elevar_2(6) :  64
elevar_3(2) :  9
elevar_3(7) :  2187

Obviamente, se puede encarar el problema por otro camino. Por ejemplo, definiendo la siguiente función:

# Definimos la función potencia 
def potenciar(base, potencia):
    return base ** potencia

# Calculamos las mismas potencias que antes con esta nueva función
print('potencia(2,3) : ', potenciar(2,3))
print('potencia(2,6) : ', potenciar(2,6))
print('potencia(3,2) : ', potenciar(3,2))
print('potencia(3,7) : ', potenciar(3,7))

potencia(2,3) :  8
potencia(2,6) :  64
potencia(3,2) :  9
potencia(3,7) :  2187

En cierta manera, con la función factoría estamos definiendo una función $F$ sobre $\mathbb{R}$ tal que: $$F(x) = f_x \quad \text{siendo } f_x(y) = x^y $$ Por otro lado, la función potencia simplemente define: $$f:\mathbb{R}^2\rightarrow \mathbb{R} \quad \text{como } f(x,y)=x^y$$

Librería Numpy

Utilizaremos los objetos array de la librería numpy para trabajar con matrices en Python. Es importante notar que un arrayes mutable y que, a diferencia de las listas, todos sus elementos deben ser del mismo tipo. Es decir, por ejemplo, no podemos crear un array que contenga enteros y strings.

La librería numpy se instala con el siguiente comando en la consola:

pip install numpy

Al comienzo de nuestro script en Python importamos la librería numpy con el alias np (para que sea más rápido escribirlo luego):

import numpy as np

Una vez hecho eso, podemos empezar a trabajr con arrays. Veamos un par de ejemplos.

Definimos los vectores $v=(0, 1, -1)$ y $w=(2,1, 3)$.

v = np.array([0, 1, -1])
w = np.array([2, 1, 3])

Ahora podemos realizar distintas operaciones.

Importante: el operador * no realiza el producto interno entre dos vectores o el producto entre dos matrices. Utilizaremos * sólo cuando querramos multiplicar una matriz o un vector por un escalar, ya que * realiza multiplicación elemento a elemento. Para el producto interno entre vectores, el producto entre matrices y el producto entre un vector y una matriz se utiliza el comando dotpara Python 2.7 o el operador @ para Python 3+. A continuación, algunos ejemplos.

# Sumamos w y v
z = w+v
print('z = w + v : ',z)

# Realizamos el producto interno entre v y w: z=<v,w>
z = v.dot(w)    # Para Python 2.7
z = v @ w       # Para Python 3+
print('z = v @ w : ', z)

# Si realizamos operaciones entre vectores y escalares, se interpretan como operaciones lugar a lugar
print(' v + 1 : ', v+1)
print(' w * 2 : ', w*2)

z = w + v :  [2 2 2]
z = v @ w :  -2
 v + 1 :  [1 2 0]
 w * 2 :  [4 2 6]

Las matrices se definen de manera similar a los vectores, sólo que en vez de estar definidas en base a listas, lo están en base a listas de listas. Definimos la siguiente matriz: $$A =\left( \begin{array}{ccc} 1 & -3 & 2 \\ 0 & 6 & -2 \\ 4 & 8 & 0 \\ \end{array} \right) $$

A = np.array([[1, -3, 2], [0, 6, -2], [4, 8 ,0]]) # Notar que cada una de las listas es una fila

También se pueden realizar operaciones entre matrices o entre matrices y vectores, siempre y cuando las dimensiones sean adecuadas. Lo bueno de definir vectores como arrarys es que no tenemos que preocuparnos por trasponerlos si deseamos multiplicarlos por una matriz:

b = A @ v         # A.dot(v) para Python 2.7
print(b)

[-5  8  8]

Recordar que $v=(0, 1, -1)$, sin embargo, para efectuar el cálculo $Av^t$, no necesitamos trasponer v.

También podemos acceder a elementos de un array. Si se trata de un vector, accedemos a un elemento como lo haríamos si se tratara de una lista, es decir, con [ ].

print('Segunda coordenada de v : ', v[1])
print('Primera coordenada de w : ', w[0])

Segunda coordenada de v :  1
Primera coordenada de w :  2

En el caso de las matrices, la sintaxis es [fila, columna]. Por ejemplo, A[0,1] es $A_{1 2}$.

Como en el caso de las listas, también podemos utilizar slices para obtener partes de la matriz o vector. Por ejemplo:

• si nos queremos quedar con la primera fila de A, lo hacemos de la siguiente manera: A[0, :]
• si queremos la submatriz formada por las últimas dos filas y últimas dos columnas: A[-2:, -2:]
• si queremos la segunda columna de: A[:, 1]

Comandos útiles para arrays

• el atributo shape nos devuelve las dimensiones del array: A.shape devuelve la tupla (3, 3). Así, si queremos la cantidad de filas de una matriz, usamos A.shape[0] y si queremos la cantidad de columnas, A.shape[1]. En el caso de los arrays que representan vectores, shape devuelve una tupla de un solo elemento, que representa la longitud del vector.
• el atributo T permite trasponer la matriz. No modifica la matriz original. Por ejemplo, si queremos calcular $A^tA$ basta escribir A.T @ A.
• el comando zeros permite inicializar una matriz o vector nulo (con $0$ en todas sus coordenadas). Hay que pasarle las dimensiones como input. Por ejemplo, np.zeros((4,3)) devuelve la matriz nula de $4\times 3$ y np.zeros(A.shape) devuelve una matriz nula del mismo tamaño que A.
• el comando ones es análogo a zeros, sólo que devuelve una matriz con 1 en todas sus filas y columnas.
• el comando eye nos permite crear la matriz identidad. Como genera una matriz cuadrada, sólo requiere un entero como input. Así pues, np.eye(4) devuelve la matriz identidad de tamaño $4\times 4$
• el comando arange permite generar un vector que contiene a todos los números en un determinado rango. La sintaxis es np.arange(inicio, fin, paso) donde finno está incluido y paso es optativo (el valor por defecto es 1). Por ejemplo, np.arange(1, 5) devuelve el array que representa al vector $(1, 2, 3, 4)$ y np.arange(0,10,2) al array que representa a $(0,2,4,6,8)$.

• el comando random.random nos permite generar una matriz aleatoria de un determinado tamaño. Toma como input una tupla con el tamaño de la matriz. Por ejemplo, np.random.random((3,4)) devuelve una matriz de $3\times 4$ y np.random.random(A.shape) devuelve una matriz aleatoria con el mismo tamaño que A. Los valores aleatorios se encuentran en el intervalo $[0,1)$
• recordar que los array son mutables. El comando copy nos permite crear la copia de un array. Por ejemplo, si queremos crear B una copia de A, lo hacemos de la siguiente manera: B = A.copy()

• para concatenar arrays, se puede usar el comando concatenate. Los arrays deben tener dimensiones adecuadas para poder concatenarse.
  • Por ejemplo, supongamos que: $$A = \left( \begin{array}{cc} 1 & 3 \\ -1 & 2 \\ 0 & 2 \end{array} \right) \qquad B = \left( \begin{array}{ccc} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array} \right) $$ Entonces el comando np.concatenate((A, B), axis=1) devuelve la siguiente matriz: $$ \left( \begin{array}{ccccc} 1 & 3 & 1 & 0 & 0 \\ -1 & 2 & 0 & 1 & 0 \\ 0 & 2 & 0 & 0 & 1 \end{array} \right) $$ El argumento opcional axis sirve para indicar cómo queremos concatenar los arrays. Con axis=0, se intenta concatenar los arrays verticalmente; con axis=1, horizontalmente. En el ejemplo anterior, saltará un error al interntar concatenar verticalmente $A$ y $B$ puesto que sus dimensiones no lo permiten.

• el paquete linalg de numpy tiene algunas funciones que nos serán de utilidad. Por ejemplo, si deseamos importar la función norm de linalg, que sirve para calcular la norma de un vector o una matriz, escribimos al comienzo del script: from numpy.linalg import norm Luego, si queremos calcular la norma de v, basta con escribir norm(v)

Librería matplotlib

La librería matplotlib, gracias a su gran versatilidad, es una de las más utilizadas para graficar en Python. Como veremos más adelante, tiene muchos comandos que son análogos a los de MATLAB.

Para instalar la librería, en la consola ejecutamos:

pip install matplotlib

Para los fines de la materia, bastará usar el módulo pyplotde matplotlib, por lo que al comienzo de los scripts lo importaremos con el alias plt:

import matplotlib.pyplot as plt

A continuación un ejemplo de cómo se grafica la función $f(x)=sen(x)$

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0,2*np.pi,100)       # linspace(inicio, fin, cantidad de puntos)
plt.plot(x, np.sin(x))
plt.show()

También podemos incluir funciones que hayamos definido nosotros.

import matplotlib.pyplot as plt
import numpy as np

def f(x):
    if x <= 0:
        return -x**2
    else:
        return x**2

x = np.linspace(-2,2,100)
vf = np.vectorize(f)   # Permitimos que nuestra función sea aplicable a arrays
y = vf(x)
plt.plot(x, y)
plt.show()

Podemos graficar varias funciones en el mismo gráfico

import matplotlib.pyplot as plt
import numpy as np

def f(x):
    if x <= 0:
        return -x**2
    else:
        return x**2

def g(x):
    return x**3

x = np.linspace(-2,2,100)
vf = np.vectorize(f)   # A partir de nuestra función f definimos vf que es aplicable a arrays
vg = np.vectorize(g)   # A partir de nuestra función g definimos vg que es aplicable a arrays
y = vf(x)
z = vg(x)
plt.axis([-2, 2, -4, 4])  # Fijamos los limites de los ejes del gráfico [x0, x1, y0, y1]
plt.plot(x, y, label='f(x)')  # Podemos poner etiquetas para añadir una leyenda
plt.plot(x, z, label='g(x)')
plt.legend()
plt.show()