Python

Fundamentos de Python 1
Fundamentos de Python 1: Introducción a Python y a la Programación Informática

En este curso aprenderás:

 Los conceptos universales de la programación informática;
 La sintaxis y la semántica del lenguaje Python;
 Habilidades prácticas para resolver desafíos típicos de implementación;
 Cómo utilizar los elementos más importantes de la biblioteca estándar de
Python;
 Cómo instalar tu entorno de ejecución;
 Cómo diseñar, desarrollar, probar y depurar programas simples de Python.

El curso se divide en cuatro módulos:

1. Módulo 1
Introducción a Python y programación informática;

2. Módulo 2
Tipos de datos, variables, operaciones básicas de entrada-salida y operadores básicos;

3. Módulo 3
Valores booleanos, ejecución condicional, bucles, listas y procesamiento de listas,
operaciones lógicas y bit a bit;

4. Módulo 4
Funciones, tuplas, diccionarios, excepciones y procesamiento de datos.

¿Qué compone a un lenguaje?

Podemos decir que cada lenguaje (máquina o natural, no importa) consta de los siguientes
elementos:

 Un alfabeto

 Un léxico:

En programación, el léxico se refiere al conjunto de palabras o símbolos que se utilizan en un

lenguaje de programación para construir programas. El léxico incluye palabras clave, como "if",
"else", "while", "for", "class", "def", entre otras, que tienen un significado especial y son
reservadas para propósitos específicos en el lenguaje.
  Una sintaxis:

La sintaxis se refiere a las reglas que rigen la estructura y la composición de los

programas en un lenguaje de programación. La sintaxis define cómo se deben escribir
las instrucciones de programación para que sean válidas y legibles por la computadora.

 Una semántica:

La semántica se refiere al significado de las instrucciones de un programa y cómo se

relacionan con el mundo real. La semántica describe lo que hace un programa y cómo
afecta al sistema en el que se ejecuta. La semántica también se refiere a cómo las
instrucciones interactúan entre sí.

Nota 1:

Un programa escrito en un lenguaje de programación de alto nivel se denomina código

fuente (en contraste con el código máquina ejecutado por las computadoras). Del mismo
modo, el archivo que contiene el código fuente se denomina archivo fuente.

Nota 2:

Compilacion : Compilar en programación se refiere al proceso de traducir un código fuente

escrito en un lenguaje de programación en código ejecutable por una computadora. El
compilador es un programa que realiza esta tarea y produce un archivo ejecutable que se
puede utilizar en una computadora.

VS

Interpretación: La interpretación en programación es un método de ejecución de

código fuente en el cual un programa llamado intérprete analiza y ejecuta las
instrucciones del código fuente línea por línea, en tiempo real, sin la necesidad de
compilar el código previamente.
PosDta:

En algunos lenguajes de programación, como Python o JavaScript, el código no se compila en

un archivo ejecutable, sino que se interpreta en tiempo real por un intérprete. En estos casos, el
intérprete realiza la tarea de traducir el código a medida que se ejecuta en lugar de compilarlo
de antemano.
Palabras Clave

Observa las palabras que juegan un papel muy importante en cada programa de Python.

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else',
'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Son llamadas palabras clave o (mejor dicho) palabras clave reservadas. Son reservadas
porque no se deben utilizar como nombres: ni para variables, ni para funciones, ni para
cualquier otra cosa que se desee crear.

El significado de la palabra reservada está predefinido, y no debe cambiar.

RESUMEN DE SECCIÓN
Una variable es una ubicación nombrada reservada para almacenar valores en la memoria. Una
variable es creada o inicializada automáticamente cuando se le asigna un valor por primera vez.
(2.1.4.1)

Cada variable debe de tener un nombre único - un identificador. Un nombre válido debe ser
aquel que no contiene espacios, debe comenzar con un guion bajo(_), o una letra, y no puede
ser una palabra reservada de Python. El primer carácter puede estar seguido de guiones bajos,
letras, y dígitos. Las variables en Python son sensibles a mayúsculas y minúsculas.
Python es un lenguaje de tipo dinámico, lo que significa que no se necesita declarar variables
en él. Para asignar valores a las variables, se utiliza simplemente el operador de asignación, es
decir el signo de igual (=), por ejemplo, var = 1.

También es posible utilizar operadores de asignación compuesta (operadores abreviados) para

modificar los valores asignados a las variables, por ejemplo: var += 1, o var /= 5 * 2.

Se les puede asignar valores nuevos a variables ya existentes utilizando el operador de

asignación o un operador abreviado, por ejemplo:

var = 2

print(var)

var = 3

print(var)

var += 1

print(var)

RESUMEN DE SECCIÓN
Los operadores de comparación (o también denominados operadores relacionales) se utilizan
para comparar valores. La siguiente tabla ilustra cómo funcionan los operadores de
comparación, asumiendo que
x = 0, y = 1, y z = 0:

Operador Descripción

== Devuelve True si los valores de los operandos son iguales, y False de lo contrario.

!= Devuelve True si los valores de los operandos no son iguales, y False de lo contrario.

> Devuelve True si el valor del operando izquierdo es mayor que el valor del operando
derecho, y False de lo contrario.

< Devuelve True si el valor del operando izquierdo es menor que el valor del operando
derecho, y False de lo contrario.
 >= Devuelve True si el valor del operando izquierdo es mayor o igual al valor del operando
derecho, y False de lo contrario.

<= Devuelve True si el valor del operando izquierdo es menor o igual al valor del operando
derecho, y False de lo contrario.

