CARRERA

INGENIERÍA INFORMÁTICA

ASIGNATURA
PROGRAMACIÓN PARA CIENCIA DE DATOS

PROFESOR: MERCEDES HARNÁNDEZ DE LA CRUZ

R E P A S O P Y T H O N

PRESENTADO POR EL ESTUDIANTE

ROBERTO CARLOS HOYA FLORES.

Número de control: 22520638

CHILPANCINGO GRO., 05 DE SEPTIEMBRE DEL 2025.

Tipos de Datos en Python

Python ofrece una amplia variedad de tipos de datos que permiten trabajar de forma flexible y
sencilla. Entre los más comunes se encuentran:

 Enteros (int): Números sin decimales, por ejemplo 5 o -42.

 Flotantes (float): Números con decimales, por ejemplo 3.14 o -0.001.

 Cadenas de texto (str): Secuencias de caracteres, por ejemplo "Hola".

 Booleanos (bool): Valores lógicos, solo True o False.

Además, Python incluye tipos de datos más complejos y muy utilizados:

 Listas (list): Colecciones ordenadas y modificables, por ejemplo [1, 2, 3].

 Diccionarios (dict): Pares clave-valor, por ejemplo {"nombre": "Ana", "edad": 25}.

 Tuplas (tuple): Colecciones ordenadas pero inmutables, por ejemplo (10, 20, 30).

 Conjuntos (set): Colecciones desordenadas de elementos únicos, por ejemplo {1, 2, 3}.

🔹 Para identificar el tipo de un valor o variable se utiliza la función type().

🔹 Los comentarios en Python se escriben con el símbolo #.

Ejercicio 1: Suma

La suma en Python se realiza con el operador +. Este operador combina dos valores numéricos.

2 + 3 # Suma

➝ El resultado es 5.

[ ] 2 + 3 # Suma

Ejercicio 2: Multiplicación

La multiplicación en Python se realiza con el operador *. Este operador calcula el producto de dos
números.

2 * 3 # Multiplicación

➝ El resultado es 6.

[ ] 2 * 3 # Multiplicación

6
Ejercicio 3: División

La división en Python se realiza con el operador /. Siempre devuelve un número de tipo flotante
(float), incluso si la división es exacta.

7 / 2 # División con resultado flotante

➝ El resultado es 3.5.

[ ]7 / 2 # Division con respuesta de numero flotante

3.5

Ejercicio 4: División entera

La división entera en Python se realiza con el operador //. Devuelve únicamente la parte entera
del cociente, descartando los decimales.

5 // 2 # Parte entera de la división

➝ El resultado es 2.

[ ]5 // 2 # parte entera de la división

Ejercicio 5: Potenciación

La potenciación en Python se realiza con el operador **. Eleva un número a la potencia indicada.

2 ** 4 # Potenciación

➝ El resultado es 16.

[ ]2**4 # Potenciación

16

Ejercicio 6: Módulo

El operador % devuelve el residuo de una división. Es útil para determinar si un número es divisible
por otro.

8 % 2 # Operación módulo

➝ El resultado es 0, porque 8 es divisible entre 2 sin residuo.

[ ]8 % 2 # Operación Modulo

Ejercicio 7: Módulo

El operador % devuelve el residuo de la división entre dos números.

5 % 2 # Operación módulo
➝ El resultado es 1, porque 5 dividido entre 2 da un residuo de 1.

[ ]5 % 2 #Operación Modulo

Ejercicio 8: Módulo

El operador % devuelve el residuo de la división de dos números.

53 % 15 # Operación módulo

➝ El resultado es 8, porque 53 dividido entre 15 da un residuo de 8.

[ ]53 % 15

Orden específico para realizar las operaciones y resolver fórmulas

Para calcular expresiones matemáticas correctamente, es importante seguir un orden específico

de operaciones. Este orden determina cuál operación se realiza primero y cuál después. La
jerarquía en Python y en matemáticas es la siguiente:

 Potencias y radicales: Se realizan primero, antes de cualquier otra operación.

 Multiplicación y división: Se realizan después de potencias y radicales, de izquierda a

