Clase 8 (Sep 3, 2021)

Repaso
1. Errores: En la programación tenemos dos tipos de errores: sintácticos y lógicos a estos
últimos en python se les conoce como excepciones.
2. Anticipar los posibles errores lógicos es a lo que se le llama validación de un programa.
3. Para validar un programa se tienen los siguientes tres métodos:
Codificación del error
A través de la sentencia assert
A través de la estructura: try-except
4. La estructura try-except es la más completa de las tres. Tiene una escencia jerárquica.Esto
es, es necesario escribir el anidamiento considerando primero los casos más específicos
(al fondo de la jerarquía) e ir subiendo. Por supuesto, en este caso no es necesario abordar
el error que contiene a los de menor jerarquía debido a su rendundancia.
5. Es posible pasar una cantidad de argumentos indefinida a un programa, para ello es
necesario el uso de la sentencia *args. Este operador (* mal llamado indirección por el
profe :) ) convierte a una tupla lo que sea que almacene.
6. De forma similar es posible pasar una cantidad de argumentos por nombre de manera
indefinida a un programa, para ello es necesario el uso de la sentencia **kwargs. Este
opera convirtiendo a un diccionario los distintos argumentos.

Uso de kwargs
**kwargs permite pasar variables por nombre de manera indiscriminada a una función. Se
recomienda su uso cuando se quiere realizar una función con paso por nombre en funciones.
Para ello, se crea un diccionario donde el nombre de la variable es la clave y su respetivo valor
es, propiamente su valor.

El siguiente ejemplo muestra su uso:

