Cuaderno de Notas de Python

Cuaderno de notas de Python
Diego Augusto Cabrera Meza
Este documento pretende ser un resumen del curso de Python

de la plataforma Platzi, se han tomado apuntes, referencias y
aportes de estudiantes del curso para enriquecer este
documento
05/10/2020
Contenido
No pares de apender................................................................................................................................. 4
1. Curso de Python ............................................................................................................................. 5
1.1 Básicos de programación ........................................................................................................... 5
1.1.1 Guía de instalación y conceptos básicos ................................................................................ 5
1.1.2 ¿Por qué programar con Python? ........................................................................................ 15
1.1.3 ¿Qué es la programación? .................................................................................................... 17
1.1.4 Python 2 vs Python 3 ............................................................................................................ 25
1.1.5 Operadores matemáticos en Python 3 ................................................................................. 27
1.1.6 Tipos de datos en Python ..................................................................................................... 29
1.1.7 Declarar variables y expresiones .......................................................................................... 32
1.1.8 Definir funciones en Python ................................................................................................. 36
1.1.9 Funciones con parámetros ................................................................................................... 46
1.1.10 Estructura de condicionales en Python ............................................................................ 52
1.1.11 Calcular si un número es primo en Python ....................................................................... 57
1.1.12 Buenas prácticas del lenguaje ........................................................................................... 59
1.2 Uso de Strings y Ciclos .............................................................................................................. 63
1.2.1 Comparación de Strings y Unicode ....................................................................................... 63
1.2.2 Manejo de Strings en Python ............................................................................................... 67
1.2.3 Factorial de un número con recursión ................................................................................. 69
1.2.4 Separar cadenas de texto en Python .................................................................................... 73
1.2.5 Ciclos en Python con for ....................................................................................................... 75
1.2.6 Ciclos de Python en while ..................................................................................................... 79
1.2.7 Calcular si una palabra es palíndromo con Python .............................................................. 84
1.3 Estructuras de datos ................................................................................................................. 86
1.3.1 Introducción a las listas en Python ....................................................................................... 86
1.3.2 Operaciones con listas en Python......................................................................................... 91
1.3.3 Juego del ahorcado con Python............................................................................................ 96
1.3.4 Interfaz del ahorcado.......................................................................................................... 100
1.3.5 Lógica del ahorcado ............................................................................................................ 104
1.3.6 ¿Qué es una búsqueda binaria? ......................................................................................... 108
1.3.7 Implementar búsqueda binaria en Python ......................................................................... 108
1.3.8 Diccionarios en Python ....................................................................................................... 112
1
1.3.9 Encriptar mensajes usando diccionarios ............................................................................ 115
1.3.10 Tuplas en Python ............................................................................................................. 120
1.3.11 Se repite una letra en un string_Programa con tuplas ................................................... 124
1.3.12 Uso de sets en Python..................................................................................................... 129
1.3.13 Dictionary comprehension – list comprehension ........................................................... 132
1.4 Uso de objetos y módulos ...................................................................................................... 136
1.4.1 Manejo de errores en Python ............................................................................................. 136
1.4.2 Errores personalizados ....................................................................................................... 139
1.4.3 Manejo de archivos en Python ........................................................................................... 142
1.4.4 Programación orientada a objetos en Python.................................................................... 146
1.4.4.1 Clases en Python 3 ......................................................................................................................................... 146
1.4.4.2 ¿Qué es una clase en Python? .................................................................................................................... 146
1.4.4.3 ¿Qué es un Objeto en Python? ................................................................................................................... 146
1.4.4.4 Ejemplo gráfico de Clases en Python ...................................................................................................... 147
1.4.4.5 Sintaxis de clases en Python ...................................................................................................................... 149
1.4.5 Modular un objeto en Python ............................................................................................ 153
1.4.6 Decoradores en Python ...................................................................................................... 158
1.4.7 Paquetes y módulos............................................................................................................ 161
1.4.8 Entorno virtual en Python .................................................................................................. 167
1.5 Proyecto: Web Scraping ......................................................................................................... 176
1.5.1 ¿Qué es web scraping? ....................................................................................................... 176
1.5.2 Implementación web scraping con Python ........................................................................ 179
1.6 Proyecto: Aplicación de Terminal .......................................................................................... 185
1.6.1 Interfaz directorio de contactos ......................................................................................... 185
1.6.2 Lógica de directorio de contactos ...................................................................................... 185
1.6.3 Persistencia de datos .......................................................................................................... 191
1.7 Proyecto: Aplicación web ....................................................................................................... 198
1.7.1 Configurando el entorno de desarrollo de Google Cloud .................................................. 198
1.7.2 Crear templetes con Jinja2 ................................................................................................. 204
1.7.3 Manejar rutas y lógica con Flask......................................................................................... 204
1.7.4 Listar y eliminar contactos .................................................................................................. 204
1.8 Practicas comunes .................................................................................................................. 214
2
1.8.1 ¿Qué puedes construir con Python? .................................................................................. 214
1.8.2 Consejos para aprender a programar [1] ........................................................................... 218
1.9 Retos / Desafíos ...................................................................................................................... 221
1.9.1 Desafío 1: Crear una función que sume recursivamente ................................................... 221
1.9.2 Desafío 2: Criptografía con binarios ................................................................................... 226
1.9.3 Desafío 3: Modular un objeto ............................................................................................. 231
1.9.4 Verifique los conocimentos en Python .............................................................................. 234
3
No pares de apender
4
1. Curso de Python
1.1 Básicos de programación
1.1.1 Guía de instalación y conceptos básicos

¿Qué es Python?
Python es un lenguaje de programación creado por Guido Van Rossum, con una sintaxis muy limpia,
ideado para enseñar a la gente a programar bien. Se trata de un lenguaje interpretado o de script.
Ventajas:
 Legible: sintaxis intuitiva y estricta.
 Productivo: ahorra mucho código.
 Portable: para todo sistema operativo.
 Recargado: viene con muchas librerías por defecto.
Para empezar a utilizar el lenguaje se necesitan tres elementos:

◽ Lenguaje Python, Para este documento utilizar Python 3.8.2
◽ Editor de código o IDE
◽ Consola.
Los siguientes son ejemplos de algunos editores que se utilizan para escribir código de Python:
 Visual Studio Code

 Pycharm
 Sublime Text
 Atom
En realidad cualquier ide es bueno para programar cada editor tiene sus ventajas y desventajas:
Visual Studio Code: Pycharm:

Ayuda a generar Tiene varias funcionalidades
buenas prácticas en la pre-instaladas para trabajar
realización del código, con Python. Tiene en contra
es más ordenado, agradable, tiene auto el usos de recursos de máquina que son
completado, resalta las veces que está exigentes, consume memoria ram.
escrita una misma variable, tiene un
botón para ejecutar el código.
5
Sublime Text: Atom:
Es más rápido que Una de los pocos
VSCode pero este último problemas del editor se
tiene mayor cantidad de encuentra en su
plugins y es versátil, Sublime Text es útil rendimiento, ya que a veces puede ser
para abrir archivos de logs pesados. un poco lento. A la hora de abrir un
archivo o navegar entre diferentes
pestañas el tiempo de reacción puede
llegar a ser un poco superior a lo deseado
y eso, cuando se desea avanzaren
rápidamente en la programación, puede
ser molesto.
¿Cuál es la diferencia entre un editor de texto y un IDE ( Integrated Development

Environment)?
Un editor de texto solo edita texto. Y necesita obtener un compilador por aparte. Como
no tiene compilador ni intérprete, es mucho más ligero, por ejemplo el block de notas
que está integrado en Windows.
Por otro lado, los IDE son mucho más grandes, generalmente incluyen compiladores
para diferentes lenguajes y además poseen otras funciones como: Editor de texto,
función de autocompletar código, procedimiento de compilación que incluye
compilador, enlazador, depurador, administrador de archivos o proyectos, perfilador
de rendimiento, herramienta de implementación y según su tamaño-costo mejora sus
características.
A grandes rasgos, IDE = EDITOR + COMPILADOR + DEBUGGER
Consola permite ejecutar tareas en el computador

mediante comandos de texto. Es decir, permite
ejecutar programas e instrucciones que
normalmente se ejecutan mediante una interfaz
gráfica (usando el mouse), pero usando
instrucciones basadas en texto. Una vez escrito el código en el id (Visual Studio Code,
Pycharm, Sublime text, , Atom, otros), se necesita la consola para ejecutarlo. Es como
darle vida al código, haciendo que las instrucciones que están escritas sean ejecutadas
para obtener resultados. Sin importar cuál sea la consola que se utilice como por ejemplo:
6
cmder, powershell (windows), cmd(Windows), consola de linux, consola de mac, el
intérprete de Python ejecute el código.
Instalación de Python en diferentes plataformas y SO
Para instalar Python seguir los pasos dependiendo del sistema operativo que esté
instalado.
Windows Versión 3.x

Para instalarlo en Windows, descargas de python3 -v
la página oficial de Python sitio
reconocerá el sistema operativo y dará Si el comando arroja un error quiere
las opciones para descargar. decir que no está instalado, en ese caso
los pasos para instalarlo cambian un
Ejecutar el archivo que se descarga y poco de acuerdo con la distribución de
seguir los pasos de instalación. Al linux que se esté usando. Generalmente
finalizar va a poder utilizar Python en el el gestor de paquetes de la distribución
computador. de Linux tiene el paquete de Python
MacOS Para Ubuntu o Debian por ejemplo usar

La forma sencilla es tener instalado este comando para instalar la versión
homebrew y usar el comando: 3.1:
Para instalar la Versión 2.7 $ sudo apt-get install python3.1

brew install Python
Para instalar la Versión 3.x Para usuarios de Red Hat o Centos por
brew install python3 ejemplo puede usar este comando para
instalar Python.
Linux
Generalmente Linux ya lo trae instalado, $ sudo yum install python
para comprobarlo puedes ejecutar en la
terminal el comando Para instalar Linux manualmente
descargar los archivos
Versión 2.7
python -v
Antes de empezar:
Debe definir el Sistema Operativo que va a utilizar, la versión del lenguaje Python, el
editor de texto o IDE y la consola con las cuales va a realizar los programas.
7
Tipos de datos en Python
 Enteros (int): en este grupo están [1,2,3, ”hola” , [1,2,3] ],

todos los números, enteros y [1,“Hola”,True ]
long: ejemplo: 1, 2, 3, 2121, 2192,
-123  Diccionarios: Son un grupo de
datos que se acceden a partir de
 Booleanos (bool): Son los valores una clave: ejemplo:
falso o verdadero, compatibles {“clave”:”valor”},
con todas las operaciones {“nombre”:”Fernando”}
booleanas ( and, not, or ):
ejemplo: True, False  Tuplas: también son un grupo de
datos igual que una lista con la
 Cadenas (str): Son una cadena de diferencia que una tupla después
texto: ejemplos: “Hola”, “¿Cómo de creada no se puede modificar.
estás?” ejemplos: (1,2,3, ”hola” , (1,2,3) ),
(1,“Hola”,True) (Pero jamás
 Listas: Son un grupo o array de podremos cambiar los elementos
datos, puede contener cualquiera dentro de esa Tupla).
de los datos anteriores: ejemplos:
En Python se trabaja con módulos y ficheros que se usan para importar las librerías.
Funciones
Las funciones se definen con el comando def junto a un nombre y unos paréntesis que
reciben los parámetros a usar. Terminar con dos puntos.
def nombre_de_la_función(parametros):
Después por indentación colocar los datos que se ejecutarán desde la función:
>>> def my_first_function():
... return “Hello World!”
...
>>> my_first_function()
'Hello World!'
>>>
8
Variables
Las variables, a diferencia de los demás lenguajes de programación, no se definen, ni

tampoco su tipo de dato, ya que al momento de iterarlas se identificará su tipo. Recuerde
que en Python todo es un objeto.
A = 3
B = 4
Lista
Las listas se declaran con corchetes. Estas pueden tener una lista dentro o cualquier tipo
de dato.
>>> L = [22, True, “una lista”,[1,2]]
>>> L[0]
22
>>>
Tuplas
Las tuplas se declaran con paréntesis, recuerde que no puede editar los datos de una tupla
después de creado.
>>> L = (22, True, “una tupla”,(1,2))
>>> L[0]
22
>>>
Diccionarios
En los diccionarios se tiene un grupo de datos con un formato: la primera cadena o

número será la clave para acceder al segundo dato, el segundo dato será el dato al cual se
accederá con la llave. Recuerde que los diccionarios son listas de llave: valor.
>>> D = {“Kill Bill”: “Tamarino”, “Amelie”: “Jean-Pierre Jeunet”}

>>> D[“Kill Bill”]
‘Tamarino’
>>>
Conversiones
De flotante a entero:
9
>>> int (4.3)
4
>>>
De entero a flotante:
>>> float(4)
4.0
De>>>
entero a string:
>>> str(4.3)
‘4.3’
>>>
De tupla a lista:
>>> list((4, 5, 2))
[4, 5, 2]
>>>
Operaciones comunes
Longitud de una cadena, lista, tupla, etc.:

>>> len(“key”)
3
>>>
Tipo de dato:
>>> type(4)
<class ‘int’>
>>>
Aplicar una conversión a un conjunto como una lista:

>>> *map(str,[1, 2, 3, 4]),
('1', '2', '3', '4')
>>>
Redondear un flotante con x número de decimales:

>>>round(3.1416,2)
3,14
>>>
10
Generar un rango en una lista (esto es mágico):
>>>range(5)
range(0, 5)
>>> list (range(5))
[0, 1, 2, 3, 4]
>>>range(1, 20, 3)
range(1, 20, 3)
>>> list (range(1, 20, 3))
[1, 4, 7, 10, 13, 16, 19]
>>>
Sumar un conjunto:
>>>sum([1, 2, 4])
7
>>>
Organizar un conjunto:
>>>sorted ([5, 2, 1])
[1, 2, 5]
>>>
Conocer los comandos que le puedes aplicar a x tipo de datos:

>>>Li = [5, 2, 1]
>>>dir(Li)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__init_subclass__', '__iter__', '__le__',
'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
'__setattr__', '__setitem__', '__sizeof__', '__str__',
'__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend',
'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> ‘class’, ‘'index', 'insert', 'pop' …. Son comandos que puedes aplicar a una lista.
‘add’,
Información sobre una función o librería:
>>> help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False) Return a new list

containing all items from the iterable in ascending order. A custom
key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
>>>
11
Limpiar la consola
>>> from os import system

>>> system(“cls”)
Clases
>>>
Clases es uno de los conceptos con más definiciones en la programación, pero en resumen
sólo son la representación de un objeto. Para definir la clase usar class y el nombre. En
caso de tener parámetros se colocan entre paréntesis.
Para crear un constructor hacer una función dentro de la clase con el nombre init y de
parámetros self (significa su clase misma), nombre_r y edad_r:
>>>class Estudiante(object):
... def __init__(self,nombre_r,edad_r):
... self.nombre = nombre_r
... self.edad = edad_r
... def hola(self):
... return"Mi nombre es %s y tengo %i años" %(self.nombre,self.edad)
...
>>>e= Estudiante("Diego", 56)
>>>print (e.hola())
>>>Mi nombre es Diego y tengo 56 años
>>>
En las dos últimas líneas se realizó lo siguiente:

1. En la variable e se llama a clase Estudiante y se le pasa la cadena “Diego” y el
entero 56.
2. Se Imprime la función hola() dentro de la variable e (a la que anteriormente se le
había pasado la clase).
El resultado que arroja el código es la cadena “Mi nombre es Diego y tengo 56 años”
Métodos especiales
cmp(self,otro)
Método llamado cuando se utilizan los operadores de comparación para comprobar si el
objeto es menor, mayor o igual al objeto pasado como parámetro.
len(self)
Método llamado para comprobar la longitud del objeto. Se usa, por ejemplo, cuando se
llama la función len(obj) sobre el código. Como es de suponer el método devuelve la
longitud del objeto.
init(self,otro)
12
Es un constructor de una clase, es decir, es un “método especial” que llama
automáticamente cuando se crea un objeto.
Condicionales IF
Los condicionales tienen la siguiente estructura. Tener en cuenta que en los paréntesis
esta la comparación que debe cumplir para que los elementos se cumplan.
if ( a > b):
elementos
elif ( a == b)
elementos
else:
elementos
Bucle FOR
El bucle de for lo puede usarse de la siguiente forma: recorrer una cadena o lista la cual va
a tomar el elemento en cuestión con la siguiente estructura:
for i in ____:
elementos
Ejemplo:
for i in range(5):
print(i)
0
1
2
4
En este caso recorrerá una lista de cinco elementos, es decir el _print i _se ejecutara cinco
veces. Ahora i va a tomar cada valor de la lista, entonces este for imprimirá los números
del 0 al 4 (recordar que en un range va hasta el número puesto -1).
Otro ejemplo para cambiar el formato de salida en la impresión sería:
for i in range(5):
print(i,end= “ “)
0 1 2 3 4
13
Bucle WHILE
En este caso while tiene una condición que determina hasta cuándo se ejecutará. O sea
que dejará de ejecutarse en el momento en que la condición deje de ser cierta. La
estructura de un while es la siguiente:
while (condición):
elementos
Ejemplo:
>>> x = 0
>>> while x < 10
... print(x)
... x += 1
...
1
2
3
4
5
6
7
8
En9 este ejemplo preguntará si x es menor que diez. Dado que es menor imprimirá x y
>>>
luego sumará una unidad a x. Luego x es 1 y como sigue siendo menor a diez se seguirá
ejecutando, y así sucesivamente hasta que x llegue a ser mayor o igual a 10.
Ayudas en la red
Videos
https://www.youtube.com/watch?v=chPhlsHoEPo
Páginas web
Ejercicios básicos: Python http://aprendeconalf.es/python/ejercicios
https://github.com/gsuscastellanosSC/CursoDePython/blob/master/Generalidades.py
https://es.wikihow.com/cambiar-colores-en-command-prompt
Tutorial de Python
https://docs.python.org/es/3/tutorial/index.html
Cursos en Platzi
Curso de Introducción al Pensamiento Computacional con Python
https://platzi.com/clases/python-cs/
https://platzi.com/clases/1764-python-cs/25577-preparacion-de-tu-computadora/
14
1.1.2 ¿Por qué programar con Python?
Python es un lenguaje bastante bueno para aprender a programar ya que tiene una
comunidad muy grande que ayuda a superar las dudas, tiene una sintaxis para escribir
bastante sencilla.
Razones para aprender a Programar en Python:
1. Tiene una gran comunidad en Internet para aprender de ella. (Libros, Blogs,
Tutoriales, Videos).
2. Gracias a su sintaxis clara y precisa, la curva de aprendizaje en Python es baja, es
casi como escribir en inglés.
3. Permite Programar recurriendo a sus Frameworks y Librerías.
4. Es portable, es decir sirve tanto para Windows, Linux o Mac.
5. Es multipropósito, existen librerías que se pueden usar para desarrollo web, móvil,
Machine Learning, Big Data, Scripting, Servidor Web y otros.
¿Qué es programar?
Programar es darle instrucciones al computador, para hacer algo que se desea hacer en
ella, desde el sitio web o llevar humanos a marte.
Para lograr construir lo que se desea se deben unir piezas básicas del lenguaje y
dependiendo de cómo se unan se va a construir lo que se imagina.
Para crear el primer “hola mundo” se debe encender el intérprete de Python, este “hola
mundo” es muy sencillo, ejecutar la función print así:
>>>print (“Hola mundo”)

Hola mundo
>>>
Ayudas en la red
Páginas web
Notas de Pyton 3
https://docs.google.com/document/d/1evjmD6FMVRTM2-
_pQtsjQlBKDjhDHmZw7BYhLSpt8ew/edit?usp=sharing
Notas de Pyton 3
https://docs.google.com/document/d/1evjmD6FMVRTM2-
_pQtsjQlBKDjhDHmZw7BYhLSpt8ew/edit?usp=sharing
15
¿Qué es if __name__ == “__main__”:?
https://es.stackoverflow.com/questions/32165/qu%C3%A9-es-if-name-main
La Biblia de Python
Para resolver dudas del lenguaje puede consultar esta ruta
1. Ingresa a https://www.python.org/
2. Dar click en la sección “Documentation”
3. Selecciona la versión de Python que desee explorar.
Python para principiantes

https://uniwebsidad.com/libros/python?from=librosweb
Tutorial de Python
Cursos en Platzi
Curso de Fundamentos de Álgebra Lineal con Python:
https://platzi.com/clases/algebra-lineal/
Curso Básico de Python
https://platzi.com/clases/pythonbasico/
Libros
Gonzales Dique Raul, Pyton para todos, Este libro se distribuye bajo una licencia Creative
Commons Reconocimiento 2.5 España
5 libros para aprender más sobre Python

https://platzi.com/tutoriales/1104-python/1598-5-libros-para-aprender-mas-sobre-
python/
16
1.1.3 ¿Qué es la programación?
La programación es dar instrucciones a la computadora de forma ordenada, estas
instrucciones definen lo que se va a realizar, desde cosas sencillas hasta cosas avanzadas.
Todos los programas se componen de partes esenciales que son forma de darle datos de
entrada a la computadora y formas estructuradas para procesar estos datos.
_________________________________________________________________________
Turtle es una biblioteca preinstalada en las computadoras. Es una forma sencilla

Python que permite a los usuarios crear pero versátil de comprender los
imágenes y formas proporcionándoles un conceptos de Python. Esta biblioteca o
lienzo virtual. El lápiz en pantalla que usa librería ha demostrado ser
para dibujar se llama tortuga (turtle) y extremadamente útil para los adultos
esto es lo que le da nombre a la que están probando Python, lo que lo
biblioteca. En resumen, la biblioteca hace ideal para los principiantes de
Turrtle de Python ayuda a los nuevos Python .
programadores a tener una idea de cómo
es la programación con Python de una Con la librería turtle de Python, puede
manera divertida e interactiva. dibujar y crear varios tipos de formas e
imágenes. A continuación se muestran
Turtle es útil para introducir a los varios ejemplos de los dibujos que se
nuevos programadores en el mundo de pueden hacer con turtle.
Ejemplos:
 Ejemplo inicial (ejemplo_inicial.py)
"""
File: ejemplo_inicial.py
"""
import turtle
window = turtle.Screen()
dave = turtle.Turtle()
dave.forward(50)
dave.left(90)
dave.forward(50)
dave.left(90)
dave.forward(50)
dave.left(90)
dave.forward(50)
dave.left(90)
17
turtle.mainloop()
 Dibujar una espiral Espiral (turtle_espiral.py)
import turtle
colors=['red','purple','blue','green','yellow','orange']
t = turtle.Pen()
t.speed(0)
for x in range(360):
t.pencolor(colors[x%6])
t.width(x/100+1)
t.forward(x)
t.left(59)
turtle.mainloop()
18
 Prisma rectangular (rectángulo.py)
import turtle
david = turtle.Turtle()
david.forward(50)
david.left(90)
david.forward(50)
david.left(90)
david.forward(50)
david.left(90)
david.forward(50)
david.right(135)
david.forward(50)
david.right(45)
david.forward(50)
david.right(90)
david.forward(50)
david.right(45)
david.forward(50)
david.right(135)
david.forward(50)
david.right(45)
david.forward(50)
turtle.mainloop()
19
 Figura especial (turtle_ejemplo2.py)
import turtle
import math as mt
a=200
b=5
a1=[]
b1=[]
c=[]
f1=[]
f2=[]
for s in range(0,40):
a1.append(a)
b1.append(b)
a=a-5
b=b+5
for e in range(0,40):
q=((a1[e]**2)+(b1[e]**2))**(1/2)
c.append(q)
for g in range(0,40):
q=((mt.asin(b1[g]/c[g]))*180)/mt.pi
f1.append(q)
q1=((mt.asin(a1[g]/c[g]))*180)/mt.pi
f2.append(q1)
a1.append(5)
alejo = turtle.Turtle()
alejo.forward(200)
alejo.left(90)
20
alejo.forward(200)
for w in range(0,40):
alejo.left(f2[w])
alejo.forward(c[w])
alejo.left(f1[w])
alejo.forward(b1[w])
alejo.left(90)
alejo.forward(a1[w+1])
alejo.forward(200)
alejo.left(90)
alejo.forward(205)
alejo.left(90)
alejo.forward(205)
alejo.left(90)
alejo.forward(205)
turtle.mainloop()
 Estrella (estrella.py)
import turtle
from turtle import *
color('red', 'yellow')
froggie = turtle.Turtle()
froggie.left(-108)
froggie.forward(90)
froggie.left(144)
froggie.forward(90)
21
froggie.left(144)
froggie.forward(90)
froggie.left(144)
froggie.forward(90)
froggie.left(144)
froggie.forward(90)
froggie.left(72)
froggie.circle(45)
turtle.mainloop()
 Cubo amarillo en fondo verde (cubo_verde.py)

#import the turtle modules
import turtle
# Forming the window screen

tut = turtle.Screen()
# background color green

tut.bgcolor("green")
# window title Turtle

tut.title("Turtle")
my_pen = turtle.Turtle()
# object color
my_pen.color("orange")
tut = turtle.Screen()
my_pen.pensize(8)
# forming front square face
22
for i in range(4):
my_pen.forward(100)
my_pen.left(90)
# bottom left side

my_pen.goto(50,50)
# forming back square face

for i in range(4):
my_pen.forward(100)
my_pen.left(90)
# bottom right side

my_pen.goto(150,50)
my_pen.goto(100,0)
# top right side

my_pen.goto(100,100)
my_pen.goto(150,150)
# top left side

my_pen.goto(50,150)
my_pen.goto(0,100)
turtle.mainloop()
23
Ayudas en la red
Páginas web
The Beginner's Guide to Python Turtle
https://realpython.com/beginners-guide-python-turtle/
Tutorial de Python
Turtle
https://docs.python.org/3.6/library/turtle.html
Draw Cube and Cuboid in Python using Turtle

https://www.geeksforgeeks.org/draw-cube-and-cuboid-in-python-using-turtle/
Videos
COMO EJECUTAR PROGRAMAS DE PYTHON DESDE ATOM:
https://www.youtube.com/watch?v=tF28s0x2jHU
Para abrir Python desde el cmd de Windows en este vídeo se explica cómo hacerlo.
https://youtu.be/sGYSPaXAlkg
El siguiente video para principiantes de YouTube ayuda a la instalación de los programas y

entender cómo trabaja Python con el editor.
https://youtu.be/chPhlsHoEPo
How to Set Up Atom IDE for Python on Windows 10

https://youtu.be/nXvBrK2wxWc
En este video enseñan a cómo descargar y configurar Visual Studio Code con las
extensiones necesarias.
https://youtu.be/XRtZzlD2LJ8
Cursos en Platzi
Configurando mi editor Atom para Python
https://platzi.com/contributions/configurando-mi-editor-atom-para-python/
Libros
David Aroesti, Curso de Python
24
1.1.4 Python 2 vs Python 3
Muchos usuarios principiantes de Python se preguntan con qué versión de Python
deberían comenzar. La respuesta a esta pregunta suele ser algo así como "simplemente
elija la versión en la que está escrito el tutorial o libro que está siguiendo y compruebe las
diferencias más adelante".
Pero, ¿qué pasa si está comenzando un nuevo proyecto y tiene la opción de elegir?
Actualmente (2020) no hay "correcto" o "incorrecto" depende de las librerías que va a
utilizar con Python 2.7.xy o Python 3.x. Sin embargo, vale la pena echar un vistazo a las
principales diferencias entre esas dos versiones más populares de Python para evitar
errores comunes al escribir el código, o si planea portar el proyecto (Para más detalles ver
en este documento las Ayudas en la red> Páginas web).
Pyton2 Python 3
2010 versión 2.7 Arregla inconsistencias en el lenguaje de la
versión 2
print como un keyboard o como función print se convierte en una función
print ´Hola’ print(‘Hola’)
String no considera a las tildes, la ñ y String reconoce las tildes, ñ y caracteres
caracteres especiales. Codifica en ASCII. especiales como caracteres por defecto
Para reconocer los caracteres colocar al (UTF).
inicio del archivo # -*- coding: utf-8 -*
Resultado de dividir dos enteros es otro Resultado de dividir dos enteros es un
entero. Ej, 5/2 = 2 flotante (decimal). Ej, 5/2 = 2.5
LA SERIE PYTHON 2 SE RETIRARÁ EN Python 3 será la única versión que se
ABRIL DE 2020. actualizará para detectar errores y
La comunidad de desarrollo central de vulnerabilidades de seguridad.
CPython insta a los usuarios a migrar a
Python 3,
Ayudas en la red
Páginas web
Python2orPython3 - Python Wiki
https://wiki.python.org/moin/Python2orPython3
Las diferencias claves entre Python 2.7.xy Python 3.x con ejemplos
https://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html
Python Software Foundation: Comunicado de prensa 20 de diciembre de 2019