RESUMEN DE SECCIÓN
1. Existen dos tipos de bucles en Python: while y for:

El bucle while ejecuta una sentencia o un conjunto de sentencias siempre que una condición
booleana especificada sea verdadera, por ejemplo:

# Ejemplo 1

while True:

print("Atrapado en un bucle infinito.")

# Ejemplo 2

counter = 5

while counter > 2:

print(counter)

counter -= 1

El bucle for ejecuta un conjunto de sentencias muchas veces; se usa para iterar sobre una
secuencia (por ejemplo, una lista, un diccionario, una tupla o un conjunto; pronto aprenderás
sobre ellos) u otros objetos que son iterables (por ejemplo, cadenas). Puedes usar el bucle for
para iterar sobre una secuencia de números usando la función incorporada range. Mira los
ejemplos a continuación:

# Ejemplo 1

word = "Python"

for letter in word:

print(letter, end="*")
# Ejemplo 2

for i in range(1, 10):

if i % 2 == 0:

printprint(i)

2. Puedes usar las sentencias break y continue para cambiar el flujo de un bucle:

Utiliza break para salir de un bucle, por ejemplo:

text = "OpenEDG Python Institute

for letter in text:

if letter == "P":

break

print(letter, end="")

Utiliza continue para omitir la iteración actual, y continuar con la siguiente iteración, por
ejemplo:

text = "pyxpyxpyx

for letter in text:

if letter == "x":

continue

print(letter, end="")

3. Los bucles while y for también pueden tener una cláusula else en Python. La cláusula else se
ejecuta después de que el bucle finalice su ejecución siempre y cuando no haya terminado con
break, por ejemplo:

n=0

while n != 3:
 print(n)

n += 1

else:

print(n, "else")

print()

for i in range(0, 3):

print(i)

else:

print(i, "else")

4. La función range() genera una secuencia de números. Acepta enteros y devuelve objetos de
rango. La sintaxis de range() tiene el siguiente aspecto: range(start, stop, step), donde:

start es un parámetro opcional que especifica el número de inicio de la secuencia (0 por

defecto)

stop es un parámetro opcional que especifica el final de la secuencia generada (no está
incluido).

y step es un parámetro opcional que especifica la diferencia entre los números en la secuencia
es (1 por defecto.)

Código de ejemplo:

for i in range(3):

print(i, end=" ") # output: 0 1 2

for i in range(6, 1, -2):

print(i, end=" ") # output: 6, 4, 2

Funciones vs métodos
Un método es un tipo específico de función - se comporta como una función y se parece a una
función, pero difiere en la forma en que actúa y en su estilo de invocación.

Una función no pertenece a ningún dato - obtiene datos, puede crear nuevos datos y
(generalmente) produce un resultado.

Un método hace todas estas cosas, pero también puede cambiar el estado de una entidad
seleccionada.

Un método es propiedad de los datos para los que trabaja, mientras que una función es
propiedad de todo el código.

Esto también significa que invocar un método requiere alguna especificación de los datos a
partir de los cuales se invoca el método.

Puede parecer desconcertante aquí, pero lo trataremos en profundidad cuando profundicemos

en la programación orientada a objetos.

En general, una invocación de función típica puede tener este aspecto:

result = function(arg)

La función toma un argumento, hace algo, y devuelve un resultado.

Una invocación de un método típico usualmente se ve así:

result = data.method(arg)

Nota: el nombre del método está precedido por el nombre de los datos que posee el método.
A continuación, se agrega un punto, seguido del nombre del método y un par de paréntesis
que encierran los argumentos.

El método se comportará como una función, pero puede hacer algo más - puede cambiar el
estado interno de los datos a partir de los cuales se ha invocado.

RESUMEN DE SECCIÓN
1. La lista es un tipo de dato en Python que se utiliza para almacenar múltiples objetos. Es una
colección ordenada y mutable de elementos separados por comas entre corchetes, por
ejemplo:

my_list = [1, None, True, "Soy una cadena", 256, 0]

2. Las listas se pueden indexar y actualizar, por ejemplo:

my_list = [1, None, True, 'Soy una cadena', 256, 0]

print(my_list[3]) # output: Soy una cadena

print(my_list[-1]) # output: 0

my_list[1] = '?'

print(my_list) # output: [1, '?', True, 'Soy una cadena', 256, 0]

my_list.insert(0, "primero")

my_list.append("último")

print(my_list) # output: ['primero', 1, '?', True, 'Soy una cadena', 256, 0, 'último']

3. Las listas pueden estar anidadas, por ejemplo:

my_list = [1, 'a', ["lista", 64, [0, 1], False]]

Aprenderás más sobre el anidamiento - por el momento, solo queremos que sepas que algo
como esto también es posible.

4. Los elementos de la lista y las listas se pueden eliminar, por ejemplo:

my_list = [1, 2, 3, 4]

del my_list[2]

print(my_list) # output: [1, 2, 4]

del my_list # borra la lista entera

Nuevamente, aprenderás más sobre esto - no te preocupes. Por el momento, intenta

experimentar con el código anterior y verifica cómo cambiarlo afecta la output.
5.Las listas pueden ser iteradas mediante el uso del bucle for, por ejemplo:

my_list = ["blanco", "purpura", "azul", "amarillo", "verde"]

for color in my_list:

print(color)

6. La función len() se puede usar para verificar la longitud de la lista, por ejemplo:

my_list = ["blanco", "purpura", "azul", "amarillo", "verde"]

print(len(my_list)) # output 5

del my_list[2]

print(len(my_list)) # output 4