def usokwargs(**kwargs):
print("Los argumentos pasados por nombre son:\n===================
===== ")
for key, valor in kwargs.items():
print("{0} = {1}".format(key, valor))

In [30]: 1 ## Importación de librerias

2 import numpy as np
3 import matplotlib.pyplot as plt
In [31]: 1 def usokwargs(**kwargs):
2 """
3 Función realizada por ....
4 Esta función no hace nada :(
5 """
6 print("Los argumentos pasados por nombre son:\n=======================
7 for key, valor in kwargs.items():
8 print("{0} = {1}".format(key, valor))
9 usokwargs(a=4, b=True, c=(1, 2, 3))

Los argumentos pasados por nombre son:

========================
a = 4
b = True
c = (1, 2, 3)

In [2]: 1 def usoargs_kwargs(*args, **kwargs):

2 """
3 Función realizada por Naruto... datebayo
4
5 Esta función no hace nada, bueno quizá un rasengan.
6 """
7 print("Los argumentos pasados por nombre son:\n=======================
8 for key, valor in kwargs.items():
9 print("{0} = {1}".format(key, valor))
10 print("Los argumentos pasados por posición son:\n=====================
11 for index, valor in enumerate(args):
12 print("posición {0}, {1}".format(index, valor))
13
14 usoargs_kwargs(12, "Cierto", (0,1), False, a=4, b=True, c=(1, 2, 3))

Los argumentos pasados por nombre son:

========================
a = 4
b = True
c = (1, 2, 3)
Los argumentos pasados por posición son:
========================
posición 0, 12
posición 1, Cierto
posición 2, (0, 1)
posición 3, False

Es posible utilizar los operadores de indirección * y ** para (en Python se les llama solo
operadores * o **) para desempaqueter los elementos que componen una secuencia
In [3]: 1 a=(1, 2, 3, 4, 5, 6, 7, 8)
2 def num_sum(*args):
3
4 sumatoria=0
5 for entrada_i in args:
6 sumatoria+=entrada_i
7 return sumatoria
8 ​
9 num_sum(*a) # Pasamos todos los argumentos
10 # num_sum(*a) es equivalente a num_sum(a[0], a[1], a[2], a[3], a[4], a[5]

Out[3]: 36

In [ ]: 1 a="Hola Mundo"
2 def num_sum(*args):
3 for indice, entrada_i in enumerate(args):
4 if indice==0 :
5 sumatoria=entrada_i.upper()
6 continue # Este segmento le dice al ciclo que vaya dire
7 sumatoria+=entrada_i.upper()
8 return sumatoria
9 ​
10 num_sum(*a) # Pasamos todos los argumentos
11 # num_sum(*a) es equivalente a num_sum(a[0], a[1], a[2], a[3], a[4], a[5]

Operador ** (Permite extraer las claves y valores de un diccionario)

In [4]: 1 def usokwargs(**kwargs):

2 print("Los argumentos pasados por nombre son:\n=======================
3 for key, valor in kwargs.items():
4 print("{0} = {1}".format(key, valor))
5 ​
6
7 diccionario={"a":4, "b":True, "c":(1, 2, 3)}
8 usokwargs(**diccionario)

Los argumentos pasados por nombre son:

========================
a = 4
b = True
c = (1, 2, 3)

Funciones anónimas
Las funciones anónimas, son funciones que no tienen un nombre. Por ello, suelen utilizarse en
programas cortos. Las funciones anónimas se definen usando la palabra reservada lambda. La
sintaxis se muestra a continuación:

lambda argumentos: expresión

In [6]: 1 productorio=lambda a, b, c: a * b * c
2 print(productorio(2,3,4))
3 print(productorio(3,3,3))

24
27

In [7]: 1 # Ejercicio, cree una función lambda que sume 5 números

2 ​
3 ​
4 ​
5 ​

¿Es posible crear una función lambda que sume un número indefinido de argumentos? Sí, vea
el siguiente ejemplo:

sumatoria=lambda *args: sum(args)

Vea el siguiente ejemplo donde se ha integrado lo visto anteriormente

In [9]: 1 # Ejemplo de una función lambda con argumentos indefinidos

2 sumatoria=lambda *args: sum(args)
3 a=(1, 2, 3, 4, 5, 6, 7, 8, 9)
4 sumatoria(*a)

Out[9]: 45

Map, filter, Reduce (Usadas generalmente con las

funciones lambda)
Map, FIlter, y Reduce son paradigmas de la programación funcional. Estas permiten al
programador el escribir código de forma más simple y corta, sin la necesidad de utilizar ciclos o
alguna estructura de control.

Esencialmente, estas tres funciones permiten el aplicar código a través de iterables (listas,
tuplas). map y filter no necesitan ser importadas ya que viene con el módulo builtins. Sin
embargo, reduce necesita ser importado, ésta función se encuentra en el módulo functools.

Map

La función map() en python tiene la siguiente sintaxis:

map(func, *iterables)

La función map regresa un objeto de la clase map, el cual es un generador. Para convertir tal
resultado en una lista se utiliza la función list:
 list(map(func, *iterables))

In [ ]: 1 my_pets = ['alfred', 'tabitha', 'william', 'arla']

2 uppered_pets = []
3 ​
4 for pet in my_pets:
5 pet_ = pet.upper()
6 uppered_pets.append(pet_)
7 print("\n")
8 print(uppered_pets)

In [ ]: 1 my_pets = ['alfred', 'tabitha', 'william', 'arla']

2 ​
3 uppered_pets = list(map(str.upper, my_pets))
4 ​
5 print("\n")
6 print(uppered_pets)

In [ ]: 1 # Celda modificada automatizada para precisión a 2 decimales.

2 ​
3 ​
4 circle_areas = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.00013]
5 result = list(map(round, circle_areas, [2 for x in range(len(circle_areas)
6 print("\n")
7 print(result)

In [1]: 1 # Ejemplo 2, map en list comprehensions

2 import numpy as np
3 puntos=np.array([ [1, 2, 3], [2, 3, 1], [1, 8, 9], [1, 9, 6] ])
4 ​
5 f=lambda a,b: np.sum((a-b)**2)**0.5
6 ​
7 referencia=np.array([[3,3,8], [3,3,8], [3,3, 8], [3,3,8]])
8 ​
9 distancias=[x for x in map(f, puntos, referencia)]
10 print("\n", distancias)
11 ​

[5.477225575051661, 7.0710678118654755, 5.477225575051661, 6.6332495807108]

In [ ]: 1 #**Utilizando map y list comprehensions genere una lista con la media por
2 #renglón de una matriz aleatoria A**
3 ​
4 ​
5 ​
6 ​

Filter
 Mientras que map() pasa cada el elemento del iterable a través de una función y regresa el
resultado de todos los elementos transformados al pasar por la función, la función filter(),
requiere que la función regrese un valor de tipo boleano (True o False). filter() pasa esta
función por cada elemento del iterable y regresa aquellos con valor True. Por ello, se dice que
"filtra" todos aquellos que no cumplen la condición. La sintaxis es como sigue:

filter(func, iterable)

Resumiendo:

1. A diferencia de map(), solo un iterable es requerido.

2. Es necesario que el argumento func devuelva valores boleanos (True o False). Si no es
así, la función filter solo aplica la función sobre el iterable.
3. filter pasa cada elemento del iterable a través de la función func devolviendo solo aquellos
cuyo valor sea True.

In [39]: 1 datos = [66, 90, 68, 59, 76, 60, 88, 74, 81, 65]
2 ​
3 def aprobado(datos):
4 return datos > 70
5 ​
6 pasaron = list(filter(aprobado, datos))
7 print(pasaron)

[90, 76, 88, 74, 81]

In [52]: 1 # Reescribe la celda anterior utilizando una función anónima.

2 ​
3 ​
4 ​
5 ​
6 ​
7 ​

In [54]: 1 #
2 #
3 #
4 #
5 f2=lambda n: n>70
6 f1=lambda datos: list(filter(f2, datos))
7 print(f1(datos))

[90, 76, 88, 74, 81]

Reduce

La función reduce aplica una función de dos argumentos a un iterable, esto de forma
acumulativa. Tiene además la opción de empezar con un argumento inicial. La sintaxis es:
 reduce(func, iterable[, initial])

Donde func es la función que actuará sobre cada elemento del iterable y el inicial es el valor
opcional con el cual se incrementaría virtualmente el arreglo en la primera posición.

En resumen:

1. La función reduce aplica una función a un iterable de forma acumulativa

2. La función reduce tiene dos argumentos obligatorios de entrada: func y el iterable. func
requiere de dos argumentos.
3. reduce tiene un parámetro opcional el cual se volverá el primer elemento del iterable.
4. La función reduce "reduce" un iterable a un valor.

In [36]: 1 # Ejemplo de uso de la función reduce

2 from functools import reduce
3 def factorial(n):
4 from numpy import arange
5 """
6 Función realizada por ...
7 Esta función calcula el factorial de un número. Mírame.... 0_0
8 """
9 def f1(n1, n2): # ¡Podemos definir funciones dentro de funciones!
10 """
11 Hola, ¡no me veas!
12 """
13 return n1*n2
14 return reduce(f1, arange(1, n+1), 1)
15
16 a=0
17 print("Evaluando la primera forma: factorial(%d)="%(a),factorial(a))
18 ​
19 f1=lambda n1, n2: n1*n2
20 factorial2=lambda n: reduce(f1, np.arange(1, n+1), 1)
21 print("Evaluando la segunda forma: factorial2(%d)="%(a),factorial2(a))
22 ​
23 print("Evaluando la tercera forma: resultado: ",reduce(f1, np.arange(1, a+
24 ​

Evaluando la primera forma: factorial(0)= 1

Evaluando la segunda forma: factorial2(0)= 1
Evaluando la tercera forma: resultado: 1

In [ ]: 1 # Ejercicio, utilizando la función reduce realiza una función que calcule

2 # de los primeros n números enteros positivos.
3 ​
4 ​
5 ​
In [ ]: 1 # Ejercicio, Utilizando la función reduce realice una función que calcule
2 # los elementos de una secuencia ndarray
3 ​
4 ​
5 ​
6 ​

Tema: Manejo de archivos

1. Escritura de un archivo
2. Lectura de un archivo
3. Uso de la sentencia with
4. Manejo de cadenas de caracteres o Strings
5. Cargando ficheros de datos

5.1. Archivos CSV (Valores Separados por Comas)

5.2. Archivos pickle

6. Uso de numpy para cargar datos

7. Uso de Pandas para cargar datos

Intrucciones del uso de la notebook (cosa seria)

1. Abra el archivo
2. Disfrute :)

1. Escritura de un archivo
En el manejo de archivos, las dos tareas más básicas son las de lectura y escritura.

Para la escritura de un archivo es necesario primero el abrirlo:

archivo=open("Mi_archivo1.txt", "w")

En esta parte, se ha abierto un archivo llamado "Mi_archivo1.txt". El permiso con el que se ha

abierto es de escritura. Si el archivo no existe, la función open lo creara.

Ahora, para escribir en el archivo se utiliza el método write:

 archivo=open("Mi_archivo1.txt", "w")
archivo.write("Prueba con mi primer archivo, ahora prueba tú. ")

In [6]: 1 # Ejercicio crea un archivo llamado MI_archivo1.txt y escribe lo que quier

2 ​
3 #Escriba en esta parte su código:
4 #__________________________________________________________________
5 ​
6 archivo=open("Mi_archivo1.txt", "w")
7 archivo.write("Prueba con mi primer archivo, ahora prueba tú. ")
8 ​
9 archivo.close()
10 archivo=open("http://localhost:8888/edit/Downloads/Mi_archivo1.txt","w")
11 archivo.close()
12 ​
13 ​
14 ​
15 ​
16 ​
17 ​
18 ​
19 ​
20 #__________________________________________________________________
21 ​
22 ​
23 #¿ Cuántas veces se escribió lo que usted quería?
24 ​
25 ​
26 #¿A qué se deberá ?

---------------------------------------------------------------------------
OSError Traceback (most recent call last)
<ipython-input-6-e7b94809bc9f> in <module>
8
9 archivo.close()
---> 10 archivo=open("http://localhost:8888/edit/Downloads/Mi_archivo1.tx
t","w")
11 archivo.close()
12

OSError: [Errno 22] Invalid argument: 'http://localhost:8888/edit/Downloads/M

i_archivo1.txt'

Como ya habrán notado, los permisos de escritura...

2. Lectura de un archivo
La sintaxis en la lectura del archivo es como sigue :
 Archivo=open("Mi_archivo1.txt", "r") #Permiso de lectura
linea=Archivo.readline() # Lee el archivo
print(linea) #Muestra la primera línea del ar
chivo
Archivo.close() #Cierra el archivo

En el proceso de lectura es esencial que el archivo exista

Tambén es posible leer el contenido completo de un archivo, para ello se utliza el método read:

Archivo=open("Fragmeto.txt", "r") #Permiso de lectura

contenido=Archivo.read() # Lee el archivo
print(contenido) #Muestra el contenido del ar
chivo
In [3]: 1 # Ejercicio, Lea el archivo Fragmento.txt disponible en la carpeta de Driv
2 Archivo=open("Fragmento.txt", "r")
3 contenido=Archivo.read()
4 print(contenido)
5 Archivo.close()
6 ​
7 ​
Las ruinas circulares

Jorge Luis Borges

Nadie lo vio desembarcar en la unánime noche, nadie vio la canoa de bambú s

umiéndose en el fango sagrado, pero a los pocos dí
as nadie ignoraba que el h
ombre taciturno vení
a del Sur y que su patria era una de las infinitas aldeas
que están aguas arriba, en el flanco violento de la montaña, donde el idiom
a zend no está contaminado de griego y donde es infrecuente la lepra. Lo cie
rto es que el hombre gris besó el fango, repechó la ribera sin apartar (pro
bablemente, sin sentir) las cortaderas que le dilaceraban las carnes y se arr
astró, mareado y ensangrentado, hasta el recinto circular que corona un tigr
e o caballo de piedra, que tuvo alguna vez el color del fuego y ahora el de l
a ceniza. Ese redondel es un templo que devoraron los incendios antiguos, que
la selva palúdica ha profanado y cuyo dios no recibe honor de los hombres. E
l forastero se tendió bajo el pedestal. Lo despertó el sol alto. Comprobó
sin asombro que las heridas habí
an cicatrizado; cerró los ojos pálidos y du
rmió, no por flaqueza de la carne sino por determinación de la voluntad. Sa
bí
a que ese templo era el lugar que requerí
a su invencible propósito; sabía
que los árboles incesantes no habí
an logrado estrangular, rí
o abajo, las rui
nas de otro templo propicio, también de dioses incendiados y muertos; sabía
que su inmediata obligación era el sueño. Hacia la medianoche lo despertó
el grito inconsolable de un pájaro. Rastros de pies descalzos, unos higos y
un cántaro le advirtieron que los hombres de la región habí
an espiado con r
espeto su sueño y solicitaban su amparo o temí
an su magia. Sintió el frí
o d
el miedo y buscó en la muralla dilapidada un nicho sepulcral y se tapó con
hojas desconocidas.

El propósito que lo guiaba no era imposible, aunque sísobrenatural. Querí

a
soñar un hombre: querí
a soñarlo con integridad minuciosa e imponerlo a la r
ealidad. Ese proyecto mágico habí
a agotado el espacio entero de su alma; si
alguien le hubiera preguntado su propio nombre o cualquier rasgo de su vida a
nterior, no habrí
a acertado a responder. Le convení
a el templo inhabitado y d
espedazado, porque era un mí
nimo de mundo visible; la cercaní
a de los leñado
res también, porque éstos se encargaban de subvenir a sus necesidades fruga
les. El arroz y las frutas de su tributo eran pábulo suficiente para su cuer
po, consagrado a la única tarea de dormir y soñar.

Al principio, los sueños eran caóticos; poco después, fueron de naturaleza

dialéctica. El forastero se soñaba en el centro de un anfiteatro circular q
ue era de algún modo el templo incendiado: nubes de alumnos taciturnos fatig
aban las gradas; las caras de los últimos pendí
an a muchos siglos de distanc
ia y a una altura estelar, pero eran del todo precisas. El hombre les dictaba
lecciones de anatomí
a, de cosmografí
a, de magia: los rostros escuchaban con a
nsiedad y procuraban responder con entendimiento, como si adivinaran la impor
tancia de aquel examen, que redimirí
a a uno de ellos de su condición de vana
apariencia y lo interpolarí
a en el mundo real. El hombre, en el sueño y en l
a vigilia, consideraba las respuestas de sus fantasmas, no se dejaba embaucar
por los impostores, adivinaba en ciertas perplejidades una inteligencia creci
ente. Buscaba un alma que mereciera participar en el universo.
In [1]: 1 # Ejercicio 2:
2 # Realiza lo siguiente: Crea un código que copie las primeras 8 lineas del
3 ​
4 ​
5 ​

Es posible acceder a todas las líneas de un archivo iterandolo. Esto puede hacerse de la
siguiente forma:

Archivo=open("LasRuinasCIrculares.txt", "r")
for lineas in Archivo: #Itera mediante el ciclo for
print(lineas)
Archivo.close()

Las cadenas de caracteres admiten el mismo manejo que las listas. Los siguientes ejercicios
muestran algunos ejemplos

Ejercicios
1. Haga una copia del archivo LasRuinasCirculares.txt, al archivo generado llámelo copia.txt
2. Haga un archivo donde escriba el número de línea y el número de carácteres de la línea.
Ambos separados por ,
3. ¿Qué realiza el siguiente programa?

Archivo=open("LasRuinasCirculares.txt", "r")
Archivo2=open("LasRuinasCIrculares2.txt", "w")
for i in Archivo:
Archivo2.write(i[::-1])
Archivo.close()
Archivo2.close()

¿Le ve algún uso interesante?

4. Realice una función que haga copia de un archivo.

5. Realice una función que cifre un texto mediante la reversa del contenido línea a línea.
6. Realice una función que haga una copia de un archivo. En esta ocasión abra el archivo con
los siguientes permisos: "w+" ¿Cuál es la diferencia entre el permiso "W" y "W+"?

3. Uso de la sentencia with

La palabra reservada with es un comando que nos permite gestionar de manera más eficiente
y segura los recursos así como de las variables.

Particularmente en el uso de archivos, la palabra with abre el archivo y permite el manejo de

forma eficiente :
 with open("Fragmento.txt", "r") as Archivo:
....Bloque de código

Al final de abrir un archivo es necesario cerrarlo ya que los cambios efectuados se

guardan hasta el cerrado en diversas plataformas No obstante mediante la sentencia

In [ ]: 1 # Realiza lo siguiente: Crea un código (utilizando el comando with) que cop

2 ​

Otros modos de manipular un archivo.

Los diversos modos o permisos para abrir un archvo se listan a continuación:

‘r’ – Modo de lectura, es usado cuando solo se quiere acceder al contenido sin modificar.
‘w’ – Modo de escritura, es usado cuando se quiere escribir un archivo. Si el archivo ya
existía, el anterior será reemplazado por el creado más recientemente.
‘a’ – Modo de extensión. Esta modalidad se usa para agregar contenido al final del archivo.
Todo lo que se escriba se agregará en una nueva línea al final del archivo original
‘r +’ – Modo de lectura y escritura, este modo es el de uso básico para leer y escribir en un
archivo.
'w +'- Modo de lectura y escritura, este modo es el uso básico para leer y escribir en un
archivo.

In [ ]: 1 # Escritura de un archivo
2 ​
3 ​
4 ​
5 ​
6 ​

4. Strings o cadenas de caracteres.

Al momento de leer un archivo se tiene acceso al contenido como una cadena de caracteres.
Una cadena de caracteres es en "cierto sentido" lo mismo que una lista solo que inmutable.
Siendo así es posible acceder caracter por caracter a los elementos de la cadena de
caracteres.

Como en el caso de las listas y tuplas es posible saber la longitud del dato tipo string con el
comando len.

Confirmemos que estamos ante otro tipo de estructura de datos, para comprobarlo aplique el
comando type a una línea del archivo: type(linea)

A continuación se muestra un esquema de una palabra:

|-11|-10|-9|-8|-7|-6|-5|-4|-3 | -2| -1|

|u | n| a|--| p| a| l| a| b| r| a|
 |0 | 1| 2|3 | 4| 5| 6| 7| 8| 9| 10|
In [56]: 1 # En este código declaramos una cadena de caracteres:
2 cadena="Hola Mundo"
3 print("La variable cadena es de tipo: ",type(cadena))
4 print(cadena)
5 print(cadena[1])
6 print(cadena[4:6])
7 print(cadena[0:4])
8 ​

La variable cadena es de tipo: <class 'str'>

Hola Mundo
o
M
Hola

In [58]: 1 # Si la cadena se comporta de manera similar a una lista, qué hace el sigu
2 cadena2=cadena[0:4]+" a todos"
3 print(cadena2)

Hola a todos

In [4]: 1 #Ahora imprima en pantalla y escriba en un achivo el numero de caracteres

2 # Numero de línea tabulador numero de caracteres. Por ejemplo:
3 #1\t200\n
4 #2\t128\n
5 ​
6 #Para hacer esto, tome el archivo LasRuinasCirculares.txt que viene en la

Sentencia in
Con el operador in es posible saber si una cadena contiene una determinada subcadena o un
carácter concreto. Véase el siguiente ejemplo:

cadena="Programar es divertido"
print("P" in cadena)
print("p" in cadena)

Ejecute el ejemplo, ¿Es lo mismo una mayúscula que una minúscula?

Pruebe ahora considerando una palabra en una oración. Por ejemplo, busque si se encuentran
las palabras: Rico, cielo, ahora en la siguiente oración:

Al despertar, Roco miró el cielo.

In [63]: 1 #Aqui practique su código
2 cadena="Al despertar, Roco miró el cielo"
3 ​
4 ​
5 ​
6 ​

Buscar un substring en el string : find

El método find de string nos permite buscar una subcadena dentro de la cadena. Este método
admite hasta tres parámetros. La cadena a buscar, el índice a partir del cual empezar a buscar
y el índice a partir del cual dejar de buscar. Nos devuelve la posición en donde ha encontrado la
cadena, o -1 si no la encuentra.

find devuelve la primera posición en donde encuentra el substring dentro del string.
Alternativamente, el método rfind nos devuelve la última posición donde encuentra el substring.
También admite parámetros de índice de inicio y fin de búsqueda. Un ejemplo :

cadena="Hoy es viernes, los viernes doña Mary vende Pozole."

posicion=cadena.find("doña", 0) #Ojo, al ser un método la función
se aplica al objeto cadena
print(posicion)
print(cadena[posicion:posicion+3])

In [7]: 1 #Pruebe su código aquí.

2 ​
3 ​
4 ​
5 ​
6 ​
7 ​
8 ​
9 ​
10 ​
11 ​
12 ​
13 ​

In [ ]: 1 ​

Contar número de veces que el substring aparece en el string :

count
El método count nos dice cuántas veces aparece el substring dentro del string. Admite un
parámetro que es el substring a buscar, y opcionalmente otros dos, los índices de inicio y fin de
búsqueda.
 cadena="Para hacer un pan necesita: harina, levadura, huevo, azúcar,
un horno, aceite o mantequilla."
print("La coma aparece %d veces en cadena: %s", %(cadena.count(",") ,
cadena ))

In [10]: 1 #Ejercicio: Escriba un código que cuente cuántas veces aparece la palabra
2 ​
3 ​
4 ​

Reemplazar substring en string : replace

El método replace nos permite obtener una copia de la cadena original (no reemplaza en la
cadena original) en la que se reemplaza el substring que se le indique por uno nuevo. Admite
tres parámetros, el primero es el substring que tiene que buscar, el segundo es el nuevo
substring que tiene que poner y el tercero, opcional, es cuántas veces tiene que hacer el
reemplazo.

cadena="Pedrito fué a comprar un chetos"

cadena2=cadena.replace("chetos", "doritos")
print(cadena2)

Pruebe el código en la siguiente celda.

In [13]: 1 #Pruebe aquí su código

2 ​
3 ​
4 ​
5 ​
6 ​
7 # Intente de tarea: Escriba un código en el que reemplace la vocal u por l
8 #Ejemplo:
9 #cadena1="Hola a todos, espero que esten de maravilla"
10 #Al cambiarla, deberá quedar como:
11 #Helu u tedes, ospore qao oston do muruvliiu
12 # ¿Qué aplicación podría encontrar para una cosa así?
13 ​
14 ​
15 ​
16 ​

Método split
El método split genera una lista de los elementos separados por algún substring o caracter.

Ejemplo:
 cadena_coma="1,3,4,5,7,8,9,10"
cadena_espacio="1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20"
cadena_tab="1\t2\t3\t4\t5\t6\t7"
datos_coma=cadena_coma.split(",")
datos_espacio=cadena_espacio.split(" ")
datos_tab=cadena_tab.split("\t")
print(datos_coma)
print(datos_espacio)
print(datos_tab)

Pase este código a la celda siguiente

In [17]: 1 # Escriba aquí su código
2 ​
3 ​
4 ​
5 ​
6 ​
7 ## Adicionalmente, escriba un código que realice una separación de una cad
8 ​
9 ​
10 ​

Convertir número a string con formato

En python tenemos tres formas de conseguir un string en el que vayan formateados números y
otras variables. La forma antigua es usar el operador % el operador %

Se usa una expresión como la siguiente "string con formato" % valores. Veamos ejemplos

In [19]: 1 print ("Entero con 5 cifras, espacios por delante %5d" % 11) # saca tre
2 print ("Entero con 5 cifras, ceros por delante %05d" % 11) # saca 000
3 print ("Flotante con 2 decimales %.2f" % 12.34567) # saca 12.
4 print ("Flotante con 2 decimales, diez cifras, espacios por delante %10.2f
5 print ("Flotante con 2 decimales, diez cifras, ceros por delante %010.2f" %
6 ​

Entero con 5 cifras, espacios por delante 11

Entero con 5 cifras, ceros por delante 00011
Flotante con 2 decimales 12.35
Flotante con 2 decimales, diez cifras, espacios por delante 12.35
Flotante con 2 decimales, diez cifras, ceros por delante 0000012.35

In [ ]: 1 ​

In [ ]: 1 ​

Métodos de la clase string

Algunos otros métodos de la clase string son:
 Esta lista no es exhaustiva, para conocer los demás métodos de la clase vaya a la
documentación de python:

https://docs.python.org/3/library/stdtypes.html#string-methods
(https://docs.python.org/3/library/stdtypes.html#string-methods)

In [ ]: 1 ​

5. Carga de archivos de datos

5.1 CSV
En general, la función loadtxt de numpy permite obtener el acceso directamente a archivos de
texto plano. Es decir, sin codificación. A los archivos con separación por una coma "," se les
suele llamar formato csv y por ende se les acostumbra a poner la terminación .csv en el
nombre. No obstante, la extensión, no implica necesariamente que el separador sea una coma.
Otros separadores son: ";" tab("\t"), ":", " ".

Los archivos csv son unos de los formatos más utilizados. Esto es debido a su facilidad de uso
y a que cualquier hoja de cálculo puede usar ese formato.
In [18]: 1 # Ejemplo de carga de un archivo:
2 import csv as csv
3 total_len = 0
4 with open("Datos.csv") as fh:
5 next(fh)
6 for n, line in enumerate(fh):
7 data = line.split("\t")
8 data=[float(i) for i in data ]
9 data2.append(data)
10 print(data2)
11

[0.40682592079205615, 0.03078494948421906, 0.64750087632541, 0.942671572342

5865, 0.9516084502460033, 0.029459979285368587, 0.7216385576334571, 0.17881
003233390014, 0.39365487955247935, 0.9472291990847596, [0.9641443303501315,
0.1876669733374784, 0.3683245801210281, 0.876794005307483, 0.08005719879264
483, 0.4873048111795316, 0.3464372886682122, 0.7106806857936802, 0.32757775
90283244, 0.8145035159115767], [0.857896179836856, 0.8888589575905916, 0.17
947002953836877, 0.4689206029432228, 0.15352706178018416, 0.359756851431533
24, 0.97001973330907, 0.6916375879410901, 0.5263025744559355, 0.99021557557
02601], [0.3400447418702496, 0.4315410773576116, 0.9510657866631343, 0.3410
6735254567044, 0.33492299222481325, 0.6264546486303725, 0.0699982997320567
3, 0.6067907606714875, 0.6405946000129256, 0.6264058842665523], [0.48285132
527703234, 0.27157071075251227, 0.5939068167826732, 0.41032957940062054, 0.
6268853997777238, 0.6603404588754835, 0.27246907417816735, 0.32232203961181
95, 0.5613545141510119, 0.7264583353788676], [0.9146296637781245, 0.7313912
132595486, 0.9781101520085268, 0.6412909362414094, 0.1183279761349546, 0.35
765851725133924, 0.6852409055631041, 0.840369708905415, 0.7063014193875724,
0.14651731418946934], [0.798828699649187, 0.7691426253710025, 0.00663396318
1796432, 0.17091276865955796, 0.992961973202655, 0.7159450157628904, 0.7974
518316780458, 0.7884785363148854, 0.7274421983715083, 0.07619944941400858],
[0 31122112961516746 0 8307834620528826 0 6089446276195688 0 13888746773

5.2 Archivos pickle

Todas las variables cradas durante el tiempo de vida de un programa son temporalmente
almacenadas en la memoria y desaparecen cuando el programa o la sesión finaliza. Python
provee de un módulo para almacenar e invocar variables almacenadas en algún dispositivo: El
módulo Pickle4. Este módulo serializa la estructura de datos manejada por Python en un
formato de bits y la almacena en algún medio que se le indique. Además permite también leer
este archivo binario para convertirlo en la estructura original. De este modo, cuando se cargue
tal archivo será del tipo en que se había estado manejado anteriormente.

EL siguiente script genera un diccionario (sp_dict) y o guarda en un archivo (spdict.data):

import pickle #Carga la librería necesitada

sp_dict = {’one’:’uno’, ’two’:’dos’, ’three’:’tres’} #Crea el dicci
onario
with open(’spdict.data’, ’wb’) as fh:
pickle.dump(sp_dict, fh)
Con el método pickle.dump(), el diccionario sp_dict es almacenado en un archivo por medio de
la variable fh que maneja el archivo.

pickle.dump() acepta cuatro parámetros de entrada:

obj: el primero es el objeto que se quiere guardar,

fh: el segundo es la variable que hace referencia el archivo donde se almacenará.
Protocolo (opcional): Es un número entero que representa la froma en la cual la
información será codificada. El default es 3, el cual es un formato binario incompatible con
python 2.x.
fix_imports (opcional): Es un parámetro que cuando vale True y el Protocolo es menor
que 3, entonces se realizará una compatibilidad con Python2.x

Para leer un archivo se utiliza el métdo: pickle.load():

import pickle
pickle.load(open(’spdict.data’,’rb’)) # abre el archivo creado celda
s arriba.

El método load requiere la variable que maneja el archivo a abrir. Debe notarse que los
permisos son "rb" indicando que es de lectura binaria y "wb" indicadon que es la escritura d un
archivo binario. Si el archivo no es manipulado con estos permisos de archivo binario, resultará
en un error, y que python tratará de convertir los válores a Unicode.y to convert it to Unicode
and will fail.

Protocolos para el formato Pickle

A continuación se muestra una lista con los cinco diferentes protocolos que pueden usarse para
el guardado de variables. Entre más elevado se el valor, más reciente deberá ser la versión de
python para poder ser creado/leído:

0: Es el original fácilmente legible por humanos. Es compatible con las primeras versiones
de Python.
1: Es el formato binario antiguo, es compatible con versiones antiguas de Python.
2: Es mucho más eficiente en el codificado y compresión ademas de agregar nuevas
clases. Compatible con python 2.x
3: Es el default, tiene un soporte explícito para objetos binarios y no es compatile con
Python 2.x. Es el más recomendado si el uso será únicamente en las versiones de
Python3.x
4: Disponible a partir de la versión 3.4. Este protocolo soporta objetos más grandes que los
otros protocolos, además permite la conversión a pickle de más estructuras de datos que
los anteriores.

Adverencia: La conversión a formato pickle no es

segura con respecto a estructuras maliciosas que
pudieran afectar su dispositivo. Por ende, no lo utilice
para archivos de dudosa procedencia
5.5 Manejo de archivos: Módulos os y shutil
Además de leer y escrbir archivos, existen más maneras de manipularlos. El módulo os de
Python permite realizar operaciones realizadas más comúnmente con el sistema operativo.
Tales operaciones son: copiar archivos, moverlos, borrarlos, listarlos, cambiar de directorio, fijar
las propiedades del archivo, crear carpetas, etc.

En esta sección se verán solo algunas funciones del módulo os.

La primera función a revisar es la función getcw():

1. getcwd(): Devuelve una cadena de caracteres representando el directorio de trabajo

actual.

import os
os.getcwd()

2. chdir(path): Cambia el directoria actual al path

os.chdir(’..’)
os.getcwd()

3. listdir(dir): Devuelve una list conteniendo los nombres de las entradas en el directorio.
Para saber si un nombre regresado por listdir es un archivo o una carpeta (directorio), use
el comando: os.path.isdir() o os.path.isfile().

import os
archivos=os.listdir(os.getcwd())
print("Los elementos en este directorio son: \n", archivos)
print("\n¿Es ", archivos[1], "una carpeta?: ", os.path.isdir(archivos
[1]))
print("¿Es", archivos[1], "un archivo?: ", os.path.isfile(archivos
[1]))

4. remove(file): Borrael archivo file. El archivo debe existir y se deben tener permisos de
escritura sobre él.

os.remove("borrame.txt")

5. rename(source, destination): Renombra el archivo o directorio de source a destination

 os.rename('/home/sb/seqs/readme.txt', '/home/sb/Readme')
mkdir(path): Create a directory named path.
os.mkdir(’/home/sb/processed-seqs’)

6. mkdir(path): Crea una carpeta llamada path.

os.mkdir(’/home/sb/processed-seqs’)

7. path.join(directory1,directory2,...): Une dos o más componentes de una ruta, en la unión

inserta el separador requerido para el sistema operativo. Por ejemplo, en Windows usará
un "" mientras que en Linux y OSX insertará "/". Esta función no verifica si el path creado es
válido.

os.path.join(os.getcwd(), "images")

8. path.exists(path): Verifica si la ruta especificada existe.

os.path.exists(os.path.join(os.getcwd(), "images"))

9. path.split(path): Devuelve una tupla separando el nombre del archivo o directorio al final
del resto de la ruta.

os.path.split(’/home/sb/seqs/ms2333.ab1’)
(’/home/sb/seqs’, ’ms2333.ab1’)

10. path.splitext(path): Exrae la extensión de un archivo. Este método devuelve una tupla con
la extensión adquirida mediante un punto.

os.path.splitext(’/home/sb/seqs/ms2333.ab1’)
(’/home/sb/seqs/ms2333’, ’.ab1’)

The shutil Module.

Algunas funciones útiles relacionadas con el manejo de archivos se encuentraen en otro
módulo: shutil. Las funciones más importantes son:
 copy(source,destination): Copia el archivo source a la ubicación destination.
copy2(source,destination): Copia el archivo source a la ubicación destination. Este
comando, a diferencia del anterior copia también la información de la fecha/hora del último
acceso así como de la modificación más reciente.
copytree(source,destination): Copia de forma recursiva el árbol del directiorio entero del
directorio del archivo source a la dirección destination, este directorio no debe existir aún
para el uso de esta función.

Para mayor información, vea la documentación en: http://docs.python.org/lib/module-shutil.html

(http://docs.python.org/lib/module-shutil.html).

In [17]: 1 import os
2 archivos=os.listdir(os.getcwd())
3 print("Los elementos en este directorio son: \n", archivos)
4 print("\n¿Es ", archivos[1], "una carpeta?: ", os.path.isdir(archivos[1])
5 print("¿Es", archivos[1], "un archivo?: ", os.path.isfile(archivos[1]))

Los elementos en este directorio son:

['.ipynb_checkpoints', '2Manejo_de_archivos.ipynb', 'Datos.csv', 'Fragmento.
txt', 'LasRuinasCirculares.txt', 'LasRuinasCIrculares2.txt']

¿Es 2Manejo_de_archivos.ipynb una carpeta?: False

¿Es 2Manejo_de_archivos.ipynb un archivo?: True

6. Cargar datos con numpy: loadtxt, genfromtxt,

load
Es posible cargar archivos directamente a un arreglo de numpy. Para ello, se requieren de
ciertas características. En esta sección nos ocuparemos solamente de archivos de datos:
Suponga que se tiene un archivo sin huecos y separado por comas, un ejemplo puede ser:

1,2,3,4,5 6,7,8,9,10 11,12,13,14,15 16,17,18,19,20

Dicho archivo puede cargarse con el comando loadtxt:

from numpy import loadtxt

A=loadtxt("Archivo_datos.csv", delimiter=',') #Note que solo requirió
del nombre del archivo y su separador.

In [ ]: 1 # Práctica, Haga una función que guarde una matriz aleatoria de 200 renglon
2 # Una vez que lo haya generado, lea el archivo utilizando la función loadtx
3 ​