Te damos la bienvenida a Colab
Si ya conoces Colab, mira este video para aprender sobre las tablas interactivas, la vista histórica de código ejecutado y la paleta de comandos.
¿Qué es Colab?
Colab, o “Colaboratory”, te permite escribir y ejecutar código de Python en tu navegador, con
Una configuración lista para que empieces a programar
Acceso gratuito a GPU
Facilidad para compartir
Seas estudiante, científico de datos o investigador de IA, Colab facilita tu trabajo. Mira este video introductorio sobre Colab para obtener más información, o bien comienza a usarlo más abajo.
Introducción#
El documento que estás leyendo no es una página web estática, sino un entorno interactivo denominado notebook de Colab, que permite escribir y ejecutar código.
Por ejemplo, esta es una celda de código con una secuencia de comandos Python corta que calcula un valor, lo almacena en una variable y devuelve el resultado:
seconds_in_a_day = 24 * 60 * 60
seconds_in_a_day
86400
type(seconds_in_a_day)
int
A fin de ejecutar el código en la celda anterior, haz clic en él para seleccionarlo y luego presiona el botón de reproducción ubicado a la izquierda del código o usa la combinación de teclas “Command/Ctrl + Intro”. Para editar el código, solo haz clic en la celda y comienza a editar.
Las variables que defines en una celda pueden usarse en otras:
seconds_in_a_week = 7 * seconds_in_a_day
seconds_in_a_week
604800
Los notebooks de Colab te permiten combinar código ejecutable y texto enriquecido en un único documento, junto con imágenes, HTML, LaTeX y mucho más. Los notebooks que crees en Colab se almacenan en tu cuenta de Google Drive. Puedes compartir fácilmente los notebooks de Colab con amigos o compañeros de trabajo para que realicen comentarios o los editen. Si quieres obtener más información, consulta la Descripción general de Colab. Para crear un nuevo notebook de Colab, ve al menú Archivo que aparece más arriba o usa este vínculo: crear un nuevo notebook de Colab.
Los notebooks de Colab son notebooks de Jupyter que aloja Colab. Para obtener más información sobre el proyecto Jupyter, visita jupyter.org.
#Como saber la versión de Python
#Versión de python
!python --version
Python 3.8.10
Como saber la versión de Linux#
# Versión de Ubuntu
!lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 20.04.5 LTS
Release: 20.04
Codename: focal
Tutorial Python#
Conexión con Google drive#
from google.colab import drive
drive.mount('/content/drive')
Mounted at /content/drive
Asignación automatica de tipos de variables#
En Python no es necesario declarar explícitamente el tipo de las variables. El intérprete trata de inferir el tipo de las variables según se usan. Igualmente, las operaciones tienen semántica distinta para distintos tipos de datos. Fíjate en el ejemplo siguiente.
import numpy as np
a = 10
b = 3
c = 3.
d = "holaWorld"
e = True
f = 1e3
g = [1,2,3] # La lista es mutable
h = (1,2,3) # La tupla es inmutable
i = 5j
j = 1+2j
k = np.int16(300)
l = np.int8(6)
print ("a=",type(a))
print ("b=",type(b))
print ("c=",type(c))
print ("d=",type(d))
print ("e=",type(e))
print ("f=",type(f))
print ("g=",type(g))
print ("h=",type(h))
print ("i=",type(i))
print ("j=",type(j))
print ("k=",type(k))
print ("l=",type(l))
a= <class 'int'>
b= <class 'int'>
c= <class 'float'>
d= <class 'str'>
e= <class 'bool'>
f= <class 'float'>
g= <class 'list'>
h= <class 'tuple'>
i= <class 'complex'>
j= <class 'complex'>
k= <class 'numpy.int16'>
l= <class 'numpy.int8'>
Casteo de variables#
x='2'
y='3'
z=x+y
print('z=',z)
x1=int(x)
y1=int(y)
z1=x1+y1
print('z1=',z1)
z= 23
z1= 5
Operaciones Aritméticas#
print("Suma = ", 4+5)
print("Resta = ", 4-5)
print("Multiplicación = ", 4*5)
print("División = ", 4/5)
print("División entera = ", 10//3)
print("Residuo = ", 10%3)
print("Potencia = ", 2**3)
print("Raiz = ", 2**0.5)
Suma = 9
Resta = -1
Multiplicación = 20
División = 0.8
División entera = 3
Residuo = 1
Potencia = 8
Raiz = 1.4142135623730951
Operaciones con cadena de texto#
#Suma o concatenación
x="Un divertido"+"programa"+"de"+"radio"
print(x)
#Multiplicación de una cadena con un número
y=3*"programas"
print(y)
#Obtener longitud de una cadena
print('longitud de la cadena:',len(y))
Un divertidoprogramaderadio
programasprogramasprogramas
longitud de la cadena: 27
#Acceder a una posición de la cadena
cadena = "programA"
print('acceder a una posicion determinada:',cadena[0])
print('acceder a la última posición:',cadena[-1])
# Comillas simples
cadenaa = 'Texto entre comillas simples'
print (cadenaa)
print (type(cadenaa))
# Comillas dobles
cadenab = "Texto entre comillas dobles"
print (cadenab)
print (type(cadenab))
acceder a una posicion determinada: p
acceder a la última posición: A
Texto entre comillas simples
<class 'str'>
Texto entre comillas dobles
<class 'str'>
cad='reinel'
cad[2:5]
'ine'
cadenaesc = 'Texto entre \n\n\n \t\t\tcomillas simples'
print (cadenaesc)
print (type(cadenaesc))
Texto entre
comillas simples
<class 'str'>
Tuplas (Datos inmutables)#
Las tuplas son más rápidas que las listas. Si define un conjunto constante de valores y todo lo que va a hacer es iterar sobre ellos, use una tupla en lugar de una lista.
Una tupla es una secuencia de items ordenada e inmutable.
Los items de una tupla pueden ser objetos de cualquier tipo.
Para especificar una tupla, lo hacemos con los elementos separados por comas dentro de paréntesis.
Una tupla con únicamente dos elementos es denominada par.
Para crear una tupla con un único elemento (singleton), se añade una coma al final de la expresión.
Para definir una tupla vacía, se emplean unos paréntesis vacíos.
tupla = ('cadena de texto', 15, 2.8, 'otro dato', 25,25)
print(tupla)
print(type(tupla))
print(tupla[1:4])
print('cuantas veces hay un elemento=',tupla.count(25))
print('dice en que posicion esta el elemento=',tupla.index(15))
#tupla[0]=2# dado que es una TUPLA no se puede agregar ni borrar información.
('cadena de texto', 15, 2.8, 'otro dato', 25, 25)
<class 'tuple'>
(15, 2.8, 'otro dato')
cuantas veces hay un elemento= 2
dice en que posicion esta el elemento= 1
tupla, type(tupla), tupla[1:-1],tupla.count(25),tupla.index(15)
(('cadena de texto', 15, 2.8, 'otro dato', 25, 25),
tuple,
(15, 2.8, 'otro dato', 25),
2,
1)
#tupla[0]=2
Listas (Datos no inmutables)#
Una lista es una secuencia ordenada de elementos mutable.
Los items de una lista pueden ser objetos de distintos tipos.
Para especificar una lista se indican los elementos separados por comas en el interior de CORCHETES.
Para denotar una lista vacía se emplean dos corchetes vacíos.
a = [1,2,3,"hola", [10, "nunca", 90], -32]
print ("Toda la lista= ",a)
print(type(a))
print ("Longitud de la lista= ", len(a))
print("Acceder a un rango de posiciones=",a[0:4])
print("Acceder a una posición específica= ",a[4])
print("Acceder a la última posición= ",a[-1])
Toda la lista= [1, 2, 3, 'hola', [10, 'nunca', 90], -32]
<class 'list'>
Longitud de la lista= 6
Acceder a un rango de posiciones= [1, 2, 3, 'hola']
Acceder a una posición específica= [10, 'nunca', 90]
Acceder a la última posición= -32
a[1:-1]
[2, 3, 'hola', [10, 'nunca', 90]]
print("Lista= ",a)
a.append("Nuevo último")
print("Lista con nuevo último= ",a)
a[1]='nuevo1'
print("Lista con nuevo elemento en las posición 1= ",a)
a.insert(2,'nuevo2')
print("Lista con nuevo elemento en las posición 2= ",a)
Lista= [1, 2, 3, 'hola', [10, 'nunca', 90], -32]
Lista con nuevo último= [1, 2, 3, 'hola', [10, 'nunca', 90], -32, 'Nuevo último']
Lista con nuevo elemento en las posición 1= [1, 'nuevo1', 3, 'hola', [10, 'nunca', 90], -32, 'Nuevo último']
Lista con nuevo elemento en las posición 2= [1, 'nuevo1', 'nuevo2', 3, 'hola', [10, 'nunca', 90], -32, 'Nuevo último']
a,type(a),len(a)
([1, 'nuevo1', 'nuevo2', 3, 'hola', [10, 'nunca', 90], -32, 'Nuevo último'],
list,
8)
for i in range(len(a)):
print (i, "-->", a[i])
0 --> 1
1 --> nuevo1
2 --> nuevo2
3 --> 3
4 --> hola
5 --> [10, 'nunca', 90]
6 --> -32
7 --> Nuevo último
for i in a:
print (i)
1
nuevo1
nuevo2
3
hola
[10, 'nunca', 90]
-32
Nuevo último
print(a)
print(a[2:])
print(a[-3:])
print(a[4])
[1, 'nuevo1', 'nuevo2', 3, 'hola', [10, 'nunca', 90], -32, 'Nuevo último']
['nuevo2', 3, 'hola', [10, 'nunca', 90], -32, 'Nuevo último']
[[10, 'nunca', 90], -32, 'Nuevo último']
hola
a = [1,2,3,"hola", [10, "nunca", 90], -32]
print (a[4])
print (a[4][0])
print (a[4][1])
print (a[4][1][2:])
[10, 'nunca', 90]
10
nunca
nca
Diccionarios#
Los diccionarios de Python son una lista de consulta de términos de los cuales se proporcionan valores asociados. En Python, un diccionario es una colección no-ordenada de valores que son accedidos a traves de una clave. Es decir, en lugar de acceder a la información mediante el índice numérico, como es el caso de las listas y tuplas, es posible acceder a los valores a través de sus claves, que pueden ser de diversos tipo. Las claves son únicas dentro de un diccionario, es decir que no puede haber un diccionario que tenga dos veces la misma clave, si se asigna un valor a una clave ya existente, se reemplaza el valor anterior. No hay una forma directa de acceder a una clave a través de su valor, y nada impide que un mismo valor se encuentre asignado a distintas claves. La informacion almacenada en los diccionarios, no tiene un orden particular. Ni por clave ni por valor, ni tampoco por el orden en que han sido agregados al diccionario. Cualquier variable de tipo inmutable, puede ser clave de un diccionario: cadenas, enteros, tuplas (con valores inmutables en sus miembros), etc. No hay restricciones para los valores que el diccionario puede contener, cualquier tipo puede ser el valor: listas, cadenas, tuplas, otros diccionarios, objetos, etc.
# Definir una variable diccionario
futbolistas = dict()
futbolistas = {
1: "Casillas", 6: "Iniesta",3: "Piqué",
5: "Puyol",
7: "Villa", 8: "Xavi Hernández",
9: "Torres", 11: "Capdevila",
14: "Xavi Alonso", 15: "Ramos",
16: "Busquets"
}
# Recorrer el diccionario, imprimiendo clave - valor
print ("Vemos que los elementos no van \"ordenados\":")
for k, v in futbolistas.items():
print ("{} --> {}".format(k,v))
Vemos que los elementos no van "ordenados":
1 --> Casillas
6 --> Iniesta
3 --> Piqué
5 --> Puyol
7 --> Villa
8 --> Xavi Hernández
9 --> Torres
11 --> Capdevila
14 --> Xavi Alonso
15 --> Ramos
16 --> Busquets
futbolistas.items(),futbolistas.keys(),futbolistas.values()
(dict_items([(1, 'Casillas'), (6, 'Iniesta'), (3, 'Piqué'), (5, 'Puyol'), (7, 'Villa'), (8, 'Xavi Hernández'), (9, 'Torres'), (11, 'Capdevila'), (14, 'Xavi Alonso'), (15, 'Ramos'), (16, 'Busquets')]),
dict_keys([1, 6, 3, 5, 7, 8, 9, 11, 14, 15, 16]),
dict_values(['Casillas', 'Iniesta', 'Piqué', 'Puyol', 'Villa', 'Xavi Hernández', 'Torres', 'Capdevila', 'Xavi Alonso', 'Ramos', 'Busquets']))
# Nº de elementos que tiene un diccionario
numElemen = len(futbolistas)
print ("\nEl número de futbolistas es de {}".format(numElemen))
# Imprimir las claves que tiene un diccionario
keys = futbolistas.keys();
print ("\nLas claves de nuestro diccionario son : {}".format(keys))
# Imprimir los valores que tiene un diccionario
values = futbolistas.values();
print ("\nLos valores de nuestro diccionario son : {}".format(values))
El número de futbolistas es de 11
Las claves de nuestro diccionario son : dict_keys([1, 6, 3, 5, 7, 8, 9, 11, 14, 15, 16])
Los valores de nuestro diccionario son : dict_values(['Casillas', 'Iniesta', 'Piqué', 'Puyol', 'Villa', 'Xavi Hernández', 'Torres', 'Capdevila', 'Xavi Alonso', 'Ramos', 'Busquets'])
# Obtener el valor de un elemento dada su clave
elem = futbolistas.get(6)
print ("\nEl futbolista con clave 6 es {}".format(elem))
# Insertamos un elemento en el diccionario
## si la clave ya existe, el elemento NO se inserta
futbolistas.setdefault(10, 'Cesc')
print ("\nInsertamos el elemento con clave 10 y valor Cesc")
print ("Ahora el diccionario queda : {}".format(futbolistas))
# Añadimos, de otro modo, un elemento al diccionario
## si la clave ya existe, el valor se cambia por este nuevo
futbolistas[22] = 'Navas'
print ("\nAñadimos un nuevo elemento, ahora el diccionario queda: ")
print (futbolistas)
El futbolista con clave 6 es Iniesta
Insertamos el elemento con clave 10 y valor Cesc
Ahora el diccionario queda : {1: 'Casillas', 6: 'Iniesta', 3: 'Piqué', 5: 'Puyol', 7: 'Villa', 8: 'Xavi Hernández', 9: 'Torres', 11: 'Capdevila', 14: 'Xavi Alonso', 15: 'Ramos', 16: 'Busquets', 10: 'Cesc'}
Añadimos un nuevo elemento, ahora el diccionario queda:
{1: 'Casillas', 6: 'Iniesta', 3: 'Piqué', 5: 'Puyol', 7: 'Villa', 8: 'Xavi Hernández', 9: 'Torres', 11: 'Capdevila', 14: 'Xavi Alonso', 15: 'Ramos', 16: 'Busquets', 10: 'Cesc', 22: 'Navas'}
# Eliminamos un elemento del diccionario dada su clave
futbolistas.pop(22)
print ("\nEliminamos el elemento con clave 22")
print ("Ahora el diccionario queda: {}".format(futbolistas))
# Hacemos una copia del diccionario
futbolistas_copia = futbolistas.copy()
print ("\nLa copia del diccionario tiene los valores:")
print (futbolistas_copia)
# Borramos los elementos de un diccionario
futbolistas_copia.clear()
print ("\nVaciamos el diccionario nuevo creado, ahora los valores en el: {}".format(futbolistas_copia))
Eliminamos el elemento con clave 22
Ahora el diccionario queda: {1: 'Casillas', 6: 'Iniesta', 3: 'Piqué', 5: 'Puyol', 7: 'Villa', 8: 'Xavi Hernández', 9: 'Torres', 11: 'Capdevila', 14: 'Xavi Alonso', 15: 'Ramos', 16: 'Busquets', 10: 'Cesc'}
La copia del diccionario tiene los valores:
{1: 'Casillas', 6: 'Iniesta', 3: 'Piqué', 5: 'Puyol', 7: 'Villa', 8: 'Xavi Hernández', 9: 'Torres', 11: 'Capdevila', 14: 'Xavi Alonso', 15: 'Ramos', 16: 'Busquets', 10: 'Cesc'}
Vaciamos el diccionario nuevo creado, ahora los valores en el: {}
# Comprobamos si existe o no una clave en un diccionario
if 2 in futbolistas:
print ("\nEl futbolista con la clave 2 existe en el diccionario.")
else:
print ("\nEl futbolista con la clave 2 NO existe en el diccionario.")
if 8 in futbolistas:
print ("\nEl futbolista con la clave 8 existe en el diccionario.")
else:
print ("\nEl futbolista con la clave 8 NO existe en el diccionario.")
El futbolista con la clave 2 NO existe en el diccionario.
El futbolista con la clave 8 existe en el diccionario.
# Creamos un diccionario a partir de una lista de claves
keys = ['nombre', 'apellidos', 'edad']
datos_usuario = dict.fromkeys(keys, 'null')
print ("\nCreamos un diccionario a partir de la lista de claves:")
print (keys)
print ("y con valor 'null'")
print ("Así el diccionario queda: {}".format(datos_usuario))
# Creación de un diccionario
diccionario=dict({1:'rei',2:'pepe',3:'javier'})
print(diccionario)
Creamos un diccionario a partir de la lista de claves:
['nombre', 'apellidos', 'edad']
y con valor 'null'
Así el diccionario queda: {'nombre': 'null', 'apellidos': 'null', 'edad': 'null'}
{1: 'rei', 2: 'pepe', 3: 'javier'}
# Devolvemos los elementos del diccionario en una tupla
tupla = futbolistas.items()
print ("\nEl diccionario convertido en tupla queda así:")
print (tupla)
# Unimos dos diccionarios existentes
suplentes = {
4:'Marchena', 12:'Valdes', 13:'Mata',
17:'Arbeloa', 19:'Llorente', 20:'Javi Martinez',
21:'Silva', 23:'Reina'
}
print ("\nUnimos el diccionario: ")
print (futbolistas)
futbolistas.update(suplentes) # Aquí hacemos la unión de los diccionarios
print ("con el diccionario:")
print (suplentes)
print ("siendo el resultado:")
print (futbolistas)
El diccionario convertido en tupla queda así:
dict_items([(1, 'Casillas'), (6, 'Iniesta'), (3, 'Piqué'), (5, 'Puyol'), (7, 'Villa'), (8, 'Xavi Hernández'), (9, 'Torres'), (11, 'Capdevila'), (14, 'Xavi Alonso'), (15, 'Ramos'), (16, 'Busquets'), (10, 'Cesc')])
Unimos el diccionario:
{1: 'Casillas', 6: 'Iniesta', 3: 'Piqué', 5: 'Puyol', 7: 'Villa', 8: 'Xavi Hernández', 9: 'Torres', 11: 'Capdevila', 14: 'Xavi Alonso', 15: 'Ramos', 16: 'Busquets', 10: 'Cesc'}
con el diccionario:
{4: 'Marchena', 12: 'Valdes', 13: 'Mata', 17: 'Arbeloa', 19: 'Llorente', 20: 'Javi Martinez', 21: 'Silva', 23: 'Reina'}
siendo el resultado:
{1: 'Casillas', 6: 'Iniesta', 3: 'Piqué', 5: 'Puyol', 7: 'Villa', 8: 'Xavi Hernández', 9: 'Torres', 11: 'Capdevila', 14: 'Xavi Alonso', 15: 'Ramos', 16: 'Busquets', 10: 'Cesc', 4: 'Marchena', 12: 'Valdes', 13: 'Mata', 17: 'Arbeloa', 19: 'Llorente', 20: 'Javi Martinez', 21: 'Silva', 23: 'Reina'}
Entrada y salida de datos#
#Entrada de datos
x=input('ingrese el dato 1: ');
y=input('ingrese el dato 2: ');
print('tipo de datos',type(x),type(y))
print('suma de datos sin casteo',x+y)
print('suma de datos con casteo',float(x)+float(y))
ingrese el dato 1: 4
ingrese el dato 2: 5
tipo de datos <class 'str'> <class 'str'>
suma de datos sin casteo 45
suma de datos con casteo 9.0
Operadores relacionales#
a = 5
b = 5
a1 = 7
b1 = 3
c1 = 3
cadena1 = 'Hola'
cadena2 = 'Adios'
# igual
c = a == b
print (c)
cadenas = cadena1 == cadena2
print (cadenas)
# diferente
d = a1 != b
print (d)
cadena0 = cadena1 != cadena2
print (cadena0)
# mayor que
e = a1 > b1
print (e)
# menor que
f = b1 < a1
print (f)
# mayor o igual que
g = b1 >= c1
print (g)
# menor o igual que
h = b1 <= c1
print (h)
True
False
True
True
True
True
True
True
5==5
True
7!=9
True
Operadores lógicos#
x=3
y=7
if x==3 and y==7:
print('si')
else:
print('no')
si
Estructuras condicionadas#
if 5>2:
print('si')
print('si2')
elif 1>3:
print('sino si')
else:
print('no')
print('PorFuera')
print('PorFuera2')
si
si2
PorFuera2
Ejercicios#
Realice un programa que pida la edad de una persona en años. Si la edad es mayor o igual a 18, el programa debe imprimir la cadena: ‘ADULTO’. Si la edad es menor a 18 se debe imprimir: ‘MENOR DE EDAD’.
Diseñe un algoritmo que determine si ún número es o no es, par positivo.
Diseñe un algoritmo que lea un número de tres cifras y determine si es igual al revés del número.
# Escribe aquí tu código
Estructuras repetitivas#
#ciclo for
print("Ciclo for en un rango de datos: ")
for i in range(2,10):
print(i)
print('Ciclo for en una coleccion de datos:')
x=[3,4,5,7,8,"Hola"]
for i in x:
print("El elemento es= ",i)
for i in range(len(x)):
print("El elemento de la posicion",i,'es:',x[i])
Ciclo for en un rango de datos:
2
3
4
5
6
7
8
9
Ciclo for en una coleccion de datos:
El elemento es= 3
El elemento es= 4
El elemento es= 5
El elemento es= 7
El elemento es= 8
El elemento es= Hola
El elemento de la posicion 0 es: 3
El elemento de la posicion 1 es: 4
El elemento de la posicion 2 es: 5
El elemento de la posicion 3 es: 7
El elemento de la posicion 4 es: 8
El elemento de la posicion 5 es: Hola
print('Ciclo for en un diccionario:')
frutas = {'Fresa':'roja', 'Limon':'verde', 'Papaya':'naranja', 'Manzana':'amarilla', 'Guayaba':'rosa'}
for nombre, color in frutas.items():
print (nombre, "es de color", color)
for llave in frutas:
print(llave, 'es de color', frutas[llave])
Ciclo for en un diccionario:
Fresa es de color roja
Limon es de color verde
Papaya es de color naranja
Manzana es de color amarilla
Guayaba es de color rosa
Fresa es de color roja
Limon es de color verde
Papaya es de color naranja
Manzana es de color amarilla
Guayaba es de color rosa
frutas
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-65-af9e415d9161> in <module>
----> 1 frutas
NameError: name 'frutas' is not defined
frutas = {'Fresa':'roja', 'Limon':'verde', 'Papaya':'naranja', 'Manzana':'amarilla', 'Guayaba':'rosa'}
frutas
{'Fresa': 'roja',
'Limon': 'verde',
'Papaya': 'naranja',
'Manzana': 'amarilla',
'Guayaba': 'rosa'}
len(frutas)
5
frutas.get('Fresa')
'roja'
for i in range(10):
print(i)
0
1
2
3
4
5
6
7
8
9
v=['a','b','c','d']
for i in range(len(v)):
print(i,"-->",v[i])
0 --> a
1 --> b
2 --> c
3 --> d
for i in v:
print(i)
a
b
c
d
#ciclo while
cont=0
while cont<10:
print(cont)
cont+=2
0
2
4
6
8
Ejercicio#
Realice un programa que lea las notas de un estudiante, despues devolver el promedio, la mejor y la peor nota.
# Escribe aquí tu código
Funciones#
Python es un lenguaje indentado, no usa corchetes para delimitar el alcance de las estructuras de programación sino que se fija en los cambios de indentación.
No se declara el tipo de los argumentos de las funciones. La semática de la implementación ha de estar preparada para funcionar con los tipos de datos que quieres.
def funcion_1(a,b):
r = a**2
return r+b
def greatest(a,b):
if a>b:
return a
else:
return b
funcion_1 (10.4,2)
110.16000000000001
funcion_1 (10.4, np.array([2,4]))
array([110.16, 112.16])
funcion_1(np.array([1,5]),np.array([3,2]))
array([ 4, 27])
m1 = np.array([[3,4],[1,1]])
m2 = np.array([[5,6],[0,0]])
funcion_1 (m1,m2)
array([[14, 22],
[ 1, 1]])
greatest(10,2)
10
Podemos definir valores por defecto para los argumentos de las funciones y llamarlas usando explícitamente el nombre de los argumentos. Además, las funciones pueden devolver varios valores.
def f_power(x, p=2):
return x**p
f_power(x=3)
9
f_power(p=4, x=3)
81
def f_power(x, p=2):
return x**p, x*p
r = f_power(p=4, x=3)
print(r[0],r[1],"\n")
81 12
r1, r2 = f_power(p=4, x=3)
print(r1)
print(r2,"\n")
81
12
a,b = 10, np.array([10,4,-3])
print(a)
print(b)
10
[10 4 -3]
def f_power(x, p=2):
return x**p
def f_powers(x, p1=2, p2=3):
return x**p1, x**p2
print(f_power(4))
print(f_power(4,3))
print(f_powers(4, p1=3))
xp1, xp2 = f_powers(4, p2=4, p1=3)
print("power1",xp1, "power2", xp2)
16
64
(64, 64)
power1 64 power2 256
Paso por valor y referencia#
Dependiendo del tipo de dato que enviemos a la función, podemos diferenciar dos comportamientos:
Paso por valor: Se crea una copia local de la variable dentro de la función.
Paso por referencia: Se maneja directamente la variable, los cambios realizados dentro de la función le afectarán también fuera.
Tradicionalmente:
Los tipos simples se pasan por valor: Enteros, flotantes, cadenas, lógicos…
Los tipos compuestos se pasan por referencia: Listas, diccionarios, conjuntos…
Ejemplo de paso por valor
Como ya sabemos los números se pasan por valor y crean una copia dentro de la función, por eso no les afecta externamente lo que hagamos con ellos:
def doblar_valor(x):
x = 2*x
return x
x=10
doblar_valor(x)
print(x,doblar_valor(x))
10 20
Para modificar los tipos simples podemos devolverlos modificados y reasignarlos:
x = 10
x = doblar_valor(x)
print(x)
20
Ejemplo de paso por referencia
Sin embargo las listas u otras colecciones, al ser tipos compuestos se pasan por referencia, y si las modificamos dentro de la función estaremos modificándolas también fuera:
def doblar_valores(y):
for i,n in enumerate(y):
y[i] = 2*y[i]
y=[1,2,3]
doblar_valores(y)
print(y)
[2, 4, 6]
Algortimo multipliación 2#
# función para determinar el cociente
def funcionCociente(x,w):
q=0
r=x
while r>=w:
q=q+1
r=r-w
return q
# función para determinar el residuo
def funcionResiduo(x,w):
q=0
r=x
while r>=w:
q=q+1
r=r-w
return r
# función para determinar si un numero es par
def funcionPar(u):
if funcionResiduo(u,2)==0:
par=True
else:
par=False
return par
def funcionMultiplicar(x,w):
z=0
u=x
v=w
while u!=0:
if not funcionPar(u):
z=z+v
u=funcionCociente(u,2)
v=2*v
return z
x=int(input('Escribir un numero par multiplicar: '))
w=int(input('Escribir otro numero para multiplicar: '))
print('El resultado de la mutiplicación es: ', funcionMultiplicar(x,w))
Escribir un numero par multiplicar: 6
Escribir otro numero para multiplicar: 5
El resultado de la mutiplicación es: 30
Expresiones compactas / Comprehensions#
Fíjate cómo las siguientes expresiones son equivalentes:
a=15
if a > 10:
s = "mayor que 10"
else:
s = "menor que 10"
print(s)
mayor que 10
a = 15
s = "mayor que 10" if a > 10 else "menor que 10"
print(s)
mayor que 10
l=[]
for i in range(5):
l.append(i)
print(l)
[0, 1, 2, 3, 4]
l=[i for i in range(5)]
print(l)
[0, 1, 2, 3, 4]
a = [10, -4, 20, 5]
#o = ["10A", "-4B", "20A", "5A"]
o = []
for i in a:
if i<0:
o.append(str(i)+"B")
else:
o.append(str(i)+"A")
print(o)
['10A', '-4B', '20A', '5A']
a = [10, -4, 20, 5]
def convert(x):
return str(x)+"B" if x<0 else str(x)+"A"
o = [convert(i) for i in a]
print(o)
['10A', '-4B', '20A', '5A']
r = []
for i in range(10):
r.append("el numero "+str(i))
print(r)
['el numero 0', 'el numero 1', 'el numero 2', 'el numero 3', 'el numero 4', 'el numero 5', 'el numero 6', 'el numero 7', 'el numero 8', 'el numero 9']
r = ["el numero "+str(i) for i in range(10)]
print(r)
['el numero 0', 'el numero 1', 'el numero 2', 'el numero 3', 'el numero 4', 'el numero 5', 'el numero 6', 'el numero 7', 'el numero 8', 'el numero 9']
frutas = {'Fresa':'roja', 'Limon':'verde', 'Papaya':'naranja', 'Manzana':'amarilla', 'Guayaba':'rosa'}
for nombre, color in frutas.items():
print (nombre, "es de color", color)
print()
r = [nombre+" es de color "+color for nombre, color in frutas.items()]
r
Fresa es de color roja
Limon es de color verde
Papaya es de color naranja
Manzana es de color amarilla
Guayaba es de color rosa
['Fresa es de color roja',
'Limon es de color verde',
'Papaya es de color naranja',
'Manzana es de color amarilla',
'Guayaba es de color rosa']
Manejo de excepciones y errores.#
Catching#
int(3.2)
3
int("hola")
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-2-62025142aa33> in <cell line: 1>()
----> 1 int("hola")
ValueError: invalid literal for int() with base 10: 'hola'
Manejar cualquier tipo de error que pase en un bloque de código
def ejemplo_try_except(valor):
try:
resultado = 10 / valor
print("El resultado es:", resultado)
except Exception as e:
print("Ha ocurrido un error:", e)
# Ejemplos de llamadas a la función
ejemplo_try_except(2)
ejemplo_try_except(0)
ejemplo_try_except('cadena')
El resultado es: 5.0
Ha ocurrido un error: division by zero
Ha ocurrido un error: unsupported operand type(s) for /: 'int' and 'str'
Manejando un tipo especifico de error
def int_times_two(x):
try:
return(int(x)*2)
except ValueError:
return 0
int_times_two(2)
4
int_times_two(2.5)
4
int_times_two("hola")
0
Manejo de la sentencia finally para que, pase o no pase un error, siempre ejecute lo que se coloque en la sentencia finally
def division_segura(dividendo, divisor):
try:
resultado = dividendo / divisor
return resultado
except ZeroDivisionError:
print("¡Error! No puedes dividir entre cero.")
return None
finally:
print("Operación finalizada.")
dividendo = 10
divisor = 2
resultado_division = division_segura(dividendo, divisor)
if resultado_division is not None:
print("El resultado de la división es:", resultado_division)
Operación finalizada.
El resultado de la división es: 5.0
dividendo = 10
divisor = 0
resultado_division = division_segura(dividendo, divisor)
if resultado_division is not None:
print("El resultado de la división es:", resultado_division)
¡Error! No puedes dividir entre cero.
Operación finalizada.
Raising#
Este tipo de sentencias se utilizan para generar errores personalizados dentro del código
def get_positive_integer_from_user():
a = int(input("Enter a positive integer: "))
if a <= 0:
raise ValueError("That is not a positive number!")
print ("thanks!")
get_positive_integer_from_user()
Enter a positive integer: 1
thanks!
get_positive_integer_from_user()
Enter a positive integer: -1
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-13-ea5635cae962> in <cell line: 1>()
----> 1 get_positive_integer_from_user()
<ipython-input-11-a7d1640efb92> in get_positive_integer_from_user()
2 a = int(input("Enter a positive integer: "))
3 if a <= 0:
----> 4 raise ValueError("That is not a positive number!")
5 print ("thanks!")
ValueError: That is not a positive number!