derecha.

 División entera (//) y módulo (%): Se consideran al mismo nivel que multiplicación y
división.

 Suma y resta: Se realizan al final, de izquierda a derecha.

Ejemplo de varias operaciones en la misma ecuación

Esta línea de código combina varias operaciones matemáticas en una sola expresión. Se utilizan
paréntesis para controlar el orden de ejecución, siguiendo la jerarquía de operaciones.

((2 + 3) * (5**2 + 5)) / 2 # Uso de varias operaciones en la misma ecuación

 (2 + 3): Primero se realiza la suma dentro del primer paréntesis, resultado = 5.

 (5**2 + 5): Se calcula la potencia 5**2 = 25 y luego se suma 5, resultado = 30.

 ((2 + 3) * (5**2 + 5)): Multiplicamos los resultados de los paréntesis: 5 * 30 = 150.

 / 2: Finalmente, se divide entre 2, resultado = 75.0.

➝ Esta expresión demuestra cómo combinar suma, potencia, multiplicación y división en una sola
fórmula, respetando el orden de operaciones.

[ ]((2 + 3) * (5**2 + 5)) / 2 #Uso de varias operaciones en la misma ecuación

75.0
Booleanos Lógicos en Python

Los Booleanos son un tipo de dato fundamental en Python que representa valores de verdad. Solo
pueden tomar dos posibles valores: True (verdadero) o False (falso). Se utilizan ampliamente en
comparaciones, condiciones y control de flujo en los programas.

 Operadores de comparación: Permiten comparar valores y devuelven un Booleano.

o == : igual a → 5 == 5 ➝ True

o != : diferente de → 5 != 3 ➝ True

o > : mayor que → 7 > 2 ➝ True

o < : menor que → 3 < 1 ➝ False

 Operadores lógicos: Permiten combinar condiciones.

o and → Verdadero si ambas condiciones son verdaderas.

o or → Verdadero si al menos una condición es verdadera.

o not → Niega el valor lógico (True → False, False → True).

Función para determinar el tipo de dato númerico

int # tipo entero(int)

Ejercicio 1: Tipo entero

La función int representa números enteros en Python. Son valores sin decimales y se utilizan para
contar o realizar operaciones exactas.

# Función para determinar el tipo de dato numérico int # tipo entero (int)

➝ Representa un valor entero, por ejemplo 5, -3, etc.

[ ]# Funcion para determinar el tipo de dato númerico

int # tipo entero (int)

int

Ejercicio 2: Tipo flotante

La función float representa números con decimales. Se determina por el uso del punto decimal en
el número.

float # tipo flotante, se determina por el uso del punto

➝ Ejemplo: 3.14, -0.5.

[ ]float # tipo flotante, se determina por el uso del punto

float

Ejercicio 3: Tipo Booleano

La función bool representa valores lógicos en Python. Solo pueden ser True o False y se utilizan
para condiciones y comparaciones.

bool

➝ Ejemplo: 5 > 3 devuelve True.

[ ]bool # representa valores lógicos true o false

bool

Ejercicio 4: Tipo de número flotante

La función type() permite determinar el tipo de dato de un valor o expresión. En este caso, 5 /
2 realiza una división que devuelve un número flotante.

type(5/2) # Número flotante

➝ El resultado es float.

[ ]type (5/2) #, Número flotante

float

Ejercicio 5: Tipo de número entero

La función type() permite determinar el tipo de dato de un valor o expresión. En este caso, 5 //
2 realiza una división entera que devuelve solo la parte entera del cociente.

type(5//2) # Número entero

➝ El resultado es int.

[ ]type (5//2) #, Número entero

int

Asignación de Valores a Variables en Python

En Python, las variables no necesitan declararse previamente. Se crean automáticamente en el

momento en que se les asigna un valor por primera vez usando el operador =.

x = 5 # Variable entera
y = 3.14 # Variable flotante
nombre = "Python" # Variable tipo string
🔹 En Python, las variables son dinámicas, lo que significa que pueden cambiar de tipo si se les
asigna un nuevo valor.

x = 5 # Entero
x = "Hola" # Ahora es un string

Aunque Python lo permite, no es recomendable cambiar el tipo de una variable, ya que puede
causar confusión en el código.

Ejercicio 1: Nombres de Variables Válidos

Los nombres de variables en Python no pueden comenzar con un número ni contener caracteres
especiales. Se recomienda usar letras, números (no al inicio) y guiones bajos.

# Nombre válido de variable

name_of_var = 2 # Asignación de valor
type(name_of_var) # Verificar tipo

➝ La variable name_of_var almacena un número entero y su tipo es int.

[ ] # Los nombres No pueden empezar con un número o un carácter especial

name_of_var = 2 # asignación de valores a una variable
type(name_of_var)

int

Ejercicio 2: Reasignación de Variable

En Python, las variables son dinámicas. Esto significa que podemos cambiar su valor y tipo en
cualquier momento.

name_of_var = 5.3 # Se asigna un número flotante

type(name_of_var) # Verificar tipo

➝ Ahora name_of_var almacena un float en lugar de un entero.

[ ]name_of_var = 5.3 # asignación de valores a una variable

type(name_of_var)

float

Ejercicio 3: Asignación y Operaciones

Podemos asignar valores a varias variables y realizar operaciones entre ellas. Python permite
almacenar resultados de operaciones directamente en otra variable.

x = 2 # Asignación a la variable x
y = 3 # Asignación a la variable y
z = x + y # Suma de x e y

➝ La variable z almacena el resultado de la suma: 5.

[ ]x = 2 # asignando valores a diferentes variables
y=3
z = x + y # asignar la seuma de los dos valores

Introducción a Strings en Python

En Python, un string o cadena de texto es una secuencia de caracteres encerrada entre comillas
simples ('texto') o dobles ("texto"). Los strings se utilizan para almacenar y manipular información
textual, como nombres, mensajes, oraciones o incluso códigos de varias líneas.

Python ofrece varias operaciones para trabajar con strings, incluyendo concatenación, repetición,
indexado, slicing y funciones integradas como len() para obtener la longitud de la cadena.

Ejemplo 1: Creación de Strings

Este ejemplo muestra cómo crear cadenas de texto en Python. Podemos usar comillas dobles
("texto") o simples ('texto'). Las cadenas se almacenan en variables y se pueden imprimir en
pantalla usando print().

[ ]nombre = "Python"
mensaje = 'Hola mundo'
print(nombre)
print(mensaje)

Ejemplo 2: Concatenación

En este ejemplo se muestra cómo unir varias cadenas en una sola utilizando el operador +. Esto es
útil para crear mensajes completos combinando diferentes palabras o variables.

[ ]saludo = "Hola" + " " + "mundo"

print(saludo)

Ejemplo 3: Repetición

Podemos repetir un string varias veces usando el operador *. Esto genera una nueva cadena que
contiene el texto original repetido el número de veces indicado.

[ ]eco = "Hi! " * 3

print(eco)

Ejemplo 4: Indexado

Cada carácter en un string tiene una posición (índice) comenzando desde 0. Podemos acceder a
caracteres individuales usando corchetes [] con el índice correspondiente.

[ ]palabra = "Python"
print(palabra[0])
print(palabra[5])
Ejemplo 5: Longitud de un String

Podemos obtener la cantidad de caracteres de un string utilizando la función len(). Esto incluye
todos los caracteres, espacios y signos de puntuación.

[ ]palabra = "Python"
print(len(palabra))

Comillas sencillas

En Python, un string se puede definir utilizando comillas sencillas (' '). Esto permite crear cadenas
de texto simples.

[ ]'Comillas sencillas'

Comillas dobles

Un string también puede definirse usando comillas dobles (" "). Esto es útil cuando se desea incluir
comillas sencillas dentro del texto.

[ ]"Comillas dobles"

Comillas dentro de strings

Podemos escribir comillas dentro de un string usando el otro tipo de comillas para delimitar el
texto. Por ejemplo, se usan comillas dobles para que el string contenga comillas sencillas sin
problemas.

[ ]"Se puede escribir 'Comillas' de esta forma"

Strings largos con barra invertida

Para escribir un string largo en varias líneas de código sin romperlo, se puede usar la barra
invertida (\) al final de la línea. Esto permite que el texto se siga en la siguiente línea manteniendo
un único string.

[ ]# para escribir una frase larga se puede hacer asi:

"Aqui estoy, tristeando en la escuela recordando instrucciones de Python" \
"yo quisiera estar en Acapulco en la playa tomando aguita de coco " + \
".... pero ahorita no hay cocos, solo escuela "

Strings multilínea

Los strings de varias líneas se pueden escribir delimitando el texto con tres comillas dobles ("""
"""). Esto permite incluir saltos de línea dentro del string y se usan frecuentemente para
comentarios largos o documentación.
[ ]"""
Los strings de varias lineas pueden
escribirse delimitando con tres comillas
dobles y son usados corrientemente como
comentarios
"""

Strings largos con paréntesis

Otra forma de escribir strings largos es usando paréntesis para agrupar varias cadenas y Python las
concatenará automáticamente. Esto permite mantener la legibilidad del código sin usar la barra
invertida.

[ ]# escribir un string largo

# pero la impresión se hace en una sola linea
a=(
"Aqui estoy, tristeando en la escuela recordando instrucciones de Python, "
"yo quisiera estar en Acapulco en la playa tomando aguita de coco "
".... pero ahorita no hay cocos, solo escuela "
)
a

Tipo de dato

Usando la función type() podemos comprobar el tipo de dato de cualquier variable. En este caso,
un string devuelve str, que indica que es una cadena de texto.

[ ]type(a) # tipo de datos

str

str

Duplicar strings

Podemos repetir un string varias veces utilizando el operador *. Esto genera un nuevo string que
contiene el original repetido el número de veces indicado.

[ ]# duplicar varias veces un string

"Lamento que no haya agua de coco " * 4

Concatenar strings

Podemos unir varias cadenas en una sola usando el operador +. Esto es útil para construir
mensajes o frases combinando distintos textos.

[ ]# Contactar strings
palabra = "Aunque" + " sea un aguita" + " limón please.."
palabra
Imprimir un string

La función print() se utiliza para mostrar el contenido de un string en pantalla. Es la forma más
directa de visualizar texto en Python.

[ ]print("Hola mundo")

Hola mundo

Concatenar y repetir strings

Podemos combinar varias variables que contienen strings y luego repetir el resultado usando *.
Esto permite construir textos más largos o generar patrones de manera sencilla.

[ ] a = " Roberto Carlos "

b = " Hoya "
c = " Flores "
(a + b + c) * 3

Asignar string a una variable

Podemos almacenar un string en una variable para usarlo más adelante. Esto permite manipular y
reutilizar el texto sin reescribirlo cada vez.

[ ]x = "Hola" # asignar variable tipo string

x # limpiar la variable en Notebook

Imprimir variable

La función print() permite mostrar el contenido de cualquier variable, incluyendo strings. Es útil
para verificar valores o mostrar resultados al usuario.

[ ]print(x) # imprimir una variable en python

Hola

Asignación de variables

Podemos almacenar diferentes tipos de datos en variables. Por ejemplo, un número entero
en num y un string en name. Esto permite manipular y usar ambos valores en distintas
operaciones.

[ ]num = 27 # asignación de variables

name = "Roberto"

f-strings (formato literal)

Los f-strings permiten insertar variables dentro de un string de forma directa usando llaves {}. Esto
facilita construir mensajes que combinen texto y valores de variables de manera legible.
[ ]# f-string o string literal format
print (f"Me llamo: {name}, y mi edad es: {num}")

Me llamo: Roberto, y mi edad es: 27

Entrada de datos con input

La función input() permite al usuario ingresar datos desde el teclado. Todo lo ingresado se
almacena como string, y podemos comprobar su tipo con type().

# Entrada de datos del usuario

[ ]entrada = input("Como te llamas? ") # los datos seran tipo string

type(entrada) # tipo de dato

Como te llamas? roberto

str

Pedir datos y mostrar con bucle

Podemos pedir los datos del usuario una sola vez y luego usar un bucle for para mostrar la
información varias veces. Los f-strings permiten imprimir el índice del bucle junto con los datos
ingresados.

Introducir nombre y edad y que se repita 3 o 4 veces

[ ]# Pedir los datos solo una vez

nombre = input("¿Cómo te llamas? ")
edad = input("¿Cuál es tu edad? ")

# Mostrar el resultado 4 veces

for i in range(4):
print(f"{i+1}. Nombre: {nombre}, Edad: {edad}")

¿Cómo te llamas? roberto

¿Cuál es tu edad? 27

1. Nombre: roberto, Edad: 27

2. Nombre: roberto, Edad: 27

3. Nombre: roberto, Edad: 27

4. Nombre: roberto, Edad: 27

Listas en Python

Las listas son una de las principales estructuras para almacenar información en Python. Permiten
guardar varios elementos en una sola variable, incluyendo números, strings, booleanos o incluso
otras listas. Las listas se definen usando corchetes [] y los elementos se separan por comas.
Son mutables, lo que significa que podemos cambiar, agregar o eliminar elementos después de
haberlas creado.

Podemos acceder a los elementos usando índices (empezando en 0), recorrerlas con bucles, o
aplicar métodos integrados como append(), remove() o sort() para manipularlas.

Crear una lista

Creamos listas usando corchetes [] y separando los elementos con comas. Las listas pueden
contener distintos tipos de datos, incluyendo números, cadenas y booleanos.

[ ]# definicion de listas
numeros = [1, 2, 3, 4, 5]
nombres = ["Ana", "Luis", "Carlos"]
mixta = [1, "Hola", True, 3.14]
# las listas de delimitan entre [y] y se usa la , como separación

Acceder a elementos

Podemos obtener un elemento específico de la lista usando su índice. Los índices comienzan en 0,
por lo que el primer elemento tiene índice 0.

[ ]nombres = ["Ana", "Luis", "Carlos"]

print(nombres[0]) # Ana
print(nombres[2]) # Carlos

Modificar elementos

Las listas son mutables, lo que permite cambiar un elemento específico usando su índice. Esto es
útil para actualizar valores sin crear una nueva lista.

[ ]numeros = [1, 2, 3]
numeros[1] = 10
print(numeros) # [1, 10, 3]

[1, 10, 3]

Agregar elementos

Podemos agregar un elemento al final de la lista usando append(). Esto nos permite expandir la
lista sin redefinirla.

[ ]numeros = [1, 2, 3]
[Link](4)
print(numeros) # [1, 2, 3, 4]

[1, 2, 3, 4]
Eliminar elementos

Podemos eliminar un elemento específico usando remove() con el valor que queremos borrar.
Esto elimina la primera aparición de ese valor en la lista.

[ ]numeros = [1, 2, 3, 4]
[Link](2)
print(numeros) # [1, 3, 4]

[1, 3, 4]

Recorrer una lista

Podemos usar un bucle for para recorrer todos los elementos de una lista. Esto nos permite
procesar, imprimir o manipular cada elemento de forma individual.

[ ]nombres = ["Ana", "Luis", "Carlos"]

for nombre in nombres:
print(nombre)

Ana

Luis

Carlos

Tipo de dato de una variable

La función type() permite determinar el tipo de dato que contiene una variable. Esto es útil para
saber si la variable es un número, un string, una lista u otro tipo de dato.

[ ]type(uno) #tipo de datos

list

Lista con diferentes tipos de datos

Una lista puede contener distintos tipos de datos, como strings, números o incluso otras listas.
Esto hace que las listas sean estructuras muy flexibles para almacenar información variada.

[ ]# una lista puede tener diferentes tipos de datos

[
"hola",
1,
[1,2,3],

] # Esta lista tiene un string, un número y una lista como sus elementos

['hola', 1, [1, 2, 3]]

Crear una lista

Podemos crear una lista sencilla con corchetes [] y separando los elementos por comas. Esta lista
puede almacenarse en una variable para usarla y manipularla posteriormente.

[ ]my_list = [ "a","b","c"] # creacion de una lista

my_list

['a', 'b', 'c']

Lista anidada

Una lista puede contener otras listas como elementos, creando una estructura anidada. Esto
permite organizar información jerárquica o compleja dentro de una sola lista.

[][
"hola",
1,
[1,2,3],[
"hola",
1,
[1,2,3],

['hola', 1, [1, 2, 3], ['hola', 1, [1, 2, 3]]]

Indexación de strings y listas

La indexación permite acceder a un elemento específico de un string o lista usando su posición. El

primer elemento siempre tiene índice 0, el segundo 1, y así sucesivamente.

[ ]# La indexcacion y obtención de elementos de listas y string es igual

# a la primera posicion es en 0
word = "Python"
word[0] # carácter en la posición 0

Acceder al sexto carácter

La expresión word[5] obtiene el sexto carácter del string (los índices comienzan en 0). En word =
"Python", esto devuelve 'n'.

[ ]word[5] # carácter en la posición 5

Acceder al último carácter

El índice negativo -1 permite acceder al último carácter de un string. Para word = "Python", word[-
1] devuelve 'n'.
[ ]word[-1] #Último carácter

[ ]word[-2] # Ante penúltimo carácter

[ ]word[-6] # Primer carácter en este ejemplo

[ ]print(word[3])

NOTA IMPORTANTE

En Python la numeración de las posiciones empieza en cero (0).

Para acceder a algún elemento de la lista, se utilizan [] corchetes.

Ejemplo:
list_vble = [45, 23, 38, 2, 8, 17] # creación de una lista
list_vble[3] # accediendo al valor en la posición 3

Los strings tienen un comportamiento similar a las List, pero los strings son inmutables, mientras
que las listas sí son mutables.

Indexación en strings

La indexación en listas y strings funciona de la misma manera. La primera posición siempre

corresponde al índice 0.

Ejemplo:
word = "Python" # definición de un string
word[0] # caracter en la posición 0

En este caso, el resultado será 'P', ya que es el primer carácter del string "Python".

[ ]# La indexación y obtención de elementos de listas y strings es igual

# La primera posición es en 0
word = "Python"
word [0] # caracter en la posición 0

Acceder a un carácter específico en un string

Para obtener un carácter en una posición específica de un string, se utiliza la indexación con
corchetes [].
Ejemplo:
word = "Python"
print(word[3]) # imprime el carácter en la posición 3

Recordando que la numeración empieza en 0, el índice 3 corresponde al cuarto carácter. Por lo

tanto, el resultado será 'h'.

[ ]print(word [3])

Acceder al primer carácter usando índice negativo

En Python, los índices negativos permiten contar desde el final del string hacia el inicio. El índice -
1 corresponde al último carácter, -2 al penúltimo, y así sucesivamente.

Ejemplo:
word = "Python"
print(word[-6]) # accede al primer carácter usando índice negativo

Como la cadena "Python" tiene 6 caracteres, -6 corresponde al primer carácter, por lo que el
resultado será 'P'.

[ ]print(word [-6])

Índice negativo fuera de rango

En Python, los índices negativos permiten contar desde el final del string hacia el inicio. Sin
embargo, si el índice es menor que -len(string), se produce un error.

Ejemplo:
word = "Python"
print(word[-9]) # índice fuera del rango de la cadena

La cadena "Python" tiene 6 caracteres, por lo que los índices negativos válidos van de -6 a -1.
Intentar usar -9 genera un IndexError: índice fuera de rango.

[ ]print(word [-9])

Selección de varios elementos (Slicing)

En Python, el operador : se utiliza para indicar rangos y seleccionar varios elementos de una lista o
string.

La notación general es [inicio:final], donde inicio es el índice desde donde se comienza a

seleccionar y final es el índice hasta donde se selecciona, sin incluirlo.
Slicing: Selección de un rango de caracteres

El operador : se utiliza para seleccionar un rango de elementos en listas o strings.

La notación general es [inicio:final], donde inicio es la posición donde se comienza a seleccionar

y final es la posición donde se detiene la selección, sin incluir el índice final.

Ejemplo:
word = "Python"
word[0:3] # selecciona los caracteres desde la posición 0 hasta la 2

Esto devuelve 'Pyt', porque incluye los caracteres en los índices 0, 1 y 2.

[ ]# El operador ':' se usa para indicar rangos

# inicio [inicio:final-1], no se incluye el final
word [0:3]

Slicing desde el inicio hasta un índice específico

Cuando se omite el índice de inicio en un slicing, Python asume que se comienza desde el primer
elemento (índice 0).

La notación [:final] selecciona todos los elementos desde el inicio hasta final - 1, sin incluir el
índice final.

Ejemplo:
word = "Python"
word[:2] # selecciona los caracteres desde el inicio hasta la posición 1

Esto devuelve 'Py', que corresponde a los caracteres en los índices 0 y 1.

[ ]word [:2] # ':2' inicio [inicio:final-1], no se incluye el final

Py

Slicing desde un índice hasta el final

Cuando se omite el índice final en un slicing, Python selecciona todos los elementos desde el
índice de inicio hasta el último elemento del string o lista.

La notación [inicio:] selecciona todos los elementos desde inicio hasta el final.

Ejemplo:
word = "Python"
word[2:] # selecciona los caracteres desde la posición 2 hasta el final
Esto devuelve 'thon', que corresponde a los caracteres en los índices 2, 3, 4 y 5.

[ ]word [2:] # desde la posición 2 hasta el final

thon

Slicing con paso (stride)

En Python, se puede utilizar un tercer parámetro en el slicing llamado paso (stride), que indica
cada cuántos elementos se selecciona uno.

La notación general es [inicio:final:paso], donde:

- inicio es el índice desde donde comienza la selección.
- final es el índice hasta donde se selecciona, sin incluirlo.
- paso indica el salto entre elementos seleccionados.

Ejemplo:
word = "Python"
word[1:6:2] # selecciona los caracteres desde el índice 1 hasta el 5, tomando uno cada 2

Esto devuelve 'yhn', que corresponde a los caracteres en los índices 1, 3 y 5.

[ ]word [1:6:2] # [inicio:final-1:paso], Ej inicio = 1 , final-1 = 5, paso cada 2 elementos

yhn

Slicing con paso desde el inicio hasta el final

Cuando se omiten los índices de inicio y final, Python selecciona todos los elementos del string o
lista.
El tercer parámetro paso indica cada cuántos elementos se toma uno.

La notación [::paso] selecciona todos los elementos desde el inicio hasta el final, aplicando el paso
indicado.
Ejemplo:
word = "Python"
word[::2] # selecciona todos los caracteres, tomando uno cada 2

Esto devuelve 'Pto', que corresponde a los caracteres en los índices 0, 2 y 4.

[ ]word [::2]

Pto

Slicing con paso (stride)

En Python, se puede usar un tercer parámetro en el slicing llamado paso (stride), que indica cada
cuántos elementos se selecciona uno.
La notación general es [inicio:final:paso], donde:
- inicio es el índice desde donde comienza la selección.
- final es el índice hasta donde se selecciona, sin incluirlo.
- paso indica el salto entre elementos seleccionados.

Ejemplo:
word = "Python"
word[1:6:2] # selecciona los caracteres desde el índice 1 hasta el 5, tomando uno cada 2

Esto devuelve 'yhn', que corresponde a los caracteres en los índices 1, 3 y 5.

Concatenación de strings usando slicing

En Python, se pueden combinar (concatenar) partes de un string utilizando slicing y el operador +.

La notación string[:n] toma los primeros n caracteres, y string[n:] toma los caracteres desde la
posición n hasta el final.
Sumando ambos segmentos se reconstruye el string completo o se pueden reorganizar partes de
él.

Ejemplo:
word = "Python"
word[:2] + word[2:] # concatena los caracteres desde el inicio hasta 1, y desde 2 hasta el final

Esto devuelve 'Python', que es el string original reconstruido mediante slicing y concatenación.

[ ]word [:2] + word [2:] # concatenación de strings

Python

Concatenación de strings modificando el contenido

Al combinar diferentes partes de un string mediante slicing y el operador +, se pueden generar

nuevas cadenas.

En este caso:
- word[:4] devuelve los caracteres desde el inicio hasta el índice 3.
- word[2:] devuelve los caracteres desde el índice 2 hasta el final.

Ejemplo:
word = "Python"
word[:4] + word[2:] # concatena los caracteres de 0 a 3 con los de 2 a 5

Esto genera 'Pytthon', porque los caracteres en las posiciones 2 y 3 ('t' y 'h') se repiten en la
concatenación.
[ ]word [:4] + word [2:] # concatenación de strings

Pytthon

Obtener los últimos caracteres usando slicing negativo

En Python, los índices negativos permiten contar desde el final del string hacia el inicio.

La notación [-n:] selecciona los últimos n caracteres del string.

Ejemplo:
word = "Python"
word[-2:] # selecciona los últimos 2 caracteres

Esto devuelve 'on', que corresponde a los dos últimos caracteres del string "Python".

[ ]word [-2:] # desde la posición -2 hasta el final, osea, los últimos dos caracteres

on

Seleccionar todo el string con slicing

En Python, se puede usar la notación de slicing con ambos índices omitidos para seleccionar todos
los elementos de un string o lista.

La notación [:] devuelve una copia completa del string o lista original.

Ejemplo:
word = "Python"
word[:] # selecciona todos los caracteres

Esto devuelve 'Python', que es el string completo.

[ ]word [:]

Python

Invertir un string usando slicing

En Python, el slicing permite usar un paso negativo para recorrer el string desde el final hacia el
inicio.

La notación [inicio:final:paso] con paso = -1 recorre todos los caracteres en orden inverso.

Ejemplo:
word = "Python"
word[::-1] # recorre el string desde el final hasta el inicio

Esto devuelve 'nohtyP', que es el string original invertido.

[ ]word [::-1]

nohtyP

Intento de modificar un carácter de un string

En Python, los strings son inmutables, lo que significa que no se puede cambiar un carácter
individual asignándole un nuevo valor.

Ejemplo:
word = "Python"
word[2] = 'e' # intento de modificar el tercer carácter

Esto generará un TypeError: 'str' object does not support item assignment, porque no se puede
asignar un nuevo valor a una posición específica de un string. Para modificar un string, se deben
crear nuevos strings usando concatenación o slicing.

[ ]word [2] = 'e'

Mutabilidad: listas vs strings

En Python, las listas son estructuras de datos mutables, lo que significa que se pueden modificar,
agregar o eliminar elementos después de su creación.

Por el contrario, los strings no son mutables, es decir, no se puede cambiar un carácter individual
de un string existente. Para modificar un string, es necesario crear un nuevo string mediante
concatenación, slicing u otras operaciones.

Creación de una lista

En Python, las listas son estructuras de datos mutables que permiten almacenar múltiples
elementos en un solo objeto.

Ejemplo:
H = [1,2,3,4,5,6,7,8,9,10] # crea una lista con los números del 1 al 10

Cada elemento de la lista se puede acceder mediante su índice, modificar, eliminar o agregar
nuevos elementos, gracias a la mutabilidad de las listas.

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

Asignación de listas a otra variable

En Python, cuando se asigna una lista a otra variable usando el operador =, ambas variables
apuntan a la misma lista en memoria.

Ejemplo:
H = [1,2,3,4,5,6,7,8,9,10]
P = H # P apunta a la misma lista que H

Esto significa que cualquier modificación hecha en P también afectará a H, y viceversa, porque
ambas variables comparten la misma referencia de la lista.

[ ]P = H

Modificar un elemento de una lista

Como las listas en Python son mutables, se pueden cambiar los valores de sus elementos
mediante indexación.

Ejemplo:
P[9] = 9 # cambia el valor del décimo elemento de la lista P

Esto modifica la lista P, y dado que P y H apuntan a la misma lista, el cambio también se refleja
en H. Antes: [1,2,3,4,5,6,7,8,9,10]
Después: [1,2,3,4,5,6,7,8,9,9].

[ ] P[9] = 0

Mostrar el contenido de una lista

La función print() permite mostrar en pantalla el contenido de cualquier variable, incluyendo listas.

Ejemplo:
P # lista previamente modificada
print(P) # imprime la lista en pantalla

Después de modificar el décimo elemento con P[9] = 9, la salida será:

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

[ ]print (P)

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

Efecto de modificar una lista compartida

Cuando se asigna una lista a otra variable usando =, ambas variables apuntan a la misma lista en
memoria. Por lo tanto, cualquier cambio en una de las variables se refleja en la otra.

Ejemplo:
P=H
H[0] = 535 # se modifica el primer elemento de H
print(P) # imprime la lista a la que P también apunta

Salida:
[535, 2, 3, 4, 5, 6, 7, 8, 9, 9]
Observa que al cambiar H[0], el cambio también aparece en P, porque ambas variables comparten
la misma referencia de la lista.

[ ]print("Observar loq ue ocurre con 'P' cuando se cambia el valor de 'H', si P = H")
H[0] = 535
print (P)

#Observar lo que ocurre con 'P' cuando se cambia el valor de 'H', si P = H

[535, 2, 3, 4, 5, 6, 7, 8, 9, 0]

Imprimir variables usando f-strings

En Python, las f-strings permiten incluir el valor de variables directamente dentro de un string
usando llaves {}.

Ejemplo:
print(f"P = {P}") # imprime la lista P con formato
print(f"H = {H}") # imprime la lista H con formato

Dado que P y H apuntan a la misma lista y previamente se modificó H[0] = 535, la salida será:
P = [535, 2, 3, 4, 5, 6, 7, 8, 9, 9]
H = [535, 2, 3, 4, 5, 6, 7, 8, 9, 9]

Esto muestra cómo las f-strings permiten combinar texto y variables de manera clara y legible.

[ ]print(f"P = {P}") # uso de f-strings para imprimir los resultados

print(f"H = {H}") # uso de f-strings para imprimir los resultados

P = [535, 2, 3, 4, 5, 6, 7, 8, 9, 0]

H = [535, 2, 3, 4, 5, 6, 7, 8, 9, 0]

Asignación de listas y referencias en memoria

En este ejemplo se crean dos listas N y G con los mismos valores, pero inicialmente son listas
diferentes en memoria:

N = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
G = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Luego, al ejecutar:
G=N
la variable G pasa a referenciar la misma lista que N. Desde este momento, cualquier modificación
en N también afectará a G, y viceversa, ya que ambas apuntan al mismo objeto en memoria.

[ ]N = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
G = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
G=N
Efecto de modificar listas que comparten referencia

Como G = N, ambas variables apuntan a la misma lista en memoria.

Ejemplo:
G[0] = 81 # modifica el primer elemento de la lista G
print(G) # imprime la lista G
print(N) # imprime la lista N

Salida:
[81, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[81, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Como ambas variables comparten la misma referencia, el cambio en G también se refleja en N.

[ ]G [0] = 81
print (G)
print (N)

[81, 8, 7, 6, 5, 4, 3, 2, 1, 0]

[81, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Las listas no se copian al asignarlas a otra variable, es un puntero de a la lista orignal Esto evita
problemas de memoria pero puede llevar a errores en la programación, entonces la copia de debe
hacer explicita

Listas anidadas

En Python, una lista puede contener no solo números o strings, sino también otras listas. A esto se
le llama lista anidada.

Ejemplo:
nest = [1, 2, 3, [4, 5, ["Informática"]]] # lista con elementos anidados
nest

Al ejecutar la variable nest, se muestra su contenido completo:

[1, 2, 3, [4, 5, ["Informática"]]]

Aquí el último elemento es otra lista, que a su vez contiene otra lista con el string "Informática".

[ ]nest = [1, 2, 3, [4, 5, ["Informática"]]] # Lista con otra lista anterior

nest

[1, 2, 3, [4, 5, ['Informática']]]

Acceder a la sublista ["Informática"] en una lista anidada

Usando la notación de índices [] se accede a los elementos de la lista.

Ejemplo:
nest = [1, 2, 3, [4, 5, ["Informática"]]]
nest[3][2] # accede a la sublista ["Informática"]

Resultado:
["Informática"]

Explicación:
- nest[3] accede a la sublista que contiene [4, 5, ["Informática"]].
- nest[3][2] accede al tercer elemento de esa sublista, que es otra lista: ["Informática"].
- El tipo de este elemento es list, porque sigue siendo una lista en Python.

[ ]nest[3][1]

Acceder al string "Informática" en una lista anidada

Usando la notación de índices [] se accede a los elementos de la lista.

Ejemplo:
nest = [1, 2, 3, [4, 5, ["Informática"]]]
nest[3][2][0] # accede al string "Informática"

Resultado:
"Informática"

Explicación:
- nest[3] accede a la sublista que contiene [4, 5, ["Informática"]].
- nest[3][2] accede al tercer elemento de esa sublista, que es otra lista: ["Informática"].
- nest[3][2][0] accede al primer elemento de esa lista, que es el string "Informática".
- El tipo de este elemento es str, porque ahora es un string en Python.

[ ]nest [3]
nest [3][2] # De la lsita que es el elemento 4, obtener el elemento 3# el tipo de resultado

['Informática']

Acceder a la sublista que contiene el número 4 en una lista anidada

Usando la notación de índices [] podemos acceder a elementos dentro de listas anidadas.

Lista de ejemplo:
nest = [1, 2, 3, [4, 5, ["Informática"]]]
nest[3] # accede a la cuarta posición de la lista principal
Resultado:
[4, 5, ["Informática"]]

Explicación:
- nest[3] devuelve la sublista que contiene 4, 5 y otra lista ["Informática"].
- El primer elemento de esta sublista es 4, el segundo es 5 y el tercero es otra lista ["Informática"].
- El tipo de nest[3] es list, porque sigue siendo una lista en Python.

[ ]# obtener el elemento 4, obtener el elemento3, y obtnener el valor de esa lista

nest[3]

[4, 5, ['Informática']]

Mostrar toda la lista anidada

En Python, si simplemente escribimos el nombre de la lista, se mostrará su contenido completo.

Lista de ejemplo:
nest = [1, 2, 3, [4, 5, ["Informática"]]]
nest # muestra toda la lista

Resultado:
[1, 2, 3, [4, 5, ["Informática"]]]

Explicación:
- Al usar nest, accedemos a la lista completa, incluyendo los elementos individuales 1, 2, 3 y la
sublista [4, 5, ["Informática"]].
- El tipo de nest es list, porque todo el objeto sigue siendo una lista en Python.

[ ]nest

[1, 2, 3, [4, 5, ['Informática']]]

Mostrar toda la lista anidada compleja

En Python, si simplemente escribimos el nombre de la lista, se mostrará su contenido completo.

Lista de ejemplo:
nest = ['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]
nest # muestra toda la lista

Resultado:
['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]

Explicación:
- Al usar nest, accedemos a la lista completa, incluyendo los elementos individuales 'perro', 'gato' y
la sublista [9, [1, 2, 3, [4, 5, ["Informática"]]]].
- El tipo de nest es list, porque todo el objeto sigue siendo una lista en Python.
- Dentro de la sublista se encuentran más elementos y sublistas anidadas, que pueden accederse
usando índices adicionales.

[ ]nest = ['perro', 'gato',[9,[1,2,3, [4, 5, ['Informática']]]]]

Acceder a la sublista dentro de la lista principal

En Python, podemos acceder a un elemento específico de la lista usando índices [].

Lista de ejemplo:
nest = ['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]
nest[2] # accede a la tercera posición de la lista principal

Resultado:
[9, [1, 2, 3, [4, 5, ["Informática"]]]]

Explicación:
- nest[2] devuelve la sublista que contiene el número 9 y otra sublista [1, 2, 3, [4, 5,
["Informática"]]].
- El tipo de nest[2] es list, porque sigue siendo una lista en Python.
- Para acceder a elementos dentro de esta sublista, se pueden usar índices adicionales,
como nest[2][0] o nest[2][1].

[]

nest[2]

[9, [1, 2, 3, [4, 5, ['Informática']]]]

Acceder al segundo elemento de la lista

En Python, podemos acceder a un elemento específico de la lista usando índices [].

Lista de ejemplo:
nest = ['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]
nest[1] # accede a la segunda posición de la lista principal

Resultado:
'gato'

Explicación:
- nest[1] devuelve el segundo elemento de la lista principal, que es el string 'gato'.
- El tipo de nest[1] es str, porque se trata de un string en Python.
- Para acceder a elementos dentro de sublistas, se necesitarían índices adicionales, pero 'gato' es
un valor simple.

[ ]nest [1]

gato
Acceder a elementos de la lista anidada

En Python, podemos acceder a elementos específicos de una lista y sus sublistas usando índices [].

Lista de ejemplo:
nest = ['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]
nest[3] # intenta acceder al cuarto elemento de la lista principal
nest[2][1] # accede a la segunda posición de la sublista dentro del tercer elemento

Resultado:
nest[3] → IndexError
nest[2][1] → [1, 2, 3, [4, 5, ["Informática"]]]

Explicación:
- nest[3] genera un IndexError porque la lista principal solo tiene 3 elementos (índices 0, 1 y 2).
- nest[2] devuelve [9, [1, 2, 3, [4, 5, ["Informática"]]]], que es el tercer elemento de la lista
principal.
- Luego, [1] accede al segundo elemento de esa sublista, resultando en [1, 2, 3, [4, 5,
["Informática"]]].
- El resultado es una sublista, y no un valor simple, porque estamos dentro de un nivel anidado de
la lista.

[ ]nest [3]
nest [2][1]

Informática

Intento de acceder a un elemento dentro de un string

En Python, podemos acceder a elementos de una lista usando índices [], pero debemos tener en
cuenta el tipo de dato.

Lista de ejemplo:
nest = ['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]
nest[0][0] # intenta acceder al primer carácter del primer elemento

Resultado:
'p'

Explicación:
- nest[0] devuelve el primer elemento de la lista principal: 'perro'.
- nest[0][0] accede al primer carácter del string 'perro', que es 'p'.
- En Python, los strings son secuencias de caracteres, por lo que se pueden indexar como listas.
- Este índice no accede a una sublista, sino a un carácter individual dentro del string.

[ ]nest [0][0]

p
Acceder al primer carácter del segundo elemento de la lista

En Python, podemos acceder a elementos de una lista y de los strings dentro de ella usando
índices [].

Lista de ejemplo:
nest = ['perro', 'gato', [9, [1, 2, 3, [4, 5, ["Informática"]]]]]
nest[1][0] # accede al primer carácter del segundo elemento de la lista principal

Resultado:
'g'
Explicación:
- nest[1] devuelve el segundo elemento de la lista principal: 'gato'.
- nest[1][0] accede al primer carácter del string 'gato', que es 'g'.
- Los strings en Python son secuencias de caracteres, por lo que podemos indexarlos como si
fueran listas.
- Este índice no accede a una sublista, sino a un carácter individual dentro del string.

[ ]nest [1][0]

Ejercicio con nest

[ ]# Dada la siguiente lista de empleados con sus datos:

empleados = ["Federico Archibaldo", 35, "Departamento de Informática", 4500], ["Ximena", 29, "Si
stemas", 3800] , ["Alonso", 40, "Contabilidad", 2000] , ["maria", 27, "sistemas", 3600]
# correjir errores

[ ]# Obtener la edad de Ximena

# Obtener el salario de Alonso
# Cambiar el departamento de Maria a Ventas
# Corrigir el nombre de María
# Imprimir la nueva lista

Acceder a un dato específico de un empleado

En Python, podemos acceder a elementos dentro de una lista de listas usando índices [].

Lista de ejemplo:
empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
["Ximena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["Maria", 27, "Sistemas", 3600]
]
empleados[1][1] # accede a la edad del segundo empleado
Resultado:
29

Explicación:
- empleados[1] devuelve el segundo elemento de la lista principal: ["Ximena", 29, "Sistemas",
3800].
- [1] accede al segundo elemento de esa sublista, que es la edad: 29.
- En Python, los índices empiezan en 0, por lo que el índice 1 siempre apunta al segundo elemento.

[ ]empleados [1][1]

29

Acceder al salario de un empleado

En Python, podemos acceder a elementos dentro de una lista de listas usando índices [].

Lista de ejemplo:
empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
["Ximena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["Maria", 27, "Sistemas", 3600]
]
empleados[2][3] # accede al salario del tercer empleado

Resultado:
2000

Explicación:
- empleados[2] devuelve el tercer elemento de la lista principal: ["Alonso", 40, "Contabilidad",
2000].
- [3] accede al cuarto elemento de esa sublista, que es el salario: 2000.
- Los índices en Python comienzan en 0, por lo que el índice 2 apunta al tercer empleado y el índice
3 al cuarto dato dentro de su sublista.

[ ]empleados [2][3]

2000

Modificar el departamento de un empleado

En Python, podemos modificar elementos dentro de una lista de listas usando índices [] y el
operador de asignación =.

Lista de ejemplo:
empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
 ["Ximena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["Maria", 27, "Sistemas", 3600]
]
empleados[3][2] = "Ventas" # cambia el departamento del cuarto empleado

Resultado:
empleados[3] ahora es ["Maria", 27, "Ventas", 3600]
Explicación:
- empleados[3] accede al cuarto empleado de la lista principal: ["Maria", 27, "Sistemas", 3600].
- [2] apunta al tercer elemento de esa sublista, que corresponde al departamento.
- Al asignar "Ventas" con =, reemplazamos el valor anterior "Sistemas" por el nuevo
valor "Ventas".
- Esto modifica directamente la lista original sin crear una nueva.

[ ]empleados [3][2] = "Ventas"

Modificar el nombre de un empleado

En Python, podemos cambiar elementos dentro de una lista de listas usando índices [] y el
operador de asignación =.
Lista de ejemplo:
empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
["Ximena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["Maria", 27, "Ventas", 3600]
]
empleados[3][0] = "María" # cambia el nombre del cuarto empleado
Resultado:
empleados[3] ahora es ["María", 27, "Ventas", 3600]
Explicación:
- empleados[3] accede al cuarto empleado de la lista principal.
- [0] apunta al primer elemento de esa sublista, que corresponde al nombre.
- Al asignar "María" con =, reemplazamos el valor anterior "Maria" por el nuevo valor "María".
- Esto modifica directamente la lista original, actualizando el nombre correctamente con tilde.

[ ]empleados [3][0] = "María"

[ ]empleados [1][0] = "Jimena"

Acceder a un carácter del nombre de un empleado

En Python, podemos combinar índices de listas y de strings para acceder a partes específicas de los
datos.
Lista de ejemplo:
empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
 ["Jimena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["María", 27, "Ventas", 3600]
]
empleados[1][0][0][:2] # intenta acceder a los dos primeros caracteres del primer carácter del
nombre del segundo empleado
Resultado:
'J'
Explicación:
- empleados[1] accede al segundo empleado: ["Jimena", 29, "Sistemas", 3800].
- [0] accede al nombre del empleado: "Jimena".
- [0] accede al primer carácter del string, que es 'J'.
- [:2] hace slicing sobre el carácter `'J'`, pero como es un string de un solo carácter, el resultado
sigue siendo 'J'.
- Para obtener los dos primeros caracteres del nombre completo, habría que
usar empleados[1][0][:2] en lugar de agregar el índice `[0]`.

[ ]empleados [1][0][0][:2]

Lista completa de empleados después de las modificaciones

Esta es la lista empleados después de realizar las modificaciones:

empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
["Jimena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["María", 27, "Ventas", 3600]
]
print(empleados)

Resultado en la consola:
[['Federico Archibaldo', 35, 'Departamento de Informática', 4500],
['Jimena', 29, 'Sistemas', 3800],
['Alonso', 40, 'Contabilidad', 2000],
['María', 27, 'Ventas', 3600]]

Explicación:
- Cada sublista representa un empleado con sus datos: nombre, edad, departamento y salario.
- La lista refleja todas las modificaciones realizadas:
• El segundo empleado ahora se llama "Jimena".
• El cuarto empleado se llama "María" y su departamento fue cambiado a "Ventas".
- Esta estructura permite acceder a cualquier dato usando índices de lista, por
ejemplo empleados[1][0] para el nombre de Jimena.
[ ]print (empleados)

(['Federico Archibaldo', 35, 'Departamento de Informática', 4500], ['Jimena', 29, 'Sistemas', 3800],
['Alonso', 40, 'Contabilidad', 2000], ['María', 27, 'Ventas', 3600])

Sumar los salarios de todos los empleados

En Python, podemos acceder a elementos específicos de sublistas usando índices [] y realizar

operaciones aritméticas.
Lista de ejemplo:
empleados = [
["Federico Archibaldo", 35, "Departamento de Informática", 4500],
["Jimena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["María", 27, "Ventas", 3600]
]
empleados[0][3] + empleados[1][3] + empleados[2][3] + empleados[3][3] # suma de los salarios
Resultado:
13900
Explicación:
- empleados[0][3] → 4500 (salario de Federico)
- empleados[1][3] → 3800 (salario de Jimena)
- empleados[2][3] → 2000 (salario de Alonso)
- empleados[3][3] → 3600 (salario de María)
- La suma de todos los salarios: 4500 + 3800 + 2000 + 3600 = 13900.
- Esto muestra cómo podemos recorrer elementos específicos de sublistas y realizar cálculos con
ellos.

[ ]empleados[0][3] + empleados[1][3] + empleados[2][3] + empleados[3][3]

13900

Cálculo de salarios quincenal y anual de los empleados

Podemos calcular el salario quincenal, anual y mostrarlo con símbolo $ usando Python.

Lista de ejemplo:
empleados = ["Federico Archibaldo", 35, "Departamento de Informática", 4500],
["Jimena", 29, "Sistemas", 3800],
["Alonso", 40, "Contabilidad", 2000],
["María", 27, "Ventas", 3600]

Código para calcular salarios:

for emp in empleados:
salario_mensual = emp[3]
salario_quincenal = salario_mensual / 2
 salario_anual = salario_mensual * 12
print(f"Empleado: {emp[0]}")
print(f"Salario quincenal: ${salario_quincenal:.2f}")
print(f"Salario anual: ${salario_anual:.2f}")
print("-"*40)

Resultado esperado:
Empleado: Federico Archibaldo
Salario quincenal: $2250.00
Salario anual: $54000.00
----------------------------------------
Empleado: Jimena
Salario quincenal: $1900.00
Salario anual: $45600.00
----------------------------------------
Empleado: Alonso
Salario quincenal: $1000.00
Salario anual: $24000.00
----------------------------------------
Empleado: María
Salario quincenal: $1800.00
Salario anual: $43200.00
----------------------------------------

Explicación:
- emp[3] obtiene el salario mensual de cada empleado.
- Dividimos entre 2 para obtener el salario quincenal.
- Multiplicamos por 12 para obtener el salario anual.
- Usamos f-strings con ${valor:.2f} para mostrar el símbolo de pesos y dos decimales.
- Esto permite tener un resumen completo de los salarios de todos los empleados.

[ ]# Lista de empleados (tupla de listas)

empleados = ["Federico Archibaldo", 35, "Departamento de Informática", 4500], \
["Jimena", 29, "Sistemas", 3800], \
["Alonso", 40, "Contabilidad", 2000], \
["María", 27, "Ventas", 3600]

# Calcular y mostrar salarios

for emp in empleados:
salario_mensual = emp[3]
salario_quincenal = salario_mensual / 2
salario_anual = salario_mensual * 12
print(f"Empleado: {emp[0]}")
print(f"Salario quincenal: ${salario_quincenal:.2f}")
 print(f"Salario anual: ${salario_anual:.2f}")
print("-"*40)

Empleado: Federico Archibaldo

Salario quincenal: $2250.00

Salario anual: $54000.00

----------------------------------------

Empleado: Jimena

Salario quincenal: $1900.00

Salario anual: $45600.00

----------------------------------------

Empleado: Alonso

Salario quincenal: $1000.00

Salario anual: $24000.00

----------------------------------------

Empleado: María

Salario quincenal: $1800.00

Salario anual: $43200.00

----------------------------------------

Dada la matriz [ [1 2 3] [4 4 1] [0 9 1] ]

Cálculo de la suma de diagonales de una matriz

Podemos calcular la suma de la diagonal principal y secundaria de una matriz cuadrada usando
Python.

Matriz de ejemplo:
matriz = [[1,2,3],
[4,4,1],
[0,9,1]]

Código para calcular la suma de diagonales:

n = len(matriz)
suma_principal = 0
suma_secundaria = 0

for i in range(n):
 suma_principal += matriz[i][i]
suma_secundaria += matriz[i][n-1-i]

print("Diagonal principal:", suma_principal)

print("Diagonal secundaria:", suma_secundaria)
print("Suma de ambas:", suma_principal + suma_secundaria)

# Evitar doble conteo del centro si n es impar

if n % 2 == 1:
centro = matriz[n//2][n//2]
print("Suma sin repetir el centro:", suma_principal + suma_secundaria - centro)

Resultado esperado:
Diagonal principal: 6
Diagonal secundaria: 7
Suma de ambas: 13
Suma sin repetir el centro: 9

Explicación:
[ ]# Imprimir la suma de las diagonales
matriz = [[1,2,3],[4,4,1],[0,9,1]]

[ ]matriz [0][0] + matriz [1][1] + matriz [2][2]

Borrar Elementos de una lista

Explicación de lista anidada en Python

En Python, una lista puede contener otros tipos de datos, incluso otras listas. El ejemplo es:

nest = [1, 2, 3, [4, 5, ["Informática"]]]

Estructura:
- Primer nivel: [1, 2, 3, [...]]
- Segundo nivel: [4, 5, ["Informática"]]
- Tercer nivel: ["Informática"]

Acceso a elementos:
- nest[0] → 1
- nest[1] → 2
- nest[2] → 3
- nest[3][0] → 4
- nest[3][1] → 5
- nest[3][2][0] → "Informática"
Explicación paso a paso:
- nest es la lista principal.
- Dentro de ella, el cuarto elemento (nest[3]) es otra lista: [4, 5, ["Informática"]].
- Esa lista a su vez contiene otra lista en la tercera posición (nest[3][2]) que guarda el
texto "Informática".

Este tipo de listas se llaman listas anidadas y permiten organizar datos en niveles.

[ ]nest = [1,2,3,[4,5,["Informática"]]] # Lista con otra lista

[ ]nest[1:3] = [] #Borrar elementos de una lista, a partir del inidice

nest

[1, [4, 5, ['Informática']]]

Eliminar elementos de una lista con slicing en Python

El código:

nest = [1, 2, 3, [4, 5, ["Informática"]]]

nest[1:3] = []
print(nest)

Explicación:
- La lista original es: [1, 2, 3, [4, 5, ["Informática"]]]
- La notación nest[1:3] significa "desde el índice 1 hasta antes del índice 3".
- Esto corresponde a los elementos [2, 3].
- Al asignar = [], esos elementos se eliminan de la lista.

Resultado:
[1, [4, 5, ["Informática"]]]

Paso a paso:
- nest[0] es 1 (se mantiene).
- nest[1] y nest[2] eran 2 y 3 (se eliminan).
- Lo que queda es el último elemento [4, 5, ["Informática"]].

Este método es útil para eliminar rangos de elementos en una lista usando índices.

[ ]len(nest)

2
Explicación de lista anidada en Python

Lista definida:

nest1 = [1, 3, [4, 5, ['tecnológico', 8], 'Informática']]

Explicación:
- La lista principal contiene tres elementos: 1, 3 y otra lista.
- El tercer elemento (nest1[2]) es otra lista: [4, 5, ['tecnológico', 8], 'Informática'].
- Dentro de esa lista, el índice [2] corresponde a ['tecnológico', 8].
- Esa lista interna contiene la cadena "tecnológico" y el número 8.

Acceso a elementos:
- nest1[0] → 1
- nest1[1] → 3
- nest1[2][0] → 4
- nest1[2][1] → 5
- nest1[2][2][0] → "tecnológico"
- nest1[2][2][1] → 8
- nest1[2][3] → "Informática"

Resultado al imprimir:
[1, 3, [4, 5, ['tecnológico', 8], 'Informática']]

Paso a paso:
- nest1 comienza con dos enteros simples: 1 y 3.
- El último elemento es una lista anidada con cuatro valores (4, 5, otra lista y "Informática").
- Esa sublista demuestra cómo Python permite listas dentro de listas para organizar datos en
varios niveles.

Este tipo de estructura es útil para representar datos jerárquicos o agrupados.

[ ]nest1 = [1,3,[4,5,['tecnológico', 8], 'Informática']]

nest1

[1, 3, [4, 5, ['tecnológico', 8], 'Informática']]

Borrar elementos de una lista conociendo su índice

El código:

nest1 = [1, 2, 3, [4, 5, ["tecnológico", 8], "Informática"]]

del nest1[3][2][0]
print(nest1)
Explicación:
- La lista nest1 contiene otra lista en la posición [3]: [4, 5, ["tecnológico", 8], "Informática"].
- Dentro de esa lista, la posición [2] es otra lista: ["tecnológico", 8].
- Finalmente, [0] hace referencia al primer elemento de esa lista, que es "tecnológico".
- Usando del, se elimina exactamente ese valor.

Resultado:
[1, 2, 3, [4, 5, [8], "Informática"]]

Paso a paso:
- nest1[3] → [4, 5, ["tecnológico", 8], "Informática"]
- nest1[3][2] → ["tecnológico", 8]
- nest1[3][2][0] → "tecnológico" (este es el que se borra)
- Lo que queda es [8] dentro de la lista anidada.

De esta manera podemos borrar elementos específicos dentro de listas anidadas conociendo su
índice exacto.

[ ]# Borrar elementos de una lista conociendo su index

del nest1[2][2][0]
nest # observar que el valor este dentro de una lista

[1, 3, [4, 5, ['Informática']]]

Concatenar listas

Imprimir listas en Python

El código:
print(nest)
miLista = ["a", "b", "c"]
print(miLista)

Explicación:
- print(nest) mostrará en la consola el contenido actual de la lista nest.
- A continuación, se crea una nueva lista llamada miLista con los elementos "a", "b" y "c".
- print(miLista) mostrará el contenido de esta nueva lista en la consola.

Resultado esperado:
Si nest tiene el valor [1, [4, 5, ["Informática"]]] después de modificaciones previas:
[1, [4, 5, ["Informática"]]]
["a", "b", "c"]

Paso a paso:
- Python imprime la primera lista usando print().
- Luego se define otra lista simple con elementos de texto.
- Finalmente, se imprime la nueva lista.

Este método permite visualizar rápidamente el contenido de cualquier lista en Python.

[ ]print(nest)
miLista=["a","b","c"]
print(miLista)

[1, [4, 5, ['Informática']]]

['a', 'b', 'c']

Concatenar listas en Python

El código:

# Concatenar listas
NuevaLista = nest + miLista
print(NuevaLista)

Explicación:
- La operación nest + miLista une las dos listas en una sola.
- nest es la lista original que puede tener elementos simples o anidados.
- miLista es otra lista que se agregó al final.
- La concatenación no modifica las listas originales, sino que crea una nueva lista
llamada NuevaLista.

Resultado esperado:
Si nest = [1, [4, 5, ["Informática"]]] y miLista = ["a", "b", "c"], entonces:
[1, [4, 5, ["Informática"]], "a", "b", "c"]

Paso a paso:
- Se toma la primera lista nest.
- Se agregan los elementos de miLista al final.
- El resultado se guarda en NuevaLista y se imprime.

Este método permite combinar listas de manera sencilla y rápida en Python.

[ ]# Concatenar listas
NuevaLista = nest + miLista
NuevaLista

[1, [4, 5, ['Informática']], 'a', 'b', 'c']

Repetir varias veces una lista en Python

El código:

# Repetir varias veces una lista

repetida = miLista * 4
print(repetida)

Explicación:
- El operador * aplicado a una lista permite repetir sus elementos varias veces.
- miLista es la lista original, por ejemplo: ["a", "b", "c"].
- miLista * 4 genera una nueva lista que repite el contenido de miLista cuatro veces consecutivas.

Resultado esperado:
["a", "b", "c", "a", "b", "c", "a", "b", "c", "a", "b", "c"]

Paso a paso:
- Se toma la lista original miLista.
- Se repite su contenido 4 veces consecutivas.
- Se guarda el resultado en la nueva lista repetida y se imprime.

Este método es útil para duplicar o repetir secuencias de elementos de manera rápida sin usar
bucles.

[ ] # repetir varias veces una lista

repetida = miLista * 4

repetida

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']