PythonJupyter - Jupyter Notebook [Link]

ipynb

Introducción a la programación con Python y

Jupyter Notebooks

Previas
• Antes de comenzar, explore la interfaz ofrecida por Jupyter Notebook en "Help, User
Interface Tour". Observe que en dicho menú puede encontrar otras ayudas disponibles.
• Los Notebooks de Jupyter permiten desarrollar código con formatos de salida. Requiere
que se ejecute sobre un servidor de notebook IPython.
• Los archivos de programas de Python tienen extesión " .py ", por ejemplo, el archivo
" [Link] " estaría compuesto por sentencias Python organizadas por cada linea.
• Los comentarios en el código comienzan con # y el interprete ignora estas lineas.

Para evaluar una celda con código (como la siguiente), haga click en la celda y presione
" Shift + Enter "

In [1]: 1 a = 3 # Se asigna un valor a la variable "a"

2 b = 4 # Se asigna un valor a la variable "b"
3 a*b # Opera con "a" y "b"

Out[1]: 12

Variables
In [2]: 1 b

Out[2]: 4

Nombres

Pueden contener letras sin incluir " ñ " o " Ñ ", en minúscula ( a-z ), en mayúscula ( A-Z ),
números ( 0-9 ) y el caracter especial " _ ".

Deben comenzar con una letra.

Palabras prohibidas

Las siguientes palabras son prohibidas para nombrar, pues Python las usa como instrucciones:

and as assert break class continue

1 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

def elif else except exec finally

for global if import in is

lambda not or pass print raise

return try while with yield del

from

In [3]: 1 # uso de print

2 print('Hola a todos' +' ' + 'y todas')

Hola a todos y todas

Asignaciones y tipos de variable

Al asignar un valor a una variable usando el símbolo = se crea esa variable:

In [4]: 1 # Asignación de un entero

2 x1 = 2
3 print(x1)

In [5]: 1 # type Verifica el tipo de variable

2 print(type(x1))

<class 'int'>

In [6]: 1 # Asignación de un real

2 x2 = 5.0
3 print(x2,type(x2))

5.0 <class 'float'>

In [7]: 1 # Asignación de un string

2 x3 = "cinco"
3 print(x3," ",type(x3))

cinco <class 'str'>

In [8]: 1 # Reasignación de una variable

2 x1 = 0.5
3 print("Ahora x1 tiene el valor " + str(x1) + " y ha cambiado el tipo a ",

Ahora x1 tiene el valor 0.5 y ha cambiado el tipo a <class 'float'>

2 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [9]: 1 # Asignación de un booleano

2 bT = True
3 bF = False
4 print(" bT = ", bT,type(bT),"\n","bF = ", bF,type(bF))

bT = True <class 'bool'>

bF = False <class 'bool'>

In [10]: 1 # Asignación de un complejo

2 x4 = 4.0 + 3.3j
3 print(x4," ",type(x4))

(4+3.3j) <class 'complex'>

In [11]: 1 x1 = 2
2 float(x1)

Out[11]: 2.0

Un número complejo no puede ser convertido a un número flotante o a un entero. Necesitamos

usar [Link] , o bien [Link] , para extraer la parte que deseamos del número complejo z:

Operadores aritméticos, relacionales y booleanos

Símbolo Operación Ejemplo

+ Suma 2+3

- Resta 3-6.7

* Multiplicación 4*5.5

/ División 3/2

// División entera 3//2

** Potencia 5**2

== Comparación de igualdad 4==2

> Comparación de mayor 4>2

>= Comparación de mayor o igual 4>=2

< Comparación de menor 4<2

<= Comparación de menor o igual 4<=2

not Negación booleana not False

or O booleana True or False

and Y booleana True and False

Tipos compuestos

3 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

Strings
In [12]: 1 s = "Hola mundo :)"
2 print(type(s))

<class 'str'>

In [13]: 1 # longitud
2 len(s)

Out[13]: 13

In [14]: 1 s = [Link]('mundo','Medellin')

In [15]: 1 s

Out[15]: 'Hola Medellin :)'

In [16]: 1 # reemplaza una parte

2 s2 = [Link]("mundo", "universo")
3 print(s2)
4 print(s)
5

Hola Medellin :)
Hola Medellin :)