7. Una invocación típica de función tiene el siguiente aspecto: result = function(arg), mientras
que una invocación típica de un método se ve así: result = data.method(arg).

Ordenamiento Burbuja
Ahora que puedes hacer malabarismos con los elementos de las listas, es hora de aprender
como ordenarlos. Se han inventado muchos algoritmos de clasificación, que difieren mucho en
velocidad, así como en complejidad. Vamos a mostrar un algoritmo muy simple, fácil de
entender, pero desafortunadamente, tampoco es muy eficiente. Se usa muy raramente, y
ciertamente no para listas extensas.

Digamos que una lista se puede ordenar de dos maneras:

ascendente (o más precisamente - no descendente) - si en cada par de elementos adyacentes,

el primer elemento no es mayor que el segundo;
descendente (o más precisamente - no ascendente) - si en cada par de elementos adyacentes,
el primer elemento no es menor que el segundo.

En las siguientes secciones, ordenaremos la lista en orden ascendente, de modo que los
números se ordenen de menor a mayor.

Aquí está la lista:

10

Intentaremos utilizar el siguiente enfoque: tomaremos el primer y el segundo elemento y los

compararemos; si determinamos que están en el orden incorrecto (es decir, el primero es
mayor que el segundo), los intercambiaremos; si su orden es válido, no haremos nada. Un
vistazo a nuestra lista confirma lo último - los elementos 01 y 02 están en el orden correcto, así
como 8<10.

Ahora observa el segundo y el tercer elemento. Están en las posiciones equivocadas. Tenemos
que intercambiarlos:

10

Vamos más allá y observemos los elementos tercero y cuarto. Una vez más, esto no es lo que
se supone que es. Tenemos que intercambiarlos:

10

4
Ahora comprobemos los elementos cuarto y quinto. Si, ellos también están en las posiciones
equivocadas. Ocurre otro intercambio:

10

El primer paso a través de la lista ya está terminado. Todavía estamos lejos de terminar nuestro
trabajo, pero algo curioso ha sucedido mientras tanto. El elemento más grande, 10, ya ha
llegado al final de la lista. Ten en cuenta que este es el lugar deseado para el. Todos los
elementos restantes forman un lío pintoresco, pero este ya está en su lugar.

Ahora, por un momento, intenta imaginar la lista de una manera ligeramente diferente - es
decir, de esta manera:

10

Observa - El 10 está en la parte superior. Podríamos decir que flotó desde el fondo hasta la
superficie, al igual que las burbujas en una copa de champán. El método de clasificación deriva
su nombre de la misma observación - se denomina ordenamiento burbuja.

Ahora comenzamos con el segundo paso a través de la lista. Miramos el primer y el segundo
elemento - es necesario un intercambio:

10

Es hora del segundo y tercer elemento: también tenemos que intercambiarlos:

6

10

Ahora el tercer y cuarto elementos, y la segunda pasada, se completa, ya que 8 ya está en su

lugar:

10

Comenzamos el siguiente pase inmediatamente. Observa atentamente el primer y el segundo

elemento - se necesita otro cambio:

10

Ahora 6 necesita ir a su lugar. Cambiamos el segundo y el tercer elemento:

10

La lista ya está ordenada. No tenemos nada más que hacer. Esto es exactamente lo que
queremos.
Como puedes ver, la esencia de este algoritmo es simple: comparamos los elementos
adyacentes y, al intercambiar algunos de ellos, logramos nuestro objetivo.

Codifiquemos en Python todas las acciones realizadas durante un solo paso a través de la lista,
y luego consideraremos cuántos pases necesitamos para realizarlo. No hemos explicado esto
hasta ahora, pero lo haremos pronto.

Ordenando una lista

¿Cuántos pases necesitamos para ordenar la lista completa?

Resolvamos este problema de la siguiente manera: introducimos otra variable, su tarea es

observar si se ha realizado algún intercambio durante el pase o no. Si no hay intercambio,
entonces la lista ya está ordenada, y no hay que hacer nada más. Creamos una variable llamada
swapped, y le asignamos un valor de False para indicar que no hay intercambios. De lo
contrario, se le asignará True.

my_list = [8, 10, 6, 2, 4] # lista a ordenar

for i in range(len(my_list) - 1): # necesitamos (5 - 1) comparaciones

if my_list[i] > my_list[i + 1]: # compara elementos adyacentes

my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i] # Si terminamos aquí, tenemos que

intercambiar elementos.

Deberías poder leer y comprender este programa sin ningún problema:

my_list = [8, 10, 6, 2, 4] # lista a ordenar

swapped = True # Lo necesitamos verdadero (True) para ingresar al bucle while.

while swapped:

swapped = False # no hay intercambios hasta ahora

for i in range(len(my_list) - 1):

if my_list[i] > my_list[i + 1]:

 swapped = True # ¡ocurrió el intercambio!

my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]

print(my_list)

El ordenamiento burbuja – versión interactiva

En el editor, puedes ver un programa completo, enriquecido por una conversación con el
usuario, y que permite ingresar e imprimir elementos de la lista: El ordenamiento burbuja -
versión final interactiva.

my_list = []

swapped = True

num = int(input("¿Cuántos elementos deseas ordenar?: "))

for i in range(num):

val = float(input("Ingresa un elemento de la lista: "))

my_list.append(val)

while swapped:

swapped = False

for i in range(len(my_list) - 1):

if my_list[i] > my_list[i + 1]:

swapped = True

my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]

print("\nOrdenada:")

print(my_list)

