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.
Ciencia de datos#
Con Colab, puedes aprovechar por completo las bibliotecas más populares de Python para analizar y visualizar datos. La celda de código que se incluye a continuación usa NumPy para generar algunos datos aleatorios y matplotlib para visualizarlos. Para editar el código, haz clic en la celda y comienza a editar.
import numpy as np
from matplotlib import pyplot as plt
ys = 200 + np.random.randn(100)
x = [x for x in range(len(ys))]
plt.plot(x, ys, '-')
plt.fill_between(x, ys, 195, where=(ys > 195), facecolor='g', alpha=0.6)
plt.title("Sample Visualization - Rei")
plt.show()
Puedes importar datos propios a notebooks de Colab desde tu cuenta de Google Drive (incluso desde hojas de cálculos), GitHub y muchas otras fuentes. Para obtener más información acerca de la importación de datos y cómo puede usarse Colab para fines relacionados con la ciencia de datos, consulta los vínculos de Cómo trabajar con datos.
Aprendizaje automático#
Colab te permite importar un conjunto de datos de imágenes, entrenar un clasificador de imágenes en él y evaluar el modelo con solo unas pocas líneas de código. Los notebooks de Colab ejecutan código en los servidores alojados en la nube de Google, lo que significa que puedes aprovechar al máximo el hardware de Google, incluidas las GPU y TPU, independientemente de la potencia de tu máquina. Lo único que necesitas es un navegador.
Entre los usos que se la da a Colab en la comunidad de aprendizaje automático, se encuentran los siguientes:
Introducción a TensorFlow
Desarrollo y entrenamiento de redes neuronales
Experimentación con TPU
Diseminación de investigación de IA
Creación de instructivos
Para ver notebooks de Colab de ejemplo que muestran los usos del aprendizaje automático, consulta los ejemplos que se incluyen a continuación.
Más recursos#
Cómo trabajar con notebooks en Colab#
Descripción general de Colaboratory
Guía para usar Markdown
Cómo importar bibliotecas y luego instalar dependencias
Formularios interactivos
Widgets interactivos
Cómo trabajar con datos#
Cómo cargar datos: Drive, Hojas de cálculo y Google Cloud Storage
Gráficos: visualización de datos
Cómo comenzar a usar BigQuery
Curso intensivo de aprendizaje automático#
Estos son algunos de los notebooks del curso de aprendizaje automático en línea de Google. Para obtener más información, consulta el sitio web del curso completo.
Uso de aceleración de hardware#
TensorFlow con GPU
TensorFlow con TPU
Ejemplos destacados#
NeMo Voice Swap: Utiliza el kit de herramientas de NeMo para IA conversacional de Nvidia si quieres cambiar una voz en un fragmento de audio por otra generada por computadora.
Reentrenamiento de un clasificador de imágenes: compila un modelo de Keras sobre un clasificador de imágenes previamente entrenado para distinguir flores.
Clasificación de texto: clasifica opiniones sobre películas de IMDB como positivas o negativas.
Transferencia de estilos: usa el aprendizaje profundo para transferir el estilo de una imagen a otra.
Codificador universal de oraciones en varios idiomas para preguntas y respuestas: usa un modelo de aprendizaje automático para responder preguntas del conjunto de datos SQuAD.
Interpolación de videos: predice lo que sucedió en un video entre el primer y el último fotograma.
Como saber la versión de Python#
#Versión de python
!python --version
Python 3.8.10
Como saber los recursos de GPU#
# Recursos de GPU
!nvidia-smi
!/usr/local/cuda/bin/nvcc --version
Tue Feb 21 19:33:36 2023
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 510.47.03 Driver Version: 510.47.03 CUDA Version: 11.6 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |
| N/A 67C P0 28W / 70W | 0MiB / 15360MiB | 0% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
| No running processes found |
+-----------------------------------------------------------------------------+
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2022 NVIDIA Corporation
Built on Tue_Mar__8_18:18:20_PST_2022
Cuda compilation tools, release 11.6, V11.6.124
Build cuda_11.6.r11.6/compiler.31057947_0
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.
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
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))
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'>
True and False , True or False, not True
(False, True, False)
2>1, True<False
(True, False)
Profundizar en la representación de enteros en python:
import numpy as np
z=np.uint8(255)
z
255
z,type(z),z.nbytes
(255, numpy.uint8, 1)
x=np.int8(4)+np.int8(6)
y=np.uint8(100)+np.uint8(27)
x, y, type(x), type(y)
(10, 127, numpy.int8, numpy.uint8)
Char#
ord("a"),ord("A"), ord("b"),ord("c"),ord("d")
(97, 65, 98, 99, 100)
'a'>'b'
False
'a'>'A'
True
chr(97),chr(98)
('a', 'b')
Gestión de la memoria#
Profundizar en la gestion de memoria en Python
https://codeblessu.com/python/size-of-data-types.html#:~:text=Use sys.,to store it in memory
https://www.lesinskis.com/images/CPythonMemoryStructurePosterJanisLesinskisAlyshaIannetta.pdf
from sys import getsizeof
import sys as yi
help(getsizeof)
Help on built-in function getsizeof in module sys:
getsizeof(...)
getsizeof(object [, default]) -> int
Return the size of object in bytes.
a=100000000000000000000000000000000000
print ("a=",a,'el tamaño es=', getsizeof(a))
print ("b=", b,'el tamaño es=',getsizeof(b))
print ("c=",c,'el tamaño es=',getsizeof(c))
print ("d=",d,'el tamaño es=',getsizeof(d))
a= 100000000000000000000000000000000000 el tamaño es= 40
b= 3 el tamaño es= 28
c= 3.0 el tamaño es= 24
d= holaWorld el tamaño es= 58
a = 5
b = np.int8(5)
c = 'reine'
d = np.array([1,2,3,4]).astype('int8')
print(type(a), getsizeof(a))
print(b.nbytes, type(b))
print(type(c), getsizeof(c))
print(d.nbytes, type(d))
<class 'int'> 28
1 <class 'numpy.int8'>
<class 'str'> 54
4 <class 'numpy.ndarray'>
x=np.int8(128)
x,x.nbytes,type(x)
(-128, 1, numpy.int8)
y=40
getsizeof(y),type(y)
(28, int)
x=100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
type(x),getsizeof(x)
(int, 96)
¿Por qué el resultado de las dos últimas divisiones no es el mismo?
a=10
b=3
c=3.
print ("a =",a,"; b =",b, "; c =",c)
print ("a/b =", a/b)
print ("a/c =", a/c)
print ("a//b =", a//b)
print ("a//c =", a//c)
a = 10 ; b = 3 ; c = 3.0
a/b = 3.3333333333333335
a/c = 3.3333333333333335
a//b = 3
a//c = 3.0
Variable = """
Esta es una cadena
de varias líneas
"""
print(Variable)
Esta es una cadena
de varias líneas
type(Variable)
str
getsizeof(Variable)
110
x=np.array(['a','b','c'])
x.nbytes,type(x)
(12, numpy.ndarray)
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
Funciones útiles#
print("Redondear números= ",round(3.867483,3))
print("Valor Absoluto= ",abs(-4))
print("Convertir número a decimal= ",float('3.5'))
print("Convertir número a hexadecimal=", hex(5))
print("Convertir cadena o número decimal a entero=", int(6.9))
print("Convertir número a cadena de texto=", str(6)+str(6))
Redondear números= 3.867
Valor Absoluto= 4
Convertir número a decimal= 3.5
Convertir número a hexadecimal= 0x5
Convertir cadena o número decimal a entero= 6
Convertir número a cadena de texto= 66
Numeros Aleatorios#
import random
print('imprime un numero aleatorio entero=',random.randrange(3,10))
print('selecciona aleatoriamente=',random.choice(["uno", "dos", "tres"]))
print('imprime un numero aleatorio decimal entre 0 y 1=',random.random())
print('imprime una letra aleatoria=',random.choice("AEIOU"))
imprime un numero aleatorio entero= 9
selecciona aleatoriamente= dos
imprime un numero aleatorio decimal entre 0 y 1= 0.5008250519253324
imprime una letra aleatoria= U
print('imprime un numero aleatorio decimal entre 0 y 4=',int(4*random.random()))
imprime un numero aleatorio decimal entre 0 y 4= 3
Libreria Math#
import math
print("Factorial=",math.factorial(3))
print("PI=",math.pi)
print("E=",math.e)
print("seno=",math.sin(math.pi/6))
print("aseno=",math.degrees(math.asin(0.5)))
print("Logaritmo Natural=",math.log(math.exp(2)))
print("Logaritmo en base 10=",math.log10(100))
print("Logaritmo en base 2=",math.log2(8))
print("Potencia=",math.pow(3,2))
print("Raiz cuadrada=",math.sqrt(4))
Factorial= 6
PI= 3.141592653589793
E= 2.718281828459045
seno= 0.49999999999999994
aseno= 30.000000000000004
Logaritmo Natural= 2.0
Logaritmo en base 10= 2.0
Logaritmo en base 2= 3.0
Potencia= 9.0
Raiz cuadrada= 2.0
import numpy as np
np.float(5/0)
<ipython-input-83-136236f1537d>:2: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.
Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
np.float(5/0)
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-83-136236f1537d> in <module>
1 import numpy as np
----> 2 np.float(5/0)
ZeroDivisionError: division by zero
5/0
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-82-0106664d39e8> in <module>
----> 1 5/0
ZeroDivisionError: division by zero
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
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-6-1233f0186c5b> in <module>
5 print('cuantas veces hay un elemento=',tupla.count(25))
6 print('dice en que posicion esta el elemento=',tupla.index(15))
----> 7 tupla[0]=2# dado que es una TUPLA no se puede agregar ni borrar información.
TypeError: 'tuple' object does not support item assignment
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)
# Usando el tag: raises-exception, se evita que se detenga en compilación
#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
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: 5
ingrese el dato 2: 6
tipo de datos <class 'str'> <class 'str'>
suma de datos sin casteo 56
suma de datos con casteo 11.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
cadena1 = 'Hola'
cadena1
'Hola'
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
{'Fresa': 'roja',
'Limon': 'verde',
'Papaya': 'naranja',
'Manzana': 'amarilla',
'Guayaba': 'rosa'}
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
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
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
Algoritmo Multiplicación 1#
Multiplica los numeros naturales x y w w, sumando x veces el número número; el resultado lo asigna a la variable z
Pedimos introducir el primer número para multiplicar
x=int(input('Escribir un numero para multiplicar: '))
Escribir un numero para multiplicar: 6
Pedimos introducir el segundo número para multiplicar
w=int(input('Escribir otro numero para multiplicar: '))
Escribir otro numero para multiplicar: 5
Inicialización y asignación de variable
z=0
u=x
Realizamos la operación de multiplicación con sumas y estructuras repetitivas
while u>0:
z=z+w
u=u-1
Mostramos el resultado
print('El resultado de la multiplicacion es: ', z)
El resultado de la multiplicacion es: 30
Condensando todo el algoritmos en una sola celda y mostrando prueba de escritorio
x=int(input('Escribir un numero para multiplicar: '))
w=int(input('Escribir otro numero para multiplicar: '))
paso1=1
z=0
u=x
paso2=2
print('Paso', ' ','Z',' ','U')
print(paso1,' ',z,' ',u)
while u>0:
z=z+w
u=u-1
print(paso2,' ',z,' ',u)
print('El resultado de la multiplicacion es: ', z)
Escribir un numero para multiplicar: 5
Escribir otro numero para multiplicar: 6
Paso Z U
1 0 5
2 6 4
2 12 3
2 18 2
2 24 1
2 30 0
El resultado de la multiplicacion es: 30
Algortimo Division 1#
Divide dos números naturales x y w, utilizando restas; el cociente es asignado a la variable q y el residuo a r.
Pedimos introducir el dividendo de la división
x=int(input('Escribir el dividendo: '))
Escribir el dividendo: 9
Pedimos introducir el divisor de la división
w=int(input('Escribir el divisor: '))
Escribir el divisor: 2
Inicialización y asignación de variable
q=0
r=x
Realizamos la operación de división con restas y estructuras repetitivas
while r>=w:
q=q+1
r=r-w
Mostramos el cociente y el residuo
print('El cociente de la división es: ',q,'\n El residuo de la división es: ',r)
El cociente de la división es: 4
El residuo de la división es: 1
Condensando todo el algoritmos en una sola celda y mostrando prueba de escritorio
x=int(input('Escribir el dividendo: '))
w=int(input('Escribir el divisor: '))
paso1=1
q=0
r=x
paso2=2
print('Paso', ' ','q',' ','r')
print(paso1,' ',q,' ',r)
while r>=w:
q=q+1
r=r-w
print(paso2,' ',q,' ',r)
print('El cociente de la división es: ',q,'\n El residuo de la división es: ',r)
Escribir el dividendo: 9
Escribir el divisor: 2
Paso q r
1 0 9
2 1 7
2 2 5
2 3 3
2 4 1
El cociente de la división es: 4
El residuo de la división es: 1
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.
import numpy as np
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
f_power(4)
16
f_power(4,3)
64
f_powers(4, p1=3)
(64, 64)
xp1, xp2 = f_powers(4, p2=4, p1=3)
print("power1",xp1, "power2", xp2)
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
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!