Indexación

4 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [17]: 1 # indexación a posiciones dentro del string mediante []

2 print(s) # El string completo
3 print(s[0]) # La posición 0 (la primera)
4 print(s[0:3]) # Desde la pisición 0 hasta la posición antes de la 3
5 print(s[2:7]) # Desde la pisición 2 hasta la posición antes de la 7
6 print(s[:7]) # Todo hasta la posición antes de la 7
7 print(s[7:]) # Desde la posición 7 hasta el final
8 print(s[1:-1]) # Desde la posición 1 hasta 1 antes del final
9 print(s[Link]) # Desde la posición 1 hasta la posición 8 cada 2
10 print(s[0::2]) # Desde la posición 0 hasta la posición final cada 2
11

Hola Medellin :)
H
Hol
la Me
Hola Me
dellin :)
ola Medellin :
oaMd
Hl eeln:

Listas
Son listas de elementos que pueden ser diferente tipo y pueden ser indexados.

La sintaxis para crear listas en Python es [elemento 0, elemento 1, ...] :

In [18]: 1 lista1 = [5,8,2,9]

2
3
4 print(lista1,type(lista1))
5 print(lista1[0])
6 print(lista1[0:2])
7 print(lista1[3]) # la posición 5 no existe

[5, 8, 2, 9] <class 'list'>

5
[5, 8]
9

5 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [19]: 1 lista2 = [3, 'dos', "432", 2-3j, [3.14], lista1, [3,2,5,'a']]

2
3 print(lista2,type(lista2))
4 print(lista2[0])
5 print(lista2[0:2])
6 print(lista2[1][2])
7 print(lista2[5])
8 print(lista2[6])
9

[3, 'dos', '432', (2-3j), [3.14], [5, 8, 2, 9], [3, 2, 5, 'a']] <class 'list'
>
3
[3, 'dos']
s
[5, 8, 2, 9]
[3, 2, 5, 'a']

In [20]: 1 print(lista2)
2 print(lista2[4])

[3, 'dos', '432', (2-3j), [3.14], [5, 8, 2, 9], [3, 2, 5, 'a']]

[3.14]

In [21]: 1 type(lista2)

Out[21]: list

• Las listas juegan un rol primordial en Python y son, por ejemplo, usadas en bucles y otras
estructuras de control de flujo.
• Existen funciones convenientes para generar listas de varios tipos, por ejemplo la función
range :

6 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [22]: 1 desde = 10
2 hasta = 36
3 paso = 5
4
5 lista3 = range(desde, hasta, paso)
6 print(lista3,type(lista3))
7 print()
8 print(len(lista3))
9 print()
10 print(lista3[0])
11 print(lista3[1])
12 print(lista3[2])
13 print(lista3[3])
14 print(lista3[4])
15 print(lista3[5])
16 print(lista3[6])

range(10, 36, 5) <class 'range'>

10
15
20
25
30
35

---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
Input In [22], in <cell line: 16>()
14 print(lista3[4])
15 print(lista3[5])
---> 16 print(lista3[6])

IndexError: range object index out of range

In [ ]: 1 print([lista1[1],lista1[0],lista1[2]])
2 print(lista1)

In [23]: 1 print(list(range(desde, hasta, paso)),type(list(range(desde, hasta, paso))))

[10, 15, 20, 25, 30, 35] <class 'list'>

In [24]: 1 list(range(-10, 10))