Python, sin embargo, tiene sus propios mecanismos de clasificación. Nadie necesita escribir sus
propias clases, ya que hay un número suficiente de herramientas listas-para-usar.
Te explicamos este sistema de clasificación porque es importante aprender como procesar los
contenidos de una lista y mostrarte como puede funcionar la clasificación real.

Si quieres que Python ordene tu lista, puedes hacerlo de la siguiente manera:

my_list = [8, 10, 6, 2, 4]

my_list.sort()

print(my_list)

RESUMEN DE SECCIÓN
1. Puedes usar el método sort() para ordenar los elementos de una lista, por ejemplo:

lst = [5, 3, 1, 2, 4]

print(lst)

lst.sort()

print(lst) # output: [1, 2, 3, 4, 5]

2.También hay un método de lista llamado reverse(), que puedes usar para invertir la lista, por
ejemplo:

lst = [5, 3, 1, 2, 4]

print(lst)

lst.reverse()

print(lst) # output: [4, 2, 1, 3, 5]

RESUMEN DE SECCIÓN
1. Si tienes una lista list_1, y la siguiente asignación: list_2 = list_1 esto no hace una copia de la
lista list_1, pero hace que las variables list_1 y list_2 apunten a la misma lista en la memoria.
Por ejemplo:
vehicles_one = ['coche', 'bicicleta', 'motor']

print(vehicles_one) # output: ['coche', 'bicicleta', 'motor']

vehicles_two = vehicles_one

del vehicles_one[0] # elimina 'coche'

print(vehicles_two) # output: ['bicicleta', 'motor']

2. Si deseas copiar una lista o parte de la lista, puedes hacerlo haciendo uso de rebanadas:

colors = ['rojo', 'verde', 'naranja']

copy_whole_colors = colors[:] # copia la lista entera

copy_part_colors = colors[0:2] # copia parte de la lista

3. También puede utilizar índices negativos para hacer uso de rebanadas. Por ejemplo:

sample_list = ["A", "B", "C", "D", "E"]

new_list = sample_list[2:-1]

print(new_list) # output: ['C', 'D']

4. Los parámetros start y end son opcionales al partir en rebanadas una lista: list[start:end], por
ejemplo:

my_list = [1, 2, 3, 4, 5]

slice_one = my_list[2: ]

slice_two = my_list[ :2]

slice_three = my_list[-2: ]

print(slice_one) # output: [3, 4, 5]

print(slice_two) # output: [1, 2]

print(slice_three) # output: [4, 5]

5. Puedes eliminar rebanadas utilizando la instrucción del:

my_list = [1, 2, 3, 4, 5]

del my_list[0:2]

print(my_list) # output: [3, 4, 5]

del my_list[:]

print(my_list) # elimina el contenido de la lista, genera: []

6. Puedes probar si algunos elementos existen en una lista o no utilizando las palabras clave in
y not in, por ejemplo:

my_list = ["A", "B", 1, 2]

print("A" in my_list) # output: True

print("C" not in my_list) # output: True

print(2 not in my_list) # output: False

RESUMEN DE SECCIÓN
1. La comprensión de listas te permite crear nuevas listas a partir de las existentes de una
manera concisa y elegante. La sintaxis de una comprensión de lista es la siguiente:

[expresión para el elemento en la lista si es condicional]

El cual es un equivalente del siguiente código:

for element in list:

if conditional:

expression

Este es un ejemplo de una comprensión de lista - el código siguiente crea una lista de cinco
elementos con los primeros cinco números naturales elevados a la potencia de 3:

cubed = [num ** 3 for num in range(5)]

print(cubed) # output: [0, 1, 8, 27, 64]

RESUMEN DE SECCIÓN
1. Una función es un bloque de código que realiza una tarea especifica cuando la función es
llamada (invocada). Las funciones son útiles para hacer que el código sea reutilizable, que este
mejor organizado, y más legible. Las funciones contienen parámetros y pueden regresar
valores.

2. Existen al menos cuatro tipos de funciones básicas en Python:

funciones integradas las cuales son partes importantes de Python (como lo es la función
print()). Puedes ver una lista completa de las funciones integradas de Python en la siguiente
liga https://docs.python.org/3/library/functions.html.

también están las que se encuentran en módulos pre-instalados (se hablará acerca de ellas en
el curso Fundamentos de Python 2)

funciones definidas por el usuario las cuales son escritas por los programadores para los
programadores - puedes escribir tus propias funciones y utilizarlas libremente en tu código,

las funciones lambda (aprenderás acerca de ellas en el curso Fundamentos de Python 2.)

3. Las funciones propias se pueden definir utilizando la palabra reservada def y con la siguiente
sintaxis:

def your_function(optional parameters):

# el cuerpo de la función

Se puede definir una función sin que haga uso de argumentos, por ejemplo:

def message(): # definiendo una función

print("Hello") # cuerpo de la función

message() # invocación de la función

También es posible definir funciones con argumentos, como la siguiente que contiene un solo
parámetro:

def hello(name): # definiendo una función

 print("Hello,", name) # cuerpo de la función

name = input("Ingresa tu nombre: ")

hello(name) # invocación de la función

RESUMEN DE SECCIÓN
1. Se puede pasar información a las funciones utilizando parámetros. Las funciones pueden
tener tantos parámetros como sean necesarios.

Un ejemplo de una función con un parámetro

def hi(name):

print("Hola,", name)

hi("Greg")

Un ejemplo de una función de dos parámetros:

def hi_all(name_1, name_2):

print("Hola,", name_2)

print("Hola,", name_1)

hi_all("Sebastián", "Konrad")

