Introducción a Python

March 7, 2021

1 Introducción a Python
Python es un lenguaje de programación de alto nivel.
Es de tipado dinámico.
Es multipropósito, pero de fondo es un lenguaje orientado a objetos.
Todo en Python es un objeto.
Más adelante veremos que la indentación es indispensable en Python
La versión de Python que usaremos está escrita en el lenguaje C.

1.1 0. Zen of Python

Algunas de las ideas principales Bello es mejor que feo.
Explícito es mejor que implícito.
Simple es mejor que complejo.
Complejo es mejor que complicado.
Disperso es mejor que denso.
El código debe ser leíble.
Ahora es mejor que nunca.
[1]: import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.

Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.

1
 If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

1.2 1. Variables y tipos de datos en Python

1.2.1 1.1 Variables
Una variable es una etiqueta que referencia a algún espacio en memoria. La sintaxis para declarar
variables en Python es la siguiente (Ejemplo con un número entero):

a = 10

Cuando asignamos una variable estamos usando un espacio en memoria que referenciamos a través
del nombre de la variable. En general la creación de una variable está relacionada con la creación de
un objeto en la memoria, sin embargo en Python existe algo llamado interning que ocasiona que
crear una variable no signifique siempre crear un objeto en memoria (Lo veremos más adelante).
A pesar de que la sintaxis es la especificada más arriba, existen algunas variantes que son permitidas
en Python.
[1]: a = 2540
b = 2545
c = 2540

[2]: print(a)

2540

[3]: a == c

[3]: True

[4]: a is c

[4]: False

[6]: ## Obtener la dirección en memoria de una variable.

id(a), id(b)

[6]: (4301661632, 140581533796464)

[13]: a, b = 10, "H"

[12]: ### Python es interpretado.

print(a), print(b)

10
H

2
[12]: (None, None)

[15]: a, b = "ho", "hola"

[16]: ### Función para imprimir un objeto (Todos los objetos en Python implementan el␣
,→método print)

### Datos primitivos, no existen de manera nativa en python.

### En Python existen clases abstractas. (Interfaces)
print(a)

ho
Python permite la creación de sentencias multilínea a partir del símbolo \.
[19]: ### Ejemplo que NO se usa en la práctica para mostrar el uso de sentencias␣
,→multilínea.

for i in \
range(10):
print(i)

0
1
2
3
4
5
6
7
8
9

[22]: ### La función help() nos muestra la documentación de algún objeto:

### Todo en Python es un objeto.
## help(int)
### help(función)

1.2.2 1.2 Tipos de Datos en Python

Gerarquía de Datos en Python: Existen 6 tipos “superiores” de datos en Python, cada uno
se subdivide en una serie de subtipos que heredan las propiedades:
1. Numbers: Integer, Float, Boolean, Complex, …
2. Sequences: Tuple, String, List
3. Sets: Sets, Frozen Sets
4. Mappings: Dictionarys, …
Los estudiaremos más adelante:

3
 5. Callables
6. Singletons

Numbers
[24]: 1, 2, 3, 4, 5, -1, -10, 0, -10000000

[24]: (1, 2, 3, 4, 5, -1, -10, 0, -10000000)

[25]: ### Función que nos regresa el tipo de dato de un objeto.

a = 3
type(a)

[25]: int

[26]: 2 + 3, 2 * 3, 2 - 3, 2/3

[26]: (5, 6, -1, 0.6666666666666666)

[27]: ### Números de punto flotante

### 64 bits.
### Epsilon de maquina, error computacional.
1.2, 1.3, 9.05, 3.14159, 2.75

[27]: (1.2, 1.3, 9.05, 3.14159, 2.75)

[29]: ## Python es un lenguaje interpretado.

### Apesar de qué Python es "rápido" como es interpretado
### Existen lenguajes más rápidos como Julia, C
(1.2 + 1.3 + 3.4 + 5.6) * 54.0

[29]: 621.0

[28]: 2.3 * 6.4

### Análisis numérico.

[28]: 14.719999999999999

2.3 * 6.4
[30]: ## Boolean
True, False
## Los booleanos son realmente numeros enteros.
# True ---> 1
# False ---> 0