Out[24]: [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• La instrucción list puede convertir un elemento tipo str a uno tipo list .

7 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [25]: 1 texto1 = "Hola Mundo"

2 print(texto1,type(texto1))
3 texto2 = list(texto1)
4 print(texto2,type(texto2))
5

Hola Mundo <class 'str'>

['H', 'o', 'l', 'a', ' ', 'M', 'u', 'n', 'd', 'o'] <class 'list'>

• Las listas pueden ordenarse

In [26]: 1 [Link]()# Observe que a la lista texto2 se le aplica el método sort() y lo a

2 print(texto2)

[' ', 'H', 'M', 'a', 'd', 'l', 'n', 'o', 'o', 'u']

In [ ]: 1

Agregando, insertando, modificando, y removiendo elementos de listas

In [27]: 1 # crea una nueva lista vacía

2 lista4 = []
3 lista4

Out[27]: []

In [28]: 1 [Link]('i')
2 lista4

Out[28]: ['i']

In [29]: 1
2
3 # agrega un elemento a la lista, usando `append`
4 [Link]("R")
5 [Link]("a")
6 [Link]("n")
7 [Link]("a")
8
9 print(lista4)

['i', 'R', 'a', 'n', 'a']

Puede modificarse algunos elementos de la lista.

In [30]: 1 lista4[2] = "m"

2
3 print(lista4)

['i', 'R', 'm', 'n', 'a']

8 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [31]: 1 lista4[Link] = ["C", "s"] # los elementos desde 0 hasta 3 cada 2, [0 y 2], se ca
2
3 print(lista4)

['C', 'R', 's', 'n', 'a']

Insertar un elemento en una posición específica insert

In [32]: 1 [Link](0, "L")

2
3 print(lista4)

['L', 'C', 'R', 's', 'n', 'a']

In [33]: 1 [Link](1, "a")

2 print(lista4)
3

['L', 'a', 'C', 'R', 's', 'n', 'a']

In [34]: 1 [Link](2, " ")

2 print(lista4)
3

['L', 'a', ' ', 'C', 'R', 's', 'n', 'a']

Eliminar el primer elemento con un valor específico usando 'remove'

In [35]: 1 help([Link])

Help on method_descriptor:

remove(self, value, /)
Remove first occurrence of value.

Raises ValueError if the value is not present.

In [36]: 1 [Link]("a")
2
3 print(lista4)

['L', ' ', 'C', 'R', 's', 'n', 'a']

Eliminar un elemento en una posición específica usando del :

In [37]: 1 del lista4[3]

2 print(lista4)

['L', ' ', 'C', 's', 'n', 'a']

Puede introducir help(list) para más detalles, o leer la documentación en la red

9 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

Tuplas
Tuplas son similares a las listas, excepto que no pueden ser modificadas una vez creadas, es
decir, son inmutables.

En Python, las tuplas son creadas usando la sintaxis (elemento1, elemento2,

elemento3, ...) , o incluso elemento1, elemento2, elemento3, ... .

In [38]: 1 punto = (10, 20)

2
3 print(punto, type(punto))

(10, 20) <class 'tuple'>

In [39]: 1 punto = 10, 20

2
3 print(punto, type(punto))

(10, 20) <class 'tuple'>

Se puede separar una tupla asignándola a una lista de variables separadas por coma:

In [40]: 1 x, y = punto
2
3 print("x =", x,type(x))
4 print("y =", y,type(y))

x = 10 <class 'int'>
y = 20 <class 'int'>

Tratar de asignar un nuevo valor a un elemento de una tupla genera un error:

In [41]: 1 punto[1] = 3
2 # punto(0) = 54

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [41], in <cell line: 1>()
----> 1 punto[1] = 3

TypeError: 'tuple' object does not support item assignment

Diccionarios
Los diccionarios son listas más amplias en las que cada elemento se define por un par clave-
valor. La sintaxis de los diccionarios es {clave1 : valor1, ...} :

10 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [42]: 1 parametros = {"clave1" : 1.0,

2 "clave2" : True,
3 "clave3" : "hola",
4 1 : "algo",
5 2 : lista1}
6
7 print(type(parametros))
8 print(parametros)

<class 'dict'>
{'clave1': 1.0, 'clave2': True, 'clave3': 'hola', 1: 'algo', 2: [5, 8, 2, 9]}

In [43]: 1 parametros["clave1"]

Out[43]: 1.0

In [44]: 1 parametros[1]

Out[44]: 'algo'

In [45]: 1 print("clave1 --> " + str(parametros["clave1"]))

2 print("clave2 --> " + str(parametros["clave2"]))
3 print("clave3 --> " + str(parametros["clave3"]))

clave1 --> 1.0

clave2 --> True
clave3 --> hola

In [46]: 1 parametros["clave1"] = "A"

2 parametros["clave2"] = (4<2)
3
4 # agrega una nueva entrada
5 parametros["clave4"] = "D"
6
7 print("clave1 = " + str(parametros["clave1"]))
8 print("clave2 = " + str(parametros["clave2"]))
9 print("clave3 = " + str(parametros["clave3"]))
10 print("clave4 = " + str(parametros["clave4"]))
11 print(parametros)

clave1 = A
clave2 = False
clave3 = hola
clave4 = D
{'clave1': 'A', 'clave2': False, 'clave3': 'hola', 1: 'algo', 2: [5, 8, 2,
9], 'clave4': 'D'}

Control de flujo

Condicionales: if, elif, else

La sintaxis Python para la ejecución condicional de código usa las palabras clave if , elif

11 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

(else if), else :

• Los bloques del programa se definen por el símbolo " : " y su indentación (los espacios
antes de cada linea).

In [47]: 1 afirmacion1 = True

2 afirmacion2 = False
3 a = 0
4 if afirmacion1 and afirmacion2:
5 # Comprueba la afirmacion1
6 print("afirmacion1 es verdadera")
7 # La tarea si la afirmacion1 es verdadera
8 a = 2
9 elif afirmacion2:
10 # Si la prueba de if es falsa, comprueba la afirmacion2
11 print("afirmacion2 es verdadera")
12 # Tarea si se cumple la condición anterior
13 a = 5
14 else:
15 print("afirmacion1 o afirmacion2 son falsas")
16 # Tarea si jo se cumple la condición anterior
17 a = 10
18 print(a)

afirmacion1 o afirmacion2 son falsas

10

In [48]: 1 se= input("digite su peso:")

2 type(se)

digite su peso:

Out[48]: str

12 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [49]: 1 peso = float(input("digite su peso:"))

2 estatura = float(input("digite su estatura:"))
3 print(type(peso))
4
5 IMC = peso / (estatura**2)
6 if IMC<18.5:
7 print("bajo peso")
8 elif IMC < 24.9:
9 print("peso normal")
10 else:
11 print("sobre peso")
12
13 print("Hecho")

digite su peso:

---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Input In [49], in <cell line: 1>()
----> 1 peso = float(input("digite su peso:"))
2 estatura = float(input("digite su estatura:"))
3 print(type(peso))

ValueError: could not convert string to float: ''

In [50]: 1 afirmacion1 = False

2 afirmacion2 = True
3
4 if afirmacion1:
5 if afirmacion2:
6 print("tanto afirmacion1 como afirmacion2 son verdaderas")
7 print("final")

final

In [51]: 1 # Mala indentación!

2 if afirmacion1:
3 if afirmacion2:
4 print("¿qué pasó con las afirmaciones?") # esta línea está mal indentada
5 # observe que no se sabe qué hacer si afirmacion1 es verdadero

Input In [51]
print("¿qué pasó con las afirmaciones?") # esta línea está mal indentada

^
IndentationError: expected an indented block after 'if' statement on line 3

13 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [52]: 1 afirmacion1 = True

2
3 if afirmacion1:
4 print("afirmacion1 es verdadera")
5
6 print("aun estamos dentro del bloque if")

afirmacion1 es verdadera
aun estamos dentro del bloque if

In [53]: 1 if afirmacion1:
2 print("afirmacion1 es verdadera")
3
4 print("ahora estamos fuera del bloque")

afirmacion1 es verdadera
ahora estamos fuera del bloque

Ciclos

For
• Itera sobre los elementos de la lista, o algún tipo iterable, suministrada y ejecuta el bloque
de programa una vez para cada elemento.
• Cualquier tipo de lista puede ser usada para un ciclo for . Por ejemplo:

In [54]: 1 for x in [1,2,3]:

2 print(x)

1
2
3

In [55]: 1 for x in range(15): # por defecto range comienza con 0

2 print(x)

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

14 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [56]: 1 for x in range(-3,3):

2 print(x)

-3
-2
-1
0
1
2

In [57]: 1 for palabra in ["Python", "para", "programar", 5]:

2 print(palabra)

Python
para
programar
5

In [58]: 1 parametros

Out[58]: {'clave1': 'A',

'clave2': False,
'clave3': 'hola',
1: 'algo',
2: [5, 8, 2, 9],
'clave4': 'D'}

In [59]: 1 str("s")

Out[59]: 's'

In [60]: 1 for clave, valor in [Link]():

2 print(str(clave), " = " + str(valor))

clave1 = A
clave2 = False
clave3 = hola
1 = algo
2 = [5, 8, 2, 9]
clave4 = D

In [61]: 1 texto1

Out[61]: 'Hola Mundo'

15 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [62]: 1 for letra in texto1:

2 print(letra)

H
o
l
a

M
u
n
d
o

Si se requiere conocer los índices de los valores mientras se itera sobre una lista se usa la
función enumerate :

In [63]: 1 for idx, x in enumerate(range(-3,3)):

2 print(idx, x)

0 -3
1 -2
2 -1
3 0
4 1
5 2

In [64]: 1 for idx, x in enumerate(texto1):

2 print(idx, x)

0 H
1 o
2 l
3 a
4
5 M
6 u
7 n
8 d
9 o

Una forma conveniente y compacta de inicializar una lista es:

In [65]: 1 lista_cuadrados = [x**2 for x in range(0,5)]

2
3 print(lista_cuadrados)

[0, 1, 4, 9, 16]

While
• Itera siempre que se cumpla una condición y ejecuta el bloque de programa una vez para

16 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

cada elemento.

Por ejemplo:

In [66]: 1 i = 0 # inicializa el valor i en 0

2
3 while i < 3: # ejecuta el bloque siempre que se cumpla la condición
4 print(i) # imprime en pantalla el valor de i
5 i = i + 0.1 # actualiza el valor de i
6
7 print("terminó el ciclo") # esta fuera del ciclo

0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
1.2
1.3
1.4000000000000001
1.5000000000000002
1.6000000000000003
1.7000000000000004
1.8000000000000005
1.9000000000000006
2.0000000000000004
2.1000000000000005
2.2000000000000006
2.3000000000000007
2.400000000000001
2.500000000000001
2.600000000000001
2.700000000000001
2.800000000000001
2.9000000000000012
terminó el ciclo

Funciones definidas por el programador

• Una función se define con la palabra clave def , el nombre de la función y las argumentos
de entrada.
• La sintaxis para definir la función func0 es def func0(arg1,arg2,arg3,...):
• Puede ser que las funciones no tengan variables de entrada.

17 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [67]: 1 def func0(): # los : terminan de definir la función

2 print("test") # el bloque indentado es el código de la función

In [68]: 1 func0()

test

Se pueden incluir textos de ayuda para las funciones con """ la ayuda en varias lineas
"""

In [69]: 1 def func1(s):

2 """
3 Imprime el string 's' y cuántos caracteres tiene
4 sigue siendo texto
5 """
6
7 print(s + " tiene " + str(len(s)) + " caracteres")

In [70]: 1 help(func1)

Help on function func1 in module __main__:

func1(s)
Imprime el string 's' y cuántos caracteres tiene
sigue siendo texto

In [71]: 1 func1("testimonio con todo")

testimonio con todo tiene 19 caracteres

Para que las funciones entreguen un resultado se usa la palabra clave return :

In [72]: 1 def cuadrado(x):

2 """
3 Calcula el cuadrado de x.
4 """
5 Y = x**2
6 return Y

In [73]: 1 a = cuadrado(1+3j)
2 print(a)

(-8+6j)

18 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [74]: 1 help(cuadrado)

Help on function cuadrado in module __main__:

cuadrado(x)
Calcula el cuadrado de x.

In [75]: 1 def potencias(x):

2 """
3 Calcula algunas potencias de x.
4 """
5 return x**2, x**3, x**4

In [76]: 1 potencias(3)

Out[76]: (9, 27, 81)

In [77]: 1 x2, x3, x4 = potencias(3)

2
3 print(x3)

27

Argumentos por defecto y argumentos de palabra clave

En la definición de una función pueden incluirse valores por defecto a los argumentos de la
función:

In [78]: 1 def mifunc(x, p=2, debug=False): # la función tiene 3 argumentos de entrada

2 if debug:
3 print("evaluando mifunc para x = " + str(x) + " usando el exponente p = "
4 return x**p

In [79]: 1 mifunc(3) # solamente se entrega el primer argumento a la func

Out[79]: 9

In [80]: 1 mifunc(3, 4) # se entregan los dos primeros argumentos a la funci

Out[80]: 81

In [81]: 1 mifunc(x = 3, p = 4) # se especifica el nombre interno de las variables

Out[81]: 81

In [82]: 1 mifunc(p = 4, x = 3) # se especifica el nombre interno de las variables.

2 #Note que de esta forma el orden no es relevante

Out[82]: 81

19 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

In [83]: 1 mifunc(p=3, debug=True, x=7)

evaluando mifunc para x = 7 usando el exponente p = 3

Out[83]: 343

Help
La función help ofrece una descripción de la mayoría de funciones y módulos.

In [84]: 1 help(print)

Help on built-in function print in module builtins:

print(...)
print(value, ..., sep=' ', end='\n', file=[Link], flush=False)

Prints the values to a stream, or to [Link] by default.

Optional keyword arguments:
file: a file-like object (stream); defaults to the current [Link].
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

También usar la función help directamente sobre los módulos:

help(numpy)

Algunos módulos muy útiles son:

• os (interfaz con el sistema operativo)

• sys (Parámetros y funciones específicas del sistema)
• math (funciones matemáticas)
• shutil (operaciones con archivos)
• Numpy ([Link] Uso eficiente de arreglos numéricos multidimensionales
(vectores, matrices, etc.).
• Scipy ([Link] Funciones especiales, algoritmos de integración numérica,
optimización, interpolación, transformada de Fourier, procesamiento de señales, álgebra
lineal, estadística, procesamiento de imágenes, entre otras. Este módulo hace uso de
Numpy.
• Matplotlib ([Link] Herramientas para crear gráficos bidimensionales en
diversos formatos, y en una calidad adecuada para incluirlos en publicaciones científicas.
• Sympy ([Link] de matemática simbólica.

ETC

Lectura adicional

20 de 21 18/06/2023, 3:27 a. m.
PythonJupyter - Jupyter Notebook [Link]

• [Link] ([Link] - The official web page of the Python

programming language.
• [Link] ([Link] -
Guía de estilo para la programación en Python. Altamente recomendada (en inglés).
• [Link] ([Link] -
Un libro gratuito sobre Python.
• Python Essential Reference ([Link]
Edition/dp/0672329786) - Un buen libro de referencia sobre programación en Python.

Versiones

In [85]: 1 import sys

2 import IPython

In [86]: 1 print("Este notebook fue evaluado con: Python %s y IPython %s." % ([Link]

Este notebook fue evaluado con: Python 3.10.9 | packaged by conda-forge | (ma
in, Jan 11 2023, [Link]) [MSC v.1916 64 bit (AMD64)] y IPython 8.3.0.

In [87]: 1 nombres = ['pepe','chepe','pepa','chepa']

2 edades = [24,27,41,17]
3 dic = {'Nombres' : nombres}
4 for i,n in enumerate(dic['Nombres']):
5 print(i)
6 print(n)
7 print(edades[i])

0
pepe
24
1
chepe
27
2
pepa
41
3
chepa
17

21 de 21 18/06/2023, 3:27 a. m.