Un ejemplo de una función de tres parámetros:

def address(street, city, postal_code):

print("Tu dirección es:", street,"St.,", city, postal_code)

s = input("Calle: ")

p_c = input("Código Postal: ")

c = input("Ciudad: ")

address(s, c, p_c)
2. Puedes pasar argumentos a una función utilizando las siguientes técnicas:

paso de argumentos posicionales en la cual el orden de los parámetros es relevante (Ejemplo

1)

paso de argumentos con palabras clave en la cual el orden de los argumentos es irrelevante
(Ejemplo 2)

una mezcla de argumentos posicionales y con palabras clave (Ejemplo 3).

Ejemplo 1

def subtra(a, b):

print(a - b)

subtra(5, 2) # salida: 3

subtra(2, 5) # salida: -3

Ejemplo 2

def subtra(a, b):

print(a - b)

subtra(a=5, b=2) # salida: 3

subtra(b=2, a=5) # salida: 3

Ex. 3

def subtra(a, b):

print(a - b)

subtra(5, b=2) # salida: 3

subtra(5, 2) # salida: 3

Es importante recordar que primero se especifican los argumentos posicionales y después los
de palabras clave. Es por esa razón que si se intenta ejecutar el siguiente código:
def subtra(a, b):

print(a - b)

subtra(5, b=2) # salida: 3

subtra(a=5, 2) # Syntax Error

Python no lo ejecutará y marcará un error de sintaxis SyntaxError.

3. Se puede utilizar la técnica de argumentos con palabras clave para asignar valores
predefinidos a los argumentos:

def name(first_name, last_name="Pérez"):

print(first_name, last_name)

name("Andy") # salida: Andy Pérez

name("Bety", "Rodríguez") # salida: Bety Rodríguez (el argumento de palabra clave es

reemplazado por "Rodríguez"

RESUMEN DE SECCIÓN
1. Puedes emplear la palabra clave reservada return para decirle a una función que devuelva
algún valor. La instrucción return termina la función, por ejemplo:

def multiply(a, b):

return a * b

print(multiply(3, 4)) # salida: 12

def multiply(a, b):

return

print(multiply(3, 4)) # salida: None

2. El resultado de una función se puede asignar fácilmente a una variable, por ejemplo:

def wishes():

return "¡Felíz Cumpleaños!

w = wishes()

print(w) # salida:¡Felíz Cumpleaños!

Observa la diferencia en la salida en los siguientes dos ejemplos:

# Ejemplo 1

def wishes():

print("Mis deseos")

return "Felíz Cumpleaños

wishes() # salida: Mis deseos

# Ejemplo 2

def wishes():

print("Mis deseos")

return "Felíz Cumpleaños

print(wishes())

# salida: Mis deseos

# Felíz Cumpleaños

3. Puedes usar una lista como argumento de una función, por ejemplo:
def hi_everybody(my_list):

for name in my_list:

print("Hola,", name)

hi_everybody(["Adán", "Juan", "Lucía"])

4. Una lista también puede ser un resultado de función, por ejemplo:

def create_list(n):

my_list = []

for i in range(n):

my_list.append(i)

return my_list

print(create_list(5))

RESUMEN DE SECCIÓN
1. Una variable que existe fuera de una función tiene alcance dentro del cuerpo de la función.
(Ejemplo 1) al menos que la función defina una variable con el mismo nombre. (Ejemplo 2, y
Ejemplo 3), por ejemplo:

Ejemplo 1:

var = 2

def mult_by_var(x):

return x * var

print(mult_by_var(7)) # salida: 14

Ejemplo 2:

def mult(x):

var = 5

return x * var

print(mult(7)) # salida: 35
Ejemplo 3:

def mult(x):

var = 7

return x * var

var = 3

print(mult(7)) # salida: 49

2. Una variable que existe dentro de una función tiene un alcance solo dentro del cuerpo de la
función (Ejemplo 4), por ejemplo:

Ejemplo 4:

def adding(x):

var = 7

return x + var

print(adding(4)) # salida: 11

print(var) # NameError

3. Se puede emplear la palabra clave reservada global seguida por el nombre de una variable
para que el alcance de la variable sea global, por ejemplo:

var = 2

print(var) # salida: 2

def return_var():

global var

var = 5

return var

print(return_var()) # salida: 5

print(var) # salida: 5

RESUMEN DE SECCIÓN
1. Una función puede invocar otras funciones o incluso a sí misma. Cuando una función se
invoca a si misma, se le conoce como recursividad, y la función que se invoca a si misma y
contiene una condición de terminación (la cual le dice a la función que ya no siga invocándose
a si misma) es llamada una función recursiva.
2. Se pueden emplear funciones recursivas en Python para crear funciones limpias, elegantes, y
dividir el código en trozos más pequeños. Sin embargo, se debe tener mucho cuidado ya que es
muy fácil cometer un error y crear una función la cual nunca termine. También se debe
considerar que las funciones recursivas consumen mucha memoria, y por lo tanto pueden ser
en ocasiones ineficientes.

Al emplear la recursividad, se deben de tomar en cuenta tanto sus ventajas como desventajas.

La función factorial es un ejemplo clásico de como se puede implementar el concepto de

recursividad:

# Implementación recursiva de la función factorial

def factorial(n):

if n == 1: # El caso base (condición de terminación).

return 1

else:

return n * factorial(n - 1)

print(factorial(4)) # 4 * 3 * 2 * 1 = 24

RESUMEN DE SECCIÓN
Completo Puntos Clave: tuplasPuntos Clave: tuplas

