In [1]:
x = 20
y = 5
print(x+y)
add_numbers es una función que toma dos números y los suma.
In [2]:
def add_numbers(x, y):
return x + y
add_numbers(1, 2)
Out[2]:
add_numbers puede actualizarse agregando un tercer parámetro. Usando print se pueden imprimir múltiples opciones en una sola celda de Jupyter.
In [3]:
def add_numbers(x,y,z=None):
if (z==None):
return x+y
else:
return x+y+z
print(add_numbers(1, 2))
print(add_numbers(1, 2, 3))
A add_numbers también pordemos agregarle un parámetro opcional llamado flag.
In [1]:
def add_numbers(x, y, z=None, flag=False):
if (flag):
print('¡Flag es verdad, y es muy útil!')
if (z==None):
return x + y
else:
return x + y + z
print(add_numbers(1, 2, 20, flag=True))
Se puede también asignar la función add_numbers a una variable a.
In [5]:
def add_numbers(x,y,z):
return x+y+z
a = add_numbers
a(1, 2, -5)
Out[5]:
La función min devuelve el elemento más pequeño en un iterable o el más pequeño de dos o más argumentos.
In [3]:
x = (1,3,5, -6)
minimum = min(x)
print(minimum)
La función pow(x,y) devuelve x a la potencia de y.
In [4]:
p = pow(2,2)
print(p)
La función x//y devuelve la parte entera del cociente entre x y y.
In [5]:
div = 5/2
print(div)
divint = 5//2
print(divint)
La función x%y devuelve el resto de la división entre x y y.
In [8]:
mod1 = 4%2
print(mod1)
mod2 = 5%2
print(mod2)
Use type para devolver el tipo del objeto.
In [9]:
type('Esto es una cadena de caracteres')
Out[9]:
In [10]:
type(None)
Out[10]:
In [11]:
type(10000)
Out[11]:
In [12]:
type(100000.0)
Out[12]:
In [13]:
type(add_numbers)
Out[13]:
Una tupla es una estructura de dato inalterable. Las tuplas son secuencias, al igual que las listas. La diferencia entre las tuplas y las listas es que las tuplas no se pueden modificar a diferencia de las listas. Las tuplas usan paréntesis, mientras que las listas usan corchetes.
In [14]:
x = (1, 'b', 25, 'c')
print(type(x))
y = [1, 'b', 25, 'c']
print(type(y))
Veamos algunas modificaciones en la estructura de datos lista.
Usemos append para gregar un elemento a la lista.
In [15]:
y.append(2.5)
print(y)
Este es un ejemplo de cómo se puede hacer un ciclo para recorrer los elementos de la lista.
In [16]:
for elemento in y:
print(elemento)
O podemos utilizar el operador de índices:
In [18]:
i=0
while( i != len(y) ):
print(y[i])
i = i + 1
Use + para concatenar listas.
In [19]:
[1,25] + [3,'z']
Out[19]:
Use * para repetir listas.
In [20]:
[3, 'z']*4
Out[20]:
Use el operador in para chequear si algo está dentro de la lista.
In [21]:
'z' in [3,'z', 25]
Out[21]:
Use la notación bracket [] para picar o rebanar listas o cadenas de caracteres
In [21]:
y =[2, 'c', 34, -2, 'f']
print(y[1]) #primer elemento de la lista
print(y[0:1]) #primer elemento devuelto como lista
print(y[0:2]) #dos primeros elementos devueltos como lista
x = 'Esto es una cadena de caracteres'
print(x[0]) #primer caracter
print(x[0:1]) #primer caracter, especificando último caracter
print(x[0:2]) #dos primeros caracteres
Esta instrucción devuelve el último elemento de la lista o de la cadena.
In [24]:
print(y[-1])
print(x[-1])
Esta instrucción devuelve un pedazo de la lista o cadena empezando desde el cuarto elemento desde el final y deteniéndose antes del segundo elemento del final.
In [25]:
print(y)
print(y[-4:-2])
print(x)
print(x[-4:-2])
Este es un pedazo de la lista o cadena desde el inicio y se detiene antes del tercer elemento.
In [26]:
print(y)
print(y[:3])
print(x)
print(x[:3])
Y este es un pedazo de la lista o cadena empezando desde el tercer elemento y siguiendo hasta el final.
In [27]:
print(y)
print(y[3:])
print(x)
print(x[3:])
Vamos a importar un archivo txt como
uno CSV que contiene como columnas las etiquetas:
Y como filas:
In [35]:
import csv
with open('empleados_cumple.txt') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
print(f'Los nombres de las columnas son: {", ".join(row)}')
line_count += 1
else:
print(f'\t{row[0]} trabaja en el departamento de {row[1]}, y nació en el mes de {row[2]}.')
line_count += 1
print(f'Líneas procesadas: {line_count}.')
In [36]:
import numpy as np
Podemos generar una lista y convertirla en un arreglo NumPy.
In [44]:
milista = [1, 25, 31, 5]
x = np.array(milista)
x
Out[44]:
O simplemente podemos pasarle una lista directamente.
In [45]:
y = np.array([1, 25, 31, 5])
y
Out[45]:
Podemos pasarle una lista de listas para crear un arreglo multidimensional.
In [46]:
m = np.array([[1, 25, 31, 5], [10, 2, 11, 12], [5, 7, 0, 1]])
m
Out[46]:
Usa el método shape para encontrar las dimensiones del arreglo. (filas, columnas)
In [47]:
m.shape
Out[47]:
arange devuelve valores espaciados uniformemente dentro de un intervalo dado.
In [48]:
n = np.arange(0, 30, 2) # empieza en 0 cuenta de 2 en 2, se detiene antes de 30
n
Out[48]:
reshape devuelve una matriz con los mismos datos con una nueva forma.
In [49]:
n = n.reshape(3, 5) #cambia la forma de manera que se obtenga una matriz 3x5
n
Out[49]:
In [51]:
p = np.ones([2, 3], int)
p
Out[51]:
Use vstack para apilar matrices en secuencia verticalmente (por fila).
In [52]:
np.vstack([p, 2*p])
Out[52]:
Use hstack para apilar arreglos en secuencia horizontalmente (por columna).
In [53]:
np.hstack([p, 2*p])
Out[53]:
Use +, -, *, / and ** para realizar operaciones de suma , resta, multiplicación, división y potencia elemento a elemento.
In [54]:
print(x)
print(y)
print(x + y) # suma elemento a elemento [1 2 3] + [4 5 6] = [5 7 9]
print(x - y) # resta elemento a elemento [1 2 3] - [4 5 6] = [-3 -3 -3]
In [55]:
print(x)
print(y)
print(x * y) # multiplicación elemento a elemento [1 2 3] * [4 5 6] = [4 10 18]
print(x / y) # división elemento a elemento [1 2 3] / [4 5 6] = [0.25 0.4 0.5]
In [56]:
print(x)
print(x**2) # potencia elemento a elemento [1 2 3] ^2 = [1 4 9]
Producto punto o escalar:
$ \begin{bmatrix}x_1 \ x_2 \ x_3\end{bmatrix} \cdot \begin{bmatrix}y_1 \\ y_2 \\ y_3\end{bmatrix} = x_1 y_1 + x_2 y_2 + x_3 y_3$
In [57]:
print(x)
print(y)
x.dot(y) #producto escalar
Out[57]:
In [61]:
print(y)
z = np.array([y, y**2])
print(z)
print(len(z)) #número de filas del arreglo
Vamos a mirar la transposición de matrices. La transposición permuta las dimensiones de la matriz.
In [62]:
zt = np.transpose(z, axes=None)
zt
Out[62]:
Las dimensiones del arreglo zt son (4,2) después de la transposición.
In [63]:
zt.shape
Out[63]:
Se puede usar también .T para obtener la transpuesta de un arreglo.
In [65]:
print(zt)
zt.T
Out[65]:
In [66]:
s = np.arange(13)**2
s
Out[66]:
Use la notación de bracket [] para obtener valores en el índice indicado. Recuerde que la indexación comienza en 0.
In [67]:
s[0], s[4], s[-1]
Out[67]:
Use : para indicar un rango. array[empieza:termina]
Dejando empieza or termina vacío quedará predeterminado al principio / final de la matriz.
In [69]:
s[1:5]
Out[69]:
Use contadores negativos desde el final.
In [70]:
s[-4:]
Out[70]:
Se puede usar un segundo : para indicar el tamaño del paso. array [empieza: termina: paso]
Aquí estamos comenzando el quinto elemento desde el final, y contando hacia atrás cada 2 hasta que se alcanza el comienzo de la matriz.
In [71]:
s[-5::-2]
Out[71]: