Funciones

Tuplas

len(tupla): Devuelve la longitud de la tupla, es decir, el número de elementos.
```
mi_tupla = (1, 2, 3, 4, 5)
longitud = len(mi_tupla)  # Resultado: 5
```

tupla.count(elemento): Devuelve el número de ocurrencias de un elemento en la tupla.

mi_tupla = (1, 2, 2, 3, 2, 4)
ocurrencias_del_dos = mi_tupla.count(2)  # Resultado: 3

tupla.index(elemento): Devuelve el índice de la primera aparición de un elemento en la tupla.
```
mi_tupla = (10, 20, 30, 40, 50)
indice_del_30 = mi_tupla.index(30)  # Resultado: 2
```

+ (Concatenación de tuplas): Permite concatenar dos tuplas para formar una nueva tupla.

tupla1 = (1, 2, 3)
tupla2 = ('a', 'b', 'c')
tupla_concatenada = tupla1 + tupla2
# Resultado: (1, 2, 3, 'a', 'b', 'c')

* (Repetición de tuplas): Permite repetir una tupla varias veces para formar una nueva tupla.

tupla_original = (1, 2, 3)
tupla_repetida = tupla_original * 2
# Resultado: (1, 2, 3, 1, 2, 3)

min(tupla) y max(tupla): Devuelven el valor mínimo y máximo de la tupla, respectivamente.

mi_tupla = (10, 5, 8, 3, 15)
valor_minimo = min(mi_tupla)  # Resultado: 3
valor_maximo = max(mi_tupla)  # Resultado: 15

sum(tupla): Devuelve la suma de todos los elementos de la tupla.

mi_tupla = (1, 2, 3, 4, 5)
suma_total = sum(mi_tupla)  # Resultado: 15

len(lista): Devuelve la longitud de la lista, es decir, el número de elementos.
```
mi_lista = [1, 2, 3, 4, 5]
longitud = len(mi_lista)  # Resultado: 5
```

lista.append(elemento): Agrega un elemento al final de la lista.

mi_lista = [1, 2, 3]
mi_lista.append(4)
# Resultado: [1, 2, 3, 4]

lista.insert(indice, elemento): Inserta un elemento en una posición específica de la lista.
```
mi_lista = [1, 2, 3]
mi_lista.insert(1, 5)
# Resultado: [1, 5, 2, 3]
```
lista.remove(elemento): Elimina la primera ocurrencia del elemento en la lista.
```
mi_lista = [1, 2, 3, 2, 4]
mi_lista.remove(2)
# Resultado: [1, 3, 2, 4]
```

del lista[indice]: Elimina el elemento en la posición indicada.

mi_lista = [1, 2, 3, 4]
del mi_lista[2]
# Resultado: [1, 2, 4]

lista.pop(indice): Elimina y devuelve el elemento en la posición indicada. Si no se proporciona un índice, elimina y devuelve el último elemento.
```
mi_lista = [1, 2, 3, 4]
elemento_eliminado = mi_lista.pop(2)
# Resultado: [1, 2, 4], elemento_eliminado: 3
```

lista.sort(): Ordena la lista de forma ascendente.

mi_lista = [3, 1, 4, 1, 5, 9, 2]
mi_lista.sort()
# Resultado: [1, 1, 2, 3, 4, 5, 9]

lista.reverse(): Invierte el orden de los elementos en la lista.

mi_lista = [1, 2, 3, 4]
mi_lista.reverse()
# Resultado: [4, 3, 2, 1]

lista.count(elemento): Devuelve el número de ocurrencias de un elemento en la lista.

mi_lista = [1, 2, 2, 3, 2, 4]
ocurrencias_del_dos = mi_lista.count(2)  # Resultado: 3

lista.index(elemento): Devuelve el índice de la primera aparición de un elemento en la lista.
```
mi_lista = [10, 20, 30, 40, 50]
indice_del_30 = mi_lista.index(30)  # Resultado: 2
```

len(diccionario): Devuelve la cantidad de pares clave-valor en el diccionario.

mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
longitud = len(mi_diccionario)  # Resultado: 3

diccionario.keys(): Devuelve una vista de todas las claves en el diccionario.

mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
claves = mi_diccionario.keys()  # Resultado: dict_keys(['a', 'b', 'c'])

diccionario.values(): Devuelve una vista de todos los valores en el diccionario.

mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
valores = mi_diccionario.values()  # Resultado: dict_values([1, 2, 3])

diccionario.items(): Devuelve una vista de tuplas que contienen los pares clave-valor.

mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
elementos = mi_diccionario.items()  # Resultado: dict_items([('a', 1), ('b', 2), ('c', 3)])

diccionario.get(clave, valor_predeterminado): Devuelve el valor asociado a la clave dada. Si la clave no está en el diccionario, devuelve el valor predeterminado (o None si no se proporciona).
```
mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
valor = mi_diccionario.get('b', 0)  # Resultado: 2
```
diccionario.pop(clave, valor_predeterminado): Elimina y devuelve el valor asociado a la clave dada. Si la clave no está en el diccionario, devuelve el valor predeterminado (o lanza un error si no se proporciona).
```
mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
valor_eliminado = mi_diccionario.pop('b')  # Resultado: 2
```

diccionario.popitem(): Elimina y devuelve el último par clave-valor agregado al diccionario.

mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
par_eliminado = mi_diccionario.popitem()  # Resultado: ('c', 3)

diccionario.update(otro_diccionario): Actualiza el diccionario con elementos del otro diccionario o con pares clave-valor proporcionados como argumentos.
```
diccionario1 = {'a': 1, 'b': 2}
diccionario2 = {'b': 3, 'c': 4}
diccionario1.update(diccionario2)
# Resultado: {'a': 1, 'b': 3, 'c': 4}
```

diccionario.clear(): Elimina todos los elementos del diccionario.

mi_diccionario = {'a': 1, 'b': 2, 'c': 3}
mi_diccionario.clear()
# Resultado: {}

diccionario.setdefault(clave, valor): Si la clave está en el diccionario, devuelve su valor. Si no está, inserta la clave con el valor proporcionado y devuelve ese valor.
```
mi_diccionario = {'a': 1, 'b': 2}
valor = mi_diccionario.setdefault('c', 3)  # Resultado: 3
```

diccionario.copy(): Devuelve una copia superficial del diccionario.

mi_diccionario = {'a': 1, 'b': 2}
copia_diccionario = mi_diccionario.copy()