Primera Sesión Fundamentos de Python

February 27, 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.
[7]: a = 2540
b = 2545
c = 2540

[3]: print(a)

2540

[8]: a == c

[8]: True

[10]: a is c

[10]: 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 (donde 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

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

id(my_tuple)

[75]: 140356719427312

[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)

[23]: my_tuple[:4]

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

[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"

[94]: 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]

[92]: ## 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"]

[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

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

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

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

11
[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'}

[136]: 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}

[114]: ### Los diccionarios son mutables, es decir, puedo modificar el objeto
### en memoria.
my_dict = {
"Nombre": ["Pedro", "Memo"],
"Apellido": ["Suarez", "Perez"],
"Ciudad": ["CD de Mexico", "Madrid"],
"Teléfono": ["5543678790", "445566778899"]
}
### java script: lenguaje de progemación de alto nivel
### json : Java Script Object Notation.
### DataFrame: (Marco de Datos) una manera de almacenar datos.

[115]: print(my_dict)

{'Nombre': ['Pedro', 'Memo'], 'Apellido': ['Suarez', 'Perez'], 'Ciudad': ['CD de

Mexico', 'Madrid'], 'Teléfono': ['5543678790', '445566778899']}

[116]: my_dict["Nombre"]

[116]: ['Pedro', 'Memo']

[117]: my_dict["Apellido"]

12
[117]: ['Suarez', 'Perez']

[118]: my_dict["Ciudad"]

[118]: ['CD de Mexico', 'Madrid']

[120]: my_dict.keys()

[120]: dict_keys(['Nombre', 'Apellido', 'Ciudad', 'Teléfono'])

[121]: my_dict.items()

[121]: dict_items([('Nombre', ['Pedro', 'Memo']), ('Apellido', ['Suarez', 'Perez']),

('Ciudad', ['CD de Mexico', 'Madrid']), ('Teléfono', ['5543678790',
'445566778899'])])

[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

[145]: ## Logging
## Operaciones I/O: Input-Output
### Lo que le pedimos al usuario se almacena como un tipo string.
nombre = input("Hola, Cómo te llamas? ")
print(f"Bienvenido {nombre}!")

Hola, Cómo te llamas? Daniel

Bienvenido Daniel!

[ ]: my_list.append(5)

my_list
id(my_list)

13
my_tuple = (1, 2, 3, 6)
id(my_tuple)

my_other_tuple = my_tuple + (5, )

id(my_other_tuple)

### Concatenación de Tuplas

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

concat

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

my_list = [1, 2, 3]

### 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]

my_tuple[:4]

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

print(saludo_2)

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

print(cadena_multilinea)

### Cómo NO escribir cadenas multilínea

""
Esto no
puede ser un
string multilinea
""

(1, 2, 5) + (7, 8, 9)

14
[1, 2, 3] + [7, 8, 9]

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

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

my_string = "Esto es una cadena de texto"

my_list = [1, 4, 6, 7]

### Si quiero extraer el elemento en la posición k

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

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

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

my_tuple = (1, 5, 7, 9 , 11, "p")

my_tuple[0]

my_tuple[1]

my_string = "Hola como te va"

my_string[0]

my_string[4]

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

### [a, infinito)

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

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

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

15
my_string[5:]

my_string[:5]

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

my_list[1: 3]

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

### No se puede concatenar enteros con listas.

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

my_list[a:b] extramos los indices desde a hasta b-1

## [0, 1) = [0]
my_list[0:1] + my_list[3:]

## 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"]

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

len((1, 2, 3, 4, 5, 6))

len("Ya para cambiar de ejemplo")

# nombre = input("¿Cuál es tu nombre?")

### F-string: Una manera de formatear strings.

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

### Los conjuntos son objetos NO ordenados.

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

my_set

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

my_set = {1, 2, "perro", 7.8}

my_set

16
my_set_2 = {1, 2, "Esto es un string", complex(1, 1)}

my_set_2.union({3, 4})

my_set_2.intersection({2, 3})

### Los diccionarios son mutables, es decir, puedo modificar el objeto

### en memoria.
my_dict = {
"Nombre": ["Pedro", "Memo"],
"Apellido": ["Suarez", "Perez"],
"Ciudad": ["CD de Mexico", "Madrid"],
"Teléfono": ["5543678790", "445566778899"]
}
### java script: lenguaje de progemación de alto nivel
### json : Java Script Object Notation.
### DataFrame: (Marco de Datos) una manera de almacenar datos.

print(my_dict)

my_dict["Nombre"]

my_dict["Apellido"]

my_dict["Ciudad"]

my_dict.keys()

my_dict.items()

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

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

### Formateo de strings.

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

print(my_string)

## Logging

17
## Operaciones I/O: Input-Output
### Lo que le pedimos al usuario se almacena como un tipo string.
nombre = input("Hola, Cómo te llamas? ")
print(f"Bienvenido {nombre}!")

18