LA SERIE PYTHON 2 SE RETIRARÁ EN ABRIL DE 2020
https://www.python.org/psf/press-release/pr20191220/
25
Tutorial de Python
26
1.1.5 Operadores matemáticos en Python 3
Los operadores nos permiten trabajar con valores y generar nuevos valores por medio de
estas operaciones.
Los siguientes operadores son básicos:
 (+) Suma
 (-) Resta
 (*) Multiplicación
 (/) División
 (//) División de enteros
 (%) Operador de módulo
 (**) Potencias
 (>) Mayor que
 (<) Menor que
 (==) Igual
 (>=) Mayor igual
 (<=) Menor igual
Ejemplo:
 Operaciones matemáticas (Operaciones_matemática.py)
from os import system
system("cls")
a = int(input('ingrese un número A: '))

b = int(input('ingrese un número B: '))
print('Número A =',a)
print('Número B =',b)
print('Suma:', a + b)
print('Resta:', a - b)
print('Multiplicación:', a * b)
print('Potencia:', a ** b)
print('División:', a / b)
print('División entero:', a // b)
print('Residuo:', a % b)
print('A mayor que B:', a > b)
print('A menor que: B', a < b)
print('A Igual a B:', a == b)
print('A es diferente a B:', a != b)
27
Resultado después de ejecutar el código
Ingrese un número A: 5
Ingrese un número B: 4
Número A = 5
Número B = 4
Suma: 9
Resta: 1
Multiplicación: 20
Potencia: 625
División: 1.25
División entero: 1
Residuo: 1
A mayor que B: True
A menor que: B False
A Igual a B: False
A es diferente a B: True
Ayudas en la red
Páginas web
Tutorial de Python
Operadores en Python: muchos ejemplos reales y propios!

https://pythones.net/operadores-basicos-en-python/
Operadores en Python
https://www.fing.edu.uy/inco/cursos/fpr/wiki/index.php/Operadores_en_Python
28
1.1.6 Tipos de datos en Python
¿En qué orden se evalúan las matemáticas operaciones complejas?
Paréntesis
Exponentes
Multiplicación / División
Adición / Sustracción
Una forma fácil de recordar éste orden es usando el acrónimo PEMDAS (Paréntesis
Exponentes Multiplicación División Adición Sustracción)
Valores y Tipos
Los tipos le permiten a Python saber cuál es el resultado de aplicar determinada

operación, los tipos básicos son:
Integer <int>
Float <float>
String <str>
Boolean <bool>
Para revisar de qué tipo es un dato puedes usar la función type.
Ejemplos:
>>> type(2)
<class 'int'>
>>> type('Hola')
<class 'str'>
>>> type(2.3)
<class 'float'>
29
Los datos Boolean True o False se deben de escribir siempre la primera letra es mayúscula
para que no genere error.
>>> type(false)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'false' is not defined
>>> type(False)
<class 'bool'>
>>> type (True)
<class 'bool'>
>>>
 Programa con tipos de datos (datos_python.py)

system("cls")
print ('Bienvenido')
print ('Aqui podras encontrar los distintos tipos de DATOS en la programació
n')
print ('Integer <int> devuelve numeros enteros')
print ('100 =')
print (type(100))
print ('Float <float> devuelve numeros decimales')

print ('2.5 =')
print (type(2.5))
print ('String <str> devuelve una cadena de letras o palabras')

print ('Hola mundo =')
print (type('Hola mundo'))
print ('El valor Boleano <bool> funciona como un interruptor, solo tiene dos
estados posibles VERDADERO o FALSO <true/false>')
print ('¿10 es igual a 10?')
print('10 == 10')
print ( 10 == 10)
print (type(10 == 10))
print ('¿100 es igual a 20?')

print ('100 == 20')
print ( 100 == 20)
print (type(100 == 20))
30
Bienvenido
Aquí podrá encontrar los distintos tipos de DATOS en la programación
Integer <int> devuelve números enteros
100 =
<class 'int'>
Float <float> devuelve números decimales
2.5 =
<class 'float'>
String <str> devuelve una cadena de letras o palabras
Hola mundo =
<class 'str'>
El valor Boleano <bool> funciona como un interruptor, solo tiene dos
estados posibles VERDADERO o FALSO <true/false>
¿10 es igual a 10?
10 == 10
True
<class 'bool'>
¿100 es igual a 20?
100 == 20
False
<class 'bool'>
Ayudas en la red
Páginas web
Tutorial de Python
Pensamiento numérico y algebraico

http://pensamientoepoant.blogspot.com/20
31
1.1.7 Declarar variables y expresiones
Las variables permiten guardar valores,  Las variables se pueden reasignar

se pueden reutilizar en diferentes partes
del código, haciendo los programas más Nombres de variables
legibles.
 Tienen que tener nombres
El valor que contiene una variable puede significativos.
ser reasignado, significa que se puede
 Relacionados con lo que
asignarle diferentes valores a una misma
variable. representa la variable.
 No deben ser Keywords (palabras
Las variables tienen algunas limitantes, reservadas).
por ejemplo:
Tienen que tener un nombre Keywords (palabras reservadas)
significativo, es decir, que sugieran qué False elif lambda
están haciendo. None else monlocal
No se pueden usar palabras reservadas True except not
del lenguaje como nombres para las
And finally or
variables (por ejemplo class, False, none,
As for pass
True).
Para definir una variable escribir el assert from raise
nombre que quiere asignarle y con = Break global return
definir el valor que va a almacenar, por Class if try
ejemplo: continue import while
Def in with
pi = 3.14159
del is yield
radio = 3
area = pi * radio**2
print(area) Cadenas (strings)
Variables y expresiones  Python puede procesar texto al

igual que procesa números.
 Las expresiones se componen de  Para expresar texto, se utilizan
valores conectados por comillas. Por ejemplo: ‘Hola’ ○
operadores. “Adiós”.
 Cuando la computadora evalúa  Las cadenas pueden asignarse a
una expresión, el resultado es variables y algunos operadores
otro valor. pueden utilizarse con ellas.
 Los valores pueden guardarse en  Si se requiere utilizar una comilla,
variables. es necesario escapar el carácter.
32
Ejemplo:
 ¿Cuál es tu nombre? (cual_nombre.py)
system("cls")
nombre= (input ('Cuál es tú nombre? - '))

print('hola, '+nombre+'!')
edad= int(input('¿Cuántos años tiene? - ' ))

print('cierto! tenías '+str(edad)+'. Yo tengo '+str(edad+1))
direccion=str(input('Y dónde vives? Sorry olvidé todo :c - '))

print('claro! ya recuerdo! vives en '+direccion+', muy buen lugar')
recuerdo=str(input('Y te acuerdas de mi? :D - '))
if recuerdo in ['si', 'yes','SI','YES']:

print('Que genial! ya veo que sí te acuerdas de mí')
if recuerdo in ['no', 'nop','NO']:

print('oh! ya veo que no te acuerdas de mí')
print('no te preocupes :)')
Cuál es tú nombre? - Diego Cabrera

hola, Diego Cabrera!
¿Cuántos años tiene? - 56
cierto! tenías 56. Yo tengo 57
Y dónde vives? Sorry olvidé todo :c - Bogotá
claro! ya recuerdo! vives en Bogotá, muy buen lugar
Y te acuerdas de mí ? :D - SI
Que genial! ya veo que sí te acuerdas de mi
 Calculadora simple de dos dígitos (calculadora.py)

system("cls")
print("Bienvenido a la calculadora de dos dígitos")
a = float(input("Indique el primer valor: "))

b = float(input("Indique el segundo valor: "))
33
opc = int(input("Seleccione una opción: 1. Suma 2. Resta 3. Multiplicación
4.División "))
if(opc == 1):
suma = a + b
print(suma)
elif(opc == 2):
resta = a - b
print(resta)
elif(opc == 3):
multi = a * b
print(multi)
elif(opc == 4):
div = a/b
print(div)
Bienvenido a la calculadora de dos dígitos

Indique el primer valor: 10
Indique el segundo valor: 5
Seleccione una opción: 1. Suma 2. Resta 3. Multiplicación
4.División 4
2.0
Ayudas en la red
Páginas web
En Python 3.x se usa input() para python 2 raw_input(). En el link se explica en
profundidad las diferencias entre una y otra:
Diferencia entre input() y raw_input()

https://es.stackoverflow.com/questions/38288/diferencia-entre-input-y-raw-input
Adicione «Python» a la variable PATH del sistema

http://www.scielo.org.mx/avaliacao/manual_marcacion/instalacion_markup_paths.html
Crear, guardar y ejecutar scripts de Python – Archivos .py

https://pythones.net/archivos-py-crear-guardar-y-ejecutar-scripts-de-python/
List of Keywords in Python

https://www.programiz.com/python-programming/keyword-list
Tutorial de Python
34
Cursos en Platzi
Curso Gratis de Programación Básica
https://platzi.com/clases/programacion-basica/
Guía de expresiones regulares en Python

https://platzi.com/blog/expresiones-regulares-python/
Curso de Python
https://platzi.com/cursos/python/
Curso de Django
https://platzi.com/cursos/django/
35
1.1.8 Definir funciones en Python
Las funciones son un concepto fundamental en programación, una función es una
secuencia de comandos que realizan un cómputo.
En Python las funciones se definen usando la palabra reservada def y luego el nombre de
la función con paréntesis y dos puntos que indican que lo que sigue son los comandos,
una función debe retornar un valor, para esto se usa la palabra reservada return.
def suma(num1,num2):
return num1 + num2
Para usar una función simplemente se llama por su nombre seguido por paréntesis con los
parámetros que recibe.
suma(2,3)
 En Python 3, usar la función input() para recibir datos del usuario.

 Para definir dónde comenzar el código usar la línea
If __name__ = ‘__main__’
 Para definir un bloque dentro de la función indentar con 4 espacios.

 Las funciones permiten ejecutar determinado código con diferentes
valores.
El lenguaje de programación Python incluye un módulo que permite programar gráficas de

tortuga. Las gráficas de tortuga aparecieron por vez primera en el lenguaje de
programación ‘Logo’ por ahí de finales de los años sesenta. La idea central de este tipo de
gráficas consiste en desplazar un cursor (al que se le denomina tortuga) por la pantalla a
partir de diferentes comandos programados. Normalmente la tortuga deja un rastro por el
lugar donde se va desplazando.
Ejemplos:
 Dibujar polígonos de varios lados (polígonos.py)
length =int(input('Tamaño de las linea: '))
n = int(input('Numero de lados: '))
color =str(input('Escriba el color de la línea (red, blue, green, black) '))
lapiz=int(input('Grosor del lapiz :'))
import turtle
36
def Mifuncion():
ventana =turtle.Screen()
tortuga = turtle.Turtle()
square(tortuga)
turtle.mainloop()
def square(tortuga):
for i in range(n):
lineas(tortuga,length)
def lineas(tortuga,length):
tortuga.pencolor(color)
tortuga.pensize(lapiz)
tortuga.shape("arrow")
tortuga.forward(length)
tortuga.left(360/n)
if __name__== '__main__':
Mifuncion()
Tamaño de las líneas: 180

Numero de lados: 4
Escriba el color de la línea (red, blue, green, black) green
Grosor del lápiz: 30
37
 Dibujar Triangulo, Cuadrado, Rectángulo, (118_turtle.py)
import turtle
def main():
diego = turtle.Turtle()
make_form(diego)
turtle.mainloop()
def make_form(diego):
form = int(input("Para dibujar: Triangulo (1), Cuadrado (2), Rectangulo
(3) indique el número:"+"\n"))
if form == 1:
make_triangle(diego)
elif form == 2:
make_square(diego)
elif form == 3:
make_rectangle(diego)
else:
print("Numero incorrecto intente del 1 al 3 ")
def make_triangle(diego):
length = int(input("El tamano de cada lado es: "))
make_triline(diego, length)
def make_square(diego):
for i in range(4):
make_line_and_turn(diego, length)
def make_rectangle(diego):
side = length/2
for i in range(2):
make_four_line(diego, length, side)
def make_triline(diego, length):

diego.forward(length)
diego.left(120)
38
diego.left(120)
def make_line_and_turn(diego, length):

diego.left(90)
def make_four_line(diego, length, side):

diego.left(90)
diego.forward(side)
diego.left(90)
if __name__ == "__main__":
main()
Resultado después de ejecutar el código:
Para dibujar: Triangulo (1), Cuadrado (2), Rectángulo (3) indique el

número:
1
El tamaño de cada lado es: 180
 Código para hacer Logo de Platzi y Python (logos.py)

import turtle
turtle.title("Dibujando Logos")
def main():
condes = turtle.Turtle()
39
opcion = input("Que desea dibujar? : Logo Plazi presione (A): Logo Pytho
n presione (B): ")
if opcion.upper() == "A":
logo_platzi(condes)
turtle.mainloop()
elif opcion.upper() == "B":

logo_python(condes)
turtle.mainloop()
else :
print("No Eligio una figura")
def logo_platzi(condes):
condes.pencolor("green")
condes.fillcolor("green")
condes.pensize(5)
condes.begin_fill()
condes.left(45)
condes.forward(137.5)
condes.left(45)
condes.left(45)
condes.left(45)
condes.left(45)
condes.left(45)
condes.left(45)
condes.left(45)
condes.left(45)
condes.forward(100)
condes.left(90)
condes.forward(50)
condes.left(90)
condes.forward(50)
condes.left(270)
condes.forward(150)
40
condes.left(270)
condes.forward(150)
condes.left(270)
condes.forward(100)
condes.left(270)
condes.forward(100)
condes.left(90)
condes.forward(50)
condes.end_fill()
condes.hideturtle()
def logo_python(condes):
condes.pencolor("navyblue")
condes.fillcolor("navyblue")
condes.pensize(5)
condes.begin_fill()
condes.left(0)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(40)
condes.left(90)
condes.forward(100)
condes.left(270)
condes.forward(15)
condes.left(270)
condes.forward(150)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(40)
condes.left(90)
41
condes.forward(45)
condes.left(315)
condes.forward(65)
condes.end_fill()
condes.penup()#subir el lapiz
condes.left(45)
condes.forward(140)
condes.left(90)
condes.forward(-12)
condes.pendown()#Bajar el lapiz
condes.fillcolor("white")#DIBUJO OJO #1
condes.begin_fill()
condes.pencolor("white")
condes.left(90)
condes.forward(20)
condes.left(90)
condes.forward(20)
condes.left(90)
condes.forward(20)
condes.left(90)
condes.forward(20)
condes.end_fill()
condes.penup()#subir el lápiz
condes.left(90)
condes.forward(160)
condes.left(90)
condes.forward(100)
condes.pendown()#Bajar el lápiz
condes.fillcolor("orange")
condes.pencolor("orange")
condes.begin_fill()
condes.left(180)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(100)
condes.left(45)
42
condes.forward(50)
condes.left(45)
condes.forward(40)
condes.left(90)
condes.forward(100)
condes.left(270)
condes.forward(15)
condes.left(270)
condes.forward(150)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(100)
condes.left(45)
condes.forward(50)
condes.left(45)
condes.forward(40)
condes.left(90)
condes.forward(45)
condes.left(315)
condes.forward(65)
condes.end_fill()
condes.penup()#subir el lápiz
condes.left(45)
condes.forward(140)
condes.left(90)
condes.forward(-12)
condes.pendown()#Bajar el lápiz
condes.fillcolor("white") #Dibujando OJO #2

condes.begin_fill()
condes.pencolor("white")
condes.left(90)
condes.forward(20)
condes.left(90)
condes.forward(20)
condes.left(90)
condes.forward(20)
condes.left(90)
condes.forward(20)
condes.end_fill()
condes.hideturtle()
if __name__ == "__main__":
main()
43
Resultados después de ejecutar el código:
Que desea dibujar? : Logo Plazi presione (A): Logo Python presione
(B): A
Que desea dibujar? : Logo Plazi presione (A): Logo Python presione
(B): B
Modifique el código para hacerlo más eficiente, reducir el número de líneas utilizando
funciones de manera apropiada.
Ayudas en la red
Páginas web
Tutorial de Python
44
Turtle graphics
https://docs.python.org/3/library/turtle.html
En esta página explican paso a paso el uso de tortugas para dibujar.

Tutorial de Programación Orientada a Objetos en Python a través de Turtle Graphics en
Raspberry Pi.
https://www.programoergosum.es/tutoriales/introduccion-a-turtle-python-en-raspberry-
pi/
Cómo funcionan las sentencias condicionales en Python

https://programacion.net/articulo/como_funcionan_las_sentencias_condicionales_en_py
thon_1501
45
1.1.9 Funciones con parámetros
Límites al declarar funciones  Cada declaración se ejecuta de

 Los nombres no pueden izquierda a derecha, siguiendo el
comenzar con dígitos orden de operaciones.
 No pueden utilizar una palabra  Cuando una declaración
reservada (keyword) contiene una llamada a una
 Las variables deben tener función, el cuerpo de la función
diferentes nombres se ejecuta con las mismas reglas.
 Los nombres de las funciones Parámetros y argumentos
deben ser descriptivos de lo que  Para ejecutar ciertas funciones,
hacen las funciones es necesario “pasarles”
argumentos.
Declarar vs Ejecutar  Dichos argumentos son
Declarar una función es escribir su convertidos en parámetros
estructura (variables locales) dentro de la
Ejecutar una función es llamar la función función.
y ejecutar su código
 El campo de aplicación de los
parámetros es local (las
Donde se puede acceder a las funciones también pueden
variables declarar variables locales).
Scope de las variables, cada vez que una
función se ejecuta se genera un
contenedor donde las variables de la ¿Por qué utilizar funciones?
función van a vivir, una vez se sale de la  Permite agrupar declaraciones,
función estas variables no van a existir. esto permite códigos más fáciles
de leer.
Flujo de ejecución  Los programas se vuelven más
 Comienza con la primera compactos.
declaración de arriba hacia  Permite reutilizar código.
abajo.  Es más fácil encontrar un error y
corregirlo (sólo se tiene que
cambiar en un lugar).
Imprimir valor de variable

Para imprimir el valor de una variable dentro de un string hacerlo así:
46
>>> amount =100
>>> result =370000
>>> 'USD${} Dólares son Col${} Pesos'.format(amount,result)
'USD$100 Dólares son Col$370000 Pesos'
>>>
>>> amount =100

>>> result =370000
>>> print ('USD${} Dólares son Col${} Pesos'.format(amount,result))
USD$100 Dólares son Col$370000 Pesos
>>>
Ejemplos:
 Calculadora de divisas Bitcoin (foreign_exchange_calculator.py)
system("cls")
bitcoin_usd = 7200
bitcoin_cop = 24000000
menu= """Bienvenido al conversor de monedas
1. De Dólares
2. De Pesos Colombianos
"""
def foreign_exchange_calculator(amount, convertir):
if(convertir == 1):
return amount / bitcoin_usd
elif(convertir == 2):
return amount / bitcoin_cop
def run():
print("=============================================")
print("= == == =")
print("= == == =")
print("= ========== =")
print("= == == =")
print("= == == =")
print("= ========== =")
print("= == == =")
print("= == == =")
print("= =========== =")
print("= == == =")
print("= == == =")
print("= C A L C U L A D O R A D E B I T C O I N =")
print("=============================================","\n")
print("Tasa de cambio USD a BTC {}".format(bitcoin_usd))
print("Tasa de cambio COP a BTC {}".format(bitcoin_cop),"\n")
47
print(menu)
option1 = int(input("¿Qué tipo de cambio deseas? "))
if(option1 == 1):
amount = int(input("¿Cuantos USD deseas cambiar a BTC? : "))
result = float(foreign_exchange_calculator(amount, option1))
print("")
print("${} USD Dólares son {} BTC".format(amount, (round(result, 8))
),"\n")
elif(option1 == 2):
amount = int(input("Cuantos COP deseas cambiar a BTC? : "))
result = float(foreign_exchange_calculator(amount, option1))
print("")
print("${} COP Pesos Colombianos son {} BTC".format(amount, (round(r
esult, 8))),"\n")
if __name__ == "__main__":
run()
=============================================
= == == =
= == == =
= ========== =
= == == =
= == == =
= ========== =
= == == =
= == == =
= =========== =
= == == =
= == == =
= C A L C U L A D O R A D E B I T C O I N =
=============================================
Tasa de cambio USD a BTC 7200

Tasa de cambio COP a BTC 24000000
Bienvenido al conversor de monedas

1. De Dólares
2. De Pesos Colombianos
¿Qué tipo de cambio deseas? 1

¿Cuantos USD deseas cambiar a BTC? : 1000
$1000 USD Dólares son 0.13888889 BTC
48
 Calculadora de divisas (calculadora_divisas.py)
system("cls")
# Especificador de formato para separador de miles utilizar
# {:11,.0f} Para hacer que la salida del programa sea más legible,
# puede ser útil agregar separadores a números grandes
def mex(cantidad):
valor_mex = 167.51
return'${} Pesos Mexicanos (MEX) son ${:11,.0f} Pesos Colombianos (COP).
\n'.format(cantidad, (cantidad*valor_mex))
def usd(cantidad):
valor_usd = 3778.46
return'${} Dólares estadounidenses (USD) son ${:11,.0f} Pesos Colombiano
s (COP).\n'.format(cantidad, (cantidad*valor_usd))
def eur(cantidad):
valor_eur = 3650.00
return'${} Euros (EUR) son ${:11,.0f} Pesos Colombianos (COP).\n'.format
(cantidad, (cantidad*valor_eur))
def gbp(cantidad):
valor_gbp = 4610.57
return'${} Libras Esterlinas (GBP) son ${:11,.0f} Pesos Colombianos (COP
).\n'.format(cantidad, (cantidad*valor_gbp))
def yen(cantidad):
valor_yen = 35.06
return'${} Yenes (JPY) son ${:11,.0f} Pesos Colombianos (COP).\n'.format
(cantidad, (cantidad*valor_yen))
def cad(cantidad):
valor_cad = 2705.76
return'${} Dólares canadienses (CAD) son ${:11,.0f} Pesos Colombianos (C
OP).\n'.format(cantidad, (cantidad*valor_cad))
def default():
return'Ha seleccionado una opción invalida.\n'
def switch(opcion, cantidad):

sw = {
1: mex(cantidad),
49
2: usd(cantidad),
3: eur(cantidad),
4: gbp(cantidad),
5: yen(cantidad),
6: cad(cantidad),
}
return sw.get(opcion, default())
def run():
menu= """
==============================================
CONVERSOR DE DIVISAS A PESOS COLOMBIANOS (COP)
==============================================
1. MEX
2. USD
3. EUR
4. GBP
5. JPY
6. CAD
==============================================
"""
print(menu)
opcion = int(input('Ingrese el número de la respectiva divisa: '))
print("")
monto = int(input('Ingrese la cantidad de dinero a convertir: '))
print("")
print(switch(opcion, monto))
if __name__ == '__main__':
run()
==============================================
CONVERSOR DE DIVISAS A PESOS COLOMBIANOS (COP)
==============================================
1. MEX
2. USD
3. EUR
4. GBP
5. JPY
6. CAD
==============================================
Ingrese el número de la respectiva divisa: 2
Ingrese la cantidad de dinero a convertir: 1000
$1000 Dólares estadounidenses (USD) son $ 3.778,460 Pesos Colombianos

(COP).
50
Ayudas en la red
Páginas web
Tutorial de Python
Ejercicios de Python Colección de ejercicios resueltos

https://aprendeconalf.es/python/ejercicios/
Cursos en Platzi
Curso de POO y Algoritmos con Python

https://platzi.com/clases/poo-python/
51
1.1.10 Estructura de condicionales en Python
Uno de las cosas más poderosas en programación es controlar el flujo de ejecución, para
esto se utilizan condicionales.
Las condicionales son sentencias que devuelven un valor booleano (True, False), las mas
utilizadas son:
Operadores relacionales: Tabla and
 == Es igual A B A and B
 != Es diferente 0 0 0
 > Es mayor 0 1 0
 >= Es mayor o igual 1 0 0
 < Es menor 1 1 1
 <= Es menor o igual
Tabla or
Operadores lógicos:
A B A or B
 and 0 0 0
 or 0 1 1
 not 1 0 1
1 1 1
Tablas de verdad
Tablas de verdad o tabla de valores de
Tabla not
verdad, es una tabla que muestra el valor
de verdad de una proposición
compuesta, para cada combinación de A not A
valores de verdad que se pueda asignar a 1 0
sus componentes. Sea: 0 1
1 = True
0 = False
El código ASCII
Al comparar los caracteres tener en cuenta el código ASCII por ejemplo z (minúscula)
equivale a 122 y a (minúscula) equivale a 97. z > a = True, z (122) es mayor que a (97)
Para consultar código ASCII ver: https://elcodigoascii.com.ar/
52
Ejemplos:
 Operadores relacionados (Operadores_relacionales.py)
# Operadores relacionales: ==, !=, >, >=, <, <=
system("cls")
print ("Operadores relacionales:","\n")
print ("10 == 10 es ",10==10)
print ("a' == 'a' es ", 'a' == 'a')
print ("'diego' == 'Diego' es ", 'diego' == 'Diego') # La secuencia de carac
teres no es igual
print ("10 > 15 es ",10 > 15) # False
print ("'z' > 'a' es ", 'z' > 'a',"\n") # True ya que aplicamos comparación
lexicográfica a, b, c donde la letra derecha es mayor a la izquierda
# Operador de desigualdad
print ("Operadors de desigualdad","\n")
print("10 != 10 es",10 != 10) # False porque 10 si es igual a 10
print ("15 != 10 es", 15 != 10) # True
print ("10 >= 11 es", 10 >= 11) # False
print("15 <= 15 es", 15 <= 15) # True
# Operador lógicos: and, or, not para comparar diferentes valores booleanos
# Operador AND: Evalúa que los dos valores sean verdaderos o se cumplan
print ("10 > 15 and 15 > 20 es",10 > 15 and 15 > 20) # False ya que las dos
expresiones deben ser verdaderas
# Es igual que decir True and True = True
print ("'a' == 'a' and 'b' == 'b' es", 'a' == 'a' and 'b' == 'b') # True ya
que las dos expresiones son verdaderas
# Operador OR: Evalúa si alguno de dos valores se cumple

# Es igual que decir True or False = True
print ("'a' == 'a' or 'b' != 'b' es", 'a' == 'a' or 'b' != 'b') # True a pes
ar de que una de las expresiones es falsa
# Para obtener falso comparar: False or False
# Operador NOT: Devuelve el valor opuesto del valor booleano

not True # Si la expresión es true me devuelve un falso y viceversa
print ("")
# Condicionales
print ("Condicionales","\n")
# Generamos una función que recibe por parámetro la edad de una persona
def say_hello(age):
if age >= 18:
print("Hola senior","\n")
53
else:
print("Hola junior","\n")
say_hello(18)
Operadores relacionales:
10 == 10 es True
a' == 'a' es True
'diego' == 'Diego' es False
10 > 15 es False
'z' > 'a' es True
Operadores de desigualdad
10 != 10 es False
15 != 10 es True
10 >= 11 es False
15 <= 15 es True
10 > 15 and 15 > 20 es False
'a' == 'a' and 'b' == 'b' es True
'a' == 'a' or 'b' != 'b' es True
Condicionales
Hola senior
 Aplicación de los operadores en un tienda Una tienda de helado da un descuento

por compra a sus clientes con membresía dependiendo de su tipo, solo existen
tres tipos de membresía, Premium 1, Dorada 2 y Platino 3.
Los descuentos son los siguientes:
Premium (1) 20% de descuento
Dorada (2) 15% de descuento
Platino (3) 10% de descuento
(condicionales_aplicados.py)
system("cls")
""" Una tienda de helado da un descuento por compra a sus
clientes con membresía dependiendo de su tipo, solo
existen tres tipos de membresía, tipo 1, tipo2 y tipo 3.
Los descuentos son los siguientes:
54
Premiun 1 20% de descuento
Dorada 2 15% de descuento
Platino 3 10% de descuento
"""
def pagar(descuento,cuenta):
paga = cuenta-(cuenta * descuento)
print("")
print("TOTAL A PAGAR ${}".format(paga),"\n")
def run(cuenta):
if membresia == 1:
pagar(0.2,cuenta)
elif membresia == 2:
pagar(0.15,cuenta)
elif membresia == 3:
pagar(0.1,cuenta)
else:
print("Error. Digite nuevamente")
if __name__ == "__main__":
menu= """
----------------
CAJA MEMBRESIAS
----------------
1. Premium
2. Dorada
3. Platino
================
"""
print(menu)
membresia = int(input("Digite el tipo de membresía (1, 2 o 3): "))
print("")
cuenta = float(input("Digite TOTAL de la cuenta: $"))
run(cuenta)
55
----------------
CAJA MEMBRESIAS
----------------
1. Premium
2. Dorada
3. Platino
================
Digite el tipo de membresía (1, 2 o 3): 2
Digite TOTAL de la cuenta: $100000
TOTAL A PAGAR $85000.0
Ayudas en la red
Páginas web
Tutorial de Python
El código ASCII, sigla en inglés de American Standard Code for Information Interchange
( Código Estadounidense Estándar para el Intercambio de Información)
https://elcodigoascii.com.ar/
Tablas de la verdad
https://www.ecured.cu/Tablas_de_la_verdad
56
1.1.11 Calcular si un número es primo en Python
Construir un programa que nos permite determinar si un número es primo o no, usando
expresiones booleanas, operadores relacionales y operadores lógicos.
Recuerde
 Todas las funciones deben declararse con el keyword def
 Un bug es un error en el código y requiere ser verificado
Número primo
Un número primo (o un primo) es un número natural que tiene exactamente dos
divisores de números naturales distintos: 1 y a sí mismo. Por ejemplo, hay varios
números primos del 1 al 200: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
61, 67, 71, 73, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157,
163, 167, 173, 179, 181, 191, 193, 197, 199.
 Programa para determinar si un número es primo (numerosPrimos_opt.py)

system("cls")
print('Programa para determinar si un número es primo.',"\n")
def calcular(number):
# si el número es menor que 2, no es primo

if number < 2:
result = False
# si el número es igual a 2, es primo

elif number == 2:
result = True
# si el número es mayor que 2 y es divisible entre 2, no es primo

elif number > 2 and number % 2 == 0:
result = False
# si el número es mayor que 2 y no es divisible entre 2

else:
# toma el valor True antes de iterar en el ciclo
result = True
for i in range(3, number):

# si el número que estamos evaluando es divisible entre alguno
# de los numeros contenidos en el mismo, no es primo, se sale
# del ciclo con valor False
57
if number % i == 0:
result = False
break
return result
def run():
print('Recuerde que los números primos solo se dividen')
print('de manera exacta por 1 y por si mismos ',"\n")
number = int(input('Escriba un Número: '))
print("")
resultado = calcular(number)
if resultado is True:
print('El número {} es primo'.format(number),"\n")
else:
print('El número {} NO ES PRIMO'.format(number),"\n")
# Nuestro programa empieza aqui.

if __name__ == '__main__':
run()
Programa para determinar si un número es primo.
Recuerde que los números primos solo se dividen

de manera exacta por 1 y por si mismos
Escriba un Número: 197
El número 197 es primo
Programa para determinar si un número es primo.
Recuerde que los números primos solo se dividen

de manera exacta por 1 y por si mismos
Escriba un Número: 91
El número 91 NO ES PRIMO
58
1.1.12 Buenas prácticas del lenguaje
TUTORIAL DE PYTHON
En la página oficial www.python.org encuentra el tutorial del lenguaje no intenta ser

completo y cubrir todas las funciones, o incluso todas las funciones de uso común. En
cambio, presenta muchas de las características más notables de Python y le dará una
buena idea del sabor y estilo del lenguaje. Después de leerlo, podrá leer y escribir
módulos y programas de Python, y estará listo para aprender más sobre los diversos
módulos de la biblioteca de Python descritos en La biblioteca estándar de Python .
>>>import this
The Zen of Python, by Tim Peters
*
 Hermoso es mejor que feo.
 Explícito es mejor que implícito.
 Simple es mejor que complejo.
 Complejo es mejor que complicado.
 Plano es mejor que anidado.
 Esparcido es mejor que denso.
 La legibilidad es importante.
 Los casos especiales no son lo suficientemente especiales como para
romper las reglas.
 La practicidad le gana a la pureza.
 Los errores no deberían pasar en silencio.
 A menos que sean silenciados.
 Frente a la ambigüedad, evitar la tentación de adivinar.
 Debería haber una, y preferiblemente solo una, manera obvia de
hacerlo.
 A pesar de que esa manera no sea obvia a menos que seas Holandés.
 Ahora es mejor que nunca.
 A pesar de que nunca es muchas veces mejor que *ahora* mismo.
 Si la implementación es difícil de explicar, es una mala idea.
 Si la implementación es fácil de explicar, puede que sea una buena
idea.
 Los espacios de nombres son una gran idea, ¡tengamos más de esos!
*Traducido del inglés.
59
Declaraciones condicionales
Las declaraciones condicionales en Python se pueden usar para tomar decisiones basadas
en ciertas condiciones del programa. Las siguientes son declaraciones condicionales de
uso común en Python.
1- If then
Como su nombre lo indica es bastante simple. Si se cumple una determinada
condición, entonces realice alguna acción.
Start
Condition
True
Statements False
End
2- If then else
Se puede agregar una instrucción else adicional a una condición if, para ejecutar lo
que debería suceder si no se cumple la condición if.
Start
Condition
True
Statements False
End Else Statements
3- If then else if else

Si no se cumple una condición primaria, se puede agregar una declaración else If
para verificar otra condición si es necesario.
4- Nested if then
Anidar múltiples declaraciones If then. Tenga cuidado al usar esto, ya que puede
convertirse en un lío para leer. Puede usar && o || Operadores para evitarlo en
algunos escenarios.
60
Ejemplo:
 Utilización de condicionales (declaraciones_anidadas.py)
system("cls")
def det_gender(gender, age):

if gender == 'masculino':
if age > 18:
print("Bienvenido senior")
else:
print("Bienvenido junior")
if gender == 'femenino':
if age > 18:
print("Bienvenida señora")
else:
print("Bienvenida señorita")
def run():
# Ingresamos los valores por teclado
gender = str(input("Ingrese su género: ")).lower()
age = int(input("Ingrese su edad: "))
det_gender(gender, age)
if __name__ == '__main__':
run()
Ingrese su género: MASCULINO

Ingrese su edad: 56
Bienvenido senior
Ingrese su género: femenino

Ingrese su edad: 17
Bienvenida señorita
Ayudas en la red
Páginas web
Tutorial de Python
61
Documentación de Python (ver Library Reference)
https://www.python.org/doc/
The Python Tutorial

https://docs.python.org/3.8/tutorial/index.html
Zen de Python español, con algunos ejemplos para comprender

https://gist.github.com/javierdaza/4258b74e2eb7cfd4f55286061b592f37
https://pybaq.co/blog/el-zen-de-python-explicado/
Una entrevista con el creador de Python, Guido van Rossum

https://www.unocero.com/noticias/una-entrevista-con-el-creador-de-python-guido-van-
rossum/
62
1.2 Uso de Strings y Ciclos
1.2.1 Comparación de Strings y Unicode
Cadenas (strings)
 Un string es una secuencia de

>>> mi_string='cadenas'
caracteres. >>> mi_string[1:]
 Los caracteres se pueden acceder 'adenas'
>>> mi_string[1:3]
por índice
'ad'
Los índices empiezan en cero >>> mi_string[1:6:2]
'aea'
0 1 2 3 4 5 6 >>> mi_string[1:3:2]
c a d e n a s 'a'
>>> mi_string[1:5:2]
>>>mi_string = ‘cadenas’ 'ae'
>>> mi_string[::-1]
>>>mi_string[2]
'sanedac'
‘d’
Longitud de una string Comparación de strings

 La función len es una de las más
Se pueden realizar operaciones con
útiles. strings, por ejemplo comparar si son
 Regresa el tamaño de la string. iguales o mayores o menores.
>>>mi_string = ‘cadenas’
>>>len(mi_string)
Diferencia entre ASCII y Unicode
7
>>>longitud=len(mi_string) Los caracteres también son números,
>>> print(longitud) para esto existen estándares que asignan
7 un número a cada carácter, para generar
un estándar se creó el ASCII pero esta
solo toma en cuenta los caracteres en
Los strings tienen una característica muy inglés, para dar soporte a más lenguajes
importante: son inmutables, esto quiere se crea UNICODE.
decir que no se pueden cambiar después
de que se han declarado. Python codifica en ASCII por default, para
cambiarlo por UNICODE colocar u antes
Para modificar el texto de un string del string.
definir un nuevo string y modificarlo
usando funciones como slice (rebanadas)
63
Métodos de strings
Métodos que hacen fácil trabajar con strings.

- Upper
- supper
- lower
- islower
- find
- isdigit
- endswith
- startswith
- split
- join
Ejemplo:
 Este ejemplo permite modificar caracteres utilizando listas (string_cambios.py)
system("cls")
def run():
s = list(input('Ingrese la palabra que quiere cambiar: '))
r = str(input('Ingrese la letra que desea agregar: '))
t = int(input('Ingrese la posición que desea modificar: '))
s[t]=r
print('La nueva palabra es: ' + "".join(s))
if __name__ == '__main__':
run()
Ingrese la palabra que quiere cambiar: operasiones

Ingrese la letra que desea agregar: c
Ingrese la posición que desea modificar: 5
La nueva palabra es: operaciones
 El siguiente Programa para comprobar las diferencias que se presentan al identar

el código en diferentes ubicaciones (identado.py)
system("cls")
"""---------------------------------------------------"""
64
a=0
for i in range (5):
a=a+i
print (a)
"""---------------------------------------------------"""
print("Resultado código modificando la identación","\n")
a=0
for i in range (5):
a=a+i
print (a,"\n")
"""---------------------------------------------------"""
a=int(input("Ingrese un número "))
if (a%2==0):
print ("El número {} es par".format(a),"\n")
else:
print ("El número {} es impar".format(a),"\n")
"""---------------------------------------------------"""
for i in range (5):
a=int(input("Ingrese un número par o impar "))
if (a%2==0):
print ("El número {} es par".format(a))
else:
print ("El número {} es impar".format(a))
0
1
3
6
10
Resultado código modificando la identación
10
Ingrese un número 6
El número 6 es par
Ingrese un número par o impar 1

El número 1 es impar
El número 2 es par
El número 4 es par
65
Ayudas en la red
Páginas web
Tutorial de Python
Codificación de caracteres
https://es.wikipedia.org/wiki/Codificaci%C3%B3n_de_caracteres
El factorial de un número
https://www.sangakoo.com/es/temas/el-factorial-de-un-numero
Python Indentación
https://aprende.olimpiada-informatica.org/python-identacion
66
1.2.2 Manejo de Strings en Python
Métodos de strings
Los string, tienen varios métodos en el siguiente programa se utilizan algunos de ellos
Ejemplo:
 Utilización de métodos de string (métodos_string.py)
system("cls")
Palabra = "letras"
Texto = "Los textos pueden contener palabras"
ListaString = {"X","W","Y","Z"}
caracteres=30
#Retorna un string con todas las letras en mayúsculas
print (' 1-',Palabra.upper())
#Retorna True si todas las letras son mayúsculas

print (' 2-',Palabra.isupper())
#Retorna un string con todas las letras en minúscula

print (' 3-',Palabra.lower())
#Retorna True si todas las letras son minúsculas

print (' 4-',Palabra.islower())
#Retorna la posición dela primera letra (en este casi 'a')

#encontrada en el string
print (' 5-',Palabra.find('a'))
#Retorna True si todos son números

print (' 6-',Palabra.isdigit())
#Retorna True si el string termina en el argumento indicado

print (' 7-',Palabra.endswith("ra"))
#Retorna True si el string comienza con el string indicado

# (en este caso "ala")
print (' 8-',Palabra.startswith("ala"))
#Retorna una lista a partir de un string (en este caso nuestra

# variable Texto) y un separador (un espacio " "en este caso)
print (' 9-',Texto.split(" "))
#Retorna un string a partir de una lista de strings

print ('10-',Palabra.join(ListaString),'\n')
67
Palabra1=Palabra.center(caracteres,'=').upper()
print ('11-',Palabra1,'\n')
print ("En el renglón 11 hay {} caracteres".format(len(Palabra1)))
print("")
print ('12-', Palabra[len(Palabra)-1])
print ('13-', Palabra.find('t'))
print ('14-', Palabra[2])
1- LETRAS
2- False
3- letras
4- True
5- 4
6- False
7- False
8- False
9- ['Los', 'textos', 'pueden', 'contener', 'palabras']
10- XletrasZletrasYletrasW
11- ============LETRAS============
En el renglón 11 hay 30 caracteres
12- s
13- 2
14- t
Ayudas en la red
Páginas web
Tutorial de Python
String Methods
https://docs.python.org/3.8/library/stdtypes.html#string-methods
Métodos de formato
https://uniwebsidad.com/libros/python/capitulo-6/metodos-de-formato
68
1.2.3 Factorial de un número con recursión
Una función f está siendo recursiva

cuando dentro del bloque de Por ejemplo:
instrucciones que la conforma se usa a sí f(x) = 0 si x = 0
misma. f(x) = x + f(x-1) si x ≥ 1
El concepto puede sonar complicado En este caso f es recursiva porque vemos

pero es muy común su uso, por ejemplo que f se llama a sí misma en el segundo
cuando se calcula el número factorial de caso.
un número se utiliza una función
recursiva. ¿Qué pasa si f(0)? Se fija cómo es el x de
entrada y entiende que tiene que entrar
Este paradigma busca resolver los por el primer caso, entonces
problemas metiéndose en otro llamado simplemente retorna 0 (la única
funcional: todo son funciones ejecución de f que hubo) y termina con
matemáticas. ¿Qué tiene de distinto esto ese valor.
con lo que venimos viendo? Que en este
caso no vamos a usar ciclos, ya que al fin ¿Qué pasa si f(1)? Se fija cómo es x y esta
y al cabo se podrían imitar con vez entra por el segundo caso. Luego hay
recursiones. Para que esto tenga sentido que retornar 1 + f(1-1), o sea 1 + f(0).
y funcione tienen que pasar dos cosas: Pero el programa no permite devolver
algo no calculado, por lo cual, antes de
4. f tiene que tener un “caso base”, poder hacer return se debe llamar a f(0)
es decir, una condición que haga y resolverlo.
frenar la recursión. Es un
conjunto de valores, tales que Luego de eso, f(0) retorna 0 y la cuenta 1
cuando f los recibe, retornará una + f(0) se convirtió en 1 + 0 = 1, por lo
respuesta sin volver a realizar tanto se retornar f(1) = 1.
recursión.
5. f debería tener un “caso ¿Qué pasa si f(4)? El orden en el que se
recursivo”, es decir, una reducen los términos es:
condición que le haga seguir f(4) = 4 + f(3) = 4 + (3 + f(2)) = 4 + (3 + (2 +
haciendo recursión (hasta f(1))) = 4 + (3 + (2 + (1 + f(0)))) = 4 + (3 +
eventualmente - si las cosas están (2 + (1 + 0)))) = 4 + (3 + (2 + 1)) = 4 + (3 +
bien hechas - llegar a un caso 3) = 4 + 6 = 10.
base y así terminar).
Nota: Si los casos base están mal
programados o nunca se alcanzan, la
función f puede nunca terminar!
69
Ejemplo:
 Programa para el cálculo del factorial de un número (factorial.py)
system("cls")
def factorial(number):
if number == 0:
return 1
return number * factorial(number - 1)
if __name__ == "__main__":
number = int(input('Calculo del factorial escriba un número: '))
print("{}! es {}".format(number,factorial(number)))

Calculo del factorial escriba un número: 5
5! es 120
Donde al estar siendo recursiva se generaron 5 funciones pero se empiezan a generar los
resultados de manera inversa:
5ta operación: 1*0! = 1 “Caso base”

4ta operación: 2*1! (donde 1! = 1) = 2*1 = 2
3ra operación: 3*2! (donde 2! = 2) = 3*2 = 6
Esa es la forma en la que funciona cada operación recursiva genera una nueva función
f(n+1) y la forma en la que se resuelven es de la última función a la primera.
 Ejemplo dibujar un árbol utilizando la función dibujaArbol de forma recursiva para

crear los diferentes niveles de ramas. (árbol_recursivo,py)
import turtle,random
w = turtle.Screen()
t = turtle.Turtle()
t.color("green")
numNivel = 8
largoRama = 100
angulo = 17
70
def cambioColor():
colors=['blue' , 'red', 'orange', 'purple']
t.pencolor(random.choice(colors))
def dibujaArbol(largoRama, Nivel):
cambioColor()
width = t.width()
t.width(width * 3.0 / 4.0)
largoRama = 3.0 / 4.0 * largoRama
t.left(angulo)
t.forward(largoRama)
if Nivel < numNivel:

dibujaArbol(largoRama, Nivel + 1)
t.back(largoRama)
t.right(2 * angulo)
if Nivel < numNivel:

dibujaArbol(largoRama, Nivel + 1)
t.back(largoRama)
t.left(angulo)
t.width(width)
def main():
t.speed("fastest")
t.left(90)
t.width(numNivel) #
t.penup()
t.back(largoRama)
t.pendown()
dibujaArbol(largoRama, 2)
turtle.done()
if __name__ == "__main__":
main()
71
Ayudas en la red
Páginas web
Tutorial de Python
Algoritmos recursivos y algoritmos iterativos

https://uniwebsidad.com/libros/algoritmos-python/capitulo-18/algoritmos-recursivos-y-
algoritmos-iterativos
¿Bucle recursivo o recursividad en bucle?

https://medium.com/@E_parrado/bucle-recursivo-o-recursividad-en-bucle-
394535aa13b5
¿Cuáles son las ventajas y desventajas de la recursividad?

https://www.it-swarm.dev/es/recursion/cuales-son-las-ventajas-y-desventajas-de-la-
recursividad/971413057/
Videos
¿Qué es la RECURSIVIDAD? (en Ingeniería Informática)
https://youtu.be/yX5kR63Dpdw
72
1.2.4 Separar cadenas de texto en Python
La función slice de python nos permite separar los strings en substrings

generando nuevas secuencias (string_slice,py).
system("cls")
my_string = 'platzi'
print ('my_string =',my_string)
print ('index -> 012345','\n')
print ('my_string[1:3]',my_string[1:3])
print ('my_string[1:]',my_string[1:])
# notación [start,end,step]
print ('my_string[0:6:2]',my_string[0:6:2])
print ('my_string[::1]',my_string[::-1])
my_string = platzi
index -> 012345
my_string[1:3] la
my_string[1:] latzi
my_string[0:6:2] paz
my_string[::1] iztalp
Ejemplo:
 Código que muestra el resultado de funciones con string (funciones_cadenas.py).
system("cls")
my_string = 'buenas tardes'
dic = { 'len': len(my_string),

'upper':my_string.upper(),
'lower':my_string.lower(),
'[0]':my_string[0],
'[1:]':my_string[1:],
'[:-1]':my_string[:-1],
'[:2:-1]': my_string[:2:-1],
'[:3]':my_string[:3],
'[::-1]': my_string[::-1],
"find('a')":my_string.find('a'),
73
"capitalize":my_string.capitalize(),
'remplace':my_string.replace('a','i')
}
for key, value in dic.items():
print("Acción: " + key + " Resultado: " + str(value))
Acción: len Resultado: 13

Acción: upper Resultado: BUENAS TARDES
Acción: lower Resultado: buenas tardes
Acción: [0] Resultado: b
Acción: [1:] Resultado: uenas tardes
Acción: [:-1] Resultado: buenas tarde
Acción: [:2:-1] Resultado: sedrat san
Acción: [:3] Resultado: bue
Acción: [::-1] Resultado: sedrat saneub
Acción: find('a') Resultado: 4
Acción: capitalize Resultado: Buenas tardes
Acción: remplace Resultado: buenis tirdes
Ayudas en la red
Páginas web
Tutorial de Python
Manipular cadenas de caracteres en Python

https://programminghistorian.org/es/lecciones/manipular-cadenas-de-caracteres-en-
python
74
1.2.5 Ciclos en Python con for
Iteración
 Las iteraciones permiten realizar while loop
la misma secuencia de pasos  Similar a un for loop; pero en
varias veces. lugar de recorrer una secuencia,
 También permiten recorrer una se ejecuta hasta que una
secuencia (como una string). condición se convierta en falsa.
 Es una de las herramientas clave  Se debe tener mucho cuidado de
de cualquier programador. no caer en un infinite loop.
for loop while / else

 La función range nos permite  Cuando la condición se vuelve
definir cuántas veces se ejecutará falsa y si no se terminó el loop
una iteración. con un break, se ejecuta la
for / else cláusula else.
 La cláusula else se ejecuta si el
loop no termina con un break
Ejemplos:
 En el ejemplo se construye un triángulo en donde se incluyen el símbolo * y el
conteo de números, se pretende exponer el uso de los ciclos anidados, recordando
que por cada siclo de afuera se ejecuta en su totalidad el siclo de adentro, observar
como el siclo de adentro toma el valor del siclo de afuera para poder avanzar.
(triangulo_for.py)
system("cls")
def main():
for i in range(20):
for j in range(i):
print('*',j,end="")
print(" ",i)
if __name__ == '__main__':
main()
75
0
* 0 1
* 0* 1 2
* 0* 1* 2 3
* 0* 1* 2* 3 4
* 0* 1* 2* 3* 4 5
* 0* 1* 2* 3* 4* 5 6
* 0* 1* 2* 3* 4* 5* 6 7
* 0* 1* 2* 3* 4* 5* 6* 7 8
* 0* 1* 2* 3* 4* 5* 6* 7* 8 9
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9 10
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10 11
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11 12
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12 13
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13 14
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13* 14 15
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13* 14* 15 16
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13* 14* 15* 16 17
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13* 14* 15* 16* 17 18
* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13* 14* 15* 16* 17* 18 19
 Programa para ejecutar diferentes opciones con la iteración for. (for_loop.py)

system("cls")
def bucle():
number_finish = int(input('Ingrese un número para iterar: '))
for i in range(number_finish):
print(f'Número {i}')
print(" ")
print(list(range(0,number_finish )),"\n")
def bucle_continue():
for i in range(10):
if i % 3 != 0:
continue
else:
print('{}^2 = {} '.format(i,i ** 2))
def bucle_break():
for i in range(20):
if i % 3 == 0:
print(i)
elif i == 22:
break
76
def recorrer_string():
word = 'ferrocarril'
for letter in word:
print(letter)
def main():
menu= """Práctica con for_loop
1. bucle
2. bucle_continue
3. bucle_break
4. recorrer_string
"""
print(menu)
option1 = int(input("Seleccione una opción "))
if(option1 == 1):
bucle()
elif(option1 == 2):
bucle_continue()
elif(option1 == 3):
bucle_break()
elif(option1 == 4):
recorrer_string()
if __name__ == '__main__':
main()
Práctica con for_loop
1. bucle
2. bucle_continue
3. bucle_break
4. recorrer_string
Seleccione una opción 1

Ingrese un número para iterar: 5
Número 0
Número 1
Número 2
Número 3
Número 4
[0, 1, 2, 3, 4]
77
1. bucle
2. bucle_continue
3. bucle_break
4. recorrer_string

0^2 = 0
3^2 = 9
6^2 = 36
9^2 = 81
1. bucle
2. bucle_continue
3. bucle_break
4. recorrer_string

0
3
6
9
12
15
18
1. bucle
2. bucle_continue
3. bucle_break
4. recorrer_string

f
e
r
r
o
c
a
r
r
i
l
78
1.2.6 Ciclos de Python en while
While loop While else

 Similar a un for loop; pero en
lugar de recorrer una secuencia,  Cuando la condición se vuelve
se ejecuta hasta que una falsa y si no se terminó el loop
condición se convierta en falsa. con un break, se ejecuta la
 Tener mucho cuidado de no caer cláusula else.
en un infinite loop.
Ejemplos:
 El siguiente programa permite adivinar un número dentro de un rango fijado.
(randon.py)

system("cls")
import random
def run():
number_found = False
system("cls") #Clear the console
print(''.center(37,'='))
print('..:: EN BUSCA DEL NÚMERO SECRETO ::..')
aleatorio = calc_random()
intentos = 0
while not number_found:

number = int(input('\aAdivina el número secreto: '))
intentos = intentos +1
if number == aleatorio:
print('**** G E N I A L **** ')
print('**** Encontraste el Número! ****')
print(f' Total de intentos {intentos} '.center(33,'='),'\n')
number_found = True
pass
elif number > aleatorio:
print('\aMejor intenta con un número más bajo...')
else:
print('\aMejor intenta con un número más alto..')
79
def calc_random():
print('--> Primero definamos el rango <--')

numberInit = int(input('--> Desde el número: '))
numberEnd = int(input('--> Hasta el número: '))
print(' **** A JUGAR **** ')
aleatorio = random.randint(numberInit,numberEnd)
return aleatorio
if __name__ == '__main__':
run()
=====================================
..:: EN BUSCA DEL NÚMERO SECRETO ::..
=====================================
--> Primero definamos el rango <--
--> Desde el número: 1
--> Hasta el número: 9
======================
**** A JUGAR ****
======================
Adivina el número secreto: 3
Mejor intenta con un número más alto..
=================================
**** G E N I A L ****
**** Encontraste el Número! ****
====== Total de intentos 5 ======
80
 Programa que simula el juego de Papel, Tijeras y Piedra, se juega entre el
computador y el jugador humano ( juego_piedra_papel_tijera.py).
system("cls")
import random
def run():
player = 0
botplayer = 0
play = True
ans = 0
while play:
print ('1: Papel, 2: Tijeras, 3: Piedra ')
human = int(input('--> '))
bot = random.randint(1, 3)
if human == 3 and bot == 1:

print('Human: Piedra')
print('Bot : Papel')
print('Bot wins!')
botplayer += 1
elif human == 1 and bot == 3:
print('Human: Papel')
print('Bot : Piedra')
print('Human wins')
player += 1
print('Human: Piedra')
print('Bot : Tijeras')
print('Human wins')
player += 1
print('Human: Tijeras')
print('Bot : Piedra')
print('Bot wins')
botplayer += 1
print('Human: Papel')
print('Bot : Tijeras')
print('Bot wins')
botplayer += 1
81
print('Human: Tijeras')
print('Bot : Papel')
print('Human wins')
player += 1
else:
print('Empate')
print('Score'.center(35,'='))
print(f'Human player: {player}')
print(f'Bot player: {botplayer}')
print('Score'.center(35,'='),'\n')
ans = input('Presione 1 para volver a jugar o cualquier otra tecla p
ara salir ')
system("cls")
if ans != "1":
play = False
if __name__ == '__main__':
run()
===================================
1: Papel, 2: Tijeras, 3: Piedra
===================================
--> 2
===================================
Human: Tijeras
Bot : Piedra
Bot wins
===============Score===============
Human player: 1
Bot player: 3
===============Score===============
Presione 1 para volver a jugar o cualquier otra tecla para salir 1
Ayudas en la red
Páginas web
Tutorial de Python
Qué son las f-strings en Python :
82
https://platzi.com/blog/f-strings-en-python/
83
1.2.7 Calcular si una palabra es palíndromo con Python
Crear programas para saber si una palabra es palíndromo. Se entienden como palíndromo
o palíndromos, a las palabras o frases que se leen de igual manera hacia adelante o hacia
atrás, por ejemplo:
Ana Oro Reconocer
Araña Radar Salas
Arenera Rayar Sometemos
Ejemplo:
 Programa para saber si una palabra es palíndromo. (palindromo1.py)
system("cls")
def palindrome(word):
reversed_letters =[]
for letter in word:

reversed_letters.insert(0,letter)
reversed_word =''.join(reversed_letters)
if reversed_word == word:
return True
return False
if __name__ == '__main__':
word = str.lower(input('Escribe una palabra --> '))
result = palindrome(word)
if result is True:
print(f'La palabra {word} SI es un palíndromo')
else:
print(f'La palabra {word} NO es un palíndromo')
Escribe una palabra --> Radar

La palabra radar SI es un palíndromo
Escribe una palabra --> encontrado

La palabra encontrado NO es un palíndromo
84
 Programa modificado para verificar si una palabra es palíndromo.
(palindromo2.py)
system("cls")
def run():
word = str.lower(input('Escribe una palabra --> '))
print(f'La palabra {word} SI es un palíndromo') if word == word[::-
1] else print(f'La palabra {word} NO es un palíndromo')
if __name__ == '__main__':
run()
Escribe una palabra --> SOMETEMOS

La palabra sometemos SI es un palíndromo
Escribe una palabra --> encontrado

La palabra encontrado NO es un palíndromo
Ayudas en la red
Páginas web
Tutorial de Python
85
1.3 Estructuras de datos
1.3.1 Introducción a las listas en Python

En secciones anteriores se estudiaron los strings los cuales son una secuencia de
caracteres, las listas son secuencias de cualquier cosa, por ejemplo listas de números,
listas de strings, listas de objetos más complejos con tipos propios.
Listas
 Una lista es una secuencia de elementos.
 Cuando se asigna a una variable, permite agrupar varios elementos en un solo
lugar.
 Se crean con los corchetes [] o con la keyword list
amigos = list()
numeros = [1,2,3,4,5]
supermercado = [‘apio’, ‘tomate’, ‘queso’]
temperaturas = [24, 26, 18, 20, 21]
Acceso a elementos
Las listas son mutables, para añadir elementos a una lista utilizar el método append
Las listas se pueden acceder con índices, que inician en cero.
amigos=list()
amigos.append('Pedro')
amigos[0]
'Pedro'
amigos.append('Enrique')
amigos[1]
'Enrique'
mi_lista = [‘juan’, ‘pedro’, ‘pepe’]

mi_lista[0] # juan
mi_lista[1] # pedro
mi_lista[-1] # pepe
mi_lista[5] # IndexError
Operaciones de lista
Las listas soportan los operadores + y *
lista_a = [1, 2, 3]
lista_b = [4]
lista_a + lista_b # [1, 2, 3, 4]
lista_b * 3 # [4, 4, 4]
86
List slices
Las listas, al igual que los strings, pueden “rebanarse”.
lista = [1, 2, 3, 4, 5, 6]
lista[1:] # [2, 3, 4, 5, 6]
lista[1:3] # [2, 3]
lista[1:6:2] # [2, 4, 6]
lista[::-1] # [6, 5, 4, 3, 2, 1]
Modificación de lista
mi_lista = [‘juan’, ‘pedro’, ‘pepe’]

mi_lista[0] = ‘laura’
# [‘laura’, ‘pedro’, ‘pepe’]
mi_lista.append(‘estela’)
# [‘laura’, ‘pedro’, ‘pepe’, ‘estela’]
nombre = mi_lista.pop()
# [‘laura’, ‘pedro’, ‘pepe’]
nombre == ‘estela’
# True
mi_otra_lista = [4, 3, 7, 1]
mi_otra_lista.sort()
# [1, 3, 4, 7]
mi_lista.extend(mi_otra_lista)
# [‘juan’, ‘pedro’, ‘pepe’, 4, 3, 7, 1]
del mi_otra_lista[0]
# [3, 7, 1]
Listas y strings
Como un string es una secuencia de caracteres, se puede utilizar para inicializar una lista.
un_string = ‘cama’
una_lista = list(un_string)
# [‘c’, ‘a’, ‘m’, ‘a’]
Iteración de lista
hamburgueserias = ["burger king", "mcdonalds", "carls jr."]

for hamburgueseria in hamburgueserias:
print(hamburgueseria)
87
Conjuntos (sets)
Similares a una lista, pero no permiten repetidos. Se crean con el keyword set
onjunto = set()
conjunto.add(2)
# {2}
conjunto.add(2)
conjunto.add(3)
# {2, 3}
2 in conjunto
# True
Métodos del objeto set
 X in S
 X not in S
 s.union(t)
 s.intersection(t)
 s.difference(t)
 s.issubset(t)
 s.issuperset(t)
Ejemplos:
 Programa para manipular Listas, calcularla temperatura promedio. Para el primer
caso, convierto el valor en un entero con el operador /. Para el segundo caso, se
utiliza el operador // el cual da como resultado un numero entero según la
documentación de Python. (listas.py)
system("cls")
def promedio(temperaturas):
suma_de_temperaturas=0
for temps in temperaturas:

suma_de_temperaturas += float(temps)
promedio = suma_de_temperaturas/len(temperaturas)
pro_int = suma_de_temperaturas//len(temperaturas)
return promedio,pro_int
if __name__ == '__main__':
88
temperaturas =[18,20,16,21,19,21]
calc_temp=promedio(temperaturas)
print(f'Las temperaturas son: {(temperaturas)}')
print(f'La temperatura promedio redondeada es {calc_temp[1]}')
print('La temperatura promedio es de: {0:.3f}'.format(calc_temp[0]))
Las temperaturas son: [18, 20, 16, 21, 19, 21]

La temperatura promedio redondeada es 19.0
La temperatura promedio es de: 19.167
 Programa que calcula el promedio de las temperaturas ingresadas.

(temperaturas.py)
system("cls")
def av_tem(temps):
sum_of_temps = 0
print ('PROMEDIO DE TEMPERATURAS')
for temp in temps:
sum_of_temps += temp
grados =sum_of_temps/len(temps)
return grados
if __name__ == '__main__':
temps =list()
temmp = float(input('Temperatura del Lunes : '))
temps.append(temmp)
temmp = float(input('Temperatura del Martes : '))
temps.append(temmp)
temmp = float(input('Temperatura del Miércoles: '))
temps.append(temmp)
temmp = float(input('Temperatura del Jueves : '))
temps.append(temmp)
temmp = float(input('Temperatura del Viernes : '))
temps.append(temmp)
temmp = float(input('Temperatura del Sábado : '))
temps.append(temmp)
temmp = float(input('Temperatura del Domingo : '))
89
temps.append(temmp)
average = av_tem(temps)
print(f'Las temperaturas de la semana fueron: {(temps)}','\n')
print('La temperatura promedio es: {0:.2f}'.format(average),'\n')

Temperatura del Lunes : 16.9
Temperatura del Martes : 18
Temperatura del Miércoles: 15
Temperatura del Jueves : 19.2
Temperatura del Viernes : 17.4
Temperatura del Sábado : 14.8
Temperatura del Domingo : 20.2
=========================
PROMEDIO DE TEMPERATURAS
=========================
Las temperaturas de la semana fueron: [16.9, 18.0, 15.0, 19.2, 17.4,
14.8, 20.2]
La temperatura promedio es: 17.36
Ayudas en la red
Páginas web
Tutorial de Python
Listas
https://www.mclibre.org/consultar/python/lecciones/python-listas.html
Data Structures
https://docs.python.org/3.7/tutorial/datastructures.html
90
1.3.2 Operaciones con listas en Python
Las siguientes son las operaciones que se hacen con las listas:
Unir listas Eliminar último elemento de la lista

my_lista = [1] my_lista = [1,2,3,4,5]
my_lista2 = [2,3,4] my_lista = my_lista.pop()
my_lista3 = my_lista + my_lista2 my_lista # [1,2,3,4]
my_lista3 # [1,2,3,4]
Ordenar la lista
Multiplicar elementos my_lista = [2,1,5,4,3]
my_lista = ['a'] my_lista = my_lista.sort()
my_lista2 = my_lista * 5 my_lista # [1,2,3,4,5]
my_lista2 # ['a','a','a','a','a']
Eliminar un elemento
Dividir listas my_lista = [1,2,3,4,5]
my_lista = [1,2,3,4,5] del my_lista[0]
my_lista_reversed = my_lista[::-1] my_lista # [2,3,4,5]
my_lista_reversed # [5,4,3,2,1]
Las listas son Arrays y las tuplas son Arrays. La diferencia: las tuplas son inmutables
Algunos métodos de las listas:
 insert(posicion, elemento) --->inserta elemento

 append() ----> inserta elemento al final de la lista y puede asignarse a una
variable
 pop() ----> elimina elemento del final de la lista y puede asignarse a una
variable
 sort() ----> ordena la lista
 del(indice) -----> borra un elemento de la lista
 index(elemento) ------> busca un elemento y retorna el índice
 list()------> si esto se aplica a un string, retorna un array con cada carácter con
un índice propio
 Si a una variable que contiene por ejemplo ['H', 'o', 'l', 'a'] le aplicamos ''.join()
da como resultado 'Hola'
91
Ejemplo:
 Programa aplicando el uso de las listas (operaciones_listas.py)
system("cls")
def view_list(products):
for i in range(len(products)):
print (f'{i} -- {products[i]}')
def add_products(products):
list_products = []
new_products = products.split(',')
for new in new_products:
list_products.append(new)
return list_products
def delete_products(new_products):
select = input('¿Qué producto ya compró? (Seleccione el número del produ
cto): ')
del new_products[int(select)]
return new_products
if __name__ == '__main__':
products = input('Qué productos le gustaría agregar a su lista de compra
s \n[Sepárelos por una coma (,)]:')
new_products = add_products(products)
view_list(new_products)
delete = delete_products(new_products)
while len(delete) > 0:
view_list(delete)
new = delete_products(delete)
else:
print('¡Termino su lista de compras!')
Qué productos le gustaría agregar a su lista de compras

[Sepárelos por una coma (,)]:arroz,azúcar,sal,frijoles
0 -- arroz
1 -- azúcar
2 -- sal
3 -- frijoles
¿Qué producto ya compró? (Seleccione el número del producto):
92
 Programa utiliza diferentes metodos de listas (utilizacion_listas.py)
system("cls")
miLista=['A0','A1','A2','A3','A4']
print('Elementos de miLista = ',miLista)
print (type(miLista))
print('Elemento posición 2 de miLista',miLista[2])
print('Elemento posición -2 de miLista ',miLista[-2])
print('Todos los elementos del 2 al final. (Porciones) ',miLista[2:])
print('Elementos del 1 al 3 el 3. (Porciones) ',miLista[1:3])
print('Elementos del 0 al 3 excluye el 3. (Porciones) ',miLista[:3])
miLista.append('AX')
print('Inserta al final un dato, miLista.append(AX) ', miLista,'\n')
print('Todos los elementos ',miLista[:],'\n')
miLista.insert(2,'NYX')
print('Inserta un elemento en la posición 2, los demás se mueven ')
print('Todos los elementos',miLista[:],'\n')
nuevaLista=['Y0','Y1','Y2']
print ('inserta una lista al final de miLista')
miLista.extend(nuevaLista)
print('Elementos de miLista = ',miLista,'\n')
print('Posición de la primera coincidencia AX ',miLista.index('AX'))
print('Valor booleano si existe o no el dato R ','R' in miLista)
print('Elementos de miLista = ',miLista,'\n')
print('Elimina el elemento AX','\n')
miLista.remove('AX')
print ('Extrae el último elemento ', miLista.pop())
lista3=miLista+nuevaLista
print('Unir dos listas lista3 = miLista+nuevaLista ','\n')
print('Elementos de lista3 = ',lista3,'\n')
93
ta = ['A0', 'A1', 'A2', 'A3', 'A4']
<class 'list'>
Elemento posición 2 de miLista A2
Elemento posición -2 de miLista A3
Todos los elementos del 2 al final. (Porciones) ['A2', 'A3', 'A4']
Elementos del 1 al 3 el 3. (Porciones) ['A1', 'A2']
Elementos del 0 al 3 excluye el 3. (Porciones) ['A0', 'A1', 'A2']
Inserta al final un dato, miLista.append(AX) ['A0', 'A1', 'A2', 'A3',
'A4', 'AX']
Todos los elementos ['A0', 'A1', 'A2', 'A3', 'A4', 'AX']
Inserta un elemento en la posición 2, los demás se mueven

Todos los elementos ['A0', 'A1', 'NYX', 'A2', 'A3', 'A4', 'AX']
inserta una lista al final de miLista

Elementos de miLista = ['A0', 'A1', 'NYX', 'A2', 'A3', 'A4', 'AX',
'Y0', 'Y1', 'Y2']
Posición de la primera coincidencia AX 6

Valor booleano si existe o no el dato R False
Elementos de miLista = ['A0', 'A1', 'NYX', 'A2', 'A3', 'A4', 'AX',
'Y0', 'Y1', 'Y2']
Elimina el elemento AX
Elementos de miLista = ['A0', 'A1', 'NYX', 'A2', 'A3', 'A4', 'Y0',

'Y1', 'Y2']
Extrae el último elemento Y2
Elementos de miLista = ['A0', 'A1', 'NYX', 'A2', 'A3', 'A4', 'Y0',
'Y1']
Unir dos listas lista3 = miLista+nuevaLista
Elementos de lista3 = ['A0', 'A1', 'NYX', 'A2', 'A3', 'A4', 'Y0',

'Y1', 'Y0', 'Y1', 'Y2']
Ayudas en la red
Páginas web
Tutorial de Python
Métodos de agregado de listas

https://uniwebsidad.com/libros/python/capitulo-7/metodos-de-gregado?from=librosweb
Python para principiantes: Escrito por Eugenia Bahit
94
Data Structures- More on Lists
https://docs.python.org/3.8/tutorial/datastructures.html
Difference between del, remove and pop on lists

https://stackoverflow.com/questions/11520492/difference-between-del-remove-and-
pop-on-lists/11520540
95
1.3.3 Juego del ahorcado con Python
Descripción y objetivo: El programa ponen una palabra secreta. El jugador podrá ir
seleccionando letras que aparecerán en la palabra secreta, si ésta las contiene, se muestra
en el sitio en donde está ubicada dentro de la palabra secreta. en caso contrario contará
como fallo. El objetivo consiste en acertar la palabra secreta sin cometer errores.
Ejemplos:
 Programa juego del ahorcado versión 1 (ahorcado_juego.py)
import os
os.system('cls') #clear screen
import time
import random
IMAGES = ['''
+---+
| |
|
|
|
|
=========''', '''
+---+
| |
O |
|
|
|
=========''', '''
+---+
| |
O |
| |
|
|
=========''', '''
+---+
| |
O |
/| |
|
|
96
=========''', '''
+---+
| |
O |
/|\ |
|
|
=========''', '''
+---+
| |
O |
/|\ |
| |
|
=========''', '''
+---+
| |
O |
/|\ |
| |
/ |
=========''', '''
+---+
| |
O |
/|\ |
| |
/ \ |
=========''', '''
''']
WORDS = [
'lavadora',
'secadora',
'sofa',
'gobierno',
'diputado',
'democracia',
'computadora',
'teclado',
'electron'
]
97
def timer(run):
def calculo():
t1=time.time()
run()
t2=time.time()
tt =t2-t1
print('El juego duró {0:.2f} segundos '.format(tt))
return calculo
def random_word():
idx = random.randint(0, len(WORDS) - 1)
return WORDS[idx]
def display_board(hidden_word, tries):

print(IMAGES[tries])
print('')
print(hidden_word)
print('--- * --- * --- * --- * --- * --- ')
@timer
def run():
word = random_word()
hidden_word = ['-'] * len(word)
tries = 0
while True:
display_board(hidden_word, tries)
current_letter = str.lower(input('Escoge una letra: '))
letter_indexes = []
for idx in range(len(word)):
if word[idx] == current_letter:
letter_indexes.append(idx)
if len(letter_indexes) == 0:
tries += 1
if tries == 7:
display_board(hidden_word, tries)
print('')
print('¡Perdiste! La palabra correcta era {}'.format(word))
break
else:
for idx in letter_indexes:
hidden_word[idx] = current_letter
letter_indexes = []
98
try:
hidden_word.index('-')
except ValueError:
print('')
print('¡Felicidades! Ganaste. La palabra es: {}'.format(word))
break
if __name__ == '__main__':
print('B I E N V E N I D O S A A H O R C A D O S')
run()
+---+
| |
O |
|
|
|
=========
['g', 'o', 'b', 'i', 'e', '-', '-', 'o']

--- * --- * --- * --- * --- * ---
Escoge una letra: R
+---+
| |
O |
|
|
|
=========
['g', 'o', 'b', 'i', 'e', 'r', '-', 'o']

--- * --- * --- * --- * --- * ---
Escoge una letra: N
¡Felicidades! Ganaste. La palabra es: gobierno

El juego duró 47.90 segundos
99
1.3.4 Interfaz del ahorcado
 Programa juego del ahorcado versión 2 (ahorcado_plus.py)

system("cls")
import random
def run():
continue_to_play = True
while continue_to_play:
op = ''
print('\nBienvenido al juego del ahorcado.\n')
print_graphic(0) # 0 a 7
input_letters = []
result_found = 0
find_letter = ''
word_play = word_to_play()
max_fails = 7
while result_found == 0:
while input_letters.count(find_letter) > 0 or find_letter == '':
find_letter =str.lower(input('\nEscoge una letra: '))
if len(find_letter) > 1:
find_letter = find_letter[0]
input_letters.append(find_letter)
result_found = word_view(word_play, input_letters, max_fails)
if result_found > 0:
print('Felicidades, ganaste!!!')
elif result_found < 0:
print('Lamentablemente perdiste. La palabra a encontrar era
"{}"'.format(word_play))
while op.lower() != 's'and op.lower() != 'n':

op = str.lower(input('\nDeseas volver a jugar s/n? '))
if len(op) > 1:
op = op[0]
continue_to_play = (op == 's')
def word_view(word, input_letters, max_fails):
"""
ALT 191 ┐
ALT 192 └
ALT 218 ┌
ALT 217 ┘
100
ALT 196 ─
ALT 179 │
"""
list_word = list(word)
header = '┌' + (('─' * 3) * len(word)) + '┐'
footer = '└' + (('─' * 3) * len(word)) + '┘'
hidden_word = list('|' + (' ░ ' * len(word)) + '|')
number_fails = 0
for letter in input_letters:
occur = list_word.count(letter)
index_letter = -1
if occur > 0:
for i in range(occur):
index_letter = list_word.index(letter, index_letter + 1)
hidden_word[((index_letter +1) * 2) + index_letter] = letter
else:
number_fails += 1
print_graphic(number_fails)
print(header)
print(''.join(hidden_word))
print(footer)
if hidden_word.count('░') == 0:
return 1
elif number_fails == max_fails:
return -1
else:
return 0
def print_graphic(error):
print(' +---+')
print(' | |')
if error == 0:
print(' |')
elif error >= 1:
print(' 0 |')
if error < 2:
print(' |')
elif error == 2:
print(' | |')
elif error == 3:
print(' /| |')
101
elif error >= 4:
print(' /|\ |')
if error < 5:
print(' |')
elif error >= 5:
print(' | |')
if error < 6:
print(' |')
elif error == 6:
print(' / |')
elif error == 7:
print(' / \ |')
print(' |')
print(' ===========')
def word_to_play():
words = ['edificio',
'avenida',
'programacion',
'automovil',
'botella',
'mecanografia',
'inteligencia',
'artificial'
]
return words[random.randint(0, len(words) - 1)]
if __name__ == '__main__':
run()
102
Escoge una letra: t
+---+
| |
0 |
/|\ |
| |
/ |
|
===========
┌─────────────────────┐
| ░ o t e ░ ░ a |
└─────────────────────┘
Escoge una letra: n

+---+
| |
0 |
/|\ |
| |
/ \ |
|
===========
Escoge una letra: e
┌─────────────────────┐
+---+
| ░ o| t| e ░ ░ a |
└─────────────────────┘
0 |
Lamentablemente
/|\ | perdiste. La palabra a encontrar era "botella"
|
Deseas volver
| a jugar s/n? s
|
===========
┌─────────────────────┐
| b o t e l l a |
└─────────────────────┘
Felicidades, ganaste!!!
Deseas volver a jugar s/n? n
103
1.3.5 Lógica del ahorcado
 Programa juego del ahorcado versión 3 (ahorcado_turtle.py)

import turtle
import random
system("cls")
def hombre(seg,t):
t.pendown()
t.pencolor('black')
if seg == 1:
t.circle(25)
elif seg == 2:
t.right(90)
t.forward(100)
elif seg == 3:
t.right(45)
t.forward(75)
t.goto(0,-100)
elif seg == 4:
t.left(90)
t.forward(75)
t.penup()
t.goto(0,-40)
elif seg == 5:
t.left(45)
t.forward(50)
t.goto(0,-40)
elif seg == 6:
t.left(180)
t.forward(50)
def run(t):
words = ['arroz', 'amarillo','amor','altar','as','ave','avestrus','antro
',
'azul','atomico','beso','baston','brea','britanico','becerro','bote','bl
anco',
'brasalete','brazo','bar','casa','centavo','cianuro','coco','cuerpo','ca
labaza',
'cerro','cinturon','col','cruz','dado','dragon','dos','diente','doctor',
'doce',
'duende','dardo','desde','donde','efe','eres','elefante','entero','feo',
'frente',
'fase','futbol','frase','frio','gato','gas','gel','gol','hola','hielo','
haz','iglesia',
104
'juez','londres']
num = len(words) - 1
x = random.randint(0,num)
w_found = False
w = words[x]
word = w
lon = len(w)
y = '_'
string = ''
print('Adivina la palabra de {} letras'.format(lon))
for i in range(1,lon+1):
string = string + y
print(string)
seg = 0
while not w_found:
y = str.lower(input('¿Digite una letra o palabra ? '))
if len(y) == 1: ### una letra
if w.find(y) == -1:
print('LETRA EQUIVOCADA')
print('')
print('')
system("cls")
print(string)
seg = seg + 1
if seg >6:
print(f'La palabra oculta era {word}')
print('GAME OVER')
w_found = True
else:
hombre(seg,t)
####aqui va el codigo de dibujo ####

else:
cont = w.find(y)
print('')
string = list(string)
w = list(w)
for i in range(0,lon):
if i == cont:
string [i] = y
string = ''.join(string)
print(string)
105
w[cont] = '_'
w = ''.join(w)
else:
if y == word:
w_found = True
print('E N H O R A B U E N A H A S E N C O N T R A D O L A
P A L A B R A')
else:
print('PALABRA EQUIVOCADA')
print('')
print('')
print(string)
seg = seg + 1
if seg > 6:
print('GAME OVER')
w_found = True
else:
hombre(seg,t)
if string.find('_') == -1:
w_found = True
print('E N H O R A B U E N A H A S E N C O N T R A D O L A P
A L A B R A')
if __name__ == "__main__":
print('A H O R C A D O')
print('')
t = turtle.Turtle()
t.pencolor('blue')
t.penup()
t.goto(-200,-200)
t.pendown()
t.pensize(5)
t.forward(100)
t.penup()
t.goto(-150,-200)
t.pendown()
t.left(90)
t.forward(300)
t.right(90)
t.forward(150)
t.right(90)
t.forward(50)
106
t.penup()
t.left(90)
t.goto(0,0)
t.pensize(1)
run(t)
Adivina la palabra de 6 letras

_re__e
La palabra oculta era frente
GAME OVER
Ayudas en la red
Páginas web
Tutorial de Python
107
1.3.6 ¿Qué es una búsqueda binaria?
Los algoritmos son una serie de hay números mayores y menores que el
instrucciones que nos llevan a un número que se está buscando.
resultado, por ejemplo que tal si
queremos saber si un número se Seleccionar un numero aleatorio para
encuentra en una lista. dividir la lista, puede escoger cualquier
número, en éste caso sumar el primer y
Una forma es buscar un ítem tras otro, el último índice de la lista, se suman y
pero sí la lista es muy larga esta forma no dividen en dos (por eso se llama binario),
es la más eficiente, una forma más luego comparar el número que está en el
eficiente de solucionar éste problema es índice, de esta manera se elimina a la
usar una búsqueda binaria. mitad de las opciones. Continuar
dividiendo la lista y comparando hasta
Con el algoritmo de búsqueda binaria se que se llegue al resultado esperado.
parte de la lista ordenada, se sabe que
Estrecha el rango de búsqueda en etapas, en el siguiente cuadro se muestra los pasos

necesarios para encontrar un número Pej número 22
2 4 5 7 8 9 12 14 17 19 22 25 27 28 33 37
low mid high

2 4 5 7 8 9 12 14 17 19 22 25 27 28 33 37
low md high
2 4 5 7 8 9 12 14 17 19 22 25 27 28 33 37
low md high
2 4 5 7 8 9 12 14 17 19 22 25 27 28 33 37
Find
1.3.7 Implementar búsqueda binaria en Python
system("cls")
def binary_search(numbers, number_to_find, low, high):
if low > high:

return False
mid = int((low + high) / 2)
108
if numbers[mid] == number_to_find:
return True
elif numbers[mid] > number_to_find:
return binary_search(numbers, number_to_find, low, mid - 1)
else:
return binary_search(numbers, number_to_find, mid + 1, high)
if __name__ == '__main__':
numbers = [2, 4, 5, 7, 8, 9, 12, 14, 17, 19, 22, 25, 27, 28, 33,37]
number_to_find = int(input('Ingresa un número: '))
result = binary_search(numbers, number_to_find, 0, len(numbers) - 1)
if result is True:
print('El número SI está en la lista.')
else:
print('El número NO está en la lista.')
Ingresa un número: 22
El número SI está en la lista.
Ingresa un número: 54
El número NO está en la lista.
Ejemplo:
 Buscar un numero en una lista con números aleatorios y que esta desordenada.
(busqueda_binaria_desordenada.py)
system("cls")
import random
def random_numbers(array_quantity):
array = []
for i in range(array_quantity):
random_number = random.randint(0,100)
# print(random_number)
array.append(random_number)
return array
109
def binary_search(numbers, number_to_find, low, high):
#la función binary_search es recursiva, ya que la vamos a utilizar repet
idas veces hasta encontrar el resultado deseado
if low > high: #caso base en el que el número no está en la lista
return False
mid_index = int((low + high) / 2)
if numbers[mid_index] == number_to_find:
#caso base en el que el número está en la lista
return True
elif numbers[mid_index] > number_to_find:

return binary_search(numbers, number_to_find, low, mid_index - 1)
else:
return binary_search(numbers, number_to_find, mid_index + 1, high)
if __name__ == "__main__":
array_quantity = int(input('Ingrese el tamaño de la lista: '))
numbers = random_numbers(array_quantity)
numbers.sort() #Ordena la lista de menor a mayor
print(numbers)
number_to_find = int(input('Ingress el número a buscar en la lista: '))
result = binary_search(numbers, number_to_find, 0, len(numbers) - 1)
if result is True:
print('El número SI está en la lista.')
else:
print('El número NO está en la lista')
Ingrese el tamaño de la lista: 17

[9, 10, 13, 17, 30, 30, 43, 48, 58, 60, 60, 76, 79, 82, 89, 92, 98]
Ingrese el número a buscar en la lista: 60
El número SI está en la lista.
---------------------------------------------------------------------
Ingrese el tamaño de la lista: 10

[11, 14, 22, 24, 50, 57, 79, 89, 91, 97]
Ingrese el número a buscar en la lista: 12
El número NO está en la lista
110
Ayudas en la red
Páginas web
Tutorial de Python
Búsqueda binaria
https://es.khanacademy.org/computing/computer-science/algorithms/binary-
search/a/binary-search
111
1.3.8 Diccionarios en Python
Un diccionario es un mapa de valores, los cuales deben tener una llav. Los diccionarios se
declaran con (llaves) {} o con la función dict()
Cuando iteramos en diccionarios podemos hacerlo a través de las llaves, valores o ítems.
Declarar diccionarios
mi_diccionario ={}
mi_diccionario['primer_elemento'] = 'hola'
mi_diccionario['segundo elemento'] = 'adios'
Iterar en llaves
for key in calificaciones.keys():
print(key)
Iterar en valores
for value in calificaciones.values():
print(value)
Iterer en ítems
for key,value in calificaciones.items():
print('llave: {}, valor {}'.format(key,value))
Ejemplos:
 Creación de diccionarios (diccionario.py)
system("cls")
calificaciones = {}
calificaciones['Matemática'] = 89
calificaciones['Español'] = 89
calificaciones['Historia'] = 89
calificaciones['Ciencias Sociales'] = 96
calificaciones['Ingles'] = 89
calificaciones['Python'] = 78
calificaciones['C++'] = 32
calificaciones['C#'] = 67
if __name__ == "__main__":
for key, value in calificaciones.items():
print(f'LLave: {key}, valor: {value}')
112
LLave: Matemática, valor: 89
LLave: Español, valor: 89
LLave: Historia, valor: 89
LLave: Ciencias Sociales, valor: 96
LLave: Ingles, valor: 89
LLave: Python, valor: 78
LLave: C++, valor: 32
LLave: C#, valor: 67
 Calculo de la temperatura promedio utilizando diccionarios (diccionario_tempe.py)

system("cls")
def temper():
lista =[]
promedio = 0
temperatura = {}
temperatura['Lunes'] = 20
temperatura['Martes'] = 21
temperatura['Miercoles'] = 30
temperatura['Jueves'] = 33
temperatura['Viernes'] = 18
temperatura['Sabado'] = 22
temperatura['Domingo'] = 20
for dia,grados in temperatura.items():

print(f'{dia}------{grados}°')
lista.append(grados)
promedio +=grados
promedio = promedio/(len(lista))
print('Temperatura promedio {0:.2f}°'.format(promedio))
if __name__ == '__main__':
temper()

Lunes------20°
Martes------21°
Miercoles------30°
Jueves------33°
Viernes------18°
Sabado------22°
Domingo------20°
Temperatura promedio 23.43°
113
Ayudas en la red
Páginas web
Tutorial de Python
Diccionarios en Python
https://devcode.la/tutoriales/diccionarios-en-python/
114
1.3.9 Encriptar mensajes usando diccionarios
Encriptar un mensaje es modificarlo de forma que si alguien que no conoce la clave
intenta leerlo no va a poder hacerlo. La criptografía se usa desde hace miles de años, un
gran ejemplo es cuándo Julio Cesar por ejemplo encriptaba mensajes simplemente
modificando el orden de las letras.
El siguiente ejemplo realiza la encriptación de mensajes sencillo, piense en él más como

un juego que como una forma real de cifrar mensajes ya que en este momento con los
avances tecnológicos los computadores son tan veloces que lo descifrarían muy
rápidamente. Hay API’s de cifrado de mensajes más especializadas y complejas que se
pueden usar.
Ejemplo:
 Implementación de programa para cifrar mensajes (criptografia.py)
system("cls")
"""
Utlizar los dicionarios para cifrar y desfrirar palabras,
para ello se crea un diccionario "KEYS" donde estará el
valor de cada palabra para cifrar el mensaje.
La funcion princcipal es "def run" y dentro de ella estarnan

los llamados a las funciones de cifrar y descifrar dependiedno
"""
KEYS = {
'a': 'w',
'b': 'E',
'c': 'x',
'd': '1',
'e': 'a',
'f': 't',
'g': '0',
'h': 'C',
'i': 'b',
'j': '!',
'k': 'z',
'l': '8',
'm': 'M',
'n': 'I',
'o': 'd',
'p': '.',
'q': 'U',
'r': 'Y',
's': 'i',
115
't': '3',
'u': ',',
'v': 'J',
'w': 'N',
'x': 'f',
'y': 'm',
'z': 'W',
'A': 'G',
'B': 'S',
'C': 'j',
'D': 'n',
'E': 's',
'F': 'Q',
'G': 'o',
'H': 'e',
'I': 'u',
'J': 'g',
'K': '2',
'L': '9',
'M': 'A',
'N': '5',
'O': '4',
'P': '?',
'Q': 'c',
'R': 'r',
'S': 'O',
'T': 'P',
'U': 'h',
'V': '6',
'W': 'q',
'X': 'H',
'Y': 'R',
'Z': 'l',
'0': 'k',
'1': '7',
'2': 'X',
'3': 'L',
'4': 'p',
'5': 'v',
'6': 'T',
'7': 'V',
'8': 'y',
'9': 'K',
'.': 'Z',
',': 'D',
'?': 'F',
116
'!': 'B',
}
menu = """
M E N S A J E S C I F R A D O S
BIENVENIDO A CRIPTOGRAFIA
[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
"""
def cypher(message):
words = message.split(' ') #Separa mensajes por espacios
cypher_message = []
for word in words:
cypher_word = ''
for letter in word:
cypher_word += KEYS[letter]
cypher_message.append(cypher_word)
return ' '.join(cypher_message)
def decipher(message):
words = message.split(' ') #Separa mensajes por espacios
decipher_message = []
for word in words:
decipher_word = ''
for letter in word:
for key, value in KEYS.items():
if value == letter:
decipher_word += key
decipher_message.append(decipher_word) #Metos appned ingresa el cara
cter al final
return ' '.join(decipher_message)
"""EN la función "def run" se ejecutan "loop while" que ser infinito
por eso lo inicializa en "True" para que itere hasta que se cumpla la
condicion seleccionada.
Dentro de este "loop while" cse crea la variable "command" que sera la
encargada de guardar lo seleccionado cifrar, decifra o salir
"""
def run():
while True:
print(menu)
117
command = str.lower(input('Seleccione que desea hacer '))
if command == 'c':
system("cls")
message = str(input('Escriba su mensaje: '))
cypher_message = cypher(message)
print(cypher_message)
elif command == 'd':

system("cls")
message = str(input('Escriba su mensaje cifrado: '))
decypher_message = decipher(message)
print(decypher_message)
elif command == 's':

system("cls")
print(' SALIR '.center(40,'='))
else:
system("cls")
print('Comando no encontrado!'.center(40,'-'))
if __name__ == '__main__':
run()
[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
Seleccione que desea hacer c
Escriba su mensaje: Este mensaje es para cifrar

si3a MaIiw!a ai .wYw xbtYwY
[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
118
[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
Seleccione que desea hacer d
Escriba su mensaje cifrado: si3a MaIiw!a ai .wYw xbtYwY

Este mensaje es para cifrar
[c]ifrar mensaje
[d]ecifrar mensaje
[s]alir
Seleccione que desea hacer s
Ayudas en la red
Páginas web
Tutorial de Python
119
1.3.10 Tuplas en Python
Las tuplas a diferencia de las listas, son inmutables (no se pueden modificar) y estas se
definen con paréntesis tupla = (1,2,3) y de igual forma se accede a su información por
medio de los índices iniciando desde 0. En otras palabras una tupla es como tener una lista
de valores constantes.
Se puede crear una tupla con diferentes tipos de datos:
my_tupla = (1,(3,4,5),(‘hola’, ‘adios’))

my_tupla[2] => (‘hola’, ‘adios’)
my_tupla[1] => (3, 4, 5)
my_tupla[0] => 1
Convertir una lista en una tupla y visceversa utilizar la siguiente sintaxis:
De Tupla a Lista:
new_list = list(my_tuple)
De Lista a Tupla
new_tuple = tuple(my_list)
mi_tupla = (1,2,3)
print('Datos de mi_tupla =',mi_tupla)
print('Tipo de datos de mi_tupla ', type(mi_tupla))
nueva_lista= list(mi_tupla)
print('Convertir tupla a lista, nueva_lista = list(mi_tupla), datos de nueva
_lista =',nueva_lista)
print('Tipo de datos de nueva_lista ', type(nueva_lista),'\n')
nueva_tupla = tuple(nueva_lista)
print('Convertir lista a tupla, nueva_tupla = tuple(nueva_lista), datos de n

ueva_tupla =',nueva_tupla)
print('Tipo de datos de nueva_tupla ', type(nueva_tupla))
Datos de mi_tupla = (1, 2, 3)

Tipo de datos de mi_tupla <class 'tuple'>
Convertir tupla a lista, nueva_lista = list(mi_tupla), datos de
nueva_lista = [1, 2, 3]
Tipo de datos de nueva_lista <class 'list'>
Convertir lista a tupla, nueva_tupla = tuple(nueva_lista), datos de

nueva_tupla = (1, 2, 3)
Tipo de datos de nueva_tupla <class 'tuple'>
120
Existen 3 estructuras de datos en Python
Listas [1,2,3] Indexadas por enteros y mutables

Diccionarios {‘key’:‘value’, ‘key1’:‘value1’,} Indexadas por llaves y mutables
Tuplas (1, 2, 3) Indexadas por enteros e inmutables
Las listas y tuplas se acceden a través de índices
Las tuplas y sus métodos

No pueden añadirse elementos a una tupla. Las tuplas no tienen los métodos append ni
extend.
mi_tupla = (1,2,3)
mi_tupla.append(4,)
AttributeError: 'tuple' object has no attribute 'append'
No pueden eliminarse elementos de una tupla. Las tuplas no tienen los métodos remove
ni pop.
mi_tupla.remove(2)
AttributeError: 'tuple' object has no attribute 'remove'
Las tuplas no pueden modificarse son inmutables, para cambiarel dato se necesita generar
una nueva tupla.
mi_tupla[2] = 4
TypeError: 'tuple' object does not support item assignment
Pueden buscarse elementos en una tupla. Las tuplas usan el método index.
y = tuple((2,4,6,8,'azul'))
print(y)
print('El dato en el índice 4 es',y[4])
print(f'Index en tuplas, el índice del dato {y[4]} es', y.index(y[4]))
print('Es True o False el 8 está en la tupla', 8 in y)
Se puede usar in para ver si un elemento existe en la tupla.
(2, 4, 6, 8, 'azul')
El dato en el índice 4 es azul
Index en tuplas, el índice del dato azul es 4
Es True o False el 8 está en la tupla True
121
Para tener en cuenta de las tuplas
 Las tuplas son más rápidas que las listas. Si está definiendo un conjunto
constante de valores y todo lo que va a hacer con él es iterar a través de él, es
mejor usar una tupla en lugar de una lista.
 Las tuplas hacen que su código sea más seguro si “protege contra escritura” los
datos que no necesitan ser cambiados. Usar una tupla en lugar de una lista es
como tener una afirmación implícita de que estos datos son constantes y que
se requiere un pensamiento especial (y una función específica) para anular eso.
 Algunas tuplas pueden usarse como claves de diccionario (específicamente,

tuplas que contienen valores inmutables como cadenas, números y otras
tuplas). Las listas nunca pueden usarse como claves de diccionario, porque las
listas NO son inmutables.
Ejemplo:
 Ejemplo de usos de tuplas (tuplas_pej.py)
system("cls")
#Las tuplas no permiten cambiar el valor de un elemento
x = (1,2,3)
print(x)
print(type(x))
meses =('enero','Febrero','Marzo','Abril','Mayo','Junio','Julio','Agosto')
print(meses,'\n')
y = tuple((2,4,6,8,'azul'))
print(y)
print('El dato en el índice 4 es',y[4])
print(f'Index en tuplas, el indice del dato {y[4]} es', y.index(y[4]))
print('Es True o False el 8 está en la tupla', 8 in y)
localizacion ={(12,10): "Bogota",(11,9): "Pasto"}

print(localizacion)
print(type(localizacion),'\n')
mi_tupla = (1,2,3)
print('Datos de mi_tupla =',mi_tupla)
print('Tipo de datos de mi_tupla ', type(mi_tupla))
nueva_lista= list(mi_tupla)
print('Convertir tupla a lista nueva_lista = list(mi_tupla), datos de nueva_
lista =',nueva_lista)
print('Tipo de datos de nueva_lista ', type(nueva_lista),'\n')
122
nueva_tupla = tuple(nueva_lista)
print('Convertir lista a tupla, nueva_tupla = tuple(nueva_lista), datos de n

ueva_tupla =',nueva_tupla)
print('Tipo de datos de nueva_tupla ', type(nueva_tupla),'\n')
tupla_undato = 10,
print('Sintaxis para tupla de un solo dato tupla_undato =',tupla_undato,type
(tupla_undato) )
(1, 2, 3)
<class 'tuple'>
('enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio',
'Agosto')
(2, 4, 6, 8, 'azul')
El dato en el índice 4 es azul
Index en tuplas, el indice del dato azul es 4
Es True o False el 8 está en la tupla True
{(12, 10): 'Bogota', (11, 9): 'Pasto'}
<class 'dict'>
Datos de mi_tupla = (1, 2, 3)

Tipo de datos de mi_tupla <class 'tuple'>
Convertir tupla a lista nueva_lista = list(mi_tupla), datos de
nueva_lista = [1, 2, 3]
Tipo de datos de nueva_lista <class 'list'>
Convertir lista a tupla, nueva_tupla = tuple(nueva_lista), datos de

nueva_tupla = (1, 2, 3)
Tipo de datos de nueva_tupla <class 'tuple'>
Ayudas en la red
Páginas web
Tutorial de Python
Tuplas
https://docs.hektorprofe.net/python/colecciones-de-datos/tuplas/
TupleSuyntax
https://wiki.python.org/moin/TupleSyntax
123
1.3.11 Se repite una letra en un string_Programa con tuplas
Una de las características clave de Visual Para la versión de Visual Studio Code se
Studio Code es su excelente soporte de realizan sencillos pasos para verificar el
depuración. El depurador integrado de contenido de variables, funciones y otros
VS Code ayuda a acelerar su ciclo de datos de interés.
edición, compilación y depuración.
Permite hacer seguimiento pasa a paso

de las líneas del programa para verificar
el valor de variables, funciones y otros.
Ejemplo:
Construir un programa que permita encontrar el primer carácter que no se repite en un
string. Por ejemplo en el string mimamameama el primer carácter que no se repite es el
carácter i.
El código para esta tarea se indica a continuación. (first_not_repeating_char_initial.py)

system("cls")
def first_not_repeating_char(char_sequence):
seen_letters = {}
for idx, letter in enumerate(char_sequence):

if letter not in seen_letters:
seen_letters[letter] = (idx, 1)
else:
seen_letters[letter] = (seen_letters[letter][0], seen_letters[le
tter][1] + 1)
final_letters = []
for key, value in seen_letters.items():
if value[1] == 1:
final_letters.append( (key, value[0]) )
not_repeated_letters = sorted(final_letters, key=lambda value: value[1])
if not_repeated_letters:
return not_repeated_letters[0][0]
124
else:
return '_'
if __name__ == '__main__':
char_sequence = str(input('Escribe una secuencia de caracteres: '))
result = first_not_repeating_char(char_sequence)
if result == '_':
print('Todos los caracteres se repiten.')
else:
print('El primer carácter no repetido es: {}'.format(result))
Escribe una secuencia de caracteres: abcdabcdabzd

El primer carácter no repetido es: z
Visual Estudio Code permite hacer seguimiento line por línea al código o depuración, esto
permite verificar el valor que van tomando las variables, funciones, llamados y otros
detalles que ayudan a tomar decisiones en la elaboración de programas. En las siguientes
imágenes se muestra su utilidad:
1. Con el editor VB activar y ejecutar el modo depuración siguiendo la ruta Run>Start

Debugging.
2. Seleccionar la línea del código que permita detener el programa para realizar las
visualizaciones de las variables y funciones de interés, en el ejemplo se marca con
el cursor la línea 19, se identifica con un punto de color rojo.
125
3. Una vez activa se presenta en la pantalla el menú,
ejecutar el programa (Restar), ingresar la secuencia
de caracteres. Ubicarse con el cursor en la variable char_sequence, en la pantalla
se mostrará su contenido.
4. Colocar el cursor convenientemente en las variables de su interés.
126
5. Para terminar la ejecución presionar en el menú Stop, la ejecución se detiene y
muestra el resultado del programa.
127
Escribe una secuencia de caracteres: abcdabcdabzd
El primer carácter no repetido es: z
Ayudas en la red
Páginas web
Tutorial de Python
Configuraciones de depuración de Python en Visual Studio Code
La extensión de Python admite la depuración de varios tipos de aplicaciones de Python.

Para obtener un breve tutorial de la depuración básica, consulte Tutorial: configurar y
ejecutar el depurador . También vea el tutorial de Flask . Ambos tutoriales demuestran
habilidades básicas como establecer puntos de interrupción y recorrer el código.
https://code.visualstudio.com/docs/python/debugging
Debugging
Una de las características clave de Visual Studio Code es su excelente soporte de
depuración. El depurador integrado de VS Code ayuda a acelerar su ciclo de edición,
compilación y depuración.
https://code.visualstudio.com/docs/editor/debugging
128
1.3.12 Uso de sets en Python
Python también incluye un tipo de dato para conjuntos. Un conjunto es una colección no
ordenada y sin elementos repetidos. Los usos básicos de éstos incluyen verificación de
pertenencia y eliminación de entradas duplicadas. Los conjuntos también soportan
operaciones matemáticas como la unión, intersección, diferencia, y diferencia simétrica.
Teoría de conjuntos S intersección T
1 4
S T 3 =
2 5 3
1 2 3 4
3 5
S diferencia T
S unión T (SUT) 1 4 1 2
2 3
5 =
1 3 4
1 2 3
2 5 = 4 5
T diferencia S
4 1 = 4 5
5 3
2
Las llaves o la función set() pueden usarse para crear conjuntos. Para crear un conjunto
vacío usar set(), no {}; esto último crea un diccionario vacío.
Los sets son similares a las listas, pero Métodos del objeto set
estas no permiten elementos repetidos.
Cuando se trabaja con sets, se pueden  X in S
realizar las operaciones básicas de  X not in S
conjuntos, esto quiere decir que se
puede calcular los valores de  s.union(t) -> s | t
intercepción, diferencia, unión. Se crean  s.intersection(t) -> s & t
con el keyword set.  s.difference(t) -> s - t
 s.issubset(t)
conjunto= set()  s.issuperset(t)
conjunto.add(2)
conjunto.add(3)
129
Ejemplo:
Sintaxis y utilización de los diferentes métodos de la función set()
rom os import system
system("cls")
s = set([1,2,3])
t = set([3,4,5])
print(f's={s} , t={t}')
print('s.union(t)',s | t)
print('s.intersection(t) ',s & t)
print('s.difference(t) ',s -t)
print('t.difference(s) ',t -s)
print('s.symmetric_difference(t)',s ^ t)
print(s.issubset(t))
print(s.issuperset(t))
print('')
conjunto= set()
conjunto.add(2)
conjunto.add(3)
print('conjunto ',conjunto)
print('')
colores ={'Red','Blue','Green'}
print(colores)
print('Red' in colores)
print('black' not in colores)
colores.add('Violet')
print(colores)
colores.remove('Green')
print(colores)
colores.add('White')
print(colores)
print(type(colores))
colores.clear()
print(colores)
palabra1 = set('abracadabra')
palabra2 = set('alacazam')
print(palabra1,palabra2)
130
s={1, 2, 3} , t={3, 4, 5}
s.union(t) {1, 2, 3, 4, 5}
s.intersection(t) {3}
s.difference(t) {1, 2}
t.difference(s) {4, 5}
s.symmetric_difference(t) {1, 2, 4, 5}
False
False
conjunto {2, 3}
{'Blue', 'Red', 'Green'}

True
True
{'Blue', 'Red', 'Violet', 'Green'}
{'Blue', 'Red', 'Violet'}
{'Violet', 'Blue', 'White', 'Red'}
<class 'set'>
set()
{'r', 'c', 'a', 'b', 'd'} {'c', 'a', 'l', 'z', 'm'}
Ayudas en la red
Páginas web
Tutorial de Python
Sets
https://snakify.org/en/lessons/sets/
131
1.3.13 Dictionary comprehension – list comprehension
Dictionary comprehension y list comprehension nos permite escribir listas o diccionarios
de forma más sencilla.
El azúcar sintáctico es un término acuñado por Peter J. Landin en 1964 para referirse a
los añadidos a la sintaxis de un lenguaje de programación diseñados para hacer
algunas construcciones más fáciles de leer o expresar.
Un buen programador logra que su código sea legible y fácil de leer por otros
programadores
Ejemplo:
 En el siguiente código se muestran varios ejemplos en donde se utilizan el
concepto de Azúcar Sintáctica. (azucar_sintactico.py)
system("cls")
# 1)
print('(1)'.center(75,'='))
cities = ['Bogotá','México DC','Lima','Quito']
for i, city in enumerate(cities):
print(i,city)
# 2)
x_list ={1,2,3}
y_list ={2,4,6}
for x,y in zip(x_list,y_list):
print(x,y)
# 3)
p,q = 10, -10
print('Before: p=%d, q=%d' % (p,q))
p,q = q,p
print('After : p=%d, q=%d' % (p,q))
# 4)
ages = {
'Mary' :31,
'Pedro' :28,
'Diego' :56
}
age = ages.get('Diego','Unknown')
132
print('Diego is %s years old' % age)
# 5)
una_letra = 'D'
lista_letra = ['A','B','C']
for letter in lista_letra:
if una_letra == letter:
print('La letra',una_letra,'está en la lista',lista_letra)
break
else: #if no break occureed
print('La letra',una_letra,'No está en la lista ',lista_letra)
# 6)
with open('diccionario.txt', encoding='utf8') as f:
for line in f:
print(line)
# 7) list comprehension
print('(7) list comprehension'.center(75,'='))
print([i for i in [1,2,3,4]],'\n')
print([num for num in range(1,31) if num % 2 ==0],'\n')
print([num for num in range(2,31,2)])
# 8) Dictionary comprehension
print('(8) Dictionary comprehension'.center(75,'='))
print({i:j for i,j in{1:'a',2:'b',3:'c'}.items()},'\n')
print({num:num**2 for num in range(1,11)},'\n')
# 9 Fahrenheit Dictionary to Celsius Dictionary

print('(9) Fahrenheit dictionary '.center(75,'='))
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}
print('Fahrenheit',fahrenheit)
print('Fahren to celsius',{k:round((float(5)/9)*(v-
32),1) for (k,v) in fahrenheit.items()})
133
================================(1)=================================
0 Bogotá
1 México DC
2 Lima
3 Quito
================================(2)=================================
1 2
2 4
3 6
================================(3)=================================
Before: p=10, q=-10
After : p=-10, q=10
================================(4)=================================
Diego is 56 years old
================================(5)=================================
La letra D No está en la lista ['A', 'B', 'C']
================================(6)=================================
Los diccionarios se encuentran a veces en otros lenguajes
como memorias asociativas o arreglos asociativos.
A diferencia de las secuencias, que se indexan mediante
un rango numérico, los diccionarios se indexan con claves,
que pueden ser cualquier tipo inmutable; las cadenas y
números siempre pueden ser claves.

=======================(7) list comprehension=======================
[1, 2, 3, 4]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
====================(8) Dictionary comprehension====================
{1: 'a', 2: 'b', 3: 'c'}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
=====================(9) Fahrenheit dictionary =====================

Fahrenheit {'t1': -30, 't2': -20, 't3': -10, 't4': 0}
Fahren to celsius {'t1': -34.4, 't2': -28.9, 't3': -23.3, 't4': -17.8}
Ayudas en la red
Páginas web
Tutorial de Python
134
Azúcar sintáctico
https://es.wikipedia.org/wiki/Az%C3%BAcar_sint%C3%A1ctico
Why is there no tuple comprehension in Python?

https://stackoverflow.com/questions/16940293/why-is-there-no-tuple-comprehension-
in-python
Programar sería horrible sin el azúcar sintáctico (I)

https://www.genbeta.com/desarrollo/programar-seria-horrible-sin-el-azucar-sintactico-i
Python List Comprehension

https://www.datacamp.com/community/tutorials/python-list-comprehension
Python Dictionary Comprehension Tutorial

https://www.datacamp.com/community/tutorials/python-dictionary-comprehension
Videos
7 Simple Tricks to Write Better Python Code
https://www.youtube.com/watch?v=VBokjWj_cEA
135
1.4 Uso de objetos y módulos
1.4.1 Manejo de errores en Python
Hay (al menos) dos tipos diferentes de try:

errores: errores de sintaxis y (Bloque Obligatorio)
excepciones. Código en el que pienses que pueda
ocurrir un error.
Errores de sintaxis Ten en cuenta que cuando haya error, la
Los errores de sintaxis, también siguiente línea que se ejecutaría es la del
conocidos como errores de except, es decir salta a ese bloque, sin
interpretación terminar lo que faltaba del bloque try
Excepciones except:
Incluso si una declaración o expresión es (Bloque Obligatorio)
sintácticamente correcta, puede generar Código que se ejecuta en caso que SI
un error cuando se intenta ejecutar. Los haya error
errores detectados durante la ejecución
se llaman excepciones, y no son else:
incondicionalmente fatales. (Bloque Opcional)
Código que se ejecuta en caso que NO
 Cuando se avienta (throw) un haya error.
error, si el error no se “atrapa”,
finally:
entonces el programa se detiene. (Bloque Opcional)
 Hay veces que se quiere evitar Código que siempre se ejecuta, haya o no
este comportamiento porque se haya error.
sabe cómo arreglar el error.
 Para manejar el error se utilizan Errores propios
los keywords try / except  Python permite declarar errores
específicos para cada programa.
try / except / else / finally  Es buena práctica extender el tipo
de error del que se trate.
 La cláusula else se ejecuta si no
 Los errores se “avientan” con el
han ocurrido excepciones y antes
keyword raise
de la cláusula finally.
136
Exception Descripción
AssertionError Se genera cuando falla la declaración de aserción.
AttributeError Se genera en la asignación de atributo o falla la
referencia.
EOFError Se genera cuando la función input () alcanza la
condición de fin de archivo.
FloatingPointError Se genera cuando falla una operación de coma flotante.
GeneratorExit Se genera cuando se llama al método close () de un
generador.
ImportError Se genera cuando no se encuentra el módulo
importado.
IndexError Se aumenta cuando el índice de una secuencia está
fuera de rango.
KeyError Se genera cuando no se encuentra una clave en un
diccionario.
KeyboardInterrupt Se genera cuando el usuario presiona la tecla de
interrupción (Ctrl + c o eliminar).
MemoryError Se genera cuando una operación se queda sin memoria.
NameError Se genera cuando una variable no se encuentra en el
ámbito local o global.
NotImplementedError Criado por métodos abstractos.
OSError Se genera cuando una operación del sistema provoca
un error relacionado con el sistema.
OverflowError Se genera cuando el resultado de una operación
aritmética es demasiado grande para ser representado.
ReferenceError Se genera cuando se usa un proxy de referencia débil
para acceder a un referente recolectado de basura.
RuntimeError Se genera cuando un error no se incluye en ninguna
otra categoría.
StopIteration Lo genera la función next () para indicar que el iterador
no debe devolver más elementos.
SyntaxError Lo genera el analizador cuando se encuentra un error
de sintaxis.
IndentationError Se eleva cuando hay una sangría incorrecta.
TabError Se genera cuando la sangría consiste en tabulaciones y
espacios inconsistentes.
SystemError Se genera cuando el intérprete detecta un error interno.
SystemExit Generado por la función sys.exit ().
TypeError Se genera cuando se aplica una función u operación a
un objeto de tipo incorrecto.
UnboundLocalError Se genera cuando se hace una referencia a una variable
local en una función o método, pero no se ha vinculado
ningún valor a esa variable.
UnicodeError Se genera cuando se produce un error de codificación o
decodificación relacionado con Unicode.
UnicodeEncodeError Se genera cuando se produce un error relacionado con
Unicode durante la codificación.
UnicodeDecodeError Se genera cuando se produce un error relacionado con
Unicode durante la decodificación.
UnicodeTranslateError Se genera cuando se produce un error relacionado con
Unicode durante la traducción.
ValueError Se genera cuando una función obtiene un argumento de
tipo correcto pero valor incorrecto.
ZeroDivisionError Se genera cuando el segundo operando de una
operación de división o módulo es cero.
Ayudas en la red
Páginas web
Tutorial de Python
Errores y excepciones
https://docs.python.org/es/3/tutorial/errors.html
Compound statements
https://docs.python.org/3.5/reference/compound_stmts.html#try
Python Language Excepciones

https://sodocumentation.net/es/python/topic/1788/excepciones
Python - Error Types

https://www.tutorialsteacher.com/python/error-types-in-python
138
1.4.2 Errores personalizados
 Python permite declarar errores específicos para cada programa.

 Es buena práctica extender el tipo de error del que se trate.
 Los errores se “avientan” con el keyword raise
Ejemplo:
 Programa para indicar la población de varios países, se genera un error el cual se
puede omitir encapsulando la llamada con un bloque try/ecxept . (errores.py)
system("cls")
countries = {
'mexico': 122,
'colombia': 49,
'argentina': 43,
'chile': 18,
'peru': 31,
}
while True:
country = str.lower(input('Escriba el nombre de un país: '))
print(f'La población de {country.upper()} es: {countries[country]} millo
nes','\n')
Al ejecutar el programa se genera el siguiente error
Escriba el nombre de un país: colombia

La población de COLOMBIA es: 49 millones
Escriba el nombre de un país: venezuela

Traceback (most recent call last):
File ".\errores.py", line 14, in <module>
print(f'La población de {country.upper()} es: {countries[country]}
millones','\n')
KeyError: 'venezuela'
 Para omitir el KeyError se utiliza el bloque try/ecxept y además se permite

ingresar el nuevo país y su población.
system("cls")
countries = {
139
'mexico': 122,
'colombia': 49,
'argentina': 43,
'chile': 18,
'peru': 31,
}
while True:
country = str.lower(input('Escriba el nombre de un país: '))
try:
print(f'La población de {country.upper()} es: {countries[country]} m
illones','\n')
except KeyError:
print(f'No tenemos el dato de la población de {country.upper()}','\n
')
answer= str.lower(input('¿Desea agregarlo? SI(S), NO (N):'))
if answer == 's':
new_country = int(input(f'Escriba la población de {country}: '))
countries[country] = new_country

Escriba el nombre de un país: venezuela
No tenemos el dato de la población de VENEZUELA
¿Desea agregarlo? SI(S), NO (N):n

Escriba el nombre de un país: Venezuela
No tenemos el dato de la población de VENEZUELA
¿Desea agregarlo? SI(S), NO (N):s

Escriba la población de venezuela: 31
Escriba el nombre de un país: Venezuela
La población de VENEZUELA es: 31 millones
Escriba el nombre de un país: colombia

La población de COLOMBIA es: 49 millones
Escriba el nombre de un país: peru

La población de PERU es: 31 millones
Escriba el nombre de un país: usa

No tenemos el dato de la población de USA
¿Desea agregarlo? SI(S), NO (N):n

Escriba el nombre de un país:
140
Ayudas en la red
Páginas web
Tutorial de Python
Built-in Exceptions
https://docs.python.org/3/library/exceptions.html
Exception hierarchy
The class hierarchy for built-in exceptions is:
https://docs.python.org/3/library/exceptions.html#exception-hierarchy
141
1.4.3 Manejo de archivos en Python
 Python puede leer y escribir Lectura de archivos

archivos con la función open  El objeto archivo tiene dos
 La función open regresa un objeto métodos para leerlo: read y
archivo (file) readlines
 Los archivos pueden ser de texto with open('file.txt',’r') as f:
o binarios for line in f:
print(line)
 Se tiene que especificar el modo
en que se maneja el archivo
Escritura de archivos
‘r’ = read
 Para escribir a un archivo, se
‘w’ = write
‘a’ = append utiliza el método write
‘r+’ = read and write with open('file.txt',’w') as f:
 Se debe cerrar el archivo con el for i in range(5):
print(‘Hello’)
método close
 La mejor manera de manejar
archivos es con el keyword with
CSV
 Coma separa valores
 reader
readlines
 writer
write
Ejemplo:
 El siguiente programa permite leer, escribir, editar (busca una palabra). El archivo a
leer es aleph.txt que está donde se ejecuta el programa. (manejo_archivo.py)
system("cls")
menu = """
[1]Común escritura
[2]With escritura
[3]Leer un archivo con for
[4]Readline() para leer
[5]Buscar una palabra
"""
def writeNumbers():
with open('numeros.txt', 'w') as f:
for i in range(10):
f.write(str(i))
with open('numeros.txt') as f:
print('Archivo creado numeros.txt ',f.readlines(),'\n')
142
def writeNormal():
try:
f = open('numerosNormal.txt', 'w')
for num in range(5):
f.write(str(num))
finally:
f.close()
with open('numerosNormal.txt') as f:
print('Archivo creado numerosNormal.txt ',f.readlines(),'\n')
def readFor():
with open('aleph.txt') as f:
for line in f:
print(line)
def readLines():
print(f.readlines(),'\n')
def beatrizCounter():
counter = 0
busca_p= str(input('Escriba la palabra a buscar: '))
print('')
for line in f:
counter += line.count(busca_p)
print(f'La palabra {busca_p} se encuentra {counter} veces
en el texto','\n')
if __name__ == '__main__':
play = True
while play:
print('MANEJO DE ARCHIVOS'.center(35,'='))
print(menu)
choose = str(input('Seleccione una opción:'))
system("cls")
if choose == '1':
writeNumbers()
elif choose == '2':
writeNormal()
elif choose == '3':
readFor()
elif choose == '4':
readLines()
elif choose == '5':
143
beatrizCounter()
else:
print('La Opción no está disponible')
ans = input('Presione 6 para continuar o cualquier otra tecla para s
alir ')
system("cls")
if ans != "6":
play = False
=========MANEJO DE ARCHIVOS========
[1]Común escritura
[2]With escritura
Seleccione una opción:1
Archivo creado numeros.txt ['0123456789']
Presione 6 para continuar o cualquier otra tecla para salir 6
=========MANEJO DE ARCHIVOS========
[1]Común escritura
[2]With escritura
Seleccione una opción:5
Escriba la palabra a buscar: Beatriz
La palabra Beatriz se encuentra 27 veces en el texto
Presione 6 para continuar o cualquier otra tecla para salir
144
Ayudas en la red
Páginas web
Tutorial de Python
145
1.4.4 Programación orientada a objetos en Python
1.4.4.1 Clases en Python 3

Para aprender a crear clases en Python 3 primero se necesita aprender ¿Qué es una clase?
Aprender a pensar en términos de programación orientada a objetos que es algo diferente
a la programación estructurada con la que se aprende a programar en Python.
1.4.4.2 ¿Qué es una clase en Python?

Se define una clase como una Plantilla o modelo para crear a partir de ella ciertos
Objetos. Esta plantilla es la que contiene la información; características y capacidades que
tendrá el objeto que sea creado a partir de ella.
Así, a su vez los objetos creados a partir de ella estarán

agrupados en esa misma clase. Para explicar mejor este
concepto imagine una regla con moldes para crear
figuras geométricas perfectas. Pues algo así sería una
clase; puede crear esa regla y definir en ella las
características de cada figura sería un objeto.
Crear un objeto a partir de una clase se denomina

instanciar.
1.4.4.3 ¿Qué es un Objeto en Python?

Son entidades que tienen comportamiento, estado, almacenan información y pueden
realizar tareas. El comportamiento son acciones o capacidades para realizar cambios; y
estados como situación o modo de estar en un momento determinado.
Los objetos no necesariamente se derivar de una clase; pueden existir objetos sin que
hayan sido creados de una clase en particular. En Python casi todo es un objeto, puesto
que el concepto de la programación orientada a objetos consiste en resolver problemas
grandes subdividiendo los programas en otros más pequeños a cargo de objetos con
determinadas características y tareas encomendadas.
Los objetos se pueden asimilar como si fueran engranajes en los

programas; si habláramos más en términos de relojería podría
decirse que estos son objetos que contienen una información
específica (tamaños; apertura de dientes; material, resistencia y
otras características) a su vez realizan una acción determinada que
resulta importante para el funcionamiento de un sistema. Faltando
uno u otro engranaje el reloj dejaría de funcionar.
146
Teniendo como referencia ésta comparación se pueden planificar los programas;
pensando en clases que crearán objetos y estos objetos trabajaran y almacenarán datos
para cumplir la función o brindar la solución objetivo de los programas.
Atributos y métodos de un objeto
Los objetos almacenan información y realizan tareas. Los atributos pueden llamarse las
características que definen un objeto. Métodos las tareas que son capaces de realizar
Considere el siguiente ejemplo:

 Definir la Clase :Animal
 El Objeto instanciado (creado a partir de la clase): Perro
 Que tienen los atributos:
o Color : negro;
o Raza : Pastor Colli
o Tiene collar: True (si)
 Los métodos:
o Ladra (“Guau:gua”)
o Correr (Run)
o Caminar ()
o Olfatear ()
Los atributos y métodos se definen en la clase al momento de crear la clase y luego al

instanciar (Crear un objeto a partir de una clase se denomina instanciar) se les da los
“argumentos” para esos atributos y métodos
1.4.4.4 Ejemplo gráfico de Clases en Python

Crear la clase Humano que tendrá ciertos atributos propios de cualquier ser humano y
algunos métodos también que realizan los humanos. A partir de la clase Humanos se
crean dos objetos: Persona1 y Persona2 los cuales se van a instanciar con valores para
cada uno de sus atributos y métodos.
 Definir la Clase : Humano

 El Objeto instanciado (creado a partir de la clase): Persona
 Que tienen los atributos:
o Nombre :
o Edad :
o Ocupación:
o Genero
 Los métodos:
147
o Escribir() , Caminar(), Hablar()
Nombre
Atributos
Edad
Clase: Escribir
Métodos
Humano
Ocupación
Caminar
Instancia
Genero
Hablar
Objetos
Persona1 Persona2
Métodos Métodos
Escribir Escribir
Nombre Nombre
“Nancy” “Pedro”
Caminar Caminar
Edad Edad
“27” Hablar “26” Hablar
Atributos
Atributos
Ocupación Ocupación
“Ingeniera” “Programador”
Genero Genero
“F” “M”
148
1.4.4.5 Sintaxis de clases en Python
Para crear una clase utilizar la expresión El método constructor de las

class seguida del nombre de la clase y clases en Python (__init__)
entre paréntesis la clase de la cual
hereda (una clase puede recibir atributos
Hay diferentes clases de métodos el más
y métodos de otra).
importante es el método constructor; el
nombre hace referencia a inicializar los
Al momento de crear una clase si este
atributos del objeto creado a partir de la
parámetro entre paréntesis no se
clase que lo posea. Por supuesto no es
declara; la clase automáticamente
necesario que este método exista dentro
heredará de Object (que es una clase
de una clase para que la clase exista.
predefinida es decir existente en el
Pero si es necesario para indicarle al
propio lenguaje por defecto.). Luego
intérprete de Python que cuando se
colocar dos puntos y debajo (dentro del
Instancia un objeto a dicha clase debe
bloque de código) definir el método
asignarle los argumentos dados al
constructor de la clase seguido también
momento de la instancia. (Inicialización
de paréntesis para establecer
de atributos).
parámetros y luego colocar dos puntos
“:” teniendo así dentro de la clase otro
bloque de código. El método constructor permitirá asignar
atributos cada vez que se crea un objeto
# Declarar la clase que hereda el o a partir de esa clase haciéndolo
bject obligatorio, permite llamar métodos de
class Nombredelaclase (object): la clase sin instanciar; entre otras cosas.
def __init__ (self, parámetros)
: Para crear un método utilizar la palabra
# Constructor de la clase reservada def luego el nombre del
# Declaración de atributos método y entre paréntesis los
parámetros finalizando con dos puntos
“:”.
Ejemplo:
 Crear la clase Humano en Python (clase_python.py)
system("cls")
class Humano(): #Crear la clase Humano

def __init__(self,nombre,edad,ocupacion,genero):#Parámetros
self.nombre = nombre # Atributo nombre
self.edad = edad #Atributo edad
self.ocupacion = ocupacion # Atributo de instancia ocupación
self.genero = genero #Atributo genero
# Creación de METODO
149
def escribir(self):
escribir = ("Hola soy {}, tengo {} años, mi género es {} y mi ocupac
ión es {} ")
# Mensaje
print(escribir.format(self.nombre,self.edad,self.genero,self.ocupaci
on),'\n')
Persona1 = Humano('Nancy',27,'Ingeniera','F')
Persona2 = Humano('Pedro',26,'Programador','M')
Persona3 = Humano('Juan',20,'Desocupado','M')
#Llamar al método
Persona1.escribir()
Persona2.escribir()
Persona3.escribir()
Hola soy Nancy, tengo 27 años, mi género es F y mi ocupación es

Ingeniera
Hola soy Pedro, tengo 26 años, mi género es M y mi ocupación es

Programador
Hola soy Juan, tengo 20 años, mi género es M y mi ocupación es

Desocupado
 Cambiar atributos mediante métodos

En el ejemplo anterior se creó la clase humano con atributos y un método, ahora
se adicionara un nuevo método para modificar el atributo ocupación.
Juan está Desocupado pero se va a contratar, este nuevo estado se podrá reflejar
modificando el atributo ocupación con un nuevo método, contratar.
(clase_humano_nmetodo.py)

system("cls")
class Humano(): #Crear la clase Humano

def __init__(self,nombre,edad,ocupacion,genero):#Parámetros
self.nombre = nombre # Atributo nombre
self.edad = edad #Atributo edad
self.ocupacion = ocupacion # Atributo de instancia ocupación
self.genero = genero #Atributo genero
150
def escribir(self):
escribir = ("Hola soy {}, tengo {} años, mi género es {} y mi ocupac
ión es {} ")
# Mensaje
print(escribir.format(self.nombre,self.edad,self.genero,self.ocupaci
on),'\n')
# Crear un nuevo método para cambiar la ocupación

def contratar(self,puesto):
self.puesto = puesto
print(f'{self.nombre} ha sido contratado como {self.puesto}','\n')
self.ocupacion = puesto
# Cambiar el atributo ocupación
Persona3 = Humano('Juan',20,'Desocupado','M') #Instancia

#Llamar al método
Persona3.escribir() #Antes de ser contratado
Persona3.contratar('Instructor')
Persona3.escribir() #Presentación luego de ser contratado

Desocupado
Juan ha sido contratado como Instructor

Instructor
Ayudas en la red
Páginas web
Tutorial de Python
Clases
https://docs.python.org/es/3/tutorial/classes.html
Clases en Python (Programación orientada a objetos) *

https://pythones.net/clases-y-metodos-python-oop/
Tipos de métodos en Python
151
https://blog.nearsoftjobs.com/tipos-de-m%C3%A9todos-en-python-cls-vs-self-
d6da1e08efa8
¿Cómo son los métodos de una clase Python por defecto?

https://es.stackoverflow.com/questions/936/c%C3%B3mo-son-los-m%C3%A9todos-de-
una-clase-python-por-defecto
Properties vs. Getters and Setters

https://www.python-course.eu/python3_properties.php
Guía de estilos para el código de Python, Publicado por Luis Navarro en 30 enero, 2019
https://elsolitario.org/post/guia-de-estilos-para-el-codigo-de-python/
¿Qué es la Programación orientada a objetos?

https://ed.team/comunidad/que-es-la-programacion-orientada-a-objetos
Fundamentos de la Programación Orientada a Objetos

http://www.utn.edu.ec/reduca/programacion/poo/pilares.html
Videos
Qué es la programación Orientada a Objetos: Curso de programación
https://youtu.be/Mi_sRAfs7TE
Classes and Objects with Python - Part 1 (Python Tutorial #9)

https://www.youtube.com/watch?v=wfcWRAxRVBA

https://www.youtube.com/watch?v=WOwi0h_-dfA
Programacion Orientada a Objetos (POO) - Objetos y Clases

https://www.youtube.com/watch?v=ykpT5P7171M
Curso de Python. POO I. Vídeo 24

https://youtu.be/5Ohme4A2Weg?list=PLU8oAlHdN5BlvPxziopYZRd55pdqFwkeS
Curso de Python. POO II. Vídeo 25

https://youtu.be/2UNrSiKEI8w?list=PLU8oAlHdN5BlvPxziopYZRd55pdqFwkeS
Curso de Python. POO III. Vídeo 26

https://youtu.be/Y_SiIgxc-xI?list=PLU8oAlHdN5BlvPxziopYZRd55pdqFwkeS
Cursos en Platzi
Curso de Programación Orientada a Objetos: POO
https://platzi.com/clases/oop/
152
1.4.5 Modular un objeto en Python
Clases y objetos Por definición todos los métodos en

 Programación orientada a python son públicos. Para definir que es
objetos. privado a otros programadores se escribe
así:
 Permite definir tipos propios.
def _nombre:
 Permite manejar datos y lógica en
un solo contenedor. Esta definición no lo hace privado a otros
 Las clases son como fábricas métodos, solo es una nomenclatura. Para
(moldes) para crear otros objetos. manejar métodos privados de clase se
escribe así:
def __nombre__:
Clases y métodos
 Los métodos son como funciones Finalmente para que un método de clase
que tienen sentido únicamente sea estático se agrega la siguiente
en el contexto de una clase. etiqueta sobre el método:
 Al igual que las variables, los @staticmethod
def nombre:
métodos privados se definen con
un guion bajo.
Herencia, polimorfismo y
 La encapsulación es un concepto
composición
clave de la programación  La herencia (inheritance) permite
orientada a objetos. definir una clase (la subclase)
o La forma práctica de aplicar basada en otra clase (la
este principio es declarar
superclase).
todas las variables y métodos
como privados, a menos de  Polimorfismo permite modificar
que sea necesario exponerlos métodos preexistentes en la
a otros programadores. superclase.
 Un método clave que casi todas  Composición permite crear una
las clases deben tener es __init__ clase que depende de instancias
 Otro es __str__ de otra clase.
 Existen varios tipos de métodos,
estáticos, de clase, de instancia,
getters y setters.
Ejemplo:
 Modelar un objeto como una lámpara como clase en Python la cual tenga los
atributos de poder estar prendida y apagada, para lo cual se necesitan los
métodos que le permitan estar encendida y apagada. (lamp.py)
153
Atributos
Is_turned_on, True Clase: Turn OFF
Métodos
or False Lámpara
(Lamp)
Turn ON
Instancia
Display image
Objetos
Lámpara1 Lámpara2
Métodos Métodos
Turn ON Turn ON
Turn OFF Turn OFF

Atributos
Atributos
Is_tunred_on : True Is_tunred_on : True

Is_turned_on : False Is_turned_on : False

system("cls")
class Lamp:
_LAMPS = ['''
.
. | ,
\ ' /
` ,-. '
--- ( ) ---
\ /
_|=|_
|_____|
154
''',
'''
,-.
( )
\ /
_|=|_
|_____|
'''] #Variable de clase
def __init__(self,_is_turned_on): #Método instancia constructor

self._is_turned_on = _is_turned_on
def turn_on(self): # Método publico

self._is_turned_on =True
self._display_image()
def turn_off(self): #Método Publico

self._is_turned_on = False
def _display_image(self): #Método privado

if self._is_turned_on:
print(self._LAMPS[0])
else:
def run():
lampara1 = Lamp(_is_turned_on=False) #Crear una instancia
lampara2 = Lamp(_is_turned_on=True) #Crear una instancia
lamp_selec= str(input('''
Indique cual lámpara va a utilizar
Lámpara [1]
Lámpara [2]
'''))
while True:
command = str.lower(input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
system("cls")
if command == 'p':
155
lampara1.turn_on() #Llamar el método turn_on
elif command == 'a':

lampara1.turn_off() #Llamar el método turn_off
else:
break
if __name__ == "__main__":
run()
Lámpara [1]
Lámpara [2]
1
[p]render
[a]pagar
[s]alir
p
.
. | ,
\ ' /
` ,-. '
--- ( ) ---
\ /
_|=|_
|_____|
[p]render
[a]pagar
[s]alir
a
156
,-.
( )
\ /
_|=|_
|_____|
[p]render
[a]pagar
[s]alir
s
Ayudas en la red
Páginas web
Tutorial de Python
ASCII Art Archive

https://www.asciiart.eu/
Videos
Python OOP Tutorial 1: Classes and Instances
https://youtu.be/ZDa-Z5JzLYM
Cursos en Platzi
Curso de POO y Algoritmos con Python
https://platzi.com/clases/poo-python/

Libros
David Aroesti, Curso de Python
157
1.4.6 Decoradores en Python
Un decorador es una función que recibe como parámetro a otra función y modifica su
comportamiento y retorna otra función.
 Un decorador se aplica a una función o método con el símbolo @.

 Es útil para definir si una función debe ejecutarse o no.
o Por ejemplo, en servidores web, existen ciertas funciones que nada más deben
ejecutarse si un usuario se encuentra autenticado.
Estructura de un decorador
 3 funciones (A, B y C) donde A recibe como parámetro a B para retornar C.
 Un decorador devuelve una función.
Ejemplos:
 Generar una función que esté protegida por una contraseña. (decorador.py)
system("cls")
def protected(func):#función que recibe otra función (A) y func es B

def wrapper(password):#Declara otra función interna recibe la contraseña
(C)
if password == 'python':
return func() #Regreso la funcion parámetro osea protected_func
else:
print("La contraseña es inválida. ")
return wrapper #Retorna la función interior para ejecuta @protected (C)
@protected #Decorar la funcion protected_func encapsulando la complejidad de

la funcion protected
def protected_func():
print("La contraseña es correcta. ")
if __name__ == '__main__':
password = str(input("Escriba la contraseña: "))
protected_func(password) #Ejectuto mi función decorada
Escriba la contraseña: python

La contraseña es correcta.
Escriba la contraseña: PYTHON

La contraseña es inválida.
158
 Utilizar parámetros en la función y palabras claves dentro de los valores que se
entregan a la función a decorar. (ejemplo_decoradora.py)

system("cls")
def funcion_decoradora(funcion_parametro):
def funcion_interior(*args,**kwargs): #*args permite recibir parámetros

#**kwargs perimte key word argum
print("Se ejecutará una operación")
funcion_parametro(*args,**kwargs)
print("El cálculo ha finalizado",'\n')

return funcion_interior
@funcion_decoradora
def suma(num1,num2): #la suma tiene la funcion decoradora
print(num1+num2)
@funcion_decoradora
def potencia(base,exponente):
print(pow(base,exponente))
def resta(num1,num2): #la resta no tiene la funcion decoradora

print(f'La resta de {num1}-{num2} = {num1-num2}','\n')
if __name__ == '__main__':
num1= int(input('Ingrese un número '))
num2= int(input('Ingrese otro número '))
print('')
suma(num1,num2)
potencia(base=4,exponente=2)
resta(num1,num2)
159
Ingrese un número 200
Ingrese otro número 50
Se ejecutará una operación

250
El cálculo ha finalizado
Se ejecutará una operación

16
El cálculo ha finalizado
La resta de 200-50 = 150
Ayudas en la red
Páginas web
Tutorial de Python
Videos
Curso Python. Decoradores I. Vídeo 73
https://youtu.be/DQXm6bIZgvk
Curso Python. Decoradores II. Vídeo 74

https://youtu.be/_IwlE3Z7U04
21.- Curso Python - Decoradores

https://youtu.be/c9J7FHLjBds
160
1.4.7 Paquetes y módulos
Un módulo permite agrupar un archivo de inicio llamado __init__.py.
funcionalidad común en un sólo archivo. Este archivo, no necesita contener
ninguna instrucción. De hecho, puede
 Cuando varios módulos agrupan estar completamente vacío.
funcionalidades comunes, se
pueden agrupar en paquetes. Los módulos también son objetos; de
tipo module en concreto. Por supuesto
 Python reconoce que un
esto significa que pueden tener atributos
directorio es un paquete porque y métodos. Uno de sus atributos, name,
contiene un archivo llamado se utiliza a menudo para incluir código
__init__.py ejecutable en un módulo pero éste se
ejecute si el módulo se ejecuta como
En Python, cada uno de los archivos .py programa, y no al importarlo. Para lograr
se denominan módulos. Estos módulos, a esto basta saber que cuando se ejecuta
la vez, pueden formar parte de paquetes. el módulo directamente name tiene
Un paquete, es una carpeta que contiene como valor “main”, mientras que cuando
archivos .py. se importa, el valor de name es el
Pero, para que una carpeta pueda ser nombre del módulo.
considerada un paquete, debe contener
 Para definir dónde comenzar el código usar la línea
If __name__ = ‘__main__’
Básicamente la sentencia if __name__ == ‘main’ le dice al intérprete lo

siguiente: cuando este archivo se ejecute directamente (no ha sido
importado, por ejemplo) haga lo siguiente.
Ejemplos:
 En el código siguiente se muestra el comportamiento de los módulos y paquetes
(my_modulo.py).
system("cls")
def mi_funcion():
print("Una función",'\n')
def otra_funcion():
print("Otra función",'\n')
161
def modulo():
print ("Nombre del modulo: ", __name__,'\n')
class MiClase:
def __init__(self):
print("Una clase",'\n')
print("Este mensaje se muestra siempre, importado o ejecución directa",'\n')
if __name__== "__main__":
print("- Se muestra cuando se ejecuta directamente el módulo o archivo")
print("- Se utiliza para incluir código ejecutable en un módulo")
print("- No se ejecuta desde otro módulo a través de import",'\n')
otra_funcion()
Este mensaje se muestra siempre, importado o ejecución directa
- Se muestra cuando se ejecuta directamente el módulo o archivo

- Se utiliza para incluir código ejecutable en un módulo
- No se ejecuta desde otro módulo a través de import
Otra función
 Ejecutar el siguiente código que debe estar en la misma carpeta del programa
(my_modulo.py).
(programa.py)
import my_modulo
my_modulo.modulo()
clase = my_modulo.MiClase()
Este mensaje se muestra siempre, importado o ejecución directa
Nombre del módulo: my_modulo
Una clase
162
 Modelar un objeto como una lámpara como clase en Python la cual tenga los
atributos de poder estar prendida y apagada, para lo cual se necesitan los
métodos que le permitan estar encendida y apagada. Utilizar los conceptos de
módulos y paquetes para ejecutar el programa. (lamp_modulo.py)
class Lamp:
_LAMPS = ['''
.
. | ,
\ ' /
` ,-. '
--- ( ) ---
\ /
_|=|_
|_____|
''',
'''
,-.
( )
\ /
_|=|_
|_____|
'''] #Variable de clase
def __init__(self,_is_turned_on): #Método instancia constructor

self._is_turned_on = _is_turned_on
def turn_on(self): # Método publico

self._is_turned_on =True
def turn_off(self): #Método Publico

self._is_turned_on = False
def _display_image(self): #Método privado

if self._is_turned_on:
else:
163
 Programa que ejecuta la clase Lamp (lamp_main.py).
from lamp_modulo import Lamp
system("cls")
def run():
lampara1 = Lamp(_is_turned_on=False) #Crear una instancia
lampara2 = Lamp(_is_turned_on=True) #Crear una instancia
lamp_selec= str(input('''
Lámpara [1]
Lámpara [2]
'''))
while True:
command = str.lower(input('''
[p]render
[a]pagar
[s]alir
'''))
system("cls")
if command == 'p':
lampara1.turn_on() #Llamar el método turn_on
elif command == 'a':

lampara1.turn_off() #Llamar el método turn_off
else:
break
if __name__ == "__main__":
run()
164
Lámpara [1]
Lámpara [2]
1
[p]render
[a]pagar
[s]alir
P
.
. | ,
\ ' /
` ,-. '
--- ( ) ---
\ /
_|=|_
|_____|
[p]render
[a]pagar
[s]alir
a
,-.
( )
\ /
_|=|_
|_____|
[p]render
[a]pagar
[s]alir
s
Ayudas en la red
Páginas web
What does if __name__ == “__main__”: do?
https://stackoverflow.com/questions/419163/what-does-if-name-main-do
165
Creando módulos empaquetados
https://uniwebsidad.com/libros/python/capitulo-3/creando-modulos-empaquetados
¿Qué es if __name__ == “__main__”:?

https://es.stackoverflow.com/questions/32165/qu%C3%A9-es-if-name-main
Videos
Concept behind : if __name__ == "__main__"
https://youtu.be/JtKOP-ThcbU
Python Tutorial - 15. if __name__ == "__main__"

https://youtu.be/Huz6bS0uLm4
Tutorial de Python: if __name__ == '__main__'

https://youtu.be/sugvnHA7ElY
166
1.4.8 Entorno virtual en Python
En Python la comunidad comparte su código usando PyPi (python package index), es un
repositorio para instalar módulos de la comunidad.
Con pip install [nombre] se puede instalar el paquete que deseas.
Se utiliza el archivo requirements.txt para ordenar los paquetes que requieren los
proyectos proyecto.
Ambiente virtual
Ambientes virtuales
Es una buena práctica crear un ambiente virtual por cada proyecto de Python en el
que se trabaje.
 Realiza las instrucciones previas de configuración de según su SO (WINDOWS)
 Crear el entorno en una carpeta con el comando python -m venv proyect_ven
 Active el entorno virtual actívate.bat
 Instale el paquete flask con pip install flask
 Crear el código para generar un servidor web
Use venv para aislar dependencias
venv es una herramienta que crea entornos de Python aislados. Estos entornos
aislados pueden tener versiones separadas de paquetes de Python, lo que le permite
aislar las dependencias de un proyecto de las dependencias de otros. Recomendamos
que siempre use un entorno virtual por proyecto cuando desarrolles de forma local
con Python.
Permite encapsular un proyecto para poder instalar las versiones de los paquetes que se
requieran sin tenerlos que instalar en todo el sistema operativo.
Instrucciones previas
Para adecuar el entorno virtual en la computadora con Windows y con Python 3X realizar
los siguientes pasos:
6. Ubicar y crear en el disco duro la carpeta de trabajo pej servidor
7. En este documento se utiliza PowerShell de Windows para ejecutarlos comandos

PS C:\ai_curso> md servidor
167
PS C:\ai_curso> cd servidor
8. Dentro de la carpeta ejecutar los comandos python -m venv proyect_ven para

crear el entorno virtual
PS C:\ai_curso\servidor> python -m venv proyect_ven
PS C:\ai_curso\servidor> dir
Directorio: C:\ai_curso\servidor
Mode LastWriteTime Length Name
---- ------------- ------ ----
d----- 23/09/2020 11:50 p. m. proyect_ven
9. En la carpeta se crean los siguientes archivos y sub-carpetas
PS C:\ai_curso\servidor> cd proyect_ven
PS C:\ai_curso\servidor\proyect_ven>dir
Directorio: C:\ai_curso\servidor\proyect_ven

---- ------------- ------ ----
d----- 23/09/2020 11:50 p. m. Include
d----- 23/09/2020 11:50 p. m. Lib
d----- 23/09/2020 11:50 p. m. Scripts
-a---- 23/09/2020 11:50 p. m. 82 pyvenv.cfg
10. Verificar los archivos creados en la sub-carpeta Scripts

PS C:\ai_curso\servidor\proyect_ven>cd Scripts
PS C:\ai_curso\servidor\proyect_ven\Scripts>dir
Directorio: C:\ai_curso\servidor\proyect_ven\Scripts
---- ------------- ------ ----
-a---- 23/09/2020 11:50 p. m. 2306 activate
-a---- 23/09/2020 11:50 p. m. 976 activate.bat
-a---- 23/09/2020 11:50 p. m. 18456 Activate.ps1
-a---- 23/09/2020 11:50 p. m. 368 deactivate.bat
-a---- 23/09/2020 11:50 p. m. 106371 easy_install-3.8.exe
-a---- 23/09/2020 11:50 p. m. 106371 easy_install.exe
-a---- 23/09/2020 11:50 p. m. 106362 pip.exe
-a---- 23/09/2020 11:50 p. m. 106362 pip3.8.exe
-a---- 23/09/2020 11:50 p. m. 106362 pip3.exe
-a---- 23/09/2020 11:50 p. m. 532040 python.exe
-a---- 23/09/2020 11:50 p. m. 531016 pythonw.exe
11. En variables de entorno adicionarla nueva ruta el PATH

C:\ai_curso\servidor\proyect_ven\ Scripts
Nota: esta opción es para dejar permanente el entorno virtual, de lo contrario los
comandos se ejecutan en la carpeta en donde estén los archivos como: pip.exe,
168
activate.bat, deactivate.bat; anteponer el comando .\ pej > .\activate.bat. (Por
primera vez)
12. Verificar los paquetes que están instalados PyPi en el entorno virtual
PS C:\ai_curso\servidor\proyect_ven\Scripts>pip list
Package Version
---------- -------
pip 20.1.1
setuptools 47.1.0
WARNING: You are using pip version 20.1.1; however, version 20.2.3 is
available.
You should consider upgrading via the
'c:\ai_curso\servidor\proyect_ven\scripts\ python.exe -m pip install --
upgrade pip' command.
13. Para instalar la versión sugerida de pip, ejecutar el siguiente comando

PS C:\ai_curso\servidor\proyect_ven\Scripts\ python -m pip install --
upgrade pip
Requirement already up-to-date: pip in c:\python\python38\lib\site-packages
(20.2.3)
PS C:\ai_curso\servidor\proyect_ven\Scripts>cd..
PS C:\ai_curso\servidor\proyect_ven\cd Lib
PS C:\ai_curso\servidor\proyect_ven\Lib>
14. Copiar del path en donde está instalado Python la carpeta site-packages
PS C:\ai_curso\servidor\proyect_ven\Lib>Set-Location -
Path C:\python\python38\Lib
PS C:\python\python38\Lib>dir site-*
Directorio: C:\python\python38\Lib
169
---- ------------- ------ ----
d----- 24/09/2020 12:00 a. m. site-packages
PS C:\python\python38\Lib> copy-item site-packages -destination

C:\ai_curso\servidor\proyect_ven\lib -recurse
PS C:\ai_curso\servidor\proyect_ven\lib\site-packages> dir
Directorio: C:\ai_curso\servidor\proyect_ven\lib\site-packages

---- ------------- ------ ----
d----- 24/09/2020 12:36 a. m. pip
d----- 23/09/2020 11:50 p. m. pip-20.1.1.dist-info
d----- 24/09/2020 12:35 a. m. pip-20.2.3.dist-info
d----- 24/09/2020 12:36 a. m. pkg_resources
d----- 24/09/2020 12:36 a. m. setuptools
d----- 24/09/2020 12:36 a. m. setuptools-
47.1.0.dist-info
d----- 24/09/2020 12:36 a. m. __pycache__
-a---- 23/09/2020 11:12 p. m. 126 easy_install.py
-a---- 20/07/2020 4:03 p. m. 121 README.txt
15. Verificar los paquetes que están instalados PyPi, el mensaje de WARNING no se
genera
PS C:\ai_curso\servidor\proyect_ven\Scripts>pip list
Package Version
---------- -------
pip 20.2.3
setuptools 47.1.0
16. Verificar versión de pip instalado

PS C:\ai_curso\servidor\proyect_ven\Scripts> pip -V
pip 20.2.3 from c:\ai_curso\servidor\proyect_ven\lib\site-packages\pip
(Python3.8)
17. Instalar virtualven

PS C:\ai_curso\servidor\proyect_ven\Scripts>python -
m pip install virtualenv
Encender un entorno virtual

PS C:\ai_curso\servidor>project_ven\Scripts\activate.bat
170
Instalar dependencias del archivo requirements.txt en el interno virtual
creado
PS C:\ai_curso\servidor>project_ven\Scripts\pip install flask
PS C:\ai_curso\servidor>project_ven\Scripts\dir
Directorio: C:\ai_curso\servidor\proyect_ven\Scripts

---- ------------- ------ ----
-a---- 23/09/2020 11:50 p. m. 2306 activate
-a---- 23/09/2020 11:50 p. m. 976 activate.bat
-a---- 23/09/2020 11:50 p. m. 18456 Activate.ps1
-a---- 23/09/2020 11:50 p. m. 368 deactivate.bat
-a---- 23/09/2020 11:50 p. m. 106371 easy_install-3.8.exe
-a---- 23/09/2020 11:50 p. m. 106371 easy_install.exe
-a---- 25/09/2020 3:50 p. m. 106349 flask.exe
-a---- 23/09/2020 11:50 p. m. 106362 pip.exe
-a---- 23/09/2020 11:50 p. m. 106362 pip3.8.exe
-a---- 23/09/2020 11:50 p. m. 106362 pip3.exe
-a---- 23/09/2020 11:50 p. m. 532040 python.exe
-a---- 23/09/2020 11:50 p. m. 531016 pythonw.exe
Ejemplos:
 En la carpeta C:\ai_curso\servidor\proyect_ven> virtual_ejemplo.py
Código de prueba virtual_ejemplo.py
from flask import Flask
add = Flask(__name__)
if __name__ == "__main__":
add.run()
* Serving Flask app "virtual_ejemplo" (lazy loading)

* Environment: production
WARNING: This is a development server. Do not use it in a
production deployment.
Use a production WSGI server instead.
* Debug mode: off
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
171
Ya está funcionando flask en el entorno virtual. Para deshabilitar el entorno virtual Press
CTRL+C to quit , No se puede acceder a este sitio web
Ver las dependencias instaladas en el entorno virtual

PS C:\ai_curso\servidor\proyect_ven>pip list
Package Version
------------ -------
click 7.1.2
Flask 1.1.2
itsdangerous 1.1.0
Jinja2 2.11.2
MarkupSafe 1.1.1
pip 20.2.3
setuptools 47.1.0
Werkzeug 1.0.1
PS C:\ai_curso\servidor\proyect_ven> pip freeze >requirements.txt
PS C:\ai_curso\servidor\proyect_ven> dir
Directorio: C:\ai_curso\servidor\proyect_ven

---- ------------- ------ ----
d----- 23/09/2020 11:50 p. m. Include
d----- 23/09/2020 11:50 p. m. Lib
d----- 25/09/2020 4:08 p. m. Scripts
172
-a---- 23/09/2020 11:50 p. m. 82 pyvenv.cfg
-a---- 25/09/2020 4:40 p. m. 204 requirements.txt
-a---- 25/09/2020 4:08 p. m. 101 virtual_ejemplo.py
PS C:\ai_curso\servidor\proyect_ven> type requirements.txt

click==7.1.2
Flask==1.1.2
itsdangerous==1.1.0
Jinja2==2.11.2
MarkupSafe==1.1.1
Werkzeug==1.0.1
Para instalar los paquetes que está utilizando el código utilizar el comando
PS C:\ai_curso\servidor\proyect_ven\Lib\site-packages> pip install -r
requirements.txt
 En la carpeta C:\ai_curso\servidor\proyect_ven> main.py

Código de prueba virtual_ejemplo.py
app = Flask(__name__)
@app.route('/')
def index():
return 'Este código comprueba que el entorno virtual está operando'
if __name__ == "__main__":
app.run()
PS C:\ai_curso\servidor\proyect_ven> python main.py

* Serving Flask app "main" (lazy loading)
WARNING: This is a development server. Do not use it in a
production deployment.
* Debug mode: off
173
Ayudas en la red
Páginas web
Entornos virtuales de Python en Windows.
https://platzi.com/tutoriales/1104-python/5883-entornos-virtuales-de-python-en-
windows/
How To Install Python 3 and Set Up a Programming Environment on Ubuntu 18.04

[Quickstart]
https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-
a-programming-environment-on-ubuntu-18-04-quickstart
20 Comandos Básicos de Linux que deberías Conocer

https://marcosmarti.org/comandos-basicos-de-linux/
Cómo instalar PIP para Python en Windows, Mac y Linux

https://tecnonucleous.com/2018/01/28/como-instalar-pip-para-python-en-windows-mac-
y-linux/
Cómo se ejecutan los comandos estudiados en Windows y MacOS

https://platzi.com/clases/1748-terminal/24411-como-se-ejecutan-los-comandos-
estudiados-en-window/
Videos
INSTALACION DE PYTHON, PIP, VIRTUALENV Y FLASK EN WINDOWS | MUY FACIL 2019
https://youtu.be/zH28dM-pjlw
2.- Curso Flask - Instalación y Hola Mundo

https://youtu.be/M408lxhhok8
Instalar Python, Pip y Virtualenv en Windows 10

https://youtu.be/sG7Q-r_SZhA
Como instalar Pip y correrlo desde la terminal de Windows

https://youtu.be/t9BVg28_Slo
174
How To Install PIP for Python 2020 Windows 10
https://youtu.be/uS57HP09odc
Linux & Windows en un mismo Sistema, Windows Subsystem for Linux (WSL), Ubuntu &
bash
https://youtu.be/gm-Kym2iqss
Python Tutorial: VENV (Windows) - How to Use Virtual Environments with the Built-In
venv Module
https://youtu.be/APOPm01BVrk
175
1.5 Proyecto: Web Scraping
1.5.1 ¿Qué es web scraping?
Probablemente no sea la primera vez que para ponerlo a punto que no requieren
escuche el término web scraping. Y si no, conocimientos de programación. Eso sí,
seguro que lo ha encontrado en alguna estas herramientas nunca le van a dar
de sus otras formas, como data scraping, toda la flexibilidad que tendría si los
rastreo, scraping de datos, extracción de desarrollara en un lenguaje de
datos o, haciendo referencia a programación.
aplicaciones más concretas, como price
mapping. Quizá le hayan venido a la mente los
típicos captchas o el típico “No soy un
El web scraping consiste en navegar robot” que se encuentran normalmente
automáticamente una web y extraer de al rellenar un formulario online. ¡Exacto!
ella información. Esto puede ser muy útil Es de los crawlers de lo que se protegen.
para muchísimas cosas y beneficioso Porque además de recopilar información,
para casi cualquier negocio. A día de hoy, también se pueden utilizar para rellenar
no existe una sola empresa de éxito que formularios, crear cuentas falsas o
no lo haga —o que no quiera hacerlo—. realizar cualquier acción en la red de
De hecho, la empresa reina del scrapeo forma automática.
es Google, que para que su buscador
funcione así de bien tiene que estar Usos
constantemente scrapeando la red  Indexar la web (GOOGLE la utiliza)
entera.  Obtener la reputación de la
empresa.
Al software programado para scrapear se
le suele llamar bot, spider o crawler.  Obtener precios que cambian.
Todo el mundo puede programar un  Bajar imágenes, información.
crawler, ya que existen herramientas
176
 Buscar precios históricos de la tanto la tecnología que utilicemos y, por
bolsa de valores. tanto, elegir lo más sencillo sería lo más
 Saber qué hay en la red con los acertado. En este caso BeautifulSoup o
Selenium serían buenas opciones.
datos personales, Etc.
Términos éticos y legales
Cómo hacer web scraping
No es tan sencillo decir si scrapear es
Los recursos más utilizados para legal o no. Depende mucho de cada caso
extracción de datos en la web. y, aun así, la mayoría de las veces no
estará muy claro. Por eso, aunque sea
Prográmalo tú mismo poco probable, siempre antes de
scrapear se tiene que asumir el riesgo de
El lenguaje de programación más que la empresa scrapeada pueda poner
utilizado para scrapear es, con diferencia, una denuncia. Aunque lo más probable
Python, ya que tiene varias librerías es que, en el caso de realizar alguna
bastante competentes para scrapear: acción de respuesta, sea bloquear al bot
Scrapy, BeautifulSoup y Selenium. o dar alguna especie de aviso.
La más conocida y utilizada es, Eso sí, antes de ponerse a scrapear, es

probablemente, Scrapy. Bueno, en más que recomendable comprobar si se
realidad, ni siquiera es una librería, sino proporciona una API con la cual acceder
un framework, y eso permite que con a los datos sin tener hacer scraping. Por
Scrapy puedas administrar peticiones, ejemplo, Idealista, la conocida web de
preservar sesiones de usuario y seguir alquiler y compra de viviendas, ofrece
redirecciones. Una de las mayores una API para que ambos lados salgan
ventajas de Scrapy es que es muy ganando. Por un lado, realizar peticiones
eficiente, es capaz de scrapear más a una API requiere menos desarrollo que
cantidad, más rápido y a menos coste de scrapear y, por otro, Idealista evita todo
CPU que las otras alternativas. La única ese tráfico “indeseado”. Además, al abrir
desventaja de Scrapy es que tiene sus datos al público, dan la oportunidad
problemas scrapeando webs cuyo html de que alguien desarrolle algo potente
ha sido generado por JavaScript, pero es para ellos.
que esto tampoco es mucho problema,
ya que existen middlewares que, Si no ha habido suerte y no proporcionan
añadiéndolos al código, hacen una API, habrá que leerse los términos y
desaparecer el problema. condiciones, para comprobar que no
dicen nada con respecto a la extracción
La única razón por la que estaría automática de la información. De todas
justificado usar otra librería como formas, antes de ponerse a scrapear
BeautifulSoup o Selenium en vez de habrá que considerar si el número de
Scrapy, sería en el caso de proyectos peticiones necesarias son demasiado
muy simples, donde solo tuviéramos que abusivas y si el fin del proyecto perjudica
acceder a una dirección, scrapear un par al negocio de la página. Podría haber más
de cosas y ya está. Entonces, no importa pegas por parte de la empresa scrapeada
177
si se estás lucrando a costa de su
contenido, ya que puede ser denunciado En conclusión, con el fin de evitar sustos,
por la vulneración de los derechos de es recomendable contactar con la
propiedad intelectual. Sobre todo si el empresa para contarles en qué consiste
contenido que se quiere extraer está el proyecto o, incluso, llegar a algún
detrás del login de usuario, ya que, en acuerdo con ellos. Además, siempre es
este caso, seguro que no estamos buena idea dejarse aconsejar por un
hablando de información de dominio abogado experto [1].
público.
Ayudas en la red
Referencias Páginas web

[1] Qué es el web scraping
https://aukera.es/blog/web-scraping/
Cursos en Platzi
Curso de Web Scraping: Extracción de Datos en la Web
https://platzi.com/clases/webscraping/
178
1.5.2 Implementación web scraping con Python
Web scraping
 Realiza las instrucciones previas de configuración según su SO (WINDOWS)

 Crear el entorno en una carpeta con el comando python -m venv web_scraping
 Active el entorno virtual actívate.bat
 Instale los paquetes requests, beautifulsoup4. bs4
 pip install -r requirements.txt
 Crear el código para generar un servidor web
requirements.txt
beautifulsoup4==4.9.2
bs4==0.0.1
requests==2.24.0
Ejemplo
 Descargar de la página web https://xkcd.com cinco imágenes las cuales se van a
copiar en un subdirectorio especifico, utilice la librería os, el código es el siguiente:
<img src="//imgs.xkcd.com/comics/barrel_cropped_(1).jpg" title="Don't we all." alt="Barrel -

Part 1">
179
web_scraping.py
system("cls")
import urllib.request
import requests
from bs4 import BeautifulSoup
import urllib
import os
def run():
for i in range(1,6):
print(f"Imagen {i}")
response = requests.get('https://xkcd.com/{}'.format(i))
soup = BeautifulSoup(response.content,'html.parser')
image_container = soup.find(id="comic")
image_url = image_container.find('img')['src']
image_name = image_url.split('/')[-1]
print("Descargando la imagen {}".format(image_name))
carpeta ='C:/ai_curso/servidor/web_scraping/imag'
ruta_destino = os.path.join(carpeta, image_name)
#print(ruta_destino)
urllib.request.urlretrieve('https:{}'.format(image_url),ruta_destino
)
if __name__ == '__main__':
run()
PS C:\ai_curso\servidor\web_scraping> python web_scraping.py

Imagen 1
Descargando la imagen barrel_cropped_(1).jpg
Imagen 2
Descargando la imagen tree_cropped_(1).jpg
Imagen 3
Descargando la imagen island_color.jpg
Imagen 4
Descargando la imagen landscape_cropped_(1).jpg
Imagen 5
Descargando la imagen blownapart_color.jpg
180
Las imágenes descargadas se
ubican en el directorio de trabajo
C:/ai_curso/servidor/web_scraping/imag son:
 Web Scraping para obtener los nuevos cursos en Platzi:

cursos_platzi.py
system("cls")
import requests
from bs4 import BeautifulSoup
import urllib.request
courses = []
prox_courses = []
def nuevos_courses(courses_container):
181
contador = 1
# Extendiendo cada contenedor y encontrando títulos "h3".
for course in courses_container:
courses.extend(course.find_all('h3'))
print("Los nuevos cursos lanzados en Platzi son: ",'\n')

for course in courses:
print(contador, '.', course.text)
contador += 1
def proximos_courses(proximos_cursos):
contador = 1
# Extendiendo cada contenedor y encontrando títulos "h4".
for curso in proximos_cursos:
prox_courses.extend(curso.find_all('h4'))
print('')
print("Los próximos cursos en Platzi serán: ",'\n')
for curso in prox_courses:
print(contador, '.', curso.text)
contador += 1
def run():
response = requests.get("https://platzi.com/")
soup = BeautifulSoup(response.content, "html.parser")
courses_container = soup.find_all(lambda tag: tag.name == 'div' and tag.
get('class') == ['RecentCourses'])
proximos_cursos = soup.find_all(lambda tag: tag.name == 'div' and tag.ge
t('class') == ['NextReleases'])
nuevos_courses(courses_container)
proximos_courses(proximos_cursos)
if __name__ == "__main__":
run()
182
Los nuevos cursos lanzados en Platzi son:
1 . Curso de Trabajo Remoto o Teletrabajo

2 . Curso de Evaluación Financiera de Proyectos
3 . Curso de Marketing con YouTube
4 . Curso de Clean Architecture en Android
5 . Curso de Planeación Financiera
6 . Curso Introductorio de Spark
7 . Curso de Inglés Avanzado: Conversación
8 . Curso de Estadística Inferencial con R
9 . Curso de Introducción al Technical Writing y Documentación de
Código
10 . Curso de Gestión de Trabajo con Airtable
11 . Curso de Planeación y Medición de Campañas Digitales
12 . Curso de React Native
13 . Curso de Uso y Manejo del Color
14 . Guía para Hacer Live Streaming con tu Teléfono
15 . Curso de Java Spring
16 . Curso de Introducción al Despliegue de Aplicaciones
Los próximos cursos en Platzi serán:
1 . Curso de Inglés Intermedio Alto: Gramática

2 . Curso de Estrategia Visual de Marca
3 . Curso de Fundamentos de PHP
¿Para qué Ambientes virtuales?

El tener un ambiente virtual te permite encapsular tu proyecto de las versiones
globales. Imagina que está trabajando con la versión Python2.7 de una biblioteca en un
proyecto, pero necesitas a su vez trabajar en otro proyecto con la versión Python3.8, si
no tuviera un ambiente virtual tendría que instalar y desinstalar la versión con su
correspondiente versión cada vez que quiera cambiar de proyecto. Ahora imagine esto
con 4 - 5 proyectos, esto se resuelve con los ambientes virtuales pues le permiten
tener dependencias aisladas en cada proyecto y cambiar de proyecto sin afectar tus
paquetes globales
Ayudas en la red
Páginas web
Beautiful Soup Documentation
https://www.crummy.com/software/BeautifulSoup/bs4/doc/
Installing packages using pip and virtual environments
183
https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/
Python urllib urlopen no funciona

https://www.it-swarm-es.tech/es/python/python-urllib-urlopen-no-
funciona/1049519793/
Encuentre y conéctese a miles de API

https://docs.rapidapi.com/
Videos
Install python PIP, Requests and Beautiful soup for WINDOWS (in 5 minutes)
https://youtu.be/cGW70Hc0W4M
Cursos en Platzi

https://platzi.com/cursos/webscraping/
Curso de Fundamentos de Web Scraping con Python y Xpath
Curso de Scrapy
Fundamentos de Ingeniería de Software
https://platzi.com/clases/ingenieria/
184
1.6 Proyecto: Aplicación de Terminal
1.6.1 Interfaz directorio de contactos

En esta sección se a crear un programa que sea una agenda
de contactos, para esto debemos pensar, ¿qué es realmente
una agenda?
Una agenda es un agrupador de contactos que nos permite

añadir, eliminar y ver contactos.
Se utilizaran varios de los conceptos visto en este curos.
1.6.2 Lógica de directorio de contactos
En el siguiente código se muestra la lógica de la agenda (agenda.py )

system("cls")
def saludo():
print('Bienvenido a la agenda de contactos'.center(40,' '))
class Contacto:
def __init__(self, name, phone, email):

self.name = name
self.phone = phone
self.email = email
class Agenda:
def __init__(self):
self._contactos = []
def add(self, name, phone, email):

contact = Contacto(name, phone, email)
self._contactos.append(contact)
def update(self, name):
for idx, contact in enumerate(self._contactos):

if contact.name.lower() == name.lower():
185
#while True:
upd_command = str(input(f'''
Acualizar el contacto {name}
[1] Nombre
[2] Teléfono
[3] E-mail
[4] Nombre y Teléfono
[5] Nombre e E-mail
[6] E-mail y Teléfono
[0] Volver al menú principal
'''))
if upd_command.lower() == '1':
self._contactos[idx].name = str(input('Escriba el nuevo
nombre del contacto:'))
system("cls")
break
elif upd_command.lower() == '2':

self._contactos[idx].phone = str(input(f'Escriba el nuev
o número telefónico de {name}: '))
break

self._contactos[idx].email = str(input(f'Escriba el nuev
o E-mail de {name}: '))
break

o número telefónico de {self._contactos[idx].name}: '))
break

o E-mail de {self._contactos[idx].name}: '))
break

186
break

break
else:
print('Comando no encontrado.')
else:
self._not_found(name)
def show_all(self):
for contact in self._contactos:
self._print_contact(contact)
def delete(self, name):

del self._contactos[idx]
break
def search(self, name):

break
else:
def _print_contact(self, contact): #Metodo privado se reconoce por el _

print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
print(f'Nombre: {contact.name}')
print(f'Teléfono: {contact.phone}')
print(f'E-mail: {contact.email}')
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
def _not_found(self, name):

print('********************************************')
print(f'¡{name} no se encuentra en la agenda!')
print('********************************************')
def run():
contact_book = Agenda()
while True:
187
saludo()
command = str(input('''
[1]Añadir un contacto
[2]Actualizar un contacto
[3]Buscar un contacto
[4]Eliminar un contacto
[5]Listar todos los contactos
[0]Salir
Indique una Opción

'''))
system('cls')
if command.lower() == '1':
name = str(input('Escribe el nombre del contacto: '))
phone = str(input(f'Escribe el número telefónico de {name}: '))
email = str(input(f'Escribe el E-mail de {name}: '))
contact_book.add(name, phone, email)
elif command.lower() == '2':

name = str(input('Escribe el nombre del contacto a actualizar: '
))
contact_book.update(name)

name = str(input('Escribe el nombre del contacto que buscas: '))
contact_book.search(name)

name = str(input('Escribe el nombre del contacto a eliminar: '))
contact_book.delete(name)
contact_book.show_all()

break
else:
if __name__ == '__main__':
run()
188
========================================
Bienvenido a la agenda de contactos
========================================
[0]Salir
Indique una Opción

1
Escribe el nombre del contacto: Diego Cabrera

Escribe el número telefónico de Diego Cabrera: 2560777
Escribe el E-mail de Diego Cabrera: cabreramezadiego@gmail
========================================
========================================
[0]Salir
Indique una Opción

2
189
Escribe el nombre del contacto a actualizar: Diego Cabrera
Acualizar el contacto Diego Cabrera
[1] Nombre
[2] Teléfono
[3] E-mail
[5] Nombre e E-mail
4
Escriba el nuevo nombre del contacto:Diego Cabrera Meza
Escriba el nuevo número telefónico de Diego Cabrera Meza: 571-2560777
========================================
========================================
[0]Salir
Indique una Opción

5
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nombre: Diego Cabrera Meza
Teléfono: 571-2560777
E-mail: cabreramezadiego@gmail
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
190
1.6.3 Persistencia de datos
Para complementar la información de este apartado ver la sección 1.4.3 Manejo de
archivos en Python.
Para evitar que se borren los datos de la agenda del ejercicio de la sección anterior se
agrega al código secciones que permiten guardar datos en el disco duro utilizando el
archivo contactos.csv.
Para guardar los registros se genera la función siguiente _save(selft), la cual se agrega
adecuadamente en el código para que sea útil. El módulo csv se importa
import csv
def _save(self):
with open('contactos.csv','w', newline='') as f:
writer = csv.writer(f)
writer.writerow(('name','phone','email'))

writer.writerow((contact.name,contact.phone,contact.email))
Para leer el archivo se utiliza el siguiente código.
with open('contactos.csv','r') as f:
reader= csv.reader(f)
for idx, row in enumerate(reader):
if idx == 0:
continue
contact_book.add(row[0],row[1],row[2])
Código completo, refiérase a la sección 1.6.2 Lógica de directorio de contactos en donde

está el código completo (agenda_plus.py).
system("cls")
import csv
def saludo():
print('Bienvenido a la agenda de contactos'.center(40,' '))
class Contacto:
def __init__(self, name, phone, email):
191
self.name = name
self.phone = phone
self.email = email
class Agenda:
def __init__(self):
self._contactos = []
def add(self, name, phone, email):

contact = Contacto(name, phone, email)
self._contactos.append(contact)
self._save()
def update(self, name):

#while True:
upd_command = str(input(f'''
Acualizar el contacto {name}
[1] Nombre
[2] Teléfono
[3] E-mail
[5] Nombre e E-mail
'''))
if upd_command.lower() == '1':
system("cls")
break

break

break
192
o número telefónico de {self._contactos[idx].name}: '))
break

o E-mail de {self._contactos[idx].name}: '))
break

break

break
else:
else:
self._save()
def show_all(self):
def delete(self, name):

del self._contactos[idx]
self._save()
break
def search(self, name):

193
break
else:
def _save(self):
with open('contactos.csv','w', newline='') as f:
writer = csv.writer(f)
writer.writerow(('name','phone','email'))

writer.writerow((contact.name,contact.phone,contact.email))
def _print_contact(self, contact): #Metodo privado se reconoce por el _

print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
print(f'Nombre: {contact.name}')
print(f'Teléfono: {contact.phone}')
print(f'E-mail: {contact.email}')
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
def _not_found(self, name):

print('********************************************')
print(f'¡{name} no se encuentra en la agenda!')
print('********************************************')
def run():
contact_book = Agenda()
with open('contactos.csv','r') as f:
reader= csv.reader(f)
for idx, row in enumerate(reader):
if idx == 0:
continue
contact_book.add(row[0],row[1],row[2])
while True:
saludo()
[0]Salir
194
Indique una Opción
'''))
system('cls')
if command.lower() == '1':
name = str(input('Escribe el nombre del contacto: '))
phone = str(input(f'Escribe el número telefónico de {name}: '))
email = str(input(f'Escribe el E-mail de {name}: '))
contact_book.add(name, phone, email)

name = str(input('Escribe el nombre del contacto a actualizar: '
))
contact_book.update(name)

name = str(input('Escribe el nombre del contacto que buscas: '))
contact_book.search(name)

name = str(input('Escribe el nombre del contacto a eliminar: '))
contact_book.delete(name)
contact_book.show_all()

break
else:
if __name__ == '__main__':
run()
195
PS C:\ai_curso\python> python .\agenda_plus.py
========================================
========================================
[0]Salir
Indique una Opción

5
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nombre: Diego Cabrera
Teléfono: 25607777
E-mail: cabreramezadiego@gmail.com
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nombre: Zeus Villamil
Teléfono: 3182352321
E-mail: zeusvillamil@gmail.com
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Nombre: Chaggy Cabrera Villamil
Teléfono: 2560999
E-mail: chaggy@hotmail.com
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
========================================
========================================
[0]Salir
Indique una Opción

0
PS C:\ai_curso\python>
196
Ayudas en la red
Páginas web
Cómo Leer y Escribir Archivos CSV en Python
https://code.tutsplus.com/es/tutorials/how-to-read-and-write-csv-files-in-python--cms-
29907
Videos
Curso de Python - Lectura de archivos CSV
https://www.youtube.com/watch?v=wmNsecoZ_Go
Curso de Python - Escritura en archivos CSV

https://youtu.be/uCv5zGPGgb4
GitHub vs GitLab | PlatziLive

https://youtu.be/EscDe0jG6XM
197
1.7 Proyecto: Aplicación web
1.7.1 Configurando el entorno de desarrollo de Google

Cloud
La plataforma que se va a utilizar para ejecutarla en la nube es Google App Engine. De

Google Cloud.
18. Descargar e instalar el software de google cloud sdk.
19. Para ejecutar la aplicación en google could prepare los siguientes archivos en el
directorio del entorno virtual, appengine_contact_server
20. En la sección de este documento 1.4.8 Entorno virtual en Python se dan las
indicaciones para crear un entorno virtual. Crear el entorno
appengine_contact_server.
PS C:\ai_curso\servidor> python -m venv appengine_contact_server
PS C:\ai_curso\servidor\appengine_contact_server>.\scripts\activate.bat
PS C:\ai_curso\servidor\appengine_contact_server> .\scripts\pip freeze

click==7.1.2
Flask==1.1.2
itsdangerous==1.1.0
Jinja2==2.11.2
MarkupSafe==1.1.1
Werkzeug==1.0.1
198
21. App Engine no corre el comando pip por esto es necesario subir las librerías del
proyecto, para esto crear una carpeta Lib y el archivo appengine-config.py.
appengine-config.py.
from google.appengine.ext import vendor
vendor.add('Lib')
22. Instalar las dependencias usar el comando pip install -r requirements.txt -t Lib
requirements.txt
Flask==1.1.2
PS C:\ai_curso\servidor\appengine_contact_server> .\scripts\pip install -

r requirements.txt -t Lib
PS C:\ai_curso\servidor\appengine_contact_server\Lib> dir
Directorio: C:\ai_curso\servidor\appengine_contact_server\Lib

---- ------------- ------ ----
d----- 29/09/2020 8:10 p. m. bin
d----- 29/09/2020 8:10 p. m. click
d----- 29/09/2020 8:10 p. m. click-7.1.2.dist-info
d----- 29/09/2020 8:10 p. m. flask
d----- 29/09/2020 8:10 p. m. Flask-1.1.2.dist-info
d----- 29/09/2020 8:10 p. m. itsdangerous
d----- 29/09/2020 8:10 p. m. itsdangerous-1.1.0.dist-
info
d----- 29/09/2020 8:10 p. m. jinja2
d----- 29/09/2020 8:10 p. m. Jinja2-2.11.2.dist-info
d----- 29/09/2020 8:10 p. m. markupsafe
d----- 29/09/2020 8:10 p. m. MarkupSafe-1.1.1.dist-info
199
d----- 29/09/2020 8:03 p. m. site-packages
d----- 29/09/2020 8:10 p. m. werkzeug
d----- 29/09/2020 8:10 p. m. Werkzeug-1.0.1.dist-info
23. Contenido del archivo main.py
main.py
@app.route('/')
def index():
return 'Configurando el entorno de desarrollo de Google Cloud'
if __name__ == "__main__":
app.run()
24. Indicar el ambiente que se va a utilizar y hacia donde se va enviar el tráfico para
este caso es main.py . Configurar app.yaml.
App.yaml
service: default
runtime: python38 # or python37 for Python 3.7
api_version: 1
threadsafe: yes
handlers:
- url:.*
script: main.app
secure: always
25. Ejecutar el servidor local con dev_appserver.py. estando en el directorio del

proyecto. Ejecutar Power Sell como administrador.
200
Opcional:
Se puede ensayar corriendo el código en el servidor local con: python main.py
Entrega una ruta del local host y el puerto.
PS C:\ai_curso\servidor\appengine_contact_server> python main.py

* Serving Flask app "main" (lazy loading)
WARNING: This is a development server. Do not use it in a production depl
oyment.
* Debug mode: off
26. Para publicar el proyecto entrar a console.cloud.google.com y crear un nuevo

Proyecto platzi-68490
27. En la sección google app engine, seleccionamos el lenguaje y región.
28. Para realizar el deploy de la aplicación, autenticarse usando el comando gcloud

auth login.
PS C:\ai_curso\servidor\web_scraping> gcloud auth login
Your browser has been opened to visit:

You are now logged in as [cabreramezadiego@gmail.com].
Your current project is [None]. You can change this setting by running:
$ gcloud config set project platzi-68490
PS C:\ai_curso\servidor\appengine_contact_server>
201
29. Ejecutar gcloud app deploy --project [ID del proyecto].
PS C:\ai_curso\servidor\appengine_contact_server> gcloud config set project

platzi-68490
Updated property [core/project].
PS C:\ai_curso\servidor\appengine_contact_server> gcloud app deploy --

project platzi-68490
Ayudas en la red
Páginas web
Crea tu proyecto de Google Cloud
https://cloud.google.com/appengine/docs/standard/python3/building-app/creating-gcp-
project?hl=es-419
Escribe un servicio web básico para App Engine **

https://cloud.google.com/appengine/docs/standard/python3/building-app/writing-web-
service?hl=es-419
Documentación del SDK de Google Cloud

https://cloud.google.com/sdk/docs?hl=es-419
Guía de inicio rápido para Python 3 en el entorno estándar de App Engine *

https://cloud.google.com/appengine/docs/standard/python3/quickstart
¡Ahora estás autenticado con el SDK de Google Cloud!

https://cloud.google.com/sdk/auth_success
Tutorial de Python

https://cloud.google.com/sdk/docs/
Instala un SDK para App Engine

https://cloud.google.com/appengine/downloads
Empieza a utilizar Google Cloud Platform

https://console.cloud.google.com/getting-started
Python2orPython3 - Python Wiki

https://wiki.python.org/moin/Python2orPython3
Las diferencias claves entre Python 2.7.xy Python 3.x con ejemplos
202
https://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html
Crear un servidor simple HTTP con Python. Ejecutar código py

https://pythones.net/crear-servidor-python-http/
Implemente y ejecute Hello World en App Engine

https://cloud.google.com/appengine/docs/standard/python3/quickstart#deploy_and_run
_hello_world_on_app_engine
emoji 0.6.0 pip install emoji

https://pypi.org/project/emoji/
¿Donde conseguir mas APIs?

https://platzi.com/tutoriales/1638-api-rest/6102-donde-conseguir-mas-apis/
Videos
Qué es deploy y cómo hacerlo sin provocar incendios
https://youtu.be/UuF_T1WqlrY
Introduction App Engine’s new Python 3 Runtime *

https://www.youtube.com/watch?time_continue=81&v=qeSpDwA2qcU&feature=emb_lo
go
Python Google App Engine - Hello World - SETUP

https://youtu.be/jWRtX8vs_cM
¿Qué son las APIs y para qué sirven?

https://www.youtube.com/watch?v=u2Ms34GE14U
Cursos en Platzi
Curso de Google App Engine
https://platzi.com/clases/app-engine/

https://platzi.com/clases/webscraping/
Curso de API REST

https://platzi.com/clases/api-rest/
Libros
python/
203
1.7.2 Crear templetes con Jinja2
1.7.3 Manejar rutas y lógica con Flask
1.7.4 Listar y eliminar contactos

Para quienes utilizan Python 3.x.x
Los archivos que se van a crear en el entorno virtual son:
Los pasos para configurar el proyecto para Paython 3.7.7
Paso 01: Crear los siguientes archivos:
Archivo: main.py
# -*- coding: utf-8 -*-
from flask import Flask, render_template, request, flash, redirect

from contact_model import Contact
app.secret_key = 'some_secret'
app.debug = True
@app.route(r'/', methods=['GET'])
def contact_book():
contacts = Contact.query().fetch()
return render_template('contact_book.html', contacts=contacts)
@app.route(r'/add', methods=['GET', 'POST'])

def add_contact():
204
if request.form:
contact = Contact(name=request.form.get('name'),
phone=request.form.get('phone'),
email=request.form.get('email'))
contact.put()
flash('¡Se añadió el contacto!')
return render_template('add_contact.html')
@app.route(r'/contacts/<uid>', methods=['GET'])
def contact_details(uid):
contact = Contact.get_by_id(int(uid))
if not contact:
return redirect('/', code=301)
return render_template('contact.html', contact=contact)
@app.route(r'/delete', methods=['POST'])
def delete_contact():
contact = Contact.get_by_id(int(request.form.get('uid')))
contact.key.delete()
return redirect('/contacts/{}'.format(contact.key.id()))
if __name__ == '__main__':
app.run()
Archivo: app.yaml
service: default
runtime: python37
api_version: 1
threadsafe: yes
handlers:
- url: .*
script: main.app
secure: always
205
Archivo: appengine_config.py
from google.appengine.ext import vendor
vendor.add('lib')
Paso 02: Dentro de la carpeta del proyecto crear los archivos templetes
Archivo: Index.html
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Agenda de contactos</title>
</head>
<body>
<h1>Agenda de contactos</h1>
{% block body %}{% endblock %}
</body>
</html>
Archivo: contact_book.html
{% extends 'index.html' %}
{% block body %}
<ul>
{% for contact in contacts %}

<li>
{{ contact.name }} <a href="/contacts/{{ contact.key.id() }}">Ver má
s</a>
</li>
{% endfor %}
</ul>
<a href="/add">añadir contacto</a>

{% endblock %}
Archivo: add_contact.html
{% block body %}
{% with messages = get_flashed_messages() %}

{% if messages %}
{% for message in messages %}
<p>{{ message.decode('utf-8') }}</p>
206
{% endfor %}
{% endif %}
{% endwith %}
<form action="/add" method="post">

<fieldset>
<legend>Añadir nuevo contacto</legend>
<label for="name">Nombre</label>
<input id="name" name="name" type="text">
<label for="phone">Teléfono</label>
<input id="phone" name="phone" type="text">
<label for="email">Email</label>
<input id="email" name="email" type="email">
<button type="submit" name="button">Añadir</button>

</fieldset>
</form>
<p>
<a href="/">Regresar</a>
</p>
{% endblock %}
Archivo: contact.html
{% block body %}
<h2>{{ contact.name }}</h2>
<p>Teléfono: {{ contact.phone }}</p>
<p>Email: {{ contact.email }}</p>
<hr>
<form action="/delete" method="post">
<input type="hidden" name="uid" value="{{ contact.key.id() }}">
<button type="submit">Eliminar</button>
</form>
<p>
<a href="/">Regresar</a>
</p>
{% endblock %}
207
Archivo: contact_model.py
from google.appengine.ext import ndb
class Contact(ndb.Model):
name = ndb.StringProperty()
phone = ndb.StringProperty()
email = ndb.StringProperty()
Paso 03: Descargar el instalador del SDK de Cloud desde

https://cloud.google.com/sdk/docs/ y realizar la instalación. Instalador del
SDK de Cloud.
El SDK de Cloud requiere Python. Las versiones compatibles son las de 3.5 a 3.7, y 2.7.9 o
posteriores.
Se instalarán todas las dependencias necesarias, incluida la versión de Python

correspondiente. Si bien en la actualidad el SDK de Cloud usa Python 3 de forma
predeterminada, puedes desmarcar la opción “Instalar el paquete de Python” para usar
una instalación existente.
Paso 04: Ejecutar el siguiente comando para instalar el componente de gcloud que incluye
la extensión de App Engine extension para Python 3.7:
PS C:\ai_curso\servidor> gcloud components install app-engine-python

All components are up to date.
Paso 05: Crear el entorno virtual con Python ver 1.4.8 Entorno virtual en Python el
entorno se crea con Python 3.7.7
PS C:\ai_curso\servidor> python -m venv proyecto_cloud
Paso 06: Iniciar el entorno virtual

PS C:\ai_curso\servidor\proyecto_cloud\.\scripts\activate.bat
Paso 07: Actualizar pip a la última versión

PS C:\ai_curso\servidor\proyecto_cloud> python -m pip install --upgrade pip
Paso 08: Instalar Flask

PS C:\ai_curso\servidor\proyecto_cloud> .\scripts\pip install Flask
Paso 09: Instalar ndb

PS C:\ai_curso\servidor\proyecto_cloud>.\scripts\pip install google-cloud-ndb
Paso 10: Verificar si los paquetes están instalados en el entorno virtual adecuadamente, si
al verificar no están los paquetes necesarios borrar el entorno y empezar
nuevamente desde el Paso 1:
208
PS C:\ai_curso\servidor\proyecto_cloud> .\scripts\pip list
Package Version
------------------------ ---------
aiohttp 3.6.2
async-timeout 3.0.1
attrs 20.2.0
cachetools 4.1.1
certifi 2020.6.20
chardet 3.0.4
click 7.1.2
Flask 1.1.2
google-api-core 1.22.2
google-auth 1.22.0
google-cloud-core 1.4.1
google-cloud-datastore 1.15.1
google-cloud-ndb 1.6.0
googleapis-common-protos 1.52.0
grpcio 1.32.0
idna 2.10
itsdangerous 1.1.0
Jinja2 2.11.2
MarkupSafe 1.1.1
multidict 4.7.6
pip 19.2.3
protobuf 3.13.0
pyasn1 0.4.8
pyasn1-modules 0.2.8
pymemcache 3.4.0
pytz 2020.1
redis 3.5.3
requests 2.24.0
rsa 4.6
setuptools 41.2.0
six 1.15.0
typing-extensions 3.7.4.3
urllib3 1.25.10
Werkzeug 1.0.1
yarl 1.6.0
Paso 11: Instalar en la carpeta Lib del entorno las librerías Flask y NDB . Crear archivo
contact_model.pyc
Archivo: requirements.txt
Flask==1.1.2
google-cloud-ndb==1.6.0
209
PS C:\ai_curso\servidor\proyecto_cloud> .\scripts\pip install -
r requirements.txt -t lib
Paso 12: Crear una cuenta de servicio. Reemplaza [NAME] por el nombre de la cuenta
PS C:\ai_curso\servidor\proyecto_cloud> gcloud iam service-

accounts create diego-cabrera
Created service account [diego-cabrera].
Paso 13: Otorgar permisos a la cuenta de servicio. Remplazar [PROJET_ID] por el ID del
proyecto.
PS C:\ai_curso> gcloud projects add-iam-policy-binding platzi-12345 --

member "serviceAccount:diego-cabrera@platzi-12345.iam.gserviceaccount.com" -
-role "roles/owner"
Updated IAM policy for project [platzi-12345].

bindings:
- members:
- serviceAccount:service-10527293712345@compute-
system.iam.gserviceaccount.com
role: roles/compute.serviceAgent
- members:
- serviceAccount:1052729371234-compute@developer.gserviceaccount.com
- serviceAccount:1052729371234@cloudservices.gserviceaccount.com
- serviceAccount:platzi-68490@appspot.gserviceaccount.com
role: roles/editor
- members:
- serviceAccount:diego-cabrera@platzi-12345.iam.gserviceaccount.com
- user:cabreramezadiego@gmail.com
role: roles/owner
etag: BwWwpli7JYM=
version: 1
Paso 14: Genera el archivo de claves. Reemplaza [FILE_NAME] por un nombre para el
archivo de claves.
PS C:\ai_curso\servidor\proyecto_cloud> gcloud iam service-

accounts keys create login.json --iam-account diego-cabrera@platzi-
12345.iam.gserviceaccount.com
created key [d39366c049c24a7ad2ad5f23fbddd76fb3f87175] of type [json] as [lo

gin.json] for [diego-cabrera@platzi-12345.iam.gserviceaccount.com]
210
Paso 15: Crea una variable de entorno llamada GOOGLE_APPLICATION_CREDENTIALS con
la ruta del archivo de claves creado en el paso anterior.
set GOOGLE_APPLICATION_CREDENTIALS=[PATH]
PS C:\ai_curso\servidor\proyecto_cloud> set GOOGLE_APPLICATION_CREDENTIALS=C

:\ai_curso\servidor\proyecto_cloud\login.json
Paso 16: Ingrese a Google Cloud Platform y asegúrese de que tanto la “API de Cloud
Datastore” como la “API de Google Cloud Firestore” estén habilitadas. El link
para acceder es el siguiente.
https://console.cloud.google.com/apis/library?filter=category:database&project=[PROJEC
T_ID]
Paso 17: Ejecutar el siguiente comando para autenticarse:
PS C:\ai_curso\servidor\proyecto_cloud> gcloud auth login

.
.
Your current project is [platzi-
12345].You can change this setting by running:
$ gcloud config set project PROJECT_ID
Paso 18: En caso que se requiera cambiar el project id se debe ejecutar la siguiente
instrucción:
PS C:\ai_curso\servidor\proyecto_cloud>gcloud config set project PROJECT_ID
211
Paso 19: Ejecutar uno de los siguientes comandos para subir el código a App Engine:
Comando 1 (Se ejecuta cuando se requiere especificar el PROJECT_ID):
PS C:\ai_curso\servidor\proyecto_cloud> gcloud app deploy --project platzi-

12345
Comando 2 (Se ejecuta cuando no se requiere especificar el PROJECT_ID
PS C:\ai_curso\servidor\proyecto_cloud> gcloud app logs tail -s default

Waiting for new log entries...
PS C:\ai_curso\servidor\proyecto_cloud> gcloud app deploy --project

platzi-12345
Services to deploy:
descriptor: [C:\ai_curso\servidor\proyecto_cloud\app.yaml]
source: [C:\ai_curso\servidor\proyecto_cloud]
target project: [platzi-12345]
target service: [default]
target version: [20201002t150531]
target url: [https://platzi-68490.uc.r.appspot.com]
Do you want to continue (Y/n)? y
Beginning deployment of service [default]...

#============================================================#
#= Uploading 18 files to Google Cloud Storage =#
#============================================================#
File upload done.
Updating service [default]...done.
Setting traffic split for service [default]...done.
Deployed service [default] to [https://platzi-12345.uc.r.appspot.com]
You can stream logs from the command line by running:

$ gcloud app logs tail -s default
To view your application in the web browser run:

$ gcloud app browse
212
Paso 20: Ejecutar app
PS C:\ai_curso\servidor\proyecto_cloud> gcloud app browse
Ayudas en la red
Páginas web
Descripción general de la biblioteca cliente de NDB de Python 2

https://cloud.google.com/appengine/docs/standard/python/ndb?hl=es-419

https://cloud.google.com/sdk/docs/
Escribe un servicio web básico para App Engine

https://cloud.google.com/appengine/docs/standard/python3/building-app/writing-web-
service
Migra al entorno de ejecución estándar de Python 3

https://cloud.google.com/appengine/docs/standard/python/migrate-to-python3/?hl=es-
419
Instala la biblioteca de Cloud NDB para apps de Python 3

https://cloud.google.com/appengine/docs/standard/python/migrate-to-python3/migrate-
to-cloud-ndb#installing_the_cloud_ndb_library_for_python_3_apps
Guía de inicio rápido para Python 3 en el entorno estándar de App Engine

https://cloud.google.com/appengine/docs/standard/python3/quickstart
ndb library for Google Cloud Datastore

https://googleapis.dev/python/python-ndb/latest/index.html
213
1.8 Practicas comunes
1.8.1 ¿Qué puedes construir con Python?
Si estás pensando en aprender Python, o si recientemente

comenzaste a aprenderlo, te estarás preguntando: “¿Para
qué puedo usar exactamente Python?”. Bueno, esa es una
pregunta difícil de responder, porque hay muchas
aplicaciones para Python. Hay varias áreas las cuales utilizan
Python como:
Áreas en las que puedes desempeñar con end común. Esto incluye correlacionar
Python diferentes URLs con fragmentos de
Desarrollo web código Python, tratar con bases de datos

Ciencia de datos y generar archivos HTML que los usuarios
Machine learning e inteligencia artificial ven en sus navegadores.
Programas de escritorio
Linea de comando ¿Qué framework web de Python debería
Internet de las cosas usar?
Web Scraping y bots
Criptografia Django y Flask son dos de los frameworks
Finanzas web de Python más populares. Lo mejor
Biología computacional es usar uno de ellos si recién estás
Ciencias exactas y academia comenzando.
Desarrollo web con Python ¿Cuál es la diferencia entre Django y

Flask?
Los frameworks web basados en Python
como Django y Flask se han vuelto muy Diferencias principales:
populares recientemente para el
desarrollo web. Estos frameworks Flask proporciona simplicidad,
ayudan a crear código de servidor flexibilidad y gran control. No es
(código de back-end) en Python. Ese es el optimizado (te permite decidir cómo
código que se ejecuta en su servidor, a quieres implementar cosas).
diferencia de los dispositivos y
navegadores de los usuarios (código de Django proporciona una experiencia de
front-end). “todo incluido”: obtienes un panel de
administración, interfaces de base de
Pero, ¿por qué necesito un framework datos, un ORM (mapeo relacional de
web? objetos), una estructura de directorios
para tus aplicaciones y proyectos listos
Esto se debe a que un framework web para usar.
facilita la creación de una lógica de back-
214
Deberías elegir:
Puedes aplicar la misma idea a sistemas
Flask, si estás enfocado en la experiencia de recomendación (piensa en YouTube,
y las oportunidades de aprendizaje, o si Amazon y Netflix), Reconocimiento facial
quieres tener más control sobre qué o reconocimiento de voz entre otras
componentes usar (como qué bases de aplicaciones.
datos quieres usar y cómo quieres
interactuar con ellas). Los algoritmos populares de aprendizaje
automático de los que quizás hayas oído
Django, si te centras en el producto final. hablar incluyen redes neuronales,
Especialmente si estás trabajando en una aprendizaje profundo, máquinas de
aplicación sencilla, como un sitio de vectores de soporte, bosque aleatorio…
noticias, una tienda electrónica o un se puede usar cualquiera de estos
blog, y deseas que siempre haya una algoritmos para resolver el problema de
manera única y obvia de hacer las cosas. etiquetado de imágenes del perro y la
mesa.
En otras palabras, si eres un principiante,
Flask es probablemente una mejor Python para aprendizaje automático
opción porque tiene menos
componentes con los que lidiar. Además,
Flask es una mejor opción si quieres más
personalización. Por último, Flask es más
adecuado para crear estas cosas
denominadas API REST que Django
debido a su flexibilidad.
Por otro lado, si estás buscando construir Existen bibliotecas conocidas de

algo sencillo, Django probablemente te aprendizaje automático y frameworks
permita llegar más rápido. para Python. Dos de los más populares
son scikit-learn y TensorFlow.
Python para Ciencia de datos, incluido el
aprendizaje automático, el análisis de Scikit-learn viene con algunos de los
datos y la visualización de datos algoritmos de aprendizaje automático
más populares incorporados.
El aprendizaje automático generalmente
implementa un algoritmo que detecta TensorFlow es más una biblioteca de
automáticamente un patrón en la bajo nivel que permite crear algoritmos
entrada determinada. Por ejemplo, le de aprendizaje automático
puedes dar 1.000 imágenes de un perro y personalizados. Si estás comenzando con
1.000 imágenes de una tabla a un un proyecto de aprendizaje automático,
algoritmo de aprendizaje automático. lo recomendable es que empieces con
Luego, aprenderá la diferencia entre un scikit-learn. Si comienzas a encontrar
perro y una mesa. Cuando le das una problemas de eficiencia, entonces
nueva imagen de un perro o una mesa, comenzaría a investigar sobre
podrá reconocer cuál es. TensorFlow.
215
Análisis / visualización de datos con Otras aplicaciones de Python
Python Aplicaciones integradas: Python funciona
con Rasberry Pi. Es una aplicación
Una de las bibliotecas más populares popular entre los aficionados al
para la visualización de datos es hardware.
Matplotlib. Es una buena biblioteca para
comenzar porque: Es fácil comenzar con Gaming y desarrollo de juegos: se puede
ella, y algunas otras bibliotecas, como usar una biblioteca llamada PyGame para
seaborn, se basan en ella. Por ello, desarrollar juegos, pero no es el motor
aprender Matplotlib te ayudará a de juegos más popular que existe.
aprender estas otras bibliotecas más Podrías usarlo para construir un proyecto
adelante. como pasatiempo, pero no es
recomendable si te tomas en serio el
Scripting con Python. ¿Qué es el desarrollo del juego.
scripting?
Aplicaciones de escritorio: podrías crear
El scripting generalmente se refiere a una con Python usando Tkinter, pero
escribir pequeños programas que están tampoco es la opción más popular.
diseñados para automatizar tareas Tomado de: Blog de empleabilidad y
simples. Python es adecuado para este emprendimiento.
tipo de tareas, principalmente porque https://www.bejob.com/que-puedo-
tiene una sintaxis relativamente simple y programar-con-python-te-comentamos-
es fácil de escribir. También es rápido 3-principales-aplicaciones/
escribir algo pequeño con él y probarlo.
Ayudas en la red
Videos
Curso Python para Principiantes
Páginas web
Acercando las matemáticas a todo el mundo
https://matematicascercanas.com/2014/05/05/12345-100/
Blog de empleabilidad y emprendimiento, ¿Qué puedo programar con Python? Te

comentamos 3 principales aplicaciones
https://www.bejob.com/que-puedo-programar-con-python-te-comentamos-3-
principales-aplicaciones/
Ejercicios básicos: Python

http://aprendeconalf.es/python/ejercicios
216
Tutorial de Python
Cursos en Platzi
Libros

python/
217
1.8.2 Consejos para aprender a programar [ 1]
218
[1]Tomado en octubre de 2020 de Fundamentos de programación https://platzi.com/fundamentos-
programacion/
Ayudas en la red
Cursos en Platzi
Preparación de tu computadora



Curso de Python
https://platzi.com/clases/python/
Curso de Ingeniería de Datos con Python

https://platzi.com/clases/ingenieria-datos/
Curso de Diseño para Programadores
219
https://platzi.com/clases/diseno-programadores/
Curso de Fundamentos de Web Scraping con Python y Xpath

https://platzi.com/clases/web-scraping/
Curso de Manipulación y Análisis de Datos con Pandas y Python

https://platzi.com/clases/pandas/

Curso de Pensamiento Lógico

https://platzi.com/clases/pensamiento-logico/
220
1.9 Retos / Desafíos
1.9.1 Desafío 1: Crear una función que sume recursivamente
¿Cuánto vale la siguiente suma?

Al acabar la hora se comprobaron las
1 + 2 + 3 + 4 + 5 + … + 100 = ________ soluciones y se vio que la solución de
Gauss era correcta, mientras que no lo
Para responder a la pregunta, lo primero eran muchas de las de sus compañeros.
que se nos puede ocurrir es ir sumando
uno a uno cada número; En total La respuesta que Gauss dió fué: 5050. Si
realizaríamos 99 sumas para llegar a la hacéis esas 99 sumas de las que
solución, mentalmente o con la ayuda de habíamos hablado llegareis a esa
una calculadora (en general, hay que solución, aunque tardando bastante más
reconocer que nos cuesta bastante hacer de lo que tardó aquel joven muchacho.
cálculos mentales).
Sin duda es sorprendente la rapidez con
Antes de seguir, ya sé que muchas y la que Gauss dió la respuesta correcta, y
muchos habrán dicho: ¡Qué barbaridad! más aún teniendo en cuenta que tan solo
¡No hace falta hacer tantas sumas! ¡Con tenía 9 años. Pero ¿qué razonamiento
lo que yo sé de matemáticas lo hago pudo seguir?
mucho más rápido!… cuento con ello,
pero como no todo el mundo tiene Lo que queremos calcular es:
porque saberlo y, precisamente, de eso
trata en buena parte este blog, de S = 1 + 2 + 3 + … + 98 + 99 + 100
«acercar» lo que se tenía muy lejano o
simplemente no se conocía, permitidme Gracias a la propiedad conmutativa de la
que no desvele tan rápido el misterio que suma, podemos poner los sumandos en
tantos ya conocen. este orden:
En 1786, en una clase de Aritmética de S = 100 + 99 + 98 + … + 3 + 2 + 1

tercero de primaria, un maestro rural
llamado Büttner pidió a sus alumnos que Si ahora sumamos ambas expresiones lo
hallaran la suma de los 100 primeros podemos expresar, valga la redundancia,
números (la pregunta con la que hemos de la siguiente manera:
empezado esta entrada). Un alumno de
esa clase llamado Carl Friedrich Gauss, 2S = (1+100) + (2+99) + (3+98) + …+
que entonces tenía 9 años, halló la (98+3) + (99+2) + (100+1)
respuesta correcta en muy poco tiempo,
diciendo «Ligget se’» («ya está»). Es decir:
2S= 101 + 101 + 101 + … + 101 + 101 +

101 (100 veces 101)
221
…la solución dada por Gauss.
Luego S será:
101 Tomado de Acercando las matemáticas a

𝑺= 100 = 5050
2 todo el mundo
https://matematicascercanas.com/2014/
05/05/12345-100/
es decir, 50 veces 101…
Este mismo problema, lo podemos plantear de forma genérica, es decir, la suma de los n
primeros números. Siguiendo un razonamiento análogo al del caso de los 100 primeros
números, tendríamos:
S = 1 + 2 + 3 + … + (n-2) + (n-1) + n
Así, por ejemplo, la suma de los 5000
S = n + (n-1) + (n-2) + … + 3 + 2 + 1 primeros números es:
2S = (1+n) + (2+(n-1)) + (3+(n-2)) + … + 1 + 5000

𝑺= 5000 = 12.502.500
((n-2)+3) + ((n-1)+2) + (n+1) 2
Que resulta: Con esta expresión, no sólo podemos

calcular la suma rápidamente, por muy
2S= (1+n) + (1+n) + (1+n) + … + (1+n) + grande que sea la cantidad de números a
(1+n) + (1+n) sumar, sino que lo que es mejor aún, no
necesitamos calcular los términos
n veces (1+n)) intermedios de la sucesión de números,
únicamente tenemos en cuenta el
Luego S será: primero y el último.
1+𝑛 Tomado de Acercando las matemáticas a

𝑺= 𝑛 todo el mundo
2
https://matematicascercanas.com/2014/
05/05/12345-100/
El código para realizar la suma recursiva.

(suma_recursiva.py)
# -*- coding: utf-8 -*-

system("cls")
def suma_rec(num_a, num_b):

if num_a < num_b:
222
x = list(range(num_a,(num_b + 1)))
total = 0
for i in range(len(x)):
total = total + x[i]
return total
else:
x = list(range((num_b),(num_a + 1)))
total = 0
for i in range(len(x)):
total = total + x[i]
return total
def run():
while True:
option = str(input('''
Indique la opción
[1]Suma recursiva
[0]Salir
'''))
if option == '1':
num_a = int(input('Digite el número entero en el que inicia la s

uma: '))
num_b = int(input('Digite el número entero en el que finaliza la
suma: '))
total_sum = suma_rec(num_a, num_b)
print('La suma recursiva desde el número {} hasta el número {} e

s {}'.format(num_a,num_b,total_sum))
elif option == '0':

break
else:
print('La opción digitada es incorrecta')
if __name__== '__main__':
run()
223
=========================
CRIPTOGRAFIA BINARIA
=========================
(1) Cifrar mensaje

(2) Descifrar mensaje
(0) Salir
Indique una opción :1

Escribe un mensaje: Diego 1
Cifrado: 01000100 01101001 01100101 01100111 01101111 00100000

00110001
=========================
=========================
(1) Cifrar mensaje

(0) Salir

Escribe un mensaje: 01000100 01101001 01100101 01100111 01101111
00100000 00110001
Descifrado: Diego 1
=========================
=========================
(1) Cifrar mensaje

(0) Salir
Ayudas en la red
Videos
Curso Python para Principiantes
224
Midiendo el Mundo (2012) (Ver desde minuto 5.00)
https://youtu.be/NprKTmoNhIw
Páginas web
Acercando las matemáticas a todo el mundo
https://matematicascercanas.com/2014/05/05/12345-100/
Blog de empleabilidad y emprendimiento

https://www.bejob.com/que-puedo-programar-con-python-te-comentamos-3-
principales-aplicaciones/
Ejercicios básicos: Python
http://aprendeconalf.es/python/ejercicios

Tutorial de Python
Cursos en Platzi
Libros

python/
225
1.9.2 Desafío 2: Criptografía con binarios
Convertir de Texto (ASCII) a binario I 01001001

Í 11001101
En ASCII y en binario hay representación J 01001010
para una amplia variedad de caracteres: K 01001011
espacios, puntuación y letras. Por ahora L 01001100
nos centraremos en cómo traducir texto M 01001101
a binario, usando solo letras. Lo primero N 01001110
que necesitamos es una palabra. Vamos Ñ 11010001
a usar «perro», porque, ¿a quién no le O 01001111
gusta los perros? Ó 11010011
P 01010000
Tenemos que dividir la palabra en letras Q 01010001
individuales, p e r r o, y consultar nuestra R 01010010
tabla ASCII. En ASCII hay un número S 01010011
decimal asignado a cada carácter. Es T 01010100
importante recordar que los equivalentes U 01010101
binarios y decimales de las letras Ú 11011010
mayúsculas y minúsculas no son Ü 11011100
idénticos. Si no fuera así, el ordenador V 01010110
que lee el código binario no sabría qué W 01010111
letras poner en mayúscula. Vamos a X 01011000
revisar la tabla ASCII. Ten en cuenta que Y 01011001
esto es solo una parte de la tabla. Z 01011010
Puedes encontrar online tablas de ASCII a
binario extendidas, en esta web podrás Alfabeto en Binario (letras en minúscula)
encontrar tablas del alfabeto ASCII a
binario para las letras minúsculas y a 01100001
mayúsculas. á 11100001
b 01100010
Alfabeto en Binario (letras en c 01100011
MAYÚSCULA) d 01100100
e 01100101
A 01000001 é 11101001
Á 11000001 f 01100110
B 01000010 g 01100111
C 01000011 h 01101000
D 01000100 i 01101001
E 01000101 í 11101101
É 11001001 j 01101010
F 01000110 k 01101011
G 01000111 l 01101100
H 01001000 m 01101101
226
n 01101110 quieres aprender tú mismo, o tener un
ñ 11110001 conversor que lo haga por ti. ¿Buscas un
o 01101111 conversor de binario a texto? Puedes
ó 11110011 usar el que hay aquí, o ser tu propio
p 01110000 traductor de binario a texto.
q 01110001
r 01110010 La conversión de binario a texto puede
s 01110011 parecer complicada:
t 01110100 01001000011011110110110001100001,
u 01110101 ¿cómo podemos leer esto sin un
ú 11111010 decodificador binario? Y, ¿por qué
ü 11111100 íbamos a querer traducir una ristra de
v 01110110 unos y ceros cuando hay calculadoras de
w 01110111 binario a texto disponibles? Hay varias
x 01111000 razones por las que podrías querer
y 01111001 aprender a traducir de binario a texto.
z 01111010 Pero saber cómo convertir binario a
texto puede ser una habilidad muy
Convertir de Binario a texto (ASCII) interesante que añadir a tu arsenal.
Hay varios métodos en internet para

convertir binario a texto, ya sea porque [1] Tomado de convertbinary
En la siguiente página web se puede verificar la conversión de texto a binario y de binario

a texto:
El siguiente código realiza la criptografía de un texto ASCII a binario y de binario a texto

(criptografia_binaria.py).
system("cls")
byte = [1, 2, 4, 8, 16, 32, 64, 128] #8 bits
def cifrar(message):
cypher_words = []
for letter in message:
cypher_letter = format( ord(letter), 'b' )
if len(cypher_letter) == 6:
cypher_words.append('00'+ cypher_letter)
else:
cypher_words.append('0'+cypher_letter)
return ' '.join(cypher_words)
227
def des_cifrar(message):
words = message.split(' ')
decipher_message = []
for word in words:
word = str(word)
sumatory = 0
for value, letter in enumerate(word[::-1]):
if int(letter) == 1:
sumatory += byte[value]
decipher_letter = chr(sumatory)
decipher_message.append(decipher_letter)
return "".join(decipher_message)
def run():
while True:
print ('CRIPTOGRAFIA BINARIA'.center(25,' '))
(1) Cifrar mensaje
(0) Salir
Indique una opción :'''))

if command == '1':
message = str(input('Escribe un mensaje: '))
cypher_message = cifrar(message)
print(' ')
print(f'Cifrado: {cypher_message}','\n')
elif command == '2':
message = str(input('Escribe un mensaje: '))
decipher_message = des_cifrar(message)
print('')
print(f'Descifrado: {decipher_message}','\n')
elif command == '0':
system('cls')
break
else:
print('¡Comando no encontrado!')
if __name__ == '__main__':
run()
228
=========================
=========================
(1) Cifrar mensaje

(0) Salir

Escribe un mensaje: Diego 1
Cifrado: 01000100 01101001 01100101 01100111 01101111 00100000

00110001
=========================
=========================
(1) Cifrar mensaje

(0) Salir

Escribe un mensaje: Descifrado: Diego 1
=========================
=========================
(1) Cifrar mensaje

(0) Salir
Verificar la criptografía en la página Conversor de Código Texto a Binario

https://es.convertbinary.com/de-binario-a-texto/
229
Ayudas en la red
Páginas web
[1] Conversor de Código Binario a Texto
https://es.convertbinary.com/de-binario-a-texto/
Alfabeto binario: Las letras del alfabeto en binario

https://es.convertbinary.com/alfabeto/
Videos
How To Read Text In Binary
https://youtu.be/wCQSIub_g7M
230
1.9.3 Desafío 3: Modular un objeto
Para mayor claridad ver la sección 1.4.4
Tipo
Atributos
Color
Clase:
Brazo Rasgos
Métodos
Tamaño robótico
Ejes
Instancia
Grado libertad
Objetos
Métodos Métodos
Rasgos Rasgos
Tipo Caract Tipo
Caract
“SCARA” eristoc “CARTESIANO” eristoc
Ejes Ejes
as as
Color Edad
“negro” “rojo”
Atributos
Atributos
Marca Marca
“Festo” “Mitsubishi”
Grado libertad Genero

“5” “3”
El código que permite crear la clase brazo robótico y determinar sus instancias y métodos
es (clase_brazo_robot.py).
231
system("cls")
class Brazo_robot():
def __init__(self, tipo, color, marca, grados):
self.tipo = tipo
self.color = color
self.marca = marca
self.grados = grados
def caracteristica(self):
rasgo = ('Características del brazo robot: Tipo {}, Color {} de la m
arca {}')
# Mensaje
print(rasgo.format(self.tipo,self.color,self.marca),'\n')
def movimiento(self):
print(f'El brazo robot {self.marca} tiene {self.grados} grados de li
bertad','\n' )
r1 = Brazo_robot('SCARA','Negro','Festo',5)
r2 = Brazo_robot('CARTESIANO','Rojo','Mitsubishi',3)
r1.caracteristica()
r1.movimiento()
r2.caracteristica()
r2.movimiento()
Características del brazo robot: Tipo SCARA, Color Negro de la marca

Festo
El brazo robot Festo tiene 5 grados de libertad
Características del brazo robot: Tipo CARTESIANO, Color Rojo de la

marca Mitsubishi
El brazo robot Mitsubishi tiene 3 grados de libertad
232
Ayudas en la red
Videos
https://www.youtube.com/watch?v=wfcWRAxRVBA

https://www.youtube.com/watch?v=WOwi0h_-dfA
233
1.9.4 Verifique los conocimentos en Python
¿Cómo utilizas el código del modulo ¿Qué keyword se utiliza para declarar
mod_b en el módulo mod_a? funciones?
a. import a a. class
b. import mod_a as b b. del
c. import mod_b c. def
d. import mod_a and mod_b d. break
¿Cuál es el nombre del siguiente ¿Cúal es el resultado de range(3)?

operador %? a. [1,2,3]
a. Moda b. [1,1,1]
b. Módulo c. [0,1,2]
c. Porcentaje d. [3,3,3]
d. Division
¿Cúal de las siguientes palabras no es un
¿Cuál keyword se utiliza para declarar palíndromo?
una clase? a. Agua pasa por mi casa
a. def b. Se van sus naves
b. class c. Amor a Roma
c. del d. Anita lava la tina
d. super
¿Cómo se instala código Python de
¿Cúal sería el resultado de evaluar tercerso en los proyectos?
len(‘programador’)? a. pip install package_name
a. 11 b. npm install package_name
b. 9 c. mvn install package_name
c. 12 d. gem install package_name
d. 10
¿Qué es la búsqueda binaria?
¿Cuál es el tipo que puede contener a. Es un algoritmo eficiente para
caracteres? encontrar un elemento en una
a. str lista ordenada de elementos.
b. int b. Es un tipo de función nativa de
c. float Python
d. bool c. Es una esructura de datos para la
búsqueda de información
¿Cómo podríamos iterar a lo largo de las d. Es un algoritmo para ordenar
llaves del diccionario my_dict? elementos en línea
a. for key in my_dict.iteritems()
b. for key in my_dict.values()
c. for key in my_dict
234
Dada la lista=[‘a’,’b’,’c’], ¿qué arroja ¿Cúal es el orden de evaluación en
lista[0]? Python?
a. ‘a’ a. Paréntesis, Exponentes,
b. ‘b’ Multiplicación, División, Adición,
c. ‘c’ Sustracción
b. Multiplicación, Paréntesis,
¿Cúando se ejecuta la clausula finally? Exponentes, División, Adición,
a. Al final, únicamente si sucedió un Sustracción
error c. División, Sustracción, Adición,
b. Nunca, sirve solo para realizar Multiplicación, Paréntesis,
comentarios Exponentes
c. Al final, siempre, sin importar si d. Exponentes, División,
hubo error o no Multiplicación, Paréntesis
d. Al principio, prepara el código Sustracción, Adición
para un error
¿Qué tipo utilizar para trabajar con un
¿Cúal es la diferencia entre una tupla y decimal?
una lista? a. str
a. Las tuplas sólo almacenan b. int
enteros c. float
b. Las tuplas son iguales a las listas d. bool
c. Las tuplas son inmutables
d. Las tuplas no indexan sus valores ¿Los nombres de las clases comienzan
con mayúsculas?
¿Qué keywords utilizarías para manejar a. Verdadero
código con la posibilidad de arrojar b. Falso
errores?
a. if/ else ¿Cuál no es un nombre de variable
b. try/except permitido?
c. del/str a. house
d. float b. global
c. longitud
¿Cúal es la ldiferencia entre un conjunto d. train_2
y unalista?
a. El conjunto no permite elementos ¿Dado lista=[1], ¿Qué arroja lista *4?
repetidos a. [1,2,3,4]
b. El conjunto tiene un tamaño fijo b. [1,1,1,1]
c. El conjunto es inmutanle c. [0,1,2,3]
d. EL conjunto es igual a una lista d. [4,4,4,4]
235
¿Qué hace la función lower? ¿Cuál es la función del keyword break
a. Convierte un string a mayúsculas. dentro de una iteración?
b. Convierte un string a minúsculas. a. Termina la iteración
c. Convierte la primera letra a b. Para la siguiente iteración
minúscula. c. Ejecutar una expresión
d. Convierte la primera letra condicional
mayúscula. d. Ninguna de las nateriores
¿Cúal es el resultado de str[1:] ¿Qué keyword se utiliza para borrar un

a. Una substring desde la segunda elemento de una lista?
letra y hasta el final. a. def
b. Una substring desde la primera b. del
letra y hast ael fianal. c. class
c. Una substring que contiene d. if
únicamente la segunda letra.
¿Es posible iterar a través de los valores
¿Cuál sería el resultado de evaluar True de un diccionario?
or False?: a. Verdadero
a. Verdader b. Falso
b. Falso
¿Cómo se escribe el programa ‘hello,
¿Qué keywords utilizaría para manejar world!’ en Python
un flojo condicional? a. print(hello, world!)
a. if/else b. imprime((‘hello, world!’)
b. def/class c. print(‘hello, world’)
c. del/int d. hello, world!
d. str
¿Cuál sería el resultado de evaluar
‘PLatzi’ == ‘platzi’?
a. Verdadero
b. Falso
1. ¿Cómo funciona la gestión de la memoria en Python?

El espacio dinámico privado de Python se encarga de la gestión de la memoria en Python.
Todos los objetos y estructuras de datos se encuentran en una pila privada en Python. Los
programadores no tienen acceso a la pila privado. La asignación de espacio de pila la
realiza el administrador de memoria en Python. El lenguaje de programación también
tiene un recolector de basura incorporado, que recicla la memoria no utilizada.
2. ¿Cuál es el significado de los literales de Python?

Literal es un dato dado en una variable o constante. Python admite literales de cadena y
literales numéricos. Literales de cadena reformados mediante texto adjunto en comillas
simples o dobles. Los literales numéricos son flotantes, enteros y complejos.
236
3. ¿Qué es PythonPath?
PythonPath es una variable que se usa cuando se importa un módulo. El código puede ser
clases de función o variables. Los módulos integrados más utilizados son os, sys, math,
random, data time y JSON.
4. ¿Qué son las palabras clave globales y no locales?

Estas palabras clave se utilizan para cambiar el alcance de las variables declaradas
previamente. No local se utiliza siempre que necesite acceder a cualquier variable en una
función anidada. La palabra clave global es más sencilla. Hace que la variable declarada
previamente sea global.
5. ¿Cuál es la diferencia entre un método de clase y un método estático?

Ambos se utilizan para definir un método de clase sin instanciar el objeto de una clase. Un
método de clase también puede aceptar argumentos implícitos.
237

Cuaderno de Notas de Python

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Cuaderno de Notas de Python

Cargado por

Copyright:

Formatos disponibles

Cuaderno de notas de Python

Diego Augusto Cabrera Meza

Este documento pretende ser un resumen del curso de Python

1.1.1 Guía de instalación y conceptos básicos

Para empezar a utilizar el lenguaje se necesitan tres elementos:

 Visual Studio Code

Visual Studio Code: Pycharm:

¿Cuál es la diferencia entre un editor de texto y un IDE ( Integrated Development

A grandes rasgos, IDE = EDITOR + COMPILADOR + DEBUGGER

Consola permite ejecutar tareas en el computador

Instalación de Python en diferentes plataformas y SO

Windows Versión 3.x

MacOS Para Ubuntu o Debian por ejemplo usar

Para instalar la Versión 2.7 $ sudo apt-get install python3.1

 Enteros (int): en este grupo están [1,2,3, ”hola” , [1,2,3] ],

Las variables, a diferencia de los demás lenguajes de programación, no se definen, ni

En los diccionarios se tiene un grupo de datos con un formato: la primera cadena o

>>> D = {“Kill Bill”: “Tamarino”, “Amelie”: “Jean-Pierre Jeunet”}

Longitud de una cadena, lista, tupla, etc.:

Aplicar una conversión a un conjunto como una lista:

Redondear un flotante con x número de decimales:

Conocer los comandos que le puedes aplicar a x tipo de datos:

sorted(iterable, /, *, key=None, reverse=False) Return a new list

>>> from os import system

En las dos últimas líneas se realizó lo siguiente:

Razones para aprender a Programar en Python:

>>>print (“Hola mundo”)

Python para principiantes

5 libros para aprender más sobre Python

Turtle es una biblioteca preinstalada en las computadoras. Es una forma sencilla

 Dibujar una espiral Espiral (turtle_espiral.py)

 Cubo amarillo en fondo verde (cubo_verde.py)

# Forming the window screen

# background color green

# window title Turtle

# bottom left side

# forming back square face

# bottom right side

# top right side

# top left side

Draw Cube and Cuboid in Python using Turtle

El siguiente video para principiantes de YouTube ayuda a la instalación de los programas y

How to Set Up Atom IDE for Python on Windows 10

Python Software Foundation: Comunicado de prensa 20 de diciembre de 2019

Los siguientes operadores son básicos:

a = int(input('ingrese un número A: '))

Operadores en Python: muchos ejemplos reales y propios!

Los tipos le permiten a Python saber cuál es el resultado de aplicar determinada

Para revisar de qué tipo es un dato puedes usar la función type.

 Programa con tipos de datos (datos_python.py)

print ('Float <float> devuelve numeros decimales')

print ('String <str> devuelve una cadena de letras o palabras')

print ('¿100 es igual a 20?')

Pensamiento numérico y algebraico

Las variables permiten guardar valores,  Las variables se pueden reasignar

Variables y expresiones  Python puede procesar texto al

nombre= (input ('Cuál es tú nombre? - '))

edad= int(input('¿Cuántos años tiene? - ' ))

direccion=str(input('Y dónde vives? Sorry olvidé todo :c - '))

recuerdo=str(input('Y te acuerdas de mi? :D - '))

if recuerdo in ['si', 'yes','SI','YES']:

if recuerdo in ['no', 'nop','NO']:

Resultado después de ejecutar el código

Cuál es tú nombre? - Diego Cabrera