[30]: (True, False)

4
[32]: ### La clase bool es clase hija de la clase int.
### Esto es particular de Python.
(True + True + True + True) * False

[32]: 0

[35]: ### SUma

### Polimorfismo.
1 + 1.0 + 2.0 + 4.5678

[35]: 8.5678

[37]: ### Multiplicación

2 * 4.24

[37]: 8.48

[39]: ### División

2.7 / 3.4

[39]: 0.7941176470588236

Exponeciación
ab := eblog(a)

[40]: ### Exponenciación

2 ** 3

[40]: 8

[41]: 2 - 2.05

[41]: -0.04999999999999982

[42]: ### Operación módulo

# 7 / 4
### Algoritmo de la división:
# 7 = 4 * 1 + 3
7 % 4

[42]: 3

[43]: ### divmod: el cociente del algoritmo de la división

### cociente
7 // 4

[43]: 1

5
 Si se tienen dos números enteros m, n, sin pérdida de generalidad: m ≥ n

m=n·q+r

[44]: # m = n * (m // n) + (m % n)

Un número complejo es de la forma:

x2 + 1 = 0

√
i := −1

a + bi
También los podemos pensar como puntos en el plano.

(a, b)

[46]: ### Numeros complejos:

# 3 + 5i
type(3 + 5j)

[46]: complex

[47]: (3 + 5j) * (4+ 7j)

[47]: (-23+41j)

[45]: ### Python es una buena herramienta para trabajar con números complejos.
### Se puede graficar un Mandelbrot con Python
complex_1 = 3 + 5j

Sequences
[52]: ### Tuples : Es una estructura de datos
my_tuple = (1, 4, 3, 5, 7)

[53]: print(my_tuple)

(1, 4, 3, 5, 7)

[54]: my_other_tuple = ("Hola", 1, 0.5, (1, 2, 4))

[55]: print(my_other_tuple)

('Hola', 1, 0.5, (1, 2, 4))

6
[58]: ### Concatenación de tuplas
(2, 3, 4) + (1, 2, 3)

[58]: (2, 3, 4, 1, 2, 3)

[59]: ### Las tuplas son estructuras no mutables.

## my_tuple = (1, 2, 3)

[60]: ## id(my_tuple)

[62]: my_list = [1, 2, "Hola"]

### Las listas son mutables
### Las tuplas no son mutables.
print(my_list)

[1, 2, 'Hola']

[70]: my_list = [2, 3, 6]

id(my_list)

[70]: 140356041917248

[71]: my_list.append(5)

[73]: my_list
id(my_list)

[73]: 140356041917248

[5]: my_tuple = (1, 2, 3, 6)

id(my_tuple)

[5]: 140226119003728

[76]: my_other_tuple = my_tuple + (5, )

id(my_other_tuple)

[76]: 140356719424672

[13]: ### Concatenación de Tuplas

concat = (1, 2, 3) + (2, 3, 4)

[14]: concat

[14]: (1, 2, 3, 2, 3, 4)

[77]: [1, 2, 3] + [2, 3, 4]

7
[77]: [1, 2, 3, 2, 3, 4]

[16]: my_list = [1, 2, 3]

[22]: ### Cuando queeremos hacer slicing deberemos escribir primero el índice del␣
,→primer

### elemento que queremos tomar y por última el índice del último elemento␣
,→elemento que

### aueremos tomar más 1 [1, 4)

my_tuple[1:4]

[22]: (2, 3, 4)

[8]: my_tuple[:]

[8]: (1, 2, 3, 6)

[78]: ### Strings

saludo = "Hola que tengas muy buen día"
saludo_2 = 'Hola, cómo te va'

[80]: print(saludo_2)

Hola, cómo te va

[88]: cadena_multilinea = """

Esto es un string
que tiene más de
una línea, sin mandar
ningún error.
"""

[89]: print(cadena_multilinea)

Esto es un string
que tiene más de
una línea, sin mandar
ningún error.

[85]: ### Cómo NO escribir cadenas multilínea

""
Esto no
puede ser un
string multilinea
""

8
 File "<ipython-input-85-85d5ad07d222>", line 3
Esto no
^
SyntaxError: invalid syntax