1. Las Tuplas son colecciones de datos ordenadas e inmutables. Se puede pensar en ellas como
listas inmutables. Se definen con paréntesis:

my_tuple = (1, 2, True, "una cadena", (3, 4), [5, 6], None)

print(my_tuple)

my_list = [1, 2, True, "una cadena", (3, 4), [5, 6], None]

print(my_list)

Cada elemento de la tupla puede ser de un tipo de dato diferente (por ejemplo, enteros,
cadenas, boleanos, etc.). Las tuplas pueden contener otras tuplas o listas (y viceversa).

2. Se puede crear una tupla vacía de la siguiente manera:

empty_tuple = ()

print(type(empty_tuple)) # salida: <class 'tuple'>

3. La tupla de un solo elemento se define de la siguiente manera:

one_elem_tuple_1 = ("uno", ) # Paréntesis y una coma.

one_elem_tuple_2 = "uno", # Sin paréntesis, solo la coma.

Si se elimina la coma, Python creará una variable no una tupla:

my_tuple_1 = 1,

print(type(my_tuple_1)) # salida: <class 'tuple'>

my_tuple_2 = 1 # Esto no es una tupla.

print(type(my_tuple_2)) # salida: <class 'int'>

4. Se pueden acceder los elementos de la tupla al indexarlos:

my_tuple = (1, 2.0, "cadena", [3, 4], (5, ), True)

print(my_tuple[3]) # salida: [3, 4]

5. Las tuplas son immutable, lo que significa que no se puede agregar, modificar, cambiar o
quitar elementos. El siguiente fragmento de código provocará una excepción:

my_tuple = (1, 2.0, "cadena", [3, 4], (5, ), True)

my_tuple[2] = "guitarra" # Se genera la excepción TypeError.

Sin embargo, se puede eliminar la tupla completa:

my_tuple = 1, 2, 3,

del my_tuple

print(my_tuple) # NameError: name 'my_tuple' is not define

6. Puedes iterar a través de los elementos de una tupla con un bucle (Ejemplo 1), verificar si un
elemento o no esta presente en la tupla (Ejemplo 2), emplear la función len() para verificar
cuantos elementos existen en la tupla (Ejemplo 3), o incluso unir o multiplicar tuplas (Ejemplo
4):

# Ejemplo 1

tuple_1 = (1, 2, 3)

for elem in tuple_1:

print(elem)

# Ejemplo 2

tuple_2 = (1, 2, 3, 4)

print(5 in tuple_2)

print(5 not in tuple_2)

# Ejemplo 3

tuple_2 = (1, 2, 3, 4)

print(len(tuple_3))

print(5 not in tuple_2)

# Ejemplo 4

tuple_4 = tuple_1 + tuple_2

tuple_5 = tuple_3 * 2

print(tuple_4)

print(tuple_5)

EXTRA

También se puede crear una tupla utilizando la función integrada de Python tuple(). Esto es
particularmente útil cuando se desea convertir un iterable (por ejemplo, una lista, rango,
cadena, etcétera) en una tupla:

my_tuple = tuple((1, 2, "cadena"))

print(my_tuple)

my_list = [2, 4, 6]

print(my_list) # salida: [2, 4, 6]

print(type(my_list)) # salida: <class 'list'>

tup = tuple(my_list)

print(tup) # salida: (2, 4, 6)

print(type(tup)) # salida: <class 'tuple'>

De la misma manera, cuando se desea convertir un iterable en una lista, se puede emplear la
función integrada de Python denominada list():

tup = 1, 2, 3,

my_list = list(tup)

print(type(my_list)) # salida: <class 'list'>

Completo Puntos clave: diccionariosPuntos clave: diccionarios

1. Los diccionarios son *colecciones indexadas de datos, mutables y desordenadas. (*En
Python 3.6x los diccionarios están ordenados de manera predeterminada.

Cada diccionario es un par de clave:valor. Se puede crear empleando la siguiente sintaxis:

my_dictionary = {

key1: value1,

key2: value2,

key3: value3,

2. Si se desea acceder a un elemento del diccionario, se puede hacer haciendo referencia a su

clave colocándola dentro de corchetes (Ejemplo 1) o utilizando el método get() (Ejemplo 2):

pol_esp_dictionary = {

"kwiat": "flor",

"woda": "agua",

"gleba": "tierra"

item_1 = pol_esp_dictionary["gleba"] # Ejemplo 1

print(item_1) # salida: tierra

item_2 = pol_esp_dictionary.get("woda") # Ejemplo 2

print(item_2) # salida: agua

3. Si se desea cambiar el valor asociado a una clave específica, se puede hacer haciendo
referencia a la clave del elemento, a continuación se muestra un ejemplo:

pol_esp_dictionary = {

"zamek": "castillo",

"woda": "agua",

"gleba": "tierra"

pol_esp_dictionary["zamek"] = "cerradura"

item = pol_esp_dictionary["zamek"]

print(item) # salida: cerradura

4. Para agregar o eliminar una clave (junto con su valor asociado), emplea la siguiente sintaxis:

phonebook = {} # un diccionario vacío

phonebook["Adán"] = 3456783958 # crear/agregar un par clave-valor

print(phonebook) # salida: {'Adán': 3456783958}

del phonebook["Adán"]

print(phonebook) # salida: {}

Además, se puede insertar un elemento a un diccionario utilizando el método update(), y

eliminar el ultimo elemento con el método popitem(), por ejemplo:

pol_esp_dictionary = {"kwiat": "flor"}

pol_esp_dictionary.update({"gleba": "tierra"})

print(pol_esp_dictionary) # salida: {'kwiat': 'flor', 'gleba': 'tierra'}

pol_esp_dictionary.popitem()

print(pol_esp_dictionary) # salida: {'kwiat': 'flor'}

5. Se puede emplear el bucle for para iterar a través del diccionario, por ejemplo:

pol_esp_dictionary = {

"zamek": "castillo",

"woda": "agua",

"gleba": "tierra"

for item in pol_esp_dictionary:

print(item)

# zamek

# woda

# gleba

6. Si deseas examinar los elementos (claves y valores) del diccionario, puedes emplear el
método items(), por ejemplo:

pol_esp_dictionary = {

"zamek": "castillo",

"woda": "agua",
 "gleba": "tierra"

for key, value in pol_esp_dictionary.items():

print("Pol/Esp ->", key, ":", value)

7. Para comprobar si una clave existe en un diccionario, se puede emplear la palabra clave
reservada in:

pol_esp_dictionary = {

"zamek": "castillo",

"woda": "agua",

"gleba": "tierra"

if "zamek" in pol_esp_dictionary:

print("Si")

else:

print("No")

8. Se puede emplear la palabra reservada del para eliminar un elemento, o un diccionario

entero. Para eliminar todos los elementos de un diccionario se debe emplear el método clear():

pol_esp_dictionary = {

"zamek": "castillo",

"woda": "agua",

"gleba": "tierra"

print(len(pol_esp_dictionary)) # salida: 3

del pol_esp_dictionary["zamek"] # eliminar un elemento

print(len(pol_esp_dictionary)) # salida: 2

pol_esp_dictionary.clear() # eliminar todos los elementos

print(len(pol_esp_dictionary)) # salida: 0

del pol_esp_dictionary # elimina el diccionario

9. Para copiar un diccionario, emplea el método copy():

pol_esp_dictionary = {

"zamek": "castillo",

"woda": "agua",

"gleba": "tierra"

copy_dictionary = pol_esp_dictionary.copy()

Algunas excepciones útiles

Analicemos con más detalle algunas excepciones útiles (o más bien, las más comunes) que
puedes llegar a experimentar.

ZeroDivisionError

Esta aparece cuando intentas forzar a Python a realizar cualquier operación que provoque una
división en la que el divisor es cero o no se puede distinguir de cero. Toma en cuenta que hay
más de un operador de Python que puede hacer que se genere esta excepción. ¿Puedes
adivinarlos todos?

Si, estos son: /, //, y %.

ValueError

Espera esta excepción cuando estás manejando valores que pueden usarse de manera
inapropiada en algún contexto. En general, esta excepción se genera cuando una función
(como int() o float()) recibe un argumento de un tipo adecuado, pero su valor es inaceptable.

TypeError

Esta excepción aparece cuando intentas aplicar un dato cuyo tipo no se puede aceptar en el
contexto actual. Mira el ejemplo:

short_list = [1] one_value = short_list[0.5]

No está permitido usar un valor flotante como índice de una lista (la misma regla también se
aplica a las tuplas). TypeError es un nombre adecuado para describir el problema y una
excepción adecuada a generar.

AttributeError

Esta excepción llega - entre otras ocasiones - cuando intentas activar un método que no existe
en un elemento con el que se está tratando. Por ejemplo:

short_list = [1] short_list.append(2) short_list.depend(3)

La tercera línea de nuestro ejemplo intenta hacer uso de un método que no está incluido en las
listas. Este es el lugar donde se genera la excepción AttributeError.
SyntaxError

Esta excepción se genera cuando el control llega a una línea de código que viola la gramática de
Python. Puede sonar extraño, pero algunos errores de este tipo no se pueden identificar sin
ejecutar primero el código. Este tipo de comportamiento es típico de los lenguajes
interpretados - el intérprete siempre trabaja con prisa y no tiene tiempo para escanear todo el
código fuente. Se conforma con comprobar el código que se está ejecutando en el momento.
Muy pronto se te presentará un ejemplo de esta categoría.

Es una mala idea manejar este tipo de excepciones en tus programas. Deberías producir código
sin errores de sintaxis, en lugar de enmascarar las fallas que has causado.

Algunos consejos útiles

Aquí hay algunos consejos que pueden ayudarte a encontrar y eliminar errores. Ninguno de
ellos es definitivo. Úsalos de manera flexible y confía en tu intuición. No te creas a ti mismo -
comprueba todo dos veces.

1. Intenta decirle a alguien (por ejemplo, a tu amigo o compañero de trabajo) qué es lo

que se espera que haga tu código y cómo se espera que se comporte. Sé concreto y no
omitas detalles. Responde todas las preguntas que te hagan. Es probable que te des
cuenta de la causa del problema mientras cuentas tu historia, ya que el hablar activa
esas partes de tu cerebro que permanecen inactivas mientras codificas. Si ningún
humano puede ayudarte con el problema, usa un patito amarillo de goma en su lugar.
No estamos bromeando - consulta el artículo de Wikipedia para obtener más
información sobre esta técnica de uso común: Rubber Duck Debugging.

2. Intenta aislar el problema. Puedes extraer la parte de tu código que se sospecha que
es responsable de tus problemas y ejecutarla por separado. Puedes comentar partes
del código para ocultar el problema. Asigna valores concretos a las variables en lugar
de leerlos desde la consola. Prueba tus funciones aplicando valores de argumentos
predecibles. Analiza el código cuidadosamente. Léelo en voz alta.

3. Si el error apareció recientemente y no había aparecido antes, analiza todos los

cambios que has introducido en tu código - uno de ellos puede ser la razón.

4. Tómate un descanso, bebe una taza de café, toma a tu perro y sal a caminar, lee un
buen libro, incluso dos, haz una llamada telefónica a tu mejor amigo - te sorprenderás
de la frecuencia con la que esto ayuda.

5. Se optimista - eventualmente encontrarás el error; te lo prometemos.

RESUMEN DE SECCIÓN
1. En Python, existe una distinción entre dos tipos de errores:

errores de sintaxis (errores de análisis), que ocurren cuando el analizador encuentra una
sentencia de código que no es correcta. Por ejemplo:

El intentar ejecutar la siguiente línea:

print("Hola, ¡Mundo!)

Provocará un error del tipo SyntaxError, y da como resultado el siguiente (o similar)

mensaje que se muestra en la consola:

Presta atención a la flecha - indica el lugar donde el analizador de Python ha tenido

problemas. En este caso, la doble comilla es la que falta. ¿Lo notaste?

File "main.py", line 1 print("Hola, ¡Mundo!) ^ SyntaxError: EOL while scanning string
literalOutput

excepciones, ocurren incluso cuando una sentencia o expresión es sintácticamente

correcta. Estos son los errores que se detectan durante la ejecución, cuando tu código da
como resultado un error que no es incondicionalmente fatal. Por ejemplo:

El intentar ejecutar la siguiente línea:

print(1/0)

Provocará una excepción ZeroDivisionError, y da como resultado el siguiente (o similar)

mensaje que se muestra en la consola:

Traceback (most recent call last): File "main.py", line 1, in print(1/0) ZeroDivisionError:
division by zero

Presta atención a la última línea del mensaje de error - en realidad, te dice lo que sucedió.
Existen muchos diferentes tipos de excepciones, como ZeroDivisionError, NameError,
TypeError, y muchas mas; y esta parte del mensaje te informa qué tipo de excepción se ha
generado. Las líneas anteriores muestran el contexto en el que ha ocurrido la excepción.

2. Puedes "capturar" y manejar excepciones en Python usando el bloque try-except. Por lo

tanto, si tienes la sospecha de que cualquier fragmento de código en particular puede
generar una excepción, puedes escribir el código que la manejará con elegancia y no
interrumpirá el programa. Observa el ejemplo:

while True: try: number = int(input("Ingresa un número entero: ")) print(number/2) break
except: print("Advertencia: el valor ingresado no es un número válido. Intenta de nuevo...")

El código anterior le pide al usuario que ingrese un valor hasta que el valor ingresado sea
un número entero válido. Si el usuario ingresa un valor que no se puede convertir a un int,
el programa imprimirá en la consola Advertencia: el valor ingresado no es un número
válido. Intenta de nuevo..., y pide al usuario que ingrese un número nuevamente. Veamos
que sucede en dicho caso?

El programa entra en el bucle while.

El bloque try se ejecuta. El usuario ingresa un valor incorrecto, por ejemplo: ¡hola!.

Se genera una excepción, y el resto del código del bloque try se omite. El programa salta al
bloque except, lo ejecuta, y luego se sigue al código que se encuentra después del bloque
try-except.

Si el usuario ingresa un valor correcto y no se genera ninguna excepción, las instrucciones

subsiguientes al bloque try, son ejecutadas. En este caso, los excepts no se ejecutan.
3. Puedes manejar múltiples excepciones en tu bloque de código. Analiza los siguientes
ejemplos:

while True: try: number = int(input("Ingresa un número entero: ")) print(5/number) break
except ValueError: print("Valor incorrecto.") except ZeroDivisionError: print("Lo siento. No
puedo dividir entre cero.") except: print("No se que hacer...")

Puedes utilizar varios bloques except dentro de una sentencia try, y especificar nombres de
excepciones. Si se ejecuta alguno de los except, los otros se omitirán. Recuerda: puedes
especificar una excepción integrada solo una vez. Además, no olvides que la excepción por
defecto (o genérica), es decir, a la que no se le especifica nombre, debe ser colocada al
final (utiliza las excepciones más específicas primero, y las más generales al último).

También puedes especificar y manejar múltiples excepciones integradas dentro de un solo

bloque except:

while True: try: number = int(input("Ingresa un número entero: ")) print(5/number) break
except (ValueError, ZeroDivisionError): print("Valor incorrecto o se ha roto la regla de
división entre cero.") except: print("Lo siento, algo salió mal...")

4. Algunas de las excepciones integradas más útiles de Python son: ZeroDivisionError,

ValueError, TypeError, AttributeError, y SyntaxError. Una excepción más que, en nuestra
opinión, merece tu atención es la excepción KeyboardInterrupt, que se genera cuando el
usuario presiona la tecla de interrupción (CTRL-C o Eliminar). Ejecuta el código anterior y
presiona la combinación de teclas para ver qué sucede.

Para obtener más información sobre las excepciones integradas de Python, consulta la
documentación oficial de Python aquí.

5. Por último, pero no menos importante, debes recordar cómo probar y depurar tu
código. Utiliza técnicas de depuración como depuración de impresión; si es posible - pide a
alguien que lea tu código y te ayude a encontrar errores o mejorarlo; intenta aislar el
fragmento de código que es problemático y susceptible a errores: prueba tus funciones
aplicando valores de argumento predecibles, y trata de manejar las situaciones en las que
alguien ingresa valores incorrectos; comenta las partes del código que ocultan el problema.
Finalmente, toma descansos y vuelve a tu código después de un tiempo con un par de ojos
nuevos.