[86]: (1, 2, 5) + (7, 8, 9)

[86]: (1, 2, 5, 7, 8, 9)

[87]: [1, 2, 3] + [7, 8, 9]

[87]: [1, 2, 3, 7, 8, 9]

[93]: #"hola"+" como"+" te"+" llamas"

# "hola "+"como "+"te "+"llamas"
"hola"+" "+ "como"+" "+"te"+" "+"llamas"

[93]: 'hola como te llamas'

[30]: my_string = "Esto es una cadena de texto"

[5]: my_list = [1, 4, 6, 7]

[98]: ### Si quiero extraer el elemento en la posición k

### utilizo el índice k - 1
my_list[3]

[98]: 7

[99]: ### Hay que tener cuidado con que los índices no se salgan de rango
my_list[5]

---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-99-075ca585e721> in <module>
----> 1 my_list[5]

IndexError: list index out of range

[100]: (1, 2, "perro", 6.78)[2]

[100]: 'perro'

[75]: my_tuple = (1, 5, 7, 9 , 11, "p")

9
[76]: my_tuple[0]

[76]: 1

[78]: my_tuple[1]

[78]: 5

[101]: my_string = "Hola como te va"

[102]: my_string[0]

[102]: 'H'

[103]: my_string[4]

[103]: ' '

[106]: ### [a ,b)

### [0, 3) = [0, 2] (en los enteros)
my_string[0: 12]

[106]: 'Hola como te'

[108]: ### [a, infinito)

my_string = "Hola como te va"
my_string[4: ]

[108]: ' como te va'

[109]: ## (-infinito, a)
my_string = "Hola como te va"
my_string[: 4]

[109]: 'Hola'

[84]: ### [2, 5)

### Slicing: Extraer subsecuencias de una secuencia
my_string[2: 5]

[84]: 'la '

[85]: my_string[5:]

[85]: 'como te va hoy'

[86]: my_string[:5]

10
[86]: 'Hola '

[110]: my_list = [1, 3, 2, "p", 9]

[111]: my_list[1: 3]

[111]: [3, 2]

[121]: [my_list[3]] + my_list[3:]

[121]: ['p', 'p', 9]

[124]: ### No se puede concatenar enteros con listas.

reference = [my_list[0]] + my_list[3:]
print(reference)

[1, 'p', 9]
my_list[a:b] extramos los indices desde a hasta b-1

[116]: ## [0, 1) = [0]

my_list[0:1] + my_list[3:]

[116]: [1, 'p', 9]

[7]: ## Ejercicio:
### Dada una lista de longitud n.
### Extraer una sublista con los elementos en las posiciones impares
## my_list = [2, 3, 4, 5,7, 9,"p"]
## my_list = [2, 4, 7, "p"]

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

my_list[0:1] + my_list[2:3] + my_list[4:5] + my_list[6:7]

[7]: [1, 3, 5, 7]

[125]: len([1, 2, 3, 4])

[125]: 4

[94]: len((1, 2, 3, 4, 5, 6))

[94]: 6

[126]: len("Ya para cambiar de ejemplo")

[126]: 26

11
[96]: # nombre = input("¿Cuál es tu nombre?")

[97]: ### F-string: Una manera de formatear strings.

# print(f"Hola cómo estás {nombre}")

[127]: ### Los conjuntos son objetos NO ordenados.

my_set = {1, 2, 2, 3, 4}

[128]: my_set

[128]: {1, 2, 3, 4}

[129]: my_set = {1, 2, 3, 4, 4, 5}

[130]: my_set = {1, 2, "perro", 7.8}

[134]: my_set

[134]: {1, 2, 7.8, 'perro'}

[8]: my_set_2 = {1, 2, "Esto es un string", complex(1, 1)}

[137]: my_set_2.union({3, 4})

[137]: {(1+1j), 1, 2, 3, 4, 'Esto es un string'}

[138]: my_set_2.intersection({2, 3})

[138]: {2}

[9]: ### Los diccionarios son mutables, es decir, puedo modificar el objeto
### en memoria.
my_dict = {
"Nombre": ["Pedro", "Memo", "Jose", "Arturo"],
"Apellido": ["Lopez", "Perez", "Rios", "Hernandez"],
"Ciudad": ["Paris", "Madrid", "San Pablo", "Buenos Aires"]
}
### java script: lenguaje de progemación de alto nivel
### json : Java Script Object Notation.
### DataFrame: (Marco de Datos) una manera de almacenar datos.

[10]: print(my_dict)

{'Nombre': ['Pedro', 'Memo', 'Jose', 'Arturo'], 'Apellido': ['Lopez', 'Perez',

'Rios', 'Hernandez'], 'Ciudad': ['Paris', 'Madrid', 'San Pablo', 'Buenos
Aires']}

12
[12]: my_dict["Nombre"]

[12]: ['Pedro', 'Memo', 'Jose', 'Arturo']

[13]: my_dict["Apellido"]

[13]: ['Lopez', 'Perez', 'Rios', 'Hernandez']

[14]: my_dict["Ciudad"]

[14]: ['Paris', 'Madrid', 'San Pablo', 'Buenos Aires']

[15]: ### Método para obtener las claves de un diccionario

my_dict.keys()

[15]: dict_keys(['Nombre', 'Apellido', 'Ciudad'])

[16]: my_dict.items()

[16]: dict_items([('Nombre', ['Pedro', 'Memo', 'Jose', 'Arturo']), ('Apellido',

['Lopez', 'Perez', 'Rios', 'Hernandez']), ('Ciudad', ['Paris', 'Madrid', 'San
Pablo', 'Buenos Aires'])])

[124]: nombre = my_dict["Nombre"][1]

apellido = my_dict["Apellido"][1]
ciudad = my_dict["Ciudad"][1]

[128]: nombre = "Felipe"

apellido = "Lopez"
ciudad = "Paris"
n = 100

[130]: ### Formateo de strings.

## f-strings
my_string = f"Registro {n}: {nombre} {apellido} vive en {ciudad}"

[131]: print(my_string)

Registro 100: Felipe Lopez vive en Paris

[20]: ## Operaciones I/O: Input-Output

### Observación: Lo que le pedimos al usuario se almacena como un tipo string.
nombre = input("Hola, Cómo te llamas? ")
print(f"Hola {nombre}, cómo te va?")

Hola, Cómo te llamas? Pedro

Hola Pedro, cómo te va?

13
 1.3 2. Control de Flujo
1.3.1 2.1 Condicionales
[24]: a = -10
if a > 0:
print("El número es positivo")
else:
print("El número es negativo o cero")

El número es negativo o cero

[32]: ### La función input almacena el objeto ingresado como un String

a = input("Ingresa el número que quieres verificar:")

### Casting: Cambiar el tipo de dato de un objeto.

a = int(a)

if a > 0:
print("El número es positivo")
else:
print("El número es no positivo")

Ingresa el número que quieres verificar:32

El número es positivo

[34]: a = input("Ingresa el número que quieres verificar: ")

### necesitamos transformar el string a un entero para este caso.
### A la transformación de tipos de datos le llamamos casting.
a = int(a)

if a > 0:
print("El número es mayor positivo.")
elif a == 0:
print("El número es cero")
else:
print("El número es negativo")

Ingresa el número que quieres verificar:-5

El número es negativo

[37]: day = int(input("En qué día del mes nos encontramos?"))

if day >= 1 and day <= 7:

week = 1
elif day >= 8 and day <= 16:
week = 2
elif day >= 17 and day <= 25:

14
 week = 3
else:
week = 4

print(f"Estamos en la semana {week} del mes")

En qué día del mes nos encontramos?54

Estamos en la semana 4 del mes

[39]: number = int(input("Ingrese un número por favor..."))

### Sintacis: var = value_1 if (condición) else value_2

signo = "positvo" if number > 0 else "no positivo"

print(f"El número ingresado es {signo}")

Ingrese un número por favor…0

El número ingresado es no positivo

1.3.2 2.2 Bucles

[43]: ### El range es abierto, en el sentido de que no considera el límite superior
### range(a, b) ---> [a, b) interseccion con Z
### [0, 10) = [0, 9]
for i in range(0, 15):
print(i)

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

[44]: n = int(input("Hasta qué número quieres imprimir "))

## [1, n+1) intersección con los enteros == [1, n] intersección con los enteros
## Los for se aplican para cualquier objeto Iterable
## [1, n+1) = [1, n] en los enteros

15
## Python
for i in range(1, n + 1):
print(i)

Hasta qué número quieres imprimir 45

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

16
 43
44
45

[46]: ## Un objeto es iterable si lo puedo recorrer uno a uno (coloquialmente)

for i in [1, 2, "p", (1, 2, 3), [1, 2, 5], 6, 7]:
print(i)

1
2
p
(1, 2, 3)
[1, 2, 5]
6
7

[48]: ### todo sequence en Python es iterable.

for i in "Hola como te va el día de hoy":
print(i)

H
o
l
a

c
o
m
o

t
e

v
a

e
l

d
í
a

d
e

h
o

17
 y

[49]: ### Los sequences son iterables.

### Es decir, puedo "moverme" individualmente
### por cada uno de los elementos.
for i in (1, 2, [1, 2, 3, 4], "Esto es un string"):
print(i)

1
2
[1, 2, 3, 4]
Esto es un string

[53]: ### Queremos extraer los elementos en

### posiciones impares de la lista.
### indices = [0, 1, 2, 3, 4, 5, 6, 7, 8]
my_list = ["p", 1, 2, "Hola", 3.4, -500]
impares = []

# [0, len(my_list) - 1]
for i in range(0, len(my_list)):
if i % 2 == 0:
impares.append(my_list[i])

[54]: impares

[54]: ['p', 2, 3.4]

k = 2n
k = 2n + 1
Para identificar si un número es par o no podemos dividirlo por 2 y verificar el residuo.
n/m
n = m*q + r
%
[47]: ### Ejercicio: De los primeros n números naturales imprimir solamente los pares.
n = input("Algo")

for i in range(1, n + 1):

if i es par:
lo imprimo.

HAsta qué número quieres considerar los números pares?70

2

18
 4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50
52
54
56
58
60
62
64
66
68

[56]: lim_sup = int(input("Hasta qué número natural quieres imprimir"))

i = 1
while i <= lim_sup:
print(i)
i = i + 1

Hasta qué número natural quieres imprimir20

1
2
3
4
5
6

19
 7
8
9
10
11
12
13
14
15
16
17
18
19
20

[ ]: ## Ejercicio: De los primeros n números naturales imprimir solamente los pares.

n = input("Algo")
i = 1

while i <= n:
if i es par:
print(i)
### Falta decir como se mueve la i.

1.4 Funciones
f (x)

[59]: ### Docstring: Documentación de un bloque de código.

def hola_mundo():
print("Hola mundo!!")
print("otra cosa")

[65]: ### Los callables para ser invocados necesitar llevar paréntesis
hola_mundo()

Hola mundo!!
otra cosa

[67]: ## Docstring: Documentación de un bloque de código.

def saludar(nombre):
"""
Función que imprime un saludo para un nombre dado
"""
print(f"Hola {nombre}, cómo te va?")

[70]: saludar("Damián")

20
 Hola Damián, cómo te va?

[7]: ### Las funciones son callables

### Para llamarlas necesitamos poner los paréntesis
### Con los argumentos necesarios
hola_mundo()

Hola mundo!!

[72]: saludar()

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-72-67e92cc24e58> in <module>
----> 1 saludar()

TypeError: saludar() missing 1 required positional argument: 'nombre'

[85]: def cuadrado(x):

"""
Calcula el cuadrado de un número.
"""
return x ** 2

[86]: cuad = cuadrado(75)

[87]: print(cuad)

5625

[112]: def fibonacci(n):

"""
Función que regresa una lista con los primeros
n términos de la sucesión de fibomacci.
"""

fib = [1, 1]

## Nos faltan n-2 términos

for i in range(2, n):
fib_i = fib[i-1] + fib[i-2]
fib.append(fib_i)

return fib

[98]: fibonacci_2 = [1, 2, 3, 4, 5]

fibonacci_2[4]

21
[98]: 5

[113]: a = fibonacci(10)

[114]: print(a)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

[